summaryrefslogtreecommitdiff
path: root/src/gui
diff options
context:
space:
mode:
authorGabriel Schneider <[email protected]>2026-10-30 17:35:06 -0300
committerGabriel Schneider <[email protected]>2026-10-30 17:35:06 -0300
commit6d8da8721141284cf33bb901168b26135893eb86 (patch)
tree791d63401d4e85fbca1d597a8ce0326e70efd545 /src/gui
parentefd43a3a2cf03bb741366331158b368abf9ac583 (diff)
parentbf6810a8f9d6cc82050e7d9c0cfb06358301b574 (diff)
downloadpardes-6d8da8721141284cf33bb901168b26135893eb86.tar.gz
pardes-6d8da8721141284cf33bb901168b26135893eb86.zip
Merge latest upstream into the macOS branch for Zig 0.17
Retain the macOS branch history and local Acme selection color while adopting upstream's current core and platform changes. Pin Zig and ZLS to 0.17.0, and fetch the existing zstbi compatibility commit through upstream after its original fork was removed.
Diffstat (limited to 'src/gui')
-rw-r--r--src/gui/Post.zig688
-rw-r--r--src/gui/crt.zig101
-rw-r--r--src/gui/font.c350
-rw-r--r--src/gui/font.h84
-rw-r--r--src/gui/gui.zig7526
-rw-r--r--src/gui/pet.zig113
6 files changed, 6851 insertions, 2011 deletions
diff --git a/src/gui/Post.zig b/src/gui/Post.zig
new file mode 100644
index 00000000..a79d9f0c
--- /dev/null
+++ b/src/gui/Post.zig
@@ -0,0 +1,688 @@
+//! The post chain (docs/render-pipeline.md §6): Shadertoy passes over the
+//! finished frame, each reading the one before it (the frame first) and the
+//! last one writing the window. A pass is the bundled Crt (shaders/post/,
+//! compiled with the build) or a user's file (Shader <path>), whose SPIR-V
+//! comes from ShaderBuild.zig: compiled by the process that holds the core,
+//! this one or the detached session this GUI is attached to. A file whose
+//! compile fails keeps its last good pipeline.
+//!
+//! The uniforms are ghostty's (Uniforms), so a shader written for ghostty runs
+//! here. Their clock is the shell's and moves only when the chain draws:
+//! with a frame of the core's, or on its own while ShaderAnimation asks for
+//! it (redraw level A, §5.5: the chain alone, over the retained frame).
+const std = @import("std");
+const libc = std.c;
+const ghostty_vt = @import("ghostty-vt");
+const pardes = @import("../pardes.zig");
+const gui = @import("gui.zig");
+const c = gui.c;
+
+const Post = @This();
+const Scene = pardes.config.Runtime.Scene;
+const Chain = pardes.config.Runtime.Post;
+const Pipeline = c.SDL_GPUGraphicsPipeline;
+pub const max = Chain.max;
+
+const prefix = @embedFile("post-prefix.glsl");
+const Built = @import("../ShaderBuild.zig").Pass;
+const vert_spv = @embedFile("post.vert.spv");
+const bundled_spv = std.EnumArray(Scene, []const u8).init(.{
+ .crt = @embedFile("post-crt.frag.spv"),
+ .bloom = @embedFile("post-bloom.frag.spv"),
+ .vignette = @embedFile("post-vignette.frag.spv"),
+ .grain = @embedFile("post-grain.frag.spv"),
+});
+const bloom_down_spv = @embedFile("bloom-down.frag.spv");
+const bloom_up_spv = @embedFile("bloom-up.frag.spv");
+/// Bloom's steps below the frame, at levels 1 to 3: a half, a quarter, ...
+const bloom_steps = [_]u8{ 3, 4, 5 };
+const bloom_format = c.SDL_GPU_TEXTUREFORMAT_R16G16B16A16_FLOAT;
+
+/// pardes's own block (shaders/post/prefix.glsl PardesPost), std140.
+pub const Own = extern struct {
+ opaque_window: f32 = 1,
+ level: f32 = 0,
+ scale: f32 = 1,
+ cap: f32 = 0,
+ spare_count: f32 = 0,
+ _pad: [3]f32 = @splat(0),
+ spare: [max_spare][4]f32 = @splat(@splat(0)),
+};
+pub const max_spare = 32;
+
+/// ghostty's Shadertoy uniform block, member for member in the GLSL block's
+/// order and std140 layout (shaders/post/prefix.glsl). Filled by the GLSL
+/// names: ghostty's own Zig mirror calls the second-to-last slot
+/// selection_background, so there the two selection colours arrive swapped
+/// (docs §6, open point 1); here each is what its GLSL name says.
+pub const Uniforms = extern struct {
+ resolution: [3]f32 align(16) = .{ 0, 0, 1 },
+ time: f32 align(4) = 0,
+ time_delta: f32 align(4) = 0,
+ frame_rate: f32 align(4) = 60,
+ frame: i32 align(4) = 0,
+ channel_time: [4][4]f32 align(16) = @splat(@splat(0)),
+ channel_resolution: [4][4]f32 align(16) = @splat(@splat(0)),
+ mouse: [4]f32 align(16) = @splat(0),
+ date: [4]f32 align(16) = @splat(0),
+ sample_rate: f32 align(4) = 44100,
+ current_cursor: [4]f32 align(16) = @splat(0),
+ previous_cursor: [4]f32 align(16) = @splat(0),
+ current_cursor_color: [4]f32 align(16) = @splat(0),
+ previous_cursor_color: [4]f32 align(16) = @splat(0),
+ current_cursor_style: i32 align(4) = 0,
+ previous_cursor_style: i32 align(4) = 0,
+ cursor_visible: i32 align(4) = 0,
+ cursor_change_time: f32 align(4) = 0,
+ time_focus: f32 align(4) = 0,
+ focus: i32 align(4) = 1,
+ palette: [256][4]f32 align(16) = @splat(@splat(0)),
+ background_color: [4]f32 align(16) = @splat(0),
+ foreground_color: [4]f32 align(16) = @splat(0),
+ cursor_color: [4]f32 align(16) = @splat(0),
+ cursor_text: [4]f32 align(16) = @splat(0),
+ selection_foreground_color: [4]f32 align(16) = @splat(0),
+ selection_background_color: [4]f32 align(16) = @splat(0),
+};
+
+pub const Pass = struct {
+ scene: ?Scene = null,
+ /// A bundled pass's strength (pardesLevel); 0 for a file.
+ level: u8 = 0,
+ /// A user's file, owned; empty for a bundled pass.
+ path: []u8 = &.{},
+ pipeline: ?*Pipeline = null,
+ /// The SPIR-V revision `pipeline` was made from (ShaderBuild.Pass).
+ revision: u32 = 0,
+ /// It moves on its own (ShaderBuild.Pass).
+ animated: bool = false,
+};
+
+passes: [max]Pass = @splat(.{}),
+len: usize = 0,
+/// The chain key `passes` follow (sync); null before the first.
+key: ?u32 = null,
+bundled: std.EnumArray(Scene, ?*Pipeline) = .initFill(null),
+ping: [2]?*c.SDL_GPUTexture = .{ null, null },
+ping_w: u32 = 0,
+ping_h: u32 = 0,
+uniforms: Uniforms = .{},
+/// The display's density, for a pass whose pattern is in logical pixels
+/// (pardesScale); the shell sets it.
+scale: f32 = 1,
+/// What a bundled pass may do on this theme (pardesCap), each scene's, and
+/// the rectangles every bundled pass leaves alone (pardesSpare): both from
+/// the last frame described.
+caps: std.EnumArray(Scene, f32) = .initFill(0),
+spare: [max_spare][4]f32 = @splat(@splat(0)),
+spare_len: usize = 0,
+/// Bloom's float chain, a half the frame and down, and its two steps.
+bloom_tex: [bloom_steps[bloom_steps.len - 1]]?*c.SDL_GPUTexture = @splat(null),
+bloom_w: u32 = 0,
+bloom_h: u32 = 0,
+bloom_down: ?*Pipeline = null,
+bloom_up: ?*Pipeline = null,
+started_ns: ?u64 = null,
+last_ns: u64 = 0,
+
+/// Brings the passes to the chain a shell was given (ShaderBuild.zig: a
+/// local core's, or an attached session's over the wire), whose `key` moves
+/// whenever the chain or a file's SPIR-V does. A file whose SPIR-V has not
+/// moved keeps its pipeline; one the GPU refuses keeps its last, and is said
+/// to `core`, or logged where there is none. Each loop step, off the frame
+/// path.
+pub fn sync(post: *Post, gpa: std.mem.Allocator, device: *c.SDL_GPUDevice, format: c.SDL_GPUTextureFormat, chain: []const Built, key: u32, core: ?*pardes.Pardes) void {
+ if (post.key == key) return;
+ post.key = key;
+ var next: [max]Pass = @splat(.{});
+ for (chain, 0..) |entry, i| {
+ if (entry.scene) |scene| {
+ if (post.bundled.get(scene) == null) post.bundled.set(scene, makePipeline(device, format, bundled_spv.get(scene), if (scene == .bloom) 2 else 1, 4) catch null);
+ if (scene == .bloom and post.bloom_down == null) {
+ post.bloom_down = makePipeline(device, bloom_format, bloom_down_spv, 1, 1) catch null;
+ post.bloom_up = makePipeline(device, bloom_format, bloom_up_spv, 1, 1) catch null;
+ }
+ next[i] = .{ .scene = scene, .level = entry.level, .pipeline = post.bundled.get(scene), .animated = entry.animated };
+ continue;
+ }
+ // A file already in the chain keeps its pipeline and its path.
+ for (post.passes[0..post.len]) |*pass| {
+ if (pass.scene != null or !std.mem.eql(u8, pass.path, entry.path)) continue;
+ next[i] = pass.*;
+ pass.* = .{};
+ break;
+ } else next[i] = .{ .path = gpa.dupe(u8, entry.path) catch &.{} };
+ const pass = &next[i];
+ pass.animated = entry.animated;
+ if (pass.revision == entry.revision or entry.spirv.len == 0) continue;
+ pass.revision = entry.revision;
+ const made = makePipeline(device, format, entry.spirv, 1, 4) catch {
+ var buf: [512]u8 = undefined;
+ const text = std.fmt.bufPrint(&buf, "Shader {s}: the GPU refused it", .{entry.path}) catch "Shader: the GPU refused it";
+ if (core) |p| p.setMessage(p.active, text) else std.log.err("{s}", .{text});
+ continue;
+ };
+ if (pass.pipeline) |old| c.SDL_ReleaseGPUGraphicsPipeline(device, old);
+ pass.pipeline = made;
+ }
+ for (post.passes[0..post.len]) |pass| {
+ if (pass.scene == null) if (pass.pipeline) |pipeline| c.SDL_ReleaseGPUGraphicsPipeline(device, pipeline);
+ gpa.free(pass.path);
+ }
+ post.passes = next;
+ post.len = chain.len;
+ // An emptied chain's clock starts again with the next pass put in it.
+ if (post.len == 0) {
+ post.started_ns = null;
+ post.last_ns = 0;
+ post.uniforms.frame = 0;
+ }
+}
+
+fn makePipeline(device: *c.SDL_GPUDevice, format: c.SDL_GPUTextureFormat, frag: []const u8, samplers: u32, uniform_buffers: u32) !*Pipeline {
+ const vs = try gui.makeShader(device, vert_spv, c.SDL_GPU_SHADERSTAGE_VERTEX, 0, 0);
+ defer c.SDL_ReleaseGPUShader(device, vs);
+ const fs = try gui.makeShader(device, frag, c.SDL_GPU_SHADERSTAGE_FRAGMENT, samplers, uniform_buffers);
+ defer c.SDL_ReleaseGPUShader(device, fs);
+ var target = c.SDL_GPUColorTargetDescription{ .format = format, .blend_state = std.mem.zeroes(c.SDL_GPUColorTargetBlendState) };
+ var info = std.mem.zeroes(c.SDL_GPUGraphicsPipelineCreateInfo);
+ info.vertex_shader = vs;
+ info.fragment_shader = fs;
+ info.primitive_type = c.SDL_GPU_PRIMITIVETYPE_TRIANGLELIST;
+ 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 = &target, .num_color_targets = 1 };
+ return c.SDL_CreateGPUGraphicsPipeline(device, &info) orelse error.GpuCreate;
+}
+
+/// A pass is ready to draw.
+pub fn ready(post: *const Post) bool {
+ for (post.passes[0..post.len]) |pass| if (pass.pipeline != null) return true;
+ return false;
+}
+
+/// The chain redraws on its own (level A) as ShaderAnimation says.
+/// Only a pass that moves on its own (ShaderBuild.Pass.animated) asks for
+/// frames while idle: a still one (Bloom, Vignette, Grain, a file that reads
+/// no clock) is drawn again only with a frame of the core's.
+pub fn animating(post: *const Post, mode: pardes.config.Runtime.ShaderAnimation) bool {
+ const moving = for (post.passes[0..post.len]) |pass| {
+ if (pass.pipeline != null and pass.animated) break true;
+ } else false;
+ return moving and switch (mode) {
+ .off => false,
+ .on => post.uniforms.focus != 0,
+ .always => true,
+ };
+}
+
+/// What a frame of the core's tells the passes: where its cursor is drawn
+/// and in what, and the theme's colours.
+pub const Frame = struct {
+ pub const Cursor = struct { x0: f32, y0: f32, x1: f32, y1: f32, rgb: [3]u8, text: [3]u8, bar: bool };
+ cursor: ?Cursor,
+ /// What a bundled pass leaves alone, in framebuffer pixels: the tags,
+ /// grips and notices (and the cursor, added here).
+ spare: []const [4]f32 = &.{},
+ background: [3]u8,
+ foreground: [3]u8,
+ selection_foreground: [3]u8,
+ selection_background: [3]u8,
+};
+
+fn rgba(rgb: [3]u8) [4]f32 {
+ return .{ @as(f32, @floatFromInt(rgb[0])) / 255, @as(f32, @floatFromInt(rgb[1])) / 255, @as(f32, @floatFromInt(rgb[2])) / 255, 1 };
+}
+
+/// Takes in a frame of the core's. The cursor's rectangle is (left, BOTTOM
+/// edge, width, height) in framebuffer pixels, y down; a move or a new
+/// colour makes the old one the previous and stamps the change.
+pub fn describe(post: *Post, frame: Frame) void {
+ const u = &post.uniforms;
+ post.caps = capsOf(frame);
+ post.spare_len = 0;
+ for (frame.spare) |rect| post.addSpare(rect);
+ if (frame.cursor) |cursor| post.addSpare(.{ cursor.x0, cursor.y0, cursor.x1, cursor.y1 });
+ u.background_color = rgba(frame.background);
+ u.foreground_color = rgba(frame.foreground);
+ u.selection_foreground_color = rgba(frame.selection_foreground);
+ u.selection_background_color = rgba(frame.selection_background);
+ if (u.palette[1][3] == 0) for (&u.palette, 0..) |*slot, i| {
+ const color = ghostty_vt.color.default[i];
+ slot.* = rgba(.{ color.r, color.g, color.b });
+ };
+ u.cursor_visible = @intFromBool(frame.cursor != null);
+ const cursor = frame.cursor orelse return;
+ const rect: [4]f32 = .{ cursor.x0, cursor.y1, cursor.x1 - cursor.x0, cursor.y1 - cursor.y0 };
+ const style: i32 = if (cursor.bar) 2 else 0;
+ const color = rgba(cursor.rgb);
+ u.cursor_color = color;
+ u.cursor_text = rgba(cursor.text);
+ if (std.meta.eql(rect, u.current_cursor) and std.meta.eql(color, u.current_cursor_color) and style == u.current_cursor_style) return;
+ u.previous_cursor = u.current_cursor;
+ u.previous_cursor_color = u.current_cursor_color;
+ u.previous_cursor_style = u.current_cursor_style;
+ u.current_cursor = rect;
+ u.current_cursor_color = color;
+ u.current_cursor_style = style;
+ u.cursor_change_time = u.time;
+}
+
+/// A rectangle a bundled pass leaves alone; past `max_spare` the last one
+/// grows to cover the rest (sparing more, never less).
+fn addSpare(post: *Post, rect: [4]f32) void {
+ if (rect[2] <= rect[0] or rect[3] <= rect[1]) return;
+ if (post.spare_len < max_spare) {
+ post.spare[post.spare_len] = rect;
+ post.spare_len += 1;
+ return;
+ }
+ const last = &post.spare[max_spare - 1];
+ last.* = .{ @min(last[0], rect[0]), @min(last[1], rect[1]), @max(last[2], rect[2]), @max(last[3], rect[3]) };
+}
+
+/// sRGB's relative luminance (WCAG) and a pair's contrast.
+fn luminance(rgb: [3]f32) f32 {
+ var sum: f32 = 0;
+ for (rgb, [3]f32{ 0.2126, 0.7152, 0.0722 }) |v, weight|
+ sum += weight * (if (v <= 0.04045) v / 12.92 else std.math.pow(f32, (v + 0.055) / 1.055, 2.4));
+ return sum;
+}
+fn contrastOf(a: f32, b: f32) f32 {
+ return (@max(a, b) + 0.05) / (@min(a, b) + 0.05);
+}
+fn unit(rgb: [3]u8) [3]f32 {
+ return .{ @as(f32, @floatFromInt(rgb[0])) / 255, @as(f32, @floatFromInt(rgb[1])) / 255, @as(f32, @floatFromInt(rgb[2])) / 255 };
+}
+
+/// Each bundled pass's ceiling on this theme (pardesCap, docs/effects.md):
+/// the most it may do while the text on the page, and the selection's text
+/// on its own ground, keep min(their contrast, 4.5). Bloom adds light to
+/// both of a pair (linear, as a share of full white); a vignette darkens
+/// both (a share); grain moves the page alone, either way (sRGB units).
+pub fn capsOf(frame: Frame) std.EnumArray(Scene, f32) {
+ const pairs = [_][2][3]f32{ .{ unit(frame.foreground), unit(frame.background) }, .{ unit(frame.selection_foreground), unit(frame.selection_background) } };
+ var bloom: f32 = 1;
+ var shade: f32 = 1;
+ for (pairs) |pair| {
+ const a = luminance(pair[0]);
+ const b = luminance(pair[1]);
+ const light = @max(a, b);
+ const dark = @min(a, b);
+ const target = @min(contrastOf(a, b), 4.5);
+ // (light + e + .05) / (dark + e + .05) >= target
+ bloom = @min(bloom, @max(0, (light + 0.05 - target * (dark + 0.05)) / @max(target - 1, 1e-3)));
+ // (k light + .05) / (k dark + .05) >= target, darkened by 1 - k
+ const room = light - target * dark;
+ shade = @min(shade, if (room <= 0) 0 else std.math.clamp(1 - 0.05 * (target - 1) / room, 0, 1));
+ }
+ // Grain: the largest step off the page, up and down, that keeps the text
+ // on it at its contrast or 4.5 (searched in 1/1020 steps up to 8/255).
+ const ink = luminance(unit(frame.foreground));
+ const page = unit(frame.background);
+ const target = @min(contrastOf(ink, luminance(page)), 4.5);
+ var grain: f32 = 0;
+ var step: f32 = 0.25 / 255.0;
+ while (step <= 8.0 / 255.0) : (step += 0.25 / 255.0) {
+ var up = page;
+ var down = page;
+ for (&up, &down) |*u, *d| {
+ u.* = @min(1, u.* + step);
+ d.* = @max(0, d.* - step);
+ }
+ if (contrastOf(ink, luminance(up)) < target - 1e-4 or contrastOf(ink, luminance(down)) < target - 1e-4) break;
+ grain = step;
+ }
+ var caps: std.EnumArray(Scene, f32) = .initFill(1);
+ caps.set(.bloom, bloom);
+ caps.set(.vignette, shade);
+ caps.set(.grain, grain);
+ return caps;
+}
+
+test "no bundled pass at its ceiling takes a native theme's text or selection below its contrast or 4.5" {
+ for (pardes.themes[0..pardes.colors.native_count]) |*theme| {
+ const frame: Frame = .{ .cursor = null, .background = theme.bg orelse .{ 18, 18, 18 }, .foreground = theme.fg orelse .{ 204, 204, 204 }, .selection_foreground = theme.sel_fg, .selection_background = theme.sel_bg };
+ const caps = capsOf(frame);
+ for ([_][2][3]u8{ .{ frame.foreground, frame.background }, .{ frame.selection_foreground, frame.selection_background } }, 0..) |pair, i| {
+ const a = luminance(unit(pair[0]));
+ const b = luminance(unit(pair[1]));
+ const target = @min(contrastOf(a, b), 4.5) - 1e-3;
+ // Bloom at its ceiling, over both.
+ const e = @min(caps.get(.bloom), 0.05);
+ try std.testing.expect(contrastOf(a + e, b + e) >= target);
+ // The vignette at its ceiling, over both.
+ const k = 1 - @min(caps.get(.vignette), 0.28);
+ try std.testing.expect(contrastOf(a * k, b * k) >= target);
+ // Grain moves the page alone.
+ if (i == 0) {
+ var up = unit(pair[1]);
+ for (&up) |*v| v.* = @min(1, v.* + caps.get(.grain));
+ try std.testing.expect(contrastOf(a, luminance(up)) >= target);
+ }
+ }
+ }
+}
+
+/// The window gained or lost the focus.
+pub fn focus(post: *Post, focused: bool) void {
+ if (focused and post.uniforms.focus == 0) post.uniforms.time_focus = post.uniforms.time;
+ post.uniforms.focus = @intFromBool(focused);
+}
+
+/// The pointer, in framebuffer pixels: Shadertoy's iMouse, xy where it is,
+/// zw where the last press was, negative once released.
+pub fn mouse(post: *Post, x: f32, y: f32, press: ?bool) void {
+ const m = &post.uniforms.mouse;
+ m[0] = x;
+ m[1] = y;
+ if (press) |down| {
+ if (down) {
+ m[2] = x;
+ m[3] = y;
+ } else {
+ m[2] = -@abs(m[2]);
+ m[3] = -@abs(m[3]);
+ }
+ }
+}
+
+/// Runs the passes over `source`, the finished frame, into `target`: each
+/// reads the one before, the ones between write two ping-pong textures that
+/// start cleared, and iTime and iFrame move by this one draw.
+pub fn draw(post: *Post, device: *c.SDL_GPUDevice, cmd: *c.SDL_GPUCommandBuffer, sampler: *c.SDL_GPUSampler, format: c.SDL_GPUTextureFormat, source: *c.SDL_GPUTexture, target: *c.SDL_GPUTexture, w: u32, h: u32, now_ns: u64, opaque_window: bool) !void {
+ var live: usize = 0;
+ for (post.passes[0..post.len]) |pass| live += @intFromBool(pass.pipeline != null);
+ if (live == 0) return;
+ if (live > 1 and (post.ping[0] == null or post.ping_w != w or post.ping_h != h)) {
+ for (&post.ping) |*texture| {
+ if (texture.*) |old| c.SDL_ReleaseGPUTexture(device, old);
+ var info = std.mem.zeroes(c.SDL_GPUTextureCreateInfo);
+ info.type = c.SDL_GPU_TEXTURETYPE_2D;
+ info.format = format;
+ info.usage = c.SDL_GPU_TEXTUREUSAGE_COLOR_TARGET | c.SDL_GPU_TEXTUREUSAGE_SAMPLER;
+ info.width = w;
+ info.height = h;
+ info.layer_count_or_depth = 1;
+ info.num_levels = 1;
+ info.sample_count = c.SDL_GPU_SAMPLECOUNT_1;
+ texture.* = c.SDL_CreateGPUTexture(device, &info) orelse return error.GpuCreate;
+ }
+ post.ping_w = w;
+ post.ping_h = h;
+ }
+ const u = &post.uniforms;
+ const started = post.started_ns orelse now_ns;
+ post.started_ns = started;
+ const elapsed = @as(f64, @floatFromInt(now_ns -| started)) / std.time.ns_per_s;
+ const delta: f32 = if (post.last_ns == 0) 0 else @floatCast(@as(f64, @floatFromInt(now_ns -| post.last_ns)) / std.time.ns_per_s);
+ post.last_ns = now_ns;
+ u.time = @floatCast(elapsed);
+ u.time_delta = delta;
+ u.frame_rate = if (delta > 0) 1 / delta else 60;
+ u.resolution = .{ @floatFromInt(w), @floatFromInt(h), 1 };
+ u.channel_resolution[0] = .{ @floatFromInt(w), @floatFromInt(h), 1, 0 };
+ // UTC: the year, the month from 0, the day, the second of the day.
+ var wall: libc.timespec = undefined;
+ if (libc.clock_gettime(.REALTIME, &wall) != 0) wall.sec = 0;
+ const epoch: std.time.epoch.EpochSeconds = .{ .secs = @intCast(@max(0, wall.sec)) };
+ const day = epoch.getEpochDay().calculateYearDay();
+ const month = day.calculateMonthDay();
+ u.date = .{ @floatFromInt(day.year), @floatFromInt(month.month.numeric() - 1), @floatFromInt(month.day_index + 1), @floatFromInt(epoch.getDaySeconds().secs) };
+
+ var input = source;
+ var index: usize = 0;
+ for (post.passes[0..post.len]) |pass| {
+ const pipeline = pass.pipeline orelse continue;
+ index += 1;
+ const last = index == live;
+ const output = if (last) target else post.ping[index % 2].?;
+ var info = std.mem.zeroes(c.SDL_GPUColorTargetInfo);
+ info.texture = output;
+ info.load_op = if (last) c.SDL_GPU_LOADOP_DONT_CARE else c.SDL_GPU_LOADOP_CLEAR;
+ info.store_op = c.SDL_GPU_STOREOP_STORE;
+ // Bloom's glow first, from this pass's input, at half size and down.
+ // A chain that could not be made adds no glow, and the pass is the
+ // frame as it was.
+ const glow = if (pass.scene == .bloom) post.bloomChain(device, cmd, sampler, input, w, h, pass.level) catch null else null;
+ const pass_rp = c.SDL_BeginGPURenderPass(cmd, &info, 1, null);
+ c.SDL_BindGPUGraphicsPipeline(pass_rp, pipeline);
+ const bindings = [2]c.SDL_GPUTextureSamplerBinding{ .{ .texture = input, .sampler = sampler }, .{ .texture = glow orelse input, .sampler = sampler } };
+ c.SDL_BindGPUFragmentSamplers(pass_rp, 0, &bindings, if (pass.scene == .bloom) 2 else 1);
+ pushUniforms(cmd, u);
+ var own: Own = .{
+ .opaque_window = @floatFromInt(@intFromBool(opaque_window)),
+ .level = @floatFromInt(pass.level),
+ .scale = post.scale,
+ // A user's file has no ceiling of ours, and no spared rectangles.
+ .cap = if (pass.scene) |scene| (if (scene == .bloom and glow == null) 0 else post.caps.get(scene)) else 1,
+ .spare_count = if (pass.scene != null) @floatFromInt(post.spare_len) else 0,
+ };
+ if (pass.scene != null) @memcpy(own.spare[0..post.spare_len], post.spare[0..post.spare_len]);
+ c.SDL_PushGPUFragmentUniformData(cmd, 3, &own, @sizeOf(Own));
+ c.SDL_DrawGPUPrimitives(pass_rp, 3, 1, 0, 0);
+ c.SDL_EndGPURenderPass(pass_rp);
+ input = output;
+ }
+ u.frame +%= 1;
+}
+
+/// ghostty's block as the prefix cuts it (SDL GPU binds at most 4 KiB of a
+/// block): the globals up to the palette, the palette, the colours after it,
+/// each a slice of the one struct, at set 3 bindings 0 to 2.
+fn pushUniforms(cmd: *c.SDL_GPUCommandBuffer, u: *const Uniforms) void {
+ const bytes = std.mem.asBytes(u);
+ const palette = @offsetOf(Uniforms, "palette");
+ const colors = @offsetOf(Uniforms, "background_color");
+ c.SDL_PushGPUFragmentUniformData(cmd, 0, bytes.ptr, @intCast(palette));
+ c.SDL_PushGPUFragmentUniformData(cmd, 1, bytes.ptr + palette, @intCast(colors - palette));
+ c.SDL_PushGPUFragmentUniformData(cmd, 2, bytes.ptr + colors, @intCast(@sizeOf(Uniforms) - colors));
+}
+
+test "each slice of the uniforms fits the 4 KiB SDL GPU binds of a block" {
+ try std.testing.expect(@offsetOf(Uniforms, "palette") <= 4096);
+ try std.testing.expect(@offsetOf(Uniforms, "background_color") - @offsetOf(Uniforms, "palette") <= 4096);
+ try std.testing.expect(@sizeOf(Uniforms) - @offsetOf(Uniforms, "background_color") <= 4096);
+ try std.testing.expect(@sizeOf(Own) <= 4096);
+}
+
+/// Bloom's glow of `input` (w x h): a bright pass and dual Kawase steps
+/// down to 1/2^n of the frame and back up to a half, in float textures;
+/// the half-size result, for the composite (shaders/post/bloom.glsl).
+fn bloomChain(post: *Post, device: *c.SDL_GPUDevice, cmd: *c.SDL_GPUCommandBuffer, sampler: *c.SDL_GPUSampler, input: *c.SDL_GPUTexture, w: u32, h: u32, level: u8) !*c.SDL_GPUTexture {
+ const down = post.bloom_down orelse return error.GpuCreate;
+ const up = post.bloom_up orelse return error.GpuCreate;
+ const steps = bloom_steps[std.math.clamp(level, 1, 3) - 1];
+ if (post.bloom_tex[0] == null or post.bloom_w != w or post.bloom_h != h) {
+ for (&post.bloom_tex, 0..) |*texture, i| {
+ if (texture.*) |old| c.SDL_ReleaseGPUTexture(device, old);
+ var info = std.mem.zeroes(c.SDL_GPUTextureCreateInfo);
+ info.type = c.SDL_GPU_TEXTURETYPE_2D;
+ info.format = bloom_format;
+ info.usage = c.SDL_GPU_TEXTUREUSAGE_COLOR_TARGET | c.SDL_GPU_TEXTUREUSAGE_SAMPLER;
+ info.width = @max(1, w >> @intCast(i + 1));
+ info.height = @max(1, h >> @intCast(i + 1));
+ info.layer_count_or_depth = 1;
+ info.num_levels = 1;
+ info.sample_count = c.SDL_GPU_SAMPLECOUNT_1;
+ texture.* = c.SDL_CreateGPUTexture(device, &info) orelse return error.GpuCreate;
+ }
+ post.bloom_w = w;
+ post.bloom_h = h;
+ }
+ const Step = extern struct { texels: [4]f32, pass: [4]f32 };
+ const size = struct {
+ fn of(full: u32, i: usize) f32 {
+ return @floatFromInt(if (i == 0) full else @max(1, full >> @intCast(i)));
+ }
+ };
+ // Down: the frame (0) to 1, 1 to 2, ...; the first through the bright
+ // pass (a channel's linear peak over 0.6 to 0.75, by level).
+ const threshold: f32 = switch (std.math.clamp(level, 1, 3)) {
+ 1 => 0.75,
+ 2 => 0.7,
+ else => 0.6,
+ };
+ // Only what is brighter than the page glows: on a light page, where the
+ // ground itself would pass, nothing does.
+ const page_peak = peak: {
+ var peak: f32 = 0;
+ for (post.uniforms.background_color[0..3]) |v| peak = @max(peak, if (v <= 0.04045) v / 12.92 else std.math.pow(f32, (v + 0.055) / 1.055, 2.4));
+ break :peak peak;
+ };
+ for (0..steps) |i| {
+ const from = if (i == 0) input else post.bloom_tex[i - 1].?;
+ const to = post.bloom_tex[i].?;
+ const params: Step = .{
+ .texels = .{ 1 / size.of(w, i), 1 / size.of(h, i), 1 / size.of(w, i + 1), 1 / size.of(h, i + 1) },
+ .pass = .{ if (i == 0) @max(threshold, page_peak + 0.15) else 0, 0.25, 0, 0 },
+ };
+ bloomStep(cmd, down, sampler, from, to, &params, @sizeOf(Step));
+ }
+ // Up: each level into the one above it, back to the half.
+ var i: usize = steps - 1;
+ while (i > 0) : (i -= 1) {
+ const params: Step = .{
+ .texels = .{ 1 / size.of(w, i + 1), 1 / size.of(h, i + 1), 1 / size.of(w, i), 1 / size.of(h, i) },
+ .pass = @splat(0),
+ };
+ bloomStep(cmd, up, sampler, post.bloom_tex[i].?, post.bloom_tex[i - 1].?, &params, @sizeOf(Step));
+ }
+ return post.bloom_tex[0].?;
+}
+
+fn bloomStep(cmd: *c.SDL_GPUCommandBuffer, pipeline: *Pipeline, sampler: *c.SDL_GPUSampler, from: *c.SDL_GPUTexture, to: *c.SDL_GPUTexture, params: *const anyopaque, len: u32) void {
+ var info = std.mem.zeroes(c.SDL_GPUColorTargetInfo);
+ info.texture = to;
+ info.load_op = c.SDL_GPU_LOADOP_DONT_CARE;
+ info.store_op = c.SDL_GPU_STOREOP_STORE;
+ const rp = c.SDL_BeginGPURenderPass(cmd, &info, 1, null);
+ c.SDL_BindGPUGraphicsPipeline(rp, pipeline);
+ const binding = c.SDL_GPUTextureSamplerBinding{ .texture = from, .sampler = sampler };
+ c.SDL_BindGPUFragmentSamplers(rp, 0, &binding, 1);
+ c.SDL_PushGPUFragmentUniformData(cmd, 0, params, len);
+ c.SDL_DrawGPUPrimitives(rp, 3, 1, 0, 0);
+ c.SDL_EndGPURenderPass(rp);
+}
+
+pub fn deinit(post: *Post, gpa: std.mem.Allocator, device: *c.SDL_GPUDevice) void {
+ for (post.bloom_tex) |texture| if (texture) |t| c.SDL_ReleaseGPUTexture(device, t);
+ for ([_]?*Pipeline{ post.bloom_down, post.bloom_up }) |pipeline| if (pipeline) |p| c.SDL_ReleaseGPUGraphicsPipeline(device, p);
+ for (post.passes[0..post.len]) |pass| {
+ if (pass.scene == null) if (pass.pipeline) |pipeline| c.SDL_ReleaseGPUGraphicsPipeline(device, pipeline);
+ gpa.free(pass.path);
+ }
+ for (post.bundled.values) |pipeline| if (pipeline) |p| c.SDL_ReleaseGPUGraphicsPipeline(device, p);
+ for (post.ping) |texture| if (texture) |t| c.SDL_ReleaseGPUTexture(device, t);
+}
+
+/// ghostty 1.4.0's Uniforms (src/renderer/shadertoy.zig), copied: the offsets
+/// ours must match. Its last two names are swapped against its own GLSL.
+const GhosttyUniforms = extern struct {
+ resolution: [3]f32 align(16),
+ time: f32 align(4),
+ time_delta: f32 align(4),
+ frame_rate: f32 align(4),
+ frame: i32 align(4),
+ channel_time: [4][4]f32 align(16),
+ channel_resolution: [4][4]f32 align(16),
+ mouse: [4]f32 align(16),
+ date: [4]f32 align(16),
+ sample_rate: f32 align(4),
+ current_cursor: [4]f32 align(16),
+ previous_cursor: [4]f32 align(16),
+ current_cursor_color: [4]f32 align(16),
+ previous_cursor_color: [4]f32 align(16),
+ current_cursor_style: i32 align(4),
+ previous_cursor_style: i32 align(4),
+ cursor_visible: i32 align(4),
+ cursor_change_time: f32 align(4),
+ time_focus: f32 align(4),
+ focus: i32 align(4),
+ palette: [256][4]f32 align(16),
+ background_color: [4]f32 align(16),
+ foreground_color: [4]f32 align(16),
+ cursor_color: [4]f32 align(16),
+ cursor_text: [4]f32 align(16),
+ selection_background_color: [4]f32 align(16),
+ selection_foreground_color: [4]f32 align(16),
+};
+
+test "the uniform block is ghostty's, offset for offset, and the prefix names it in that order" {
+ const ours = @typeInfo(Uniforms).@"struct";
+ const theirs = @typeInfo(GhosttyUniforms).@"struct";
+ try std.testing.expectEqual(theirs.field_names.len, ours.field_names.len);
+ try std.testing.expectEqual(@sizeOf(GhosttyUniforms), @sizeOf(Uniforms));
+ inline for (ours.field_names, ours.field_types, theirs.field_names, theirs.field_types) |a, a_type, b, b_type| {
+ try std.testing.expectEqual(@offsetOf(GhosttyUniforms, b), @offsetOf(Uniforms, a));
+ try std.testing.expectEqual(b_type, a_type);
+ }
+ // By NAME: iSelectionForegroundColor sits where ghostty's Zig says
+ // selection_background, which is where its GLSL puts the foreground.
+ try std.testing.expectEqual(@offsetOf(GhosttyUniforms, "selection_background_color"), @offsetOf(Uniforms, "selection_foreground_color"));
+ // The prefix's block, member by member, in ghostty's GLSL names and types.
+ const glsl = [_]struct { []const u8, []const u8 }{
+ .{ "vec3", "iResolution" }, .{ "float", "iTime" }, .{ "float", "iTimeDelta" },
+ .{ "float", "iFrameRate" }, .{ "int", "iFrame" }, .{ "float", "iChannelTime[4]" },
+ .{ "vec3", "iChannelResolution[4]" }, .{ "vec4", "iMouse" }, .{ "vec4", "iDate" },
+ .{ "float", "iSampleRate" }, .{ "vec4", "iCurrentCursor" }, .{ "vec4", "iPreviousCursor" },
+ .{ "vec4", "iCurrentCursorColor" }, .{ "vec4", "iPreviousCursorColor" }, .{ "int", "iCurrentCursorStyle" },
+ .{ "int", "iPreviousCursorStyle" }, .{ "int", "iCursorVisible" }, .{ "float", "iTimeCursorChange" },
+ .{ "float", "iTimeFocus" }, .{ "int", "iFocus" }, .{ "vec3", "iPalette[256]" },
+ .{ "vec3", "iBackgroundColor" }, .{ "vec3", "iForegroundColor" }, .{ "vec3", "iCursorColor" },
+ .{ "vec3", "iCursorText" }, .{ "vec3", "iSelectionForegroundColor" }, .{ "vec3", "iSelectionBackgroundColor" },
+ };
+ try std.testing.expectEqual(ours.field_names.len, glsl.len);
+ // Its three blocks (Globals, Palette, Colors) read as one, in order.
+ const start = std.mem.indexOf(u8, prefix, "uniform Globals {").?;
+ const end = std.mem.indexOf(u8, prefix, "uniform PardesPost {").?;
+ var lines = std.mem.tokenizeScalar(u8, prefix[start..end], '\n');
+ var n: usize = 0;
+ while (lines.next()) |line| {
+ if (!std.mem.startsWith(u8, line, " uniform ")) continue;
+ var words = std.mem.tokenizeAny(u8, line, " ;");
+ try std.testing.expectEqualStrings("uniform", words.next().?);
+ try std.testing.expectEqualStrings(glsl[n][0], words.next().?);
+ try std.testing.expectEqualStrings(glsl[n][1], words.next().?);
+ n += 1;
+ }
+ try std.testing.expectEqual(glsl.len, n);
+ // Each block starts where its first member is in the one struct.
+ try std.testing.expect(std.mem.indexOf(u8, prefix, "uniform Palette {\n uniform vec3 iPalette[256];\n};") != null);
+}
+
+test "a moved cursor becomes the previous one, stamped with the time of the move" {
+ var post: Post = .{};
+ const frame: Frame = .{ .cursor = .{ .x0 = 10, .y0 = 20, .x1 = 11, .y1 = 40, .rgb = .{ 255, 0, 0 }, .text = .{ 0, 0, 0 }, .bar = true }, .background = .{ 0, 0, 0 }, .foreground = .{ 255, 255, 255 }, .selection_foreground = .{ 1, 2, 3 }, .selection_background = .{ 4, 5, 6 } };
+ post.uniforms.time = 1.5;
+ post.describe(frame);
+ // Left, BOTTOM edge, width, height, in framebuffer pixels, y down.
+ try std.testing.expectEqual([4]f32{ 10, 40, 1, 20 }, post.uniforms.current_cursor);
+ try std.testing.expectEqual(@as(i32, 2), post.uniforms.current_cursor_style);
+ try std.testing.expectEqual(@as(f32, 1.5), post.uniforms.cursor_change_time);
+ post.uniforms.time = 2;
+ post.describe(frame);
+ try std.testing.expectEqual(@as(f32, 1.5), post.uniforms.cursor_change_time);
+ var moved = frame;
+ moved.cursor.?.x0 = 20;
+ moved.cursor.?.x1 = 21;
+ post.describe(moved);
+ try std.testing.expectEqual([4]f32{ 10, 40, 1, 20 }, post.uniforms.previous_cursor);
+ try std.testing.expectEqual(@as(f32, 2), post.uniforms.cursor_change_time);
+ try std.testing.expectEqual([4]f32{ 1.0 / 255.0, 2.0 / 255.0, 3.0 / 255.0, 1 }, post.uniforms.selection_foreground_color);
+}
+
+test "a still pass asks for no idle frames; one that reads the clock does" {
+ var post: Post = .{};
+ const fake: *Pipeline = @ptrFromInt(0x1000);
+ post.passes[0] = .{ .scene = .bloom, .level = 2, .pipeline = fake };
+ post.len = 1;
+ try std.testing.expect(!post.animating(.on) and !post.animating(.always));
+ post.passes[1] = .{ .scene = .crt, .level = 2, .pipeline = fake, .animated = true };
+ post.len = 2;
+ try std.testing.expect(post.animating(.on) and post.animating(.always) and !post.animating(.off));
+ // Unfocused, `on` rests.
+ post.uniforms.focus = 0;
+ try std.testing.expect(!post.animating(.on) and post.animating(.always));
+}
diff --git a/src/gui/crt.zig b/src/gui/crt.zig
deleted file mode 100644
index 2a5ea7e4..00000000
--- a/src/gui/crt.zig
+++ /dev/null
@@ -1,101 +0,0 @@
-//! The Crt builtin's screen geometry, shared between the gui shell's input
-//! mapping and its shader: crt.frag.glsl shows the scene point
-//! uv' = cc*(1 + barrel*r2) at screen point cc, so a physical mouse position
-//! must pass through the SAME forward transform before it becomes a cell.
-//! Pure std, so the unit-test step can pin it against the shader formula.
-
-const std = @import("std");
-
-/// MUST match BARREL in shaders/crt.frag.glsl.
-pub const barrel: f32 = 0.016;
-
-pub const Point = struct { x: f32, y: f32 };
-pub const Effects = struct { crt: bool = false, ripple: bool = false, glitch: bool = false };
-pub const Frame = struct { effects: Effects = .{}, time_seconds: f32 = 0 };
-
-fn fract(x: f32) f32 {
- return x - @floor(x);
-}
-
-fn smoothstep(lo: f32, hi: f32, value: f32) f32 {
- const t = std.math.clamp((value - lo) / (hi - lo), 0, 1);
- return t * t * (3 - 2 * t);
-}
-
-/// Match `sceneUv` in crt.frag.glsl. This is a forward screen→sample mapping:
-/// a physical pointer is sent to the logical scene pixel displayed under it.
-pub fn mapScene(x: f32, y: f32, w: f32, h: f32, effects: Effects, time_seconds: f32) ?Point {
- const safe_w = @max(1, w);
- const safe_h = @max(1, h);
- const ccx = x / safe_w * 2.0 - 1.0;
- const ccy = y / safe_h * 2.0 - 1.0;
- const s = 1.0 + barrel * (ccx * ccx + ccy * ccy) * @as(f32, @floatFromInt(@intFromBool(effects.crt)));
- var u = ccx * s * 0.5 + 0.5;
- var v = ccy * s * 0.5 + 0.5;
- // The CRT shader paints no scene when this barrel-mapped coordinate lies
- // on or beyond the tube edge. There is no logical edge cell under those
- // black pixels, so input must be inert there rather than clamped.
- if (effects.crt and (u <= 0 or u >= 1 or v <= 0 or v >= 1)) return null;
- if (effects.ripple) {
- const cx = u - 0.5;
- const cy = v - 0.5;
- const radius = @sqrt(cx * cx + cy * cy);
- const envelope = 1.0 - smoothstep(0.04, 0.72, radius);
- const wave = @sin(radius * 42.0 - time_seconds * 5.2);
- const len = @max(radius, 0.00001);
- u += cx / len * wave * envelope * 0.0032;
- v += cy / len * wave * envelope * 0.0032;
- }
- if (effects.glitch) {
- const band = @floor(v * 96.0);
- const tick = @floor(time_seconds * 13.0);
- const seed = noiseAt(band, tick);
- const tear = smoothstep(0.955, 1.0, seed);
- u += (noiseAt(seed, band) - 0.5) * tear * 0.020;
- }
- return .{
- .x = std.math.clamp(u * safe_w, 0, safe_w - 1),
- .y = std.math.clamp(v * safe_h, 0, safe_h - 1),
- };
-}
-
-fn noiseAt(x: f32, y: f32) f32 {
- var qx = fract(x * 0.1031);
- var qy = fract(y * 0.1031);
- var qz = fract(x * 0.1031);
- const d = qx * (qy + 33.33) + qy * (qz + 33.33) + qz * (qx + 33.33);
- qx += d;
- qy += d;
- qz += d;
- return fract((qx + qy) * qz);
-}
-
-test "map matches the shader's barrel formula" {
- // center is a fixed point
- const center = mapScene(500, 250, 1000, 500, .{ .crt = true }, 0).?;
- try std.testing.expectApproxEqAbs(@as(f32, 500), center.x, 0.001);
- try std.testing.expectApproxEqAbs(@as(f32, 250), center.y, 0.001);
- // Corners barrel beyond the tube and are black/inert in the shader.
- try std.testing.expect(mapScene(0, 0, 1000, 500, .{ .crt = true }, 0) == null);
- try std.testing.expect(mapScene(1000, 500, 1000, 500, .{ .crt = true }, 0) == null);
- // (100,100) of 1000x500: cc=(-0.8,-0.6), r2=1.0, s=1.016 ->
- // cc'=(-0.8128,-0.6096) -> (93.6, 97.6)
- const near_edge = mapScene(100, 100, 1000, 500, .{ .crt = true }, 0).?;
- try std.testing.expectApproxEqAbs(@as(f32, 93.6), near_edge.x, 0.01);
- try std.testing.expectApproxEqAbs(@as(f32, 97.6), near_edge.y, 0.01);
- // (900,250): cc=(0.8,0), r2=0.64, s=1.01024 -> x'=904.096
- const side = mapScene(900, 250, 1000, 500, .{ .crt = true }, 0).?;
- try std.testing.expectApproxEqAbs(@as(f32, 904.096), side.x, 0.01);
-}
-
-test "scene mapping composes ripple and deterministic glitch" {
- const plain = mapScene(300, 200, 800, 600, .{}, 2.5).?;
- try std.testing.expectApproxEqAbs(@as(f32, 300), plain.x, 0.001);
- try std.testing.expectApproxEqAbs(@as(f32, 200), plain.y, 0.001);
- const ripple = mapScene(300, 200, 800, 600, .{ .ripple = true }, 2.5).?;
- try std.testing.expect(ripple.x != plain.x or ripple.y != plain.y);
- try std.testing.expectEqual(
- mapScene(300, 200, 800, 600, .{ .glitch = true }, 2.5).?,
- mapScene(300, 200, 800, 600, .{ .glitch = true }, 2.5).?,
- );
-}
diff --git a/src/gui/font.c b/src/gui/font.c
index 5989dd4e..aebe26e6 100644
--- a/src/gui/font.c
+++ b/src/gui/font.c
@@ -1,16 +1,41 @@
-// FreeType 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.
+// 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 <stdlib.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) {
@@ -38,28 +63,74 @@ static FT_Int32 load_flags(void) {
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 *)calloc(1, sizeof(UIFont));
+ UIFont *f = (UIFont *)ui_calloc(1, sizeof(UIFont));
if (!f)
return NULL;
- if (FT_Init_FreeType(&f->library) != 0) {
- free(f);
+ // 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_FreeType(f->library);
- free(f);
+ 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;
@@ -71,27 +142,39 @@ const char *ui_font_name(UIFont *f) {
return NULL;
}
-int ui_font_has_glyph(UIFont *f, int32_t cp) {
+uint32_t ui_font_glyph(UIFont *f, int32_t cp) {
if (!f || cp < 0)
return 0;
- return FT_Get_Char_Index(f->face, (FT_ULong)(uint32_t)cp) != 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_FreeType(f->library);
- free(f);
+ FT_Done_Library(f->library);
+ ui_free(f->own);
+ ui_free(f->state);
+ ui_free(f);
}
-float ui_font_scale_for_height(UIFont *f, float px) {
- (void)f;
- // Kept as a size token so the Zig renderer can continue to distinguish
- // measurement size from high-DPI raster size.
- return px;
+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,
@@ -126,20 +209,35 @@ void ui_font_cell_metrics(UIFont *f, float px, int32_t *cell_w, int32_t *cell_h,
*ascent = asc > 0 ? asc : 1;
}
-static int raster(UIFont *f, float px, int32_t cp, uint8_t *out,
- int32_t stride, int32_t cell_w, int32_t cell_h,
- int32_t ascent, int centered) {
- if (!f || !out || stride < cell_w || cell_w <= 0 || cell_h <= 0)
+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 < cell_h; y++)
- memset(out + (size_t)y * (size_t)stride, 0, (size_t)cell_w);
+ 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;
- const FT_UInt glyph_index =
- FT_Get_Char_Index(f->face, (FT_ULong)(uint32_t)cp);
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;
@@ -151,23 +249,24 @@ static int raster(UIFont *f, float px, int32_t cp, uint8_t *out,
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 ? (cell_w - (int)bitmap->width) / 2
- : glyph->bitmap_left + (cell_w - advance) / 2;
- const int gy = centered ? (cell_h - (int)bitmap->rows) / 2
- : ascent - glyph->bitmap_top;
+ 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 >= cell_h)
+ 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 >= cell_w)
+ if (dx < 0 || dx >= width)
continue;
uint8_t coverage;
@@ -187,13 +286,186 @@ static int raster(UIFont *f, float px, int32_t cp, uint8_t *out,
return 1;
}
-int ui_font_raster(UIFont *f, float px, int32_t cp, uint8_t *out,
- int32_t stride, int32_t cell_w, int32_t cell_h,
- int32_t ascent) {
- return raster(f, px, cp, out, stride, cell_w, cell_h, ascent, 0);
+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);
}
-int ui_font_raster_centered(UIFont *f, float px, int32_t cp, uint8_t *out,
- int32_t stride, int32_t width, int32_t height) {
- return raster(f, px, cp, out, stride, width, height, 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/src/gui/font.h b/src/gui/font.h
index d965b418..db964fb0 100644
--- a/src/gui/font.h
+++ b/src/gui/font.h
@@ -1,8 +1,10 @@
-// Tiny C shim over FreeType, so gui.zig only imports the stable renderer API.
-// The implementation owns FreeType's library and face objects and keeps the
-// caller's font bytes borrowed for the face lifetime.
+// 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
@@ -11,6 +13,15 @@ extern "C" {
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);
@@ -20,30 +31,67 @@ UIFont *ui_font_new(const uint8_t *data, int32_t len);
// font has no PostScript table. Borrowed for the UIFont lifetime.
const char *ui_font_name(UIFont *f);
-// Whether the selected Unicode charmap maps `cp` to a real glyph. Glyph zero is
-// the face's .notdef box and deliberately does not count for fallback choice.
-int ui_font_has_glyph(UIFont *f, int32_t cp);
+// 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);
-// The size token is a pixel height. Metrics and rasterization both configure
-// FreeType at that size, so hinted advances, baseline and bitmaps stay in step.
-float ui_font_scale_for_height(UIFont *f, float px);
+// `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);
-// Rasterize `cp` into `out` as a hinted grayscale cell mask (`stride` bytes per
-// row). The origin is the baseline `ascent` pixels from the top. Pixels outside
-// the glyph are zero. Missing codepoints render the face's .notdef glyph.
-// Returns 1 when the glyph produced coverage, 0 for blank/error.
-int ui_font_raster(UIFont *f, float px, int32_t cp, uint8_t *out,
- int32_t stride, 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, int32_t cp, uint8_t *out,
- int32_t stride, int32_t width, int32_t height);
+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
diff --git a/src/gui/gui.zig b/src/gui/gui.zig
index d871e55e..01272b41 100644
--- a/src/gui/gui.zig
+++ b/src/gui/gui.zig
@@ -6,25 +6,26 @@ const libc = std.c;
const vaxis = @import("vaxis"); // test modes only: the stdin escape-seq parser
const ghostty_vt = @import("ghostty-vt"); // 256-color palette for .index cells
const pardes = @import("../pardes.zig");
+const vaxis_input = @import("../vaxis_input.zig");
+const dump = @import("../dump.zig");
const config = @import("../config.zig");
const look = @import("../look.zig");
-const message = pardes.Pardes.Message;
+const message = pardes.Messages.Message;
const file_watch = @import("../file_watch.zig");
+const ShaderBuild = @import("../ShaderBuild.zig");
const deck = @import("deck.zig");
-const crt = @import("crt.zig");
+const Post = @import("Post.zig");
const pet = @import("pet.zig");
const fonts = @import("../fonts.zig"); // the Font builtin's half of the seam
const selection_pipe = @import("../selection_pipe.zig");
+const c_heap = @import("c_heap");
const ninep_io = @import("../9p_io.zig");
const detached_client = @import("../detached/client.zig");
+const tracy = @import("../tracy.zig");
-pub const c = @cImport({
- @cDefine("SDL_DISABLE_OLD_NAMES", "1");
- @cInclude("SDL3/SDL.h");
- @cInclude("font.h");
-});
+pub const c = @import("gui_c"); // SDL3 and font.h, translated by build.zig
const host_io = @import("../host_io.zig");
extern "c" fn setenv(name: [*:0]const u8, value: [*:0]const u8, overwrite: c_int) c_int;
@@ -35,12 +36,11 @@ const log = std.log.scoped(.gui);
const font_ttf = @embedFile("AdwaitaMono-Regular.ttf");
const vert_spv = @embedFile("ui.vert.spv");
const frag_spv = @embedFile("ui.frag.spv");
+const decor_frag_spv = @embedFile("decor.frag.spv");
const overlay_vert_spv = @embedFile("overlay.vert.spv");
const overlay_frag_spv = @embedFile("overlay.frag.spv");
const image_vert_spv = @embedFile("image.vert.spv");
const image_frag_spv = @embedFile("image.frag.spv");
-const crt_vert_spv = @embedFile("crt.vert.spv");
-const crt_frag_spv = @embedFile("crt.frag.spv");
const bg_default = [3]u8{ 18, 18, 18 };
const fg_default = [3]u8{ 204, 204, 204 };
@@ -54,11 +54,6 @@ const Ground = struct {
}
};
-fn ground(theme_bg: ?[3]u8, transparent: bool) Ground {
- if (theme_bg) |rgb| return .opaqueRgb(rgb);
- return .{ .rgb = bg_default, .clear = transparent };
-}
-
const p9_arrow_clr = [32]u8{
0xFF, 0xFF, 0x80, 0x01, 0x80, 0x02, 0x80, 0x0C,
0x80, 0x10, 0x80, 0x10, 0x80, 0x08, 0x80, 0x04,
@@ -71,6 +66,24 @@ const p9_arrow_set = [32]u8{
0x7F, 0xFC, 0x7F, 0xFE, 0x7F, 0xFC, 0x73, 0xF8,
0x61, 0xF0, 0x60, 0xE0, 0x40, 0x40, 0x00, 0x00,
};
+/// acme's boxcursor (acme.c:956), while a grip carries a pane or column.
+const p9_box_clr = [32]u8{
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xF8, 0x1F, 0xF8, 0x1F, 0xF8, 0x1F,
+ 0xF8, 0x1F, 0xF8, 0x1F, 0xF8, 0x1F, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+};
+const p9_box_set = [32]u8{
+ 0x00, 0x00, 0x7F, 0xFE, 0x7F, 0xFE, 0x7F, 0xFE,
+ 0x70, 0x0E, 0x70, 0x0E, 0x70, 0x0E, 0x70, 0x0E,
+ 0x70, 0x0E, 0x70, 0x0E, 0x70, 0x0E, 0x70, 0x0E,
+ 0x7F, 0xFE, 0x7F, 0xFE, 0x7F, 0xFE, 0x00, 0x00,
+};
+const p9_box_mask = blk: {
+ var m: [32]u8 = undefined;
+ for (&m, p9_box_set, p9_box_clr) |*b, s, cl| b.* = s | cl;
+ break :blk m;
+};
const p9_arrow_mask = blk: {
var m: [32]u8 = undefined;
for (&m, p9_arrow_set, p9_arrow_clr) |*b, s, cl| b.* = s | cl;
@@ -80,14 +93,65 @@ const p9_arrow_mask = blk: {
const atlas_w: u32 = 2048;
const atlas_h: u32 = 2048;
const Slot = struct { u: u32, v: u32 };
-const GlyphKey = struct {
- codepoint: u32,
- centered: bool = false,
+/// 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.
+const GlyphKey = packed struct(u64) {
+ face: u8,
+ glyph: u32,
role: pardes.FontRole,
decoration: GlyphDecoration = .{},
+ 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,
};
-const GlyphDecoration = struct {
+/// 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.
+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,
+ };
+}
+
+fn drawRule(out: [*]u8, stride: usize, width: usize, height: usize, arms: [4]bool) void {
+ if (width == 0 or height == 0) return;
+ const t: usize = @min(@max(1, @as(usize, @intFromFloat(dp(1)))), @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);
+ }
+}
+
+const GlyphDecoration = packed struct(u5) {
bold: bool = false,
underline: @FieldType(pardes.CellStyle, "ul") = .off,
strikethrough: bool = false,
@@ -103,7 +167,7 @@ const GlyphDecoration = struct {
};
const TaglineRaster = struct {
- scale: f32,
+ px: f32,
width: u32,
baseline: i32,
height: u32,
@@ -111,21 +175,72 @@ const TaglineRaster = struct {
fn taglineRaster(font: *c.UIFont, body_px: f32, body_cell_w: u32, body_cell_h: u32, percent: u8) TaglineRaster {
const px = body_px * @as(f32, @floatFromInt(percent)) / 100.0;
- const scale = c.ui_font_scale_for_height(font, px);
var own_w: c_int = 1;
var own_h: c_int = 1;
var own_ascent: c_int = 1;
- c.ui_font_cell_metrics(font, scale, &own_w, &own_h, &own_ascent);
+ c.ui_font_cell_metrics(font, px, &own_w, &own_h, &own_ascent);
const fixed_w: c_int = @intCast(body_cell_w);
const fixed_h: c_int = @intCast(body_cell_h);
const band_h = std.math.clamp(own_h, 1, fixed_h);
return .{
- .scale = scale,
+ .px = px,
.width = @intCast(std.math.clamp(own_w, 1, fixed_w)),
.baseline = std.math.clamp(own_ascent, 1, band_h),
.height = @intCast(band_h),
};
}
+/// What FreeType and HarfBuzz allocate from, through ui_malloc and friends:
+/// the shared C heap, exported under the names font.c and HarfBuzz's
+/// hb_malloc_impl expect. runNative points it at the gui's gpa once
+/// HarfBuzz's process-wide objects exist (ui_font_prime), so a Debug build's
+/// leak report is about fonts; a test that counts what fonts leak points it
+/// at std.testing.allocator the same way. Only the render thread calls into
+/// fonts, and every allocator it is pointed at is thread-safe anyway.
+var font_allocator: std.mem.Allocator = std.heap.smp_allocator;
+const font_heap = c_heap.Heap(&font_allocator);
+comptime {
+ @export(&font_heap.malloc, .{ .name = "ui_malloc" });
+ @export(&font_heap.calloc, .{ .name = "ui_calloc" });
+ @export(&font_heap.realloc, .{ .name = "ui_realloc" });
+ @export(&font_heap.free, .{ .name = "ui_free" });
+}
+
+test "FreeType and HarfBuzz allocate from the gui allocator and give it all back" {
+ // HarfBuzz's process-wide objects come from the default heap, as in runNative.
+ const primer = c.ui_font_new(font_ttf.ptr, @intCast(font_ttf.len)).?;
+ c.ui_font_prime(primer);
+ c.ui_font_free(primer);
+ font_allocator = std.testing.allocator;
+ defer font_allocator = std.heap.smp_allocator;
+
+ const font = c.ui_font_new(font_ttf.ptr, @intCast(font_ttf.len)).?;
+ defer c.ui_font_free(font);
+ var mask: [64 * 64]u8 = undefined;
+ try std.testing.expectEqual(@as(c_int, 1), c.ui_font_raster(font, 27, c.ui_font_glyph(font, 'g'), 1, &mask, 64, 32, 48, 0, 32, 30));
+ try std.testing.expectEqual(@as(c_int, 0), c.ui_font_substitutes(font, c.ui_font_glyph(font, '-')));
+
+ // A font with ligatures runs the whole HarfBuzz pass.
+ const bytes = try filesystem.readFile(std.testing.allocator, "assets/MapleMono-NF-Regular.ttf");
+ defer std.testing.allocator.free(bytes);
+ const maple = c.ui_font_new(bytes.ptr, @intCast(bytes.len)) orelse return error.FontInit;
+ defer c.ui_font_free(maple);
+ var cell_w: c_int = 0;
+ var cell_h: c_int = 0;
+ var ascent: c_int = 0;
+ c.ui_font_cell_metrics(maple, 27, &cell_w, &cell_h, &ascent);
+ const text = [_]u32{ 'a', '-', '>', 'b', '=', '=' };
+ var shaped: [text.len]c.UIShapedCell = undefined;
+ c.ui_font_shape(maple, 27, cell_w, &text, text.len, &shaped);
+ try std.testing.expectEqual(@as(u8, 2), shaped[1].span);
+ try std.testing.expectEqual(@as(u8, 2), shaped[4].span);
+}
+
+/// What SDL allocates from, on its own threads as well as the render thread:
+/// the gui's gpa, through the shared C heap, which is thread-safe in every
+/// build. runNative hands everything back and calls SDL_Quit on the way out.
+var sdl_allocator: std.mem.Allocator = undefined;
+const sdl_heap = c_heap.Heap(&sdl_allocator);
+
const max_fallback_fonts = 1 + fonts.fallback_names.len;
const LoadedFallback = struct {
face: *c.UIFont,
@@ -139,55 +254,17 @@ const touch_click_flash_max_frames: u8 = 14;
const touch_click_flash_vertices: usize = 1400;
const touch_scroll_tick: f32 = 0.02;
-const AnimationClock = struct {
- next_ns: u64 = 0,
-
- fn due(clock: *AnimationClock, active: bool, now_ns: u64) bool {
- if (!active) {
- clock.next_ns = 0;
- return false;
- }
- if (clock.next_ns == 0) {
- clock.next_ns = now_ns +| pardes.layout.Animation.frame_ns;
- return false;
- }
- if (now_ns < clock.next_ns) return false;
- clock.next_ns = now_ns +| pardes.layout.Animation.frame_ns;
- return true;
- }
-};
-
-fn finishPresentedAnimationFrame(
- clock: *AnimationClock,
- core: *pardes.Pardes,
- tracks: []const pardes.layout.Track,
- now_ns: u64,
-) void {
- core.acknowledgePanelPresentation(tracks);
- if (clock.due(core.animationActive(), now_ns)) core.update(.tick);
-}
-
-test "GUI animation clock is active-only and cadence gated" {
- var clock: AnimationClock = .{};
- try std.testing.expect(!clock.due(false, 100));
- try std.testing.expect(!clock.due(true, 100));
- try std.testing.expect(!clock.due(true, 100 + pardes.layout.Animation.frame_ns - 1));
- try std.testing.expect(clock.due(true, 100 + pardes.layout.Animation.frame_ns));
- try std.testing.expect(!clock.due(false, 100 + 2 * pardes.layout.Animation.frame_ns));
- try std.testing.expectEqual(@as(u64, 0), clock.next_ns);
-}
-
-test "a persistent scene presents a new panel's frame zero before advancing it" {
+test "a new panel's frame zero is presented before it advances" {
const core = try pardes.Pardes.init(std.testing.allocator, .{ .tty_only = true });
defer core.deinit();
var arena: std.heap.ArenaAllocator = .init(std.testing.allocator);
defer arena.deinit();
- var clock: AnimationClock = .{};
+ const frame = pardes.animation.frame_ns;
- core.settings.scene_effects.crt = true;
- const scene_frame = try core.render(arena.allocator());
- finishPresentedAnimationFrame(&clock, core, scene_frame.panelTracks(), 100);
- try std.testing.expectEqual(@as(u64, 100 + pardes.layout.Animation.frame_ns), clock.next_ns);
+ core.advance(100);
+ const idle = try core.render(arena.allocator());
+ core.acknowledgePanelPresentation(idle.panelTracks());
+ try std.testing.expectEqual(@as(?u64, null), core.nextWake());
core.settings.panel_transition = .slide;
core.update(.{ .command = "Newcol" });
@@ -197,21 +274,21 @@ test "a persistent scene presents a new panel's frame zero before advancing it"
try std.testing.expect(track_count > 0);
for (first.panelTracks()) |track| try std.testing.expectEqual(@as(u16, 0), track.frame);
- finishPresentedAnimationFrame(
- &clock,
- core,
- first.panelTracks(),
- 100 + pardes.layout.Animation.frame_ns,
- );
+ core.acknowledgePanelPresentation(first.panelTracks());
+ // Just short of a frame is no frame at all.
+ core.advance(100 + frame - 1);
+ _ = arena.reset(.retain_capacity);
+ for ((try core.render(arena.allocator())).panelTracks()) |track| try std.testing.expectEqual(@as(u16, 0), track.frame);
+ core.advance(100 + frame);
_ = arena.reset(.retain_capacity);
const second = try core.render(arena.allocator());
try std.testing.expectEqual(track_count, second.panelTracks().len);
for (second.panelTracks()) |track| try std.testing.expectEqual(@as(u16, 1), track.frame);
}
-// Per pane: background, rule, two grip strokes, and two square rails.
-const pane_chrome_vertices: usize = 6 * 6;
-const max_overlay_vertices: usize = 24 + pet.max_vertices + pardes.MAX_COLS * 6 + pardes.MAX_PANES * pane_chrome_vertices + touch_click_flash_vertices + max_touch_points * (1100 + max_touch_trail_points * overlay_circle_vertices);
+// The triangle overlay holds only the pet and the touch view: the chrome is
+// decor.
+const max_overlay_vertices: usize = pet.max_vertices + touch_click_flash_vertices + max_touch_points * (1100 + max_touch_trail_points * overlay_circle_vertices);
const font_px_step: f32 = 2.0;
const font_px_min: f32 = 8.0;
@@ -227,8 +304,8 @@ test "every font size step moves the cell, and the ends are reachable exactly" {
var asc: c_int = 0;
var pw: c_int = 0;
var ph: c_int = 0;
- c.ui_font_cell_metrics(font, c.ui_font_scale_for_height(font, px), &cw, &ch, &asc);
- c.ui_font_cell_metrics(font, c.ui_font_scale_for_height(font, px - font_px_step), &pw, &ph, &asc);
+ c.ui_font_cell_metrics(font, px, &cw, &ch, &asc);
+ c.ui_font_cell_metrics(font, px - font_px_step, &pw, &ph, &asc);
try std.testing.expect(cw > pw and ch > ph);
}
try std.testing.expectEqual(font_px_max, std.math.clamp(font_px_max + font_px_step, font_px_min, font_px_max));
@@ -238,10 +315,11 @@ test "every font size step moves the cell, and the ends are reachable exactly" {
test "FreeType atlas raster is grayscale, bounded, and clears blank cells" {
const font = c.ui_font_new(font_ttf.ptr, @intCast(font_ttf.len)).?;
defer c.ui_font_free(font);
- try std.testing.expectEqual(@as(c_int, 1), c.ui_font_has_glyph(font, 'H'));
- try std.testing.expectEqual(@as(c_int, 0), c.ui_font_has_glyph(font, 0x10ffff));
+ 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 = c.ui_font_scale_for_height(font, 13.0);
+ const size: f32 = 13.0;
var cell_w: c_int = 0;
var cell_h: c_int = 0;
var ascent: c_int = 0;
@@ -253,7 +331,7 @@ test "FreeType atlas raster is grayscale, bounded, and clears blank cells" {
var bitmap: [128 * 128]u8 = @splat(0xaa);
try std.testing.expectEqual(
@as(c_int, 1),
- c.ui_font_raster(font, size, 'H', &bitmap, stride, cell_w, cell_h, ascent),
+ c.ui_font_raster(font, size, h, 0, &bitmap, stride, cell_w, cell_h, 0, cell_w, ascent),
);
var ink: usize = 0;
@@ -269,7 +347,11 @@ test "FreeType atlas raster is grayscale, bounded, and clears blank cells" {
}
try std.testing.expect(ink > 0);
try std.testing.expect(soft > 0);
- decorateGlyph(&bitmap, @intCast(stride), @intCast(cell_w), @intCast(cell_h), ascent, .{ .bold = true });
+ // 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];
@@ -280,7 +362,7 @@ test "FreeType atlas raster is grayscale, bounded, and clears blank cells" {
try std.testing.expectEqual(
@as(c_int, 0),
- c.ui_font_raster(font, size, ' ', &bitmap, stride, cell_w, cell_h, ascent),
+ 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|
@@ -310,38 +392,21 @@ test "tagline glyph shrinks into its own cell and stays vertically centered" {
const font = c.ui_font_new(font_ttf.ptr, @intCast(font_ttf.len)).?;
defer c.ui_font_free(font);
- const body_scale = c.ui_font_scale_for_height(font, 27.0);
+ const body_px: f32 = 27.0;
var cell_w: c_int = 1;
var cell_h: c_int = 1;
var body_ascent: c_int = 1;
- c.ui_font_cell_metrics(font, body_scale, &cell_w, &cell_h, &body_ascent);
- const tag = taglineRaster(font, 27.0, @intCast(cell_w), @intCast(cell_h), config.gui_tagline_font_percent);
- try std.testing.expect(tag.scale < body_scale);
+ c.ui_font_cell_metrics(font, body_px, &cell_w, &cell_h, &body_ascent);
+ const tag = taglineRaster(font, body_px, @intCast(cell_w), @intCast(cell_h), config.gui_tagline_font_percent);
+ try std.testing.expect(tag.px < body_px);
try std.testing.expect(tag.width < @as(u32, @intCast(cell_w)));
const stride: c_int = 128;
var body: [128 * 128]u8 = @splat(0);
var tagline: [128 * 128]u8 = @splat(0);
- try std.testing.expectEqual(@as(c_int, 1), c.ui_font_raster(
- font,
- body_scale,
- 'H',
- &body,
- stride,
- cell_w,
- cell_h,
- body_ascent,
- ));
- try std.testing.expectEqual(@as(c_int, 1), c.ui_font_raster(
- font,
- tag.scale,
- 'H',
- &tagline,
- stride,
- @intCast(tag.width),
- @intCast(tag.height),
- tag.baseline,
- ));
+ const h = c.ui_font_glyph(font, 'H');
+ try std.testing.expectEqual(@as(c_int, 1), c.ui_font_raster(font, body_px, h, 0, &body, stride, cell_w, cell_h, 0, cell_w, body_ascent));
+ try std.testing.expectEqual(@as(c_int, 1), c.ui_font_raster(font, tag.px, h, 0, &tagline, stride, @intCast(tag.width), @intCast(tag.height), 0, @intCast(tag.width), tag.baseline));
const b = inkBounds(&body, @intCast(stride), @intCast(cell_w), @intCast(cell_h)).?;
const t = inkBounds(&tagline, @intCast(stride), @intCast(tag.width), @intCast(tag.height)).?;
try std.testing.expect(t.max_x - t.min_x < b.max_x - b.min_x);
@@ -361,11 +426,10 @@ test "tagline glyph shrinks into its own cell and stays vertically centered" {
test "tagline percentage changes measured band height without body metrics" {
const font = c.ui_font_new(font_ttf.ptr, @intCast(font_ttf.len)).?;
defer c.ui_font_free(font);
- const body_scale = c.ui_font_scale_for_height(font, 27.0);
var cell_w: c_int = 1;
var cell_h: c_int = 1;
var ascent: c_int = 1;
- c.ui_font_cell_metrics(font, body_scale, &cell_w, &cell_h, &ascent);
+ c.ui_font_cell_metrics(font, 27.0, &cell_w, &cell_h, &ascent);
const small = taglineRaster(font, 27.0, @intCast(cell_w), @intCast(cell_h), 40);
const configured = taglineRaster(font, 27.0, @intCast(cell_w), @intCast(cell_h), 82);
const full = taglineRaster(font, 27.0, @intCast(cell_w), @intCast(cell_h), 100);
@@ -375,18 +439,17 @@ test "tagline percentage changes measured band height without body metrics" {
try std.testing.expect(small.height < configured.height);
try std.testing.expect(configured.height <= full.height);
try std.testing.expect(full.height <= @as(u32, @intCast(cell_h)));
- try std.testing.expectEqual(body_scale, c.ui_font_scale_for_height(font, 27.0));
}
test "glyph atlas cache separates body and tagline roles" {
var glyphs = std.AutoHashMap(GlyphKey, Slot).init(std.testing.allocator);
defer glyphs.deinit();
- try glyphs.put(.{ .codepoint = 'A', .role = .body }, .{ .u = 0, .v = 0 });
- try glyphs.put(.{ .codepoint = 'A', .role = .tagline }, .{ .u = 10, .v = 0 });
- try glyphs.put(.{ .codepoint = 'A', .role = .body, .decoration = .{ .bold = true } }, .{ .u = 20, .v = 0 });
+ try glyphs.put(.{ .face = 0, .glyph = 36, .role = .body }, .{ .u = 0, .v = 0 });
+ try glyphs.put(.{ .face = 0, .glyph = 36, .role = .tagline }, .{ .u = 10, .v = 0 });
+ try glyphs.put(.{ .face = 0, .glyph = 36, .role = .body, .decoration = .{ .bold = true } }, .{ .u = 20, .v = 0 });
try std.testing.expectEqual(@as(usize, 3), glyphs.count());
- try std.testing.expectEqual(@as(u32, 0), glyphs.get(.{ .codepoint = 'A', .role = .body }).?.u);
- try std.testing.expectEqual(@as(u32, 10), glyphs.get(.{ .codepoint = 'A', .role = .tagline }).?.u);
+ try std.testing.expectEqual(@as(u32, 0), glyphs.get(.{ .face = 0, .glyph = 36, .role = .body }).?.u);
+ try std.testing.expectEqual(@as(u32, 10), glyphs.get(.{ .face = 0, .glyph = 36, .role = .tagline }).?.u);
}
test "installed Nerd Symbols fallback covers Yazi directory icons" {
@@ -402,7 +465,7 @@ test "installed Nerd Symbols fallback covers Yazi directory icons" {
defer std.testing.allocator.free(bytes);
const face = c.ui_font_new(bytes.ptr, @intCast(bytes.len)) orelse return error.FontInit;
defer c.ui_font_free(face);
- try std.testing.expectEqual(@as(c_int, 1), c.ui_font_has_glyph(face, 0xe5ff));
+ try std.testing.expect(c.ui_font_glyph(face, 0xe5ff) != 0);
}
const CellInstance = extern struct {
@@ -432,6 +495,11 @@ const CellInstance = extern struct {
progress_bits: u32 = @bitCast(@as(f32, 1)),
serial: u32 = 0,
cell_coord: 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,
};
const OverlayVertex = extern struct {
@@ -473,6 +541,14 @@ const initial_image_capacity: u32 = pardes.MAX_PANES;
const old_layer_bit: u32 = 0x8000_0000;
const clear_bg_bit: u32 = 0x4000_0000;
const opaque_bg_bit: u32 = 0x2000_0000;
+/// Decor that is a soft shadow, not a flat fill (decor.frag.glsl).
+const soft_shadow_bit: u32 = 0x1000_0000;
+/// Decor that is a checker (decor.frag.glsl).
+const checker_bit: u32 = 0x0800_0000;
+/// A cell on the page's ground under the theme's dots, and a file name's
+/// cell that casts the theme's shadow (ui.frag.glsl, Chrome.decor_*).
+const dotted_bit: u32 = 0x1000_0000;
+const title_bit: u32 = 0x0800_0000;
const SavedImagePlace = struct {
key: pardes.ImageCacheKey,
@@ -509,8 +585,8 @@ const SavedImagePlace = struct {
const PreparedImage = struct {
place: SavedImagePlace,
texture: *c.SDL_GPUTexture,
- track: ?pardes.layout.Track = null,
- clip: ?pardes.layout.Box = null,
+ track: ?pardes.animation.Track = null,
+ clip: ?pardes.animation.Box = null,
old_layer: bool = false,
};
@@ -534,7 +610,8 @@ test "saved native placement retains identity and geometry but no producer bytes
}
test "shader instance ABI carries aligned transition vectors" {
- try std.testing.expectEqual(@as(usize, 104), @sizeOf(CellInstance));
+ try std.testing.expectEqual(@as(usize, 120), @sizeOf(CellInstance));
+ try std.testing.expectEqual(@as(usize, 104), @offsetOf(CellInstance, "clip_x0"));
try std.testing.expectEqual(@as(usize, 56), @offsetOf(CellInstance, "panel_x0"));
try std.testing.expectEqual(@as(usize, 72), @offsetOf(CellInstance, "present_x0"));
try std.testing.expectEqual(@as(usize, 88), @offsetOf(CellInstance, "effect"));
@@ -544,43 +621,52 @@ test "shader instance ABI carries aligned transition vectors" {
try std.testing.expectEqual(@as(usize, 64), @offsetOf(ImageInstance, "effect"));
try std.testing.expectEqual(@as(usize, 32), @sizeOf([8]f32));
- const tracks = [_]pardes.layout.Track{
+ const tracks = [_]pardes.animation.Track{
.{ .pane = 0, .phase = .opening, .effect = .slide },
.{ .pane = 1, .phase = .moving, .effect = .slide },
.{ .pane = 2, .phase = .moving, .effect = .slide },
};
- const plan = makePaintPlan(&tracks, true);
- try std.testing.expectEqual(@as(usize, 4), plan.len);
- try std.testing.expect(plan.batches[0].track == null);
- try std.testing.expectEqual(@as(u8, 1), plan.batches[1].track.?.pane);
- try std.testing.expectEqual(@as(u8, 2), plan.batches[2].track.?.pane);
- try std.testing.expectEqual(@as(u8, 0), plan.batches[3].track.?.pane);
+ // Tier 0, the tracks as the core ordered them, then tiers 4 and 5.
+ const groups = makeGroups(&tracks, true);
+ try std.testing.expectEqual(@as(usize, 7), groups.len);
+ try std.testing.expect(groups.items[0].track == null);
+ try std.testing.expectEqual(@as(u8, 0), groups.items[1].track.?.pane);
+ try std.testing.expectEqual(@as(u8, 1), groups.items[2].track.?.pane);
+ try std.testing.expectEqual(@as(u8, 2), groups.items[3].track.?.pane);
+ try std.testing.expectEqual(@as(usize, 4), groups.notices);
+ try std.testing.expectEqual(@as(usize, 5), groups.guides);
+ try std.testing.expectEqual(@as(usize, 6), groups.ink);
+ for ([_]usize{ groups.notices, groups.guides, groups.ink }) |index| try std.testing.expect(groups.items[index].track == null);
}
test "GUI paint plan snaps history effects without a frozen grid" {
- const tracks = [_]pardes.layout.Track{
+ const tracks = [_]pardes.animation.Track{
.{ .pane = 0, .phase = .opening, .effect = .ascii },
.{ .pane = 1, .phase = .closing, .effect = .vertical },
};
- try std.testing.expectEqual(@as(usize, 1), makePaintPlan(&tracks, false).len);
- const ready = makePaintPlan(&tracks, true);
- try std.testing.expectEqual(@as(usize, 3), ready.len);
- try std.testing.expectEqual(pardes.layout.Phase.opening, ready.batches[1].track.?.phase);
- try std.testing.expectEqual(pardes.layout.Phase.closing, ready.batches[2].track.?.phase);
+ try std.testing.expectEqual(@as(usize, 0), makeGroups(&tracks, false).tracks);
+ const ready = makeGroups(&tracks, true);
+ try std.testing.expectEqual(@as(usize, 2), ready.tracks);
+ try std.testing.expectEqual(pardes.animation.Phase.opening, ready.items[1].track.?.phase);
+ try std.testing.expectEqual(pardes.animation.Phase.closing, ready.items[2].track.?.phase);
}
test "closing tombstone overlays but never owns canonical cells" {
- const closing: pardes.layout.Track = .{
+ const closing: pardes.animation.Track = .{
.pane = 0,
.phase = .closing,
.effect = .vertical,
.from = .{ .x = 2, .y = 3, .w = 10, .h = 4 },
.to = .{ .x = 2, .y = -1, .w = 10, .h = 4 },
};
- const plan = makePaintPlan(&.{closing}, true);
- try std.testing.expectEqual(@as(usize, 0), paintBatchAt(&plan, 4, 4));
- try std.testing.expectEqual(@as(usize, 2), plan.len);
- try std.testing.expectEqual(pardes.layout.Phase.closing, plan.batches[1].track.?.phase);
+ const groups = makeGroups(&.{closing}, true);
+ try std.testing.expectEqual(@as(usize, 0), groupAt(&groups, 4, 4));
+ // A still pane's notice stays under the tombstone sliding over it.
+ const notice: pardes.Layer = .{ .kind = .notice, .viewport = .{ .x = 4, .y = 4, .w = 3, .h = 1 }, .rows = 1 };
+ try std.testing.expectEqual(@as(usize, 0), noticeGroup(&groups, &notice));
+ try std.testing.expectEqual(makeGroups(&.{}, false).notices, noticeGroup(&makeGroups(&.{}, false), &notice));
+ try std.testing.expectEqual(@as(usize, 1), groups.tracks);
+ try std.testing.expectEqual(pardes.animation.Phase.closing, groups.items[1].track.?.phase);
}
fn updateCoreResize(core: *pardes.Pardes, cols: u16, rows: u16, cell_w: u32, cell_h: u32, tag_w: u32, tag_h: u32) bool {
@@ -780,288 +866,37 @@ fn emitTouchClick(t: *Touch, in: *Input, point: TouchNormPoint, button: pardes.M
in.post(.{ .mouse = .{ .button = button, .kind = .release, .col = cell.col, .row = cell.row, .tag_hit = cell.tag_hit, .body_hit = cell.body_hit } });
}
-fn normCell(norm: f32, win: f32, cell: f32) u16 {
- const px = std.math.clamp(norm, 0.0, 1.0) * win;
- return @intFromFloat(@max(0, @floor(px / cell)));
-}
-
const Pty = struct {
fd: c_int,
pid: libc.pid_t,
serial: u32,
kill_at: i64 = 0,
- reader: ?std.Thread = null,
- stop: [2]c_int = .{ -1, -1 },
+ /// Its reader, blocked in an Io read: `closePty` cancels it.
+ reader: ?std.Io.Future(void) = null,
+ /// A command pane's child, watched to its exit (host_io.watchExit);
+ /// the pty stays open until both its end of file and its exit.
+ cmd: host_io.CommandWatch = .{},
};
-const RetiredShell = struct { pid: libc.pid_t = 0, kill_at: i64 = 0 };
-
-const Msg = union(enum) {
- output: struct { pane: u8, gen: u32, bytes: []u8 },
- eof: struct { pane: u8, gen: u32, failure: ?anyerror = null },
- lsp: struct { id: u32, rows: ?[]u8 },
- lsp_status: []u8,
- pipe: selection_pipe.Response,
- files_changed,
- fs_ready,
- fn deinit(m: Msg, gpa: std.mem.Allocator, lsp_allocator: std.mem.Allocator) void {
- switch (m) {
- .output => |o| gpa.free(o.bytes),
- .lsp => |l| if (l.rows) |rows| lsp_allocator.free(rows),
- .lsp_status => |t| lsp_allocator.free(t),
- .pipe => |response_value| {
- var response = response_value;
- response.deinit(gpa);
- },
- .eof, .files_changed, .fs_ready => {},
- }
- }
-};
-
-const LspWorkers = struct {
- const capacity = 16;
- active: std.atomic.Value(usize) = .init(0),
-
- fn start(workers: *LspWorkers) bool {
- var count = workers.active.load(.monotonic);
- while (count < capacity)
- count = workers.active.cmpxchgWeak(count, count + 1, .monotonic, .monotonic) orelse return true;
- return false;
- }
+const RetiredShell = struct { pid: libc.pid_t = 0, kill_at: i64 = 0 };
- fn finish(workers: *LspWorkers) void {
- const previous = workers.active.fetchSub(1, .release);
- std.debug.assert(previous > 0);
- }
-
- fn wait(workers: *LspWorkers) void {
- var spins: u8 = 0;
- while (workers.active.load(.acquire) != 0) {
- spins +%= 1;
- if (spins == 0) std.Thread.yield() catch {} else std.atomic.spinLoopHint();
- }
- }
-};
+const Queue = host_io.Inbox;
+/// Wakes a blocking SDL_WaitEventTimeout after a push from another thread.
+fn sdlWake(_: ?*anyopaque) void {
+ var sev = std.mem.zeroes(c.SDL_Event);
+ sev.type = c.SDL_EVENT_USER;
+ _ = c.SDL_PushEvent(&sev);
+}
+const Msg = Queue.Msg;
+const MessageBatch = Queue.Batch;
const PipeTasks = selection_pipe.Tasks;
-
-const queue_capacity = 512;
-const output_capacity = queue_capacity - pardes.MAX_PANES;
-
-const MessageBatch = struct {
- items: [queue_capacity + PipeTasks.capacity + 2]Msg = undefined,
- len: usize = 0,
-
- fn slice(batch: *MessageBatch) []Msg {
- return batch.items[0..batch.len];
- }
-};
-
-const Queue = struct {
- gpa: std.mem.Allocator,
- lsp_allocator: std.mem.Allocator,
- lsp_workers: *LspWorkers,
- sdl_wake: bool, // wake a blocking SDL_WaitEventTimeout on cross-thread push
- mutex: libc.pthread_mutex_t = .{},
- space: libc.pthread_cond_t = .{},
- items: [queue_capacity]Msg = undefined,
- head: usize = 0,
- len: usize = 0,
- closed: bool = false,
- files_changed: bool = false,
- readers: [pardes.MAX_PANES]?u32 = @splat(null),
- waiting: usize = 0,
- lsp_id: ?u32 = null,
- completions: [PipeTasks.capacity + 1]Msg = undefined,
- completion_len: usize = 0,
-
- fn lock(q: *Queue) void {
- std.debug.assert(libc.pthread_mutex_lock(&q.mutex) == .SUCCESS);
- }
-
- fn unlock(q: *Queue) void {
- std.debug.assert(libc.pthread_mutex_unlock(&q.mutex) == .SUCCESS);
- }
-
- fn wake(q: *Queue) void {
- if (q.sdl_wake) {
- var sev = std.mem.zeroes(c.SDL_Event);
- sev.type = c.SDL_EVENT_USER;
- _ = c.SDL_PushEvent(&sev);
- }
- }
-
- fn acceptReader(q: *Queue, pane: u8, gen: u32) void {
- q.lock();
- defer q.unlock();
- std.debug.assert(q.readers[pane] == null);
- q.readers[pane] = gen;
- }
-
- fn cancelReader(q: *Queue, pane: u8, gen: u32) void {
- q.lock();
- defer q.unlock();
- if (q.readers[pane] != gen) return;
- q.readers[pane] = null;
- var i: usize = 0;
- while (i < q.len) {
- const msg = q.items[(q.head + i) % q.items.len];
- const matches = switch (msg) {
- .output => |o| o.pane == pane and o.gen == gen,
- .eof => |e| e.pane == pane and e.gen == gen,
- else => false,
- };
- if (matches) q.removeAt(i).deinit(q.gpa, q.lsp_allocator) else i += 1;
- }
- std.debug.assert(libc.pthread_cond_broadcast(&q.space) == .SUCCESS);
- }
-
- fn pushOutput(q: *Queue, pane: u8, gen: u32, bytes: []u8) bool {
- q.lock();
- while (!q.closed and q.readers[pane] == gen and q.len >= output_capacity) {
- q.waiting += 1;
- std.debug.assert(libc.pthread_cond_wait(&q.space, &q.mutex) == .SUCCESS);
- q.waiting -= 1;
- }
- if (q.closed or q.readers[pane] != gen) {
- q.unlock();
- q.gpa.free(bytes);
- return false;
- }
- q.items[(q.head + q.len) % q.items.len] = .{ .output = .{ .pane = pane, .gen = gen, .bytes = bytes } };
- q.len += 1;
- q.unlock();
- q.wake();
- return true;
- }
-
- fn removeAt(q: *Queue, offset: usize) Msg {
- const removed = q.items[(q.head + offset) % q.items.len];
- var i = offset;
- while (i + 1 < q.len) : (i += 1)
- q.items[(q.head + i) % q.items.len] = q.items[(q.head + i + 1) % q.items.len];
- q.len -= 1;
- return removed;
- }
-
- fn discardLsp(q: *Queue) void {
- for (q.completions[0..q.completion_len], 0..) |msg, i| if (msg == .lsp) {
- msg.deinit(q.gpa, q.lsp_allocator);
- q.completion_len -= 1;
- std.mem.copyForwards(Msg, q.completions[i..q.completion_len], q.completions[i + 1 .. q.completion_len + 1]);
- return;
- };
- }
-
- fn push(q: *Queue, m: Msg) void {
- if (m == .output) {
- _ = q.pushOutput(m.output.pane, m.output.gen, m.output.bytes);
- return;
- }
- q.lock();
- if (q.closed) {
- q.unlock();
- m.deinit(q.gpa, q.lsp_allocator);
- return;
- }
- switch (m) {
- .files_changed => q.files_changed = true,
- .lsp, .pipe => {
- if (m == .lsp) {
- if (q.lsp_id != m.lsp.id) {
- q.unlock();
- m.deinit(q.gpa, q.lsp_allocator);
- return;
- }
- q.discardLsp();
- }
- std.debug.assert(q.completion_len < q.completions.len);
- q.completions[q.completion_len] = m;
- q.completion_len += 1;
- },
- else => {
- if (m == .eof) {
- if (q.readers[m.eof.pane] != m.eof.gen) {
- q.unlock();
- return;
- }
- std.debug.assert(q.len < q.items.len);
- } else if (q.len >= output_capacity) {
- q.unlock();
- m.deinit(q.gpa, q.lsp_allocator);
- return;
- }
- q.items[(q.head + q.len) % q.items.len] = m;
- q.len += 1;
- },
- }
- q.unlock();
- q.wake();
- }
-
- fn take(q: *Queue) MessageBatch {
- q.lock();
- defer q.unlock();
- var batch: MessageBatch = .{};
- while (q.len > 0) {
- batch.items[batch.len] = q.items[q.head];
- batch.len += 1;
- q.head = (q.head + 1) % q.items.len;
- q.len -= 1;
- }
- q.head = 0;
- if (q.files_changed) {
- batch.items[batch.len] = .files_changed;
- batch.len += 1;
- q.files_changed = false;
- }
- @memcpy(batch.items[batch.len..][0..q.completion_len], q.completions[0..q.completion_len]);
- batch.len += q.completion_len;
- q.completion_len = 0;
- std.debug.assert(libc.pthread_cond_broadcast(&q.space) == .SUCCESS);
- return batch;
- }
-
- fn discardCompletions(q: *Queue) void {
- q.lock();
- defer q.unlock();
- q.lsp_id = null;
- for (q.completions[0..q.completion_len]) |msg| msg.deinit(q.gpa, q.lsp_allocator);
- q.completion_len = 0;
- }
-
- fn close(q: *Queue) void {
- q.lock();
- q.closed = true;
- q.files_changed = false;
- q.readers = @splat(null);
- std.debug.assert(libc.pthread_cond_broadcast(&q.space) == .SUCCESS);
- q.unlock();
- q.discardCompletions();
- q.lock();
- defer q.unlock();
- while (q.len > 0) {
- const m = q.items[q.head];
- m.deinit(q.gpa, q.lsp_allocator);
- q.head = (q.head + 1) % q.items.len;
- q.len -= 1;
- }
- q.head = 0;
- }
-
- fn deinit(q: *Queue) void {
- q.close();
- std.debug.assert(q.waiting == 0);
- std.debug.assert(libc.pthread_cond_destroy(&q.space) == .SUCCESS);
- std.debug.assert(libc.pthread_mutex_destroy(&q.mutex) == .SUCCESS);
- }
-};
+const output_capacity = Queue.output_capacity;
test "GUI completion survives a full output queue" {
const gpa = std.testing.allocator;
- var workers: LspWorkers = .{};
- var queue: Queue = .{ .gpa = gpa, .lsp_allocator = gpa, .lsp_workers = &workers, .sdl_wake = false, .lsp_id = 7 };
+ var queue: Queue = .{ .io = std.testing.io, .gpa = gpa, .lsp_allocator = gpa, .lsp_id = 7 };
defer queue.deinit();
queue.acceptReader(0, 1);
for (0..output_capacity) |_| queue.push(.{ .output = .{
@@ -1099,8 +934,8 @@ test "GUI completion survives a full output queue" {
const PtyTests = struct {
fn waitBlocked(queue: *Queue) !void {
- const until = shellClock() + 2_000;
- while (shellClock() < until) {
+ const until = std.Io.Clock.awake.now(std.testing.io).toMilliseconds() + 2_000;
+ while (std.Io.Clock.awake.now(std.testing.io).toMilliseconds() < until) {
queue.lock();
const waiting = queue.waiting;
queue.unlock();
@@ -1117,8 +952,7 @@ const PtyTests = struct {
test "GUI PTY backpressure retains byte order and tail before EOF" {
const gpa = std.testing.allocator;
- var workers: LspWorkers = .{};
- var queue: Queue = .{ .gpa = gpa, .lsp_allocator = gpa, .lsp_workers = &workers, .sdl_wake = false };
+ var queue: Queue = .{ .io = std.testing.io, .gpa = gpa, .lsp_allocator = gpa };
defer queue.deinit();
queue.acceptReader(0, 1);
for (0..output_capacity) |_| queue.push(.{ .output = .{ .pane = 0, .gen = 1, .bytes = try gpa.dupe(u8, "before") } });
@@ -1152,8 +986,7 @@ test "GUI PTY backpressure retains byte order and tail before EOF" {
test "GUI PTY backpressure cancellation and close release owned producers" {
const gpa = std.testing.allocator;
for ([_]bool{ false, true }) |close| {
- var workers: LspWorkers = .{};
- var queue: Queue = .{ .gpa = gpa, .lsp_allocator = gpa, .lsp_workers = &workers, .sdl_wake = false };
+ var queue: Queue = .{ .io = std.testing.io, .gpa = gpa, .lsp_allocator = gpa };
defer queue.deinit();
queue.acceptReader(0, 1);
for (0..output_capacity) |_| queue.push(.{ .output = .{ .pane = 0, .gen = 1, .bytes = try gpa.dupe(u8, "before") } });
@@ -1184,15 +1017,14 @@ test "GUI PTY backpressure cancellation and close release owned producers" {
test "GUI PTY EOF reserve cannot evict terminal output" {
const gpa = std.testing.allocator;
- var workers: LspWorkers = .{};
- var queue: Queue = .{ .gpa = gpa, .lsp_allocator = gpa, .lsp_workers = &workers, .sdl_wake = false };
+ var queue: Queue = .{ .io = std.testing.io, .gpa = gpa, .lsp_allocator = gpa };
defer queue.deinit();
for (0..pardes.MAX_PANES) |pane| queue.acceptReader(@intCast(pane), 1);
for (0..output_capacity) |_| queue.push(.{ .output = .{ .pane = 0, .gen = 1, .bytes = try gpa.dupe(u8, "before") } });
for (0..pardes.MAX_PANES) |pane| queue.push(.{ .eof = .{ .pane = @intCast(pane), .gen = 1 } });
var batch = queue.take();
defer for (batch.slice()) |msg| msg.deinit(gpa, gpa);
- try std.testing.expectEqual(queue_capacity, batch.len);
+ try std.testing.expectEqual(Queue.capacity, batch.len);
for (batch.items[0..output_capacity]) |msg| try std.testing.expectEqualStrings("before", msg.output.bytes);
for (batch.items[output_capacity..batch.len], 0..) |msg, pane| try std.testing.expectEqual(pane, msg.eof.pane);
}
@@ -1201,8 +1033,7 @@ test "GUI PTY reader delivers a real shell tail before EOF and joins on close" {
const gpa = std.testing.allocator;
const core = try pardes.Pardes.init(gpa, .{ .tty_only = true });
defer core.deinit();
- var workers: LspWorkers = .{};
- var queue: Queue = .{ .gpa = gpa, .lsp_allocator = gpa, .lsp_workers = &workers, .sdl_wake = false };
+ var queue: Queue = .{ .io = std.testing.io, .gpa = gpa, .lsp_allocator = gpa };
defer queue.deinit();
var ptys: [pardes.MAX_PANES]?Pty = @splat(null);
var gens: [pardes.MAX_PANES]u32 = @splat(1);
@@ -1217,13 +1048,13 @@ test "GUI PTY reader delivers a real shell tail before EOF and joins on close" {
const rcs: host_io.Shell.PromptFiles = .{};
const child = try host_io.forkShell(null, 0, &rcs, "/bin/sh", "", 24, 80, null);
ptys[0] = .{ .fd = child.file.handle, .pid = child.pid, .serial = core.panes[0].?.serial };
- try spawnReader(gpa, &ptys[0].?, 0, 1, &queue);
+ ptys[0].?.reader = try queue.startReader(.{ .handle = ptys[0].?.fd, .flags = .{ .nonblocking = false } }, 0, 1);
try std.testing.expect(host_io.writeFd(child.file.handle, "printf '\\120\\101\\122\\104\\105\\123\\055\\124\\101\\111\\114'; exit\n"));
var bytes: std.ArrayList(u8) = .empty;
defer bytes.deinit(gpa);
var eof = false;
- const until = shellClock() + 2_000;
- while (!eof and shellClock() < until) {
+ const until = std.Io.Clock.awake.now(std.testing.io).toMilliseconds() + 2_000;
+ while (!eof and std.Io.Clock.awake.now(std.testing.io).toMilliseconds() < until) {
var batch = queue.take();
defer for (batch.slice()) |msg| msg.deinit(gpa, gpa);
for (batch.slice()) |msg| switch (msg) {
@@ -1251,9 +1082,8 @@ test "GUI PTY Restore joins a real reader waiting for queue space" {
const gpa = std.testing.allocator;
var core = try pardes.Pardes.init(gpa, .{ .tty_only = true });
defer core.deinit();
- try core.dumpState();
- var workers: LspWorkers = .{};
- var queue: Queue = .{ .gpa = gpa, .lsp_allocator = gpa, .lsp_workers = &workers, .sdl_wake = false };
+ try dump.dumpState(core);
+ var queue: Queue = .{ .io = std.testing.io, .gpa = gpa, .lsp_allocator = gpa };
defer queue.deinit();
queue.acceptReader(1, 1);
for (0..output_capacity) |_| queue.push(.{ .output = .{ .pane = 1, .gen = 1, .bytes = try gpa.dupe(u8, "other pane") } });
@@ -1270,11 +1100,11 @@ test "GUI PTY Restore joins a real reader waiting for queue space" {
const rcs: host_io.Shell.PromptFiles = .{};
const child = try host_io.forkShell(null, 0, &rcs, "/bin/sh", "", 24, 80, null);
ptys[0] = .{ .fd = child.file.handle, .pid = child.pid, .serial = core.panes[0].?.serial };
- try spawnReader(gpa, &ptys[0].?, 0, 1, &queue);
+ ptys[0].?.reader = try queue.startReader(.{ .handle = ptys[0].?.fd, .flags = .{ .nonblocking = false } }, 0, 1);
try std.testing.expect(host_io.writeFd(child.file.handle, "printf 'after-full'; exit\n"));
try PtyTests.waitBlocked(&queue);
const old_serial = core.panes[0].?.serial;
- const replacement = try core.restore(core.dump_out.?);
+ const replacement = try dump.restore(core, core.dump_out.?, "test");
shell.stopPtys();
core.deinit();
core = replacement;
@@ -1297,8 +1127,7 @@ test "GUI PTY deletion joins an idle reader and retains only its owned child for
const gpa = std.testing.allocator;
const core = try pardes.Pardes.init(gpa, .{ .tty_only = true });
defer core.deinit();
- var workers: LspWorkers = .{};
- var queue: Queue = .{ .gpa = gpa, .lsp_allocator = gpa, .lsp_workers = &workers, .sdl_wake = false };
+ var queue: Queue = .{ .io = std.testing.io, .gpa = gpa, .lsp_allocator = gpa };
defer queue.deinit();
var ptys: [pardes.MAX_PANES]?Pty = @splat(null);
var gens: [pardes.MAX_PANES]u32 = @splat(1);
@@ -1313,8 +1142,8 @@ test "GUI PTY deletion joins an idle reader and retains only its owned child for
const rcs: host_io.Shell.PromptFiles = .{};
const child = try host_io.forkShell(null, 0, &rcs, "/bin/sh", "", 24, 80, null);
ptys[0] = .{ .fd = child.file.handle, .pid = child.pid, .serial = core.panes[0].?.serial };
- try spawnReader(gpa, &ptys[0].?, 0, 1, &queue);
- try core.removePane(0);
+ ptys[0].?.reader = try queue.startReader(.{ .handle = ptys[0].?.fd, .flags = .{ .nonblocking = false } }, 0, 1);
+ try core.removePane(0, null);
shell.reconcilePtys();
try std.testing.expect(queue.readers[0] == null);
try std.testing.expectEqual(@as(usize, 0), queue.waiting);
@@ -1329,8 +1158,7 @@ test "GUI PTY deletion joins an idle reader and retains only its owned child for
test "GUI PTY file watcher stops and joins without closing its watched descriptor" {
if (!file_watch.supported) return error.SkipZigTest;
const gpa = std.testing.allocator;
- var workers: LspWorkers = .{};
- var queue: Queue = .{ .gpa = gpa, .lsp_allocator = gpa, .lsp_workers = &workers, .sdl_wake = false };
+ var queue: Queue = .{ .io = std.testing.io, .gpa = gpa, .lsp_allocator = gpa };
defer queue.deinit();
const fd = file_watch.init(true);
if (fd < 0) return error.WatchInitFailed;
@@ -1351,11 +1179,10 @@ test "GUI completion failure survives backlog and leaves the document unchanged"
const core = try pardes.Pardes.init(gpa, .{ .tty_only = true });
defer core.deinit();
const pane = try core.setTestFile("abc");
- pane.cur_col = 1;
+ pane.body.cur_col = 1;
core.lspRequest(core.active, .completion, "");
const id = core.lsp_wait.?.id;
- var workers: LspWorkers = .{};
- var queue: Queue = .{ .gpa = gpa, .lsp_allocator = gpa, .lsp_workers = &workers, .sdl_wake = false, .lsp_id = id };
+ var queue: Queue = .{ .io = std.testing.io, .gpa = gpa, .lsp_allocator = gpa, .lsp_id = id };
defer queue.deinit();
queue.acceptReader(0, 1);
for (0..output_capacity) |_| queue.push(.{ .output = .{
@@ -1378,14 +1205,13 @@ test "GUI completion failure survives backlog and leaves the document unchanged"
shell.drainQueue();
try std.testing.expect(core.lsp_wait == null);
try std.testing.expectEqualStrings("abc", pane.file.?.content);
- try std.testing.expectEqual(@as(i32, 1), pane.cur_col);
+ try std.testing.expectEqual(@as(i32, 1), pane.body.cur_col);
try std.testing.expect(shell.saw_event);
}
test "GUI completions retain their arrival order across LSP and pipes" {
const gpa = std.testing.allocator;
- var workers: LspWorkers = .{};
- var queue: Queue = .{ .gpa = gpa, .lsp_allocator = gpa, .lsp_workers = &workers, .sdl_wake = false, .lsp_id = 2 };
+ var queue: Queue = .{ .io = std.testing.io, .gpa = gpa, .lsp_allocator = gpa, .lsp_id = 2 };
defer queue.deinit();
queue.push(.{ .pipe = .{ .id = 1, .success = true, .outputs = &.{} } });
queue.push(.{ .lsp = .{ .id = 2, .rows = try gpa.dupe(u8, "second") } });
@@ -1401,8 +1227,7 @@ test "GUI completions retain their arrival order across LSP and pipes" {
test "GUI completion reset frees queued payloads and rejects late LSP workers" {
const gpa = std.testing.allocator;
- var workers: LspWorkers = .{};
- var queue: Queue = .{ .gpa = gpa, .lsp_allocator = gpa, .lsp_workers = &workers, .sdl_wake = false, .lsp_id = 9 };
+ var queue: Queue = .{ .io = std.testing.io, .gpa = gpa, .lsp_allocator = gpa, .lsp_id = 9 };
defer queue.deinit();
queue.acceptReader(0, 1);
queue.push(.{ .output = .{ .pane = 0, .gen = 1, .bytes = try gpa.dupe(u8, "retained") } });
@@ -1449,42 +1274,7 @@ test "GUI completion reset frees queued payloads and rejects late LSP workers" {
try std.testing.expectEqual(@as(usize, 0), queue.take().len);
}
-fn lspStatusSink(ctx: ?*anyopaque, text: []const u8) void {
- const q: *Queue = @ptrCast(@alignCast(ctx orelse return));
- const copy = q.lsp_allocator.dupe(u8, text) catch return;
- q.push(.{ .lsp_status = copy });
-}
-fn readPtyThread(gpa: std.mem.Allocator, fd: c_int, stop: c_int, pane: u8, gen: u32, q: *Queue) void {
- var buf: [0x10000]u8 = undefined;
- var failure: ?anyerror = null;
- while (true) {
- var fds = [_]libc.pollfd{
- .{ .fd = stop, .events = libc.POLL.IN, .revents = 0 },
- .{ .fd = fd, .events = libc.POLL.IN, .revents = 0 },
- };
- if (libc.poll(&fds, fds.len, -1) < 0) {
- if (libc.errno(-1) == .INTR) continue;
- failure = error.PollFailed;
- break;
- }
- if (fds[0].revents != 0) return;
- if (fds[1].revents == 0) continue;
- const n = libc.read(fd, &buf, buf.len);
- if (n < 0) {
- if (libc.errno(n) == .INTR) continue;
- if (libc.errno(n) != .IO) failure = error.ReadFailed;
- break;
- }
- if (n == 0) break;
- const bytes = gpa.dupe(u8, buf[0..@intCast(n)]) catch |err| {
- failure = err;
- break;
- };
- if (!q.pushOutput(pane, gen, bytes)) return;
- }
- q.push(.{ .eof = .{ .pane = pane, .gen = gen, .failure = failure } });
-}
fn stopPipe() ![2]c_int {
var fds: [2]c_int = undefined;
@@ -1496,17 +1286,6 @@ fn stopPipe() ![2]c_int {
return fds;
}
-fn spawnReader(gpa: std.mem.Allocator, pt: *Pty, pane: u8, gen: u32, q: *Queue) !void {
- std.debug.assert(pt.reader == null and pt.fd >= 0);
- const stop = try stopPipe();
- errdefer for (stop) |fd| {
- _ = libc.close(fd);
- };
- q.acceptReader(pane, gen);
- errdefer q.cancelReader(pane, gen);
- pt.reader = try std.Thread.spawn(.{}, readPtyThread, .{ gpa, pt.fd, stop[0], pane, gen, q });
- pt.stop = stop;
-}
fn watchThread(fd: c_int, stop: c_int, q: *Queue) void {
while (true) {
@@ -1524,149 +1303,32 @@ fn watchThread(fd: c_int, stop: c_int, q: *Queue) void {
}
}
-fn lspThread(lsp_allocator: std.mem.Allocator, workers: *LspWorkers, job: *host_io.Lsp.Job, q: *Queue) void {
- defer workers.finish();
- host_io.Lsp.work(lsp_allocator, job, q, pushLspRows);
-}
-fn pushLspRows(ctx: ?*anyopaque, id: u32, rows: ?[]u8) void {
- const q: *Queue = @ptrCast(@alignCast(ctx orelse return));
- q.push(.{ .lsp = .{ .id = id, .rows = rows } });
-}
-fn spawnLsp(core: *pardes.Pardes, q: *Queue, e: host_io.Lsp.Request) void {
- const lsp_allocator = q.lsp_allocator;
- q.lock();
- q.lsp_id = e.id;
- q.discardLsp();
- q.unlock();
- if (!q.lsp_workers.start()) {
- core.update(.{ .lsp_resp = .{ .id = e.id, .rows = null } });
- return core.reportError(e.pane, "lsp", error.WorkersBusy);
- }
- const job = host_io.Lsp.snapshot(lsp_allocator, core, e) catch |err| {
- q.lsp_workers.finish();
- core.update(.{ .lsp_resp = .{ .id = e.id, .rows = null } });
- return core.reportError(e.pane, "lsp", err);
- };
- const th = std.Thread.spawn(.{}, lspThread, .{ lsp_allocator, q.lsp_workers, job, q }) catch |err| {
- q.lsp_workers.finish();
- job.free(lsp_allocator);
- core.update(.{ .lsp_resp = .{ .id = e.id, .rows = null } });
- return core.reportError(e.pane, "lsp", err);
- };
- th.detach();
-}
-
-test "GUI LSP worker limit rejects before allocation and recovers after owned workers exit" {
+test "GUI LSP query answers, and a newer one cancels it" {
const gpa = std.testing.allocator;
+ const io = std.testing.io;
const core = try pardes.Pardes.init(gpa, .{ .tty_only = true });
defer core.deinit();
- const pane = try core.setTestFile("abc");
- pane.cur_col = 1;
- var workers: LspWorkers = .{};
- var gate: std.Io.Event = .unset;
- var threads: [LspWorkers.capacity]?std.Thread = @splat(null);
- defer {
- gate.set(std.testing.io);
- for (threads) |thread| if (thread) |owned| owned.join();
- workers.wait();
- }
- for (&threads) |*thread| {
- try std.testing.expect(workers.start());
- thread.* = std.Thread.spawn(.{}, struct {
- fn run(active: *LspWorkers, ready: *std.Io.Event) void {
- defer active.finish();
- ready.waitUncancelable(std.testing.io);
- }
- }.run, .{ &workers, &gate }) catch |err| {
- workers.finish();
- return err;
- };
- }
- try std.testing.expectEqual(@as(usize, LspWorkers.capacity), workers.active.load(.monotonic));
- try std.testing.expect(!workers.start());
- var failing = std.testing.FailingAllocator.init(gpa, .{ .fail_index = 0 });
- var queue: Queue = .{ .gpa = gpa, .lsp_allocator = failing.allocator(), .lsp_workers = &workers, .sdl_wake = false };
+ _ = try core.setTestFile("abc");
+ var queue: Queue = .{ .io = std.testing.io, .gpa = gpa, .lsp_allocator = gpa };
defer queue.deinit();
- core.lspRequest(core.active, .completion, "");
- const rejected = core.lsp_wait.?.id;
- queue.lsp_id = rejected -% 1;
- queue.push(.{ .lsp = .{ .id = queue.lsp_id.?, .rows = try gpa.dupe(u8, "obsolete queued result") } });
- spawnLsp(core, &queue, .{
- .id = rejected,
- .kind = .completion,
- .pane = @intCast(core.active),
- .offset = 1,
- .arg = "",
- });
- try std.testing.expect(core.lsp_wait == null);
- try std.testing.expectEqualStrings("abc", pane.file.?.content);
- try std.testing.expectEqual(@as(i32, 1), pane.cur_col);
- try std.testing.expect(std.mem.indexOf(u8, pane.msg[0..pane.msg_len], "WorkersBusy") != null);
- try std.testing.expectEqual(@as(usize, 0), failing.alloc_index);
- try std.testing.expect(!failing.has_induced_failure);
- try std.testing.expectEqual(rejected, queue.lsp_id.?);
- try std.testing.expectEqual(@as(usize, 0), queue.completion_len);
- queue.push(.{ .lsp = .{ .id = rejected -% 1, .rows = try gpa.dupe(u8, "obsolete late result") } });
- try std.testing.expectEqual(@as(usize, 0), queue.completion_len);
- try std.testing.expectEqual(@as(usize, LspWorkers.capacity), workers.active.load(.monotonic));
-
- gate.set(std.testing.io);
- workers.wait();
- try std.testing.expectEqual(@as(usize, 0), workers.active.load(.monotonic));
- queue.lsp_allocator = gpa;
- core.lspRequest(core.active, .status, "");
- const accepted = core.lsp_wait.?.id;
- spawnLsp(core, &queue, .{
- .id = accepted,
- .kind = .status,
- .pane = @intCast(core.active),
- .offset = 0,
- .arg = "",
- });
- workers.wait();
+ for (0..2) |_| {
+ core.lspRequest(core.active, .status, "");
+ queue.startLsp(core, .{ .id = core.lsp_wait.?.id, .kind = .status, .pane = @intCast(core.active), .offset = 0, .arg = "" });
+ }
+ const last = core.lsp_wait.?.id;
+ queue.lsp_task.?.future.await(io);
+ queue.lsp_task = null;
var batch = queue.take();
defer for (batch.slice()) |msg| msg.deinit(gpa, gpa);
try std.testing.expectEqual(@as(usize, 1), batch.len);
- try std.testing.expectEqual(accepted, batch.items[0].lsp.id);
+ try std.testing.expectEqual(last, batch.items[0].lsp.id);
try std.testing.expect(batch.items[0].lsp.rows != null);
- core.update(.{ .lsp_resp = .{ .id = accepted, .rows = batch.items[0].lsp.rows } });
+ core.update(.{ .lsp_resp = .{ .id = last, .rows = batch.items[0].lsp.rows } });
try std.testing.expect(core.lsp_wait == null);
- try std.testing.expectEqual(@as(usize, 0), workers.active.load(.monotonic));
- try std.testing.expectEqualStrings("abc", pane.file.?.content);
}
-fn pipeThread(io: std.Io, gpa: std.mem.Allocator, job: *selection_pipe.Job, q: *Queue) anyerror!void {
- defer job.deinit(gpa);
- const response = selection_pipe.runJob(gpa, io, job);
- q.push(.{ .pipe = response });
-}
-
-fn spawnPipe(
- core: *pardes.Pardes,
- io: std.Io,
- gpa: std.mem.Allocator,
- q: *Queue,
- tasks: *PipeTasks,
- id: u32,
-) void {
- if (tasks.len == tasks.items.len) {
- core.update(.{ .pipe_resp = .{ .id = id, .success = false, .outputs = &.{} } });
- return;
- }
- const view = core.pipeRequest(id) orelse return;
- const job = selection_pipe.Job.copy(gpa, view) catch |err| {
- core.update(.{ .pipe_resp = .{ .id = id, .success = false, .outputs = &.{} } });
- return core.reportError(core.active, "pipe", err);
- };
- const future = io.concurrent(pipeThread, .{ io, gpa, job, q }) catch |err| {
- job.deinit(gpa);
- core.update(.{ .pipe_resp = .{ .id = id, .success = false, .outputs = &.{} } });
- return core.reportError(core.active, "pipe", err);
- };
- std.debug.assert(tasks.add(.{ .id = id, .future = future }));
-}
test "GUI worker setup failures finish matching LSP and pipe requests" {
const gpa = std.testing.allocator;
@@ -1680,12 +1342,10 @@ test "GUI worker setup failures finish matching LSP and pipe requests" {
var failing = std.testing.FailingAllocator.init(gpa, .{
.fail_index = if (failure == 0) 0 else std.math.maxInt(usize),
});
- var workers: LspWorkers = .{};
var queue: Queue = .{
+ .io = std.testing.io,
.gpa = gpa,
.lsp_allocator = failing.allocator(),
- .lsp_workers = &workers,
- .sdl_wake = false,
};
defer queue.deinit();
var tasks: PipeTasks = .{};
@@ -1700,7 +1360,7 @@ test "GUI worker setup failures finish matching LSP and pipe requests" {
if (failure == 0) {
queue.lsp_id = req.id -% 1;
queue.push(.{ .lsp = .{ .id = queue.lsp_id.?, .rows = try gpa.dupe(u8, "old queued result") } });
- spawnLsp(core, &queue, req);
+ queue.startLsp(core, req);
try std.testing.expectEqual(req.id, queue.lsp_id.?);
try std.testing.expectEqual(@as(usize, 0), queue.completion_len);
queue.push(.{ .lsp = .{ .id = req.id -% 1, .rows = try gpa.dupe(u8, "late old result") } });
@@ -1714,16 +1374,16 @@ test "GUI worker setup failures finish matching LSP and pipe requests" {
try std.testing.expect(core.lsp_wait == null);
try std.testing.expectEqualStrings("abc", pane.file.?.content);
- pane.cur_col = 2;
- pane.vsel = .{ .active = true, .row = 0, .col = 0, .explicit = true };
+ pane.body.cur_col = 2;
+ pane.body.vsel = .{ .active = true, .row = 0, .col = 0, .explicit = true };
core.update(.{ .key = .{ .cp = '|' } });
core.update(.{ .key = .{ .cp = 't', .text = "tr a-z A-Z" } });
core.update(.{ .key = .{ .cp = pardes.Key.enter } });
- const pipe_id = core.pipe_wait.?.id;
- spawnPipe(core, failing_io, failing.allocator(), &queue, &tasks, pipe_id);
- try std.testing.expect(core.pipe_wait == null);
+ const pipe_id = core.pipe.wait.?.id;
+ selection_pipe.start(failing_io, failing.allocator(), core, &tasks, pipe_id, &queue, Queue.pushPipe);
+ try std.testing.expect(core.pipe.wait == null);
try std.testing.expectEqualStrings("abc", pane.file.?.content);
- try std.testing.expectEqual(@as(usize, 0), workers.active.load(.monotonic));
+ try std.testing.expect(queue.lsp_task == null);
try std.testing.expectEqual(@as(usize, 0), tasks.len);
try std.testing.expectEqual(@as(usize, 0), queue.len);
}
@@ -1734,9 +1394,13 @@ const Gui = struct {
device: *c.SDL_GPUDevice,
swapchain_format: c.SDL_GPUTextureFormat,
pipeline: *c.SDL_GPUGraphicsPipeline,
+ /// The cell pipeline, blending premultiplied over what is drawn under:
+ /// for a frame with a theme's tag plaques, whose blank tag cells let
+ /// them show (tagPlaques).
+ pipeline_over: *c.SDL_GPUGraphicsPipeline,
+ decor_pipeline: *c.SDL_GPUGraphicsPipeline,
overlay_pipeline: *c.SDL_GPUGraphicsPipeline,
image_pipeline: *c.SDL_GPUGraphicsPipeline,
- crt_pipeline: *c.SDL_GPUGraphicsPipeline,
atlas_tex: *c.SDL_GPUTexture,
atlas_sampler: *c.SDL_GPUSampler,
linear_sampler: *c.SDL_GPUSampler,
@@ -1753,6 +1417,11 @@ const Gui = struct {
native_images: std.AutoHashMapUnmanaged(pardes.ImageCacheKey, *c.SDL_GPUTexture) = .empty,
presented_images: std.ArrayListUnmanaged(SavedImagePlace) = .empty,
prepared_images: std.ArrayListUnmanaged(PreparedImage) = .empty,
+ /// renderFrame's cover of the grid (coverFrame): this frame's, then the
+ /// frame a panel transition is leaving.
+ cover: std.ArrayListUnmanaged(Cover) = .empty,
+ /// renderFrame's decor instances, group by group (buildDecor).
+ decor: std.ArrayListUnmanaged(CellInstance) = .empty,
font: *c.UIFont,
font_bytes: []u8 = &.{},
@@ -1761,13 +1430,12 @@ const Gui = struct {
fallbacks: [max_fallback_fonts]?LoadedFallback = @splat(null),
fallback_count: usize = 0,
px: f32,
- scale: f32,
- tagline_scale: f32,
+ tagline_px: f32,
tagline_percent: u8,
tagline_width: u32,
tagline_height: u32,
- attached_layers: ?*const [pardes.MAX_PANES]pardes.BodyLayer = null,
- attached_tag_layers: ?*const [pardes.MAX_TAG_LAYERS]pardes.TagLayer = null,
+ attached_layers: ?*const [pardes.MAX_PANES]pardes.Layer = null,
+ attached_tag_layers: ?*const [pardes.MAX_TAG_LAYERS]pardes.Layer = null,
cell_w: u32,
cell_h: u32,
ascent: i32,
@@ -1777,8 +1445,12 @@ const Gui = struct {
glyphs: std.AutoHashMap(GlyphKey, Slot),
pen_x: u32 = 0,
pen_y: u32 = 0,
- atlas_dirty: bool = true,
+ /// 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 },
+ words: Words = .{},
touch: Touch = .{},
pet_state: pet.State = .{},
@@ -1788,28 +1460,68 @@ const Gui = struct {
scroll_pane: ?usize = null,
scroll_rect: pardes.Rect = .{ .x = 0, .y = 0, .w = 0, .h = 0 },
scroll_body_y: u16 = 0, // that rect's first BODY row (Tagbottom moves it)
+ scroll_body_h: u16 = 0, // and its BODY rows, which a taller tag leaves fewer of
+ scroll_held_px: f32 = 0, // its tree-sitter context band, which never moves
scroll_col: u16 = 0, // where the wheel turned: crossed rows are delivered
scroll_row: u16 = 0, // THERE, not wherever the pointer has drifted to since
scroll_delta: f32 = 0, // finite raw distance waiting for the render batch
scroll_lag: f32 = 0, // picture position - core position, in rows
scroll_edge: []pardes.Cell = &.{}, // the row that just left the pane
scroll_edge_len: u16 = 0,
-
+ /// G6: a wheel's notches, whole lines, scroll the core at once and the
+ /// picture follows on a spring (Glide), never the other way round.
+ scroll_notch: i32 = 0,
+ /// A touchpad's fraction toward the next turn sent to a program that
+ /// owns the wheel (terminal.ownsWheel).
+ program_wheel: f32 = 0,
+ glide: Glide = .{},
+ /// PARDES_FRAMES_DEMO: the timedemo (FrameStats.named), its next step
+ /// and when it started; null when none runs.
+ demo: []const pardes.FrameStats.Step = &.{},
+ demo_name: []const u8 = "",
+ demo_next: ?usize = null,
+ demo_start_ns: u64 = 0,
+ /// The tick the last paced frame was sampled at (waitInput), and
+ /// whether this loop's wait read an input (drawn at once, not paced).
+ pace_ns: u64 = 0,
+ input_seen: bool = false,
+ /// G9 and G11: the selection's and the hovered word's glow blocks as
+ /// last drawn, for their fade-in.
+ sel_glow: SelGlow = .{},
+ hover_glow: SelGlow = .{},
+ /// G14: the cells last drawn and when each last changed.
+ /// The cursor's blink (blinkNow): when the frame drawn last arrived,
+ /// a redraw owed for an edge, and this frame's cursor mode and alpha.
+ frame_arrival_ns: u64 = 0,
+ blink_due: bool = false,
+ no_blink: bool = false,
+ cursor_quad_alpha: f32 = 0,
scene_tex: ?*c.SDL_GPUTexture = null,
scene_tex_w: u32 = 0,
scene_tex_h: u32 = 0,
scene_failures: u8 = 0,
scene_target_failed: bool = false,
- presented_scene: crt.Frame = .{},
+ /// The post chain, run over the frame in scene_tex.
+ post: Post = .{},
pointer_present: bool = false,
arrow_cursor: ?*c.SDL_Cursor = null,
link_cursor: ?*c.SDL_Cursor = null,
+ box_cursor: ?*c.SDL_Cursor = null,
pointer_shape: pardes.Surface.PointerShape = .arrow,
pointer_mapped: bool = false,
pointer_cell: ?MouseCell = null,
+ /// The core the hit test asks (hitTest), while a local session runs;
+ /// null attached, where the session's tag is another process's.
+ hit_core: ?*pardes.Pardes = null,
capture: bool = false,
+ /// Pixels the capture holds past the grid (PARDES_TEST_PAD).
+ capture_pad: u32 = 0,
capture_dir: []const u8 = "",
+ /// PARDES_TEST_SERIES: every captured frame is kept too, numbered, for a
+ /// feel review's frame series (docs/render-pipeline.md §8.4).
+ capture_series: bool = false,
+ captured: u32 = 0,
capture_tex: ?*c.SDL_GPUTexture = null,
capture_tex_w: u32 = 0,
capture_tex_h: u32 = 0,
@@ -1817,7 +1529,6 @@ const Gui = struct {
capture_xfer_size: u32 = 0,
soft_present: bool = false,
- transparent: bool = false,
surface_opacity: bool = false,
applied_window_opacity: u8 = 100,
soft_renderer: ?*c.SDL_Renderer = null,
@@ -1886,17 +1597,27 @@ fn deinitFallbackFonts(g: *Gui, gpa: std.mem.Allocator) void {
}
}
-fn fontForCodepoint(g: *const Gui, cp: u32) *c.UIFont {
- if (c.ui_font_has_glyph(g.font, @intCast(cp)) != 0) return g.font;
- for (g.fallbacks[0..g.fallback_count]) |loaded| {
- const face = loaded.?.face;
- if (c.ui_font_has_glyph(face, @intCast(cp)) != 0) return face;
+const FaceGlyph = struct { face: u8, glyph: u32 };
+
+/// The face and glyph that draw `cp`, the face as a GlyphKey face: 0 is the
+/// primary font and i the fallback i - 1. A codepoint no face has draws the
+/// primary's .notdef.
+fn glyphForCodepoint(g: *const Gui, cp: u32) FaceGlyph {
+ const primary = c.ui_font_glyph(g.font, @intCast(cp));
+ if (primary != 0) return .{ .face = 0, .glyph = primary };
+ for (g.fallbacks[0..g.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 g.font;
+ return .{ .face = 0, .glyph = 0 };
}
const CellLayout = struct { w: f32, h: f32, x_off: f32, y_off: f32 };
-const MouseCell = struct { col: u16, row: u16, body_hit: ?pardes.Mouse.BodyHit = null, tag_hit: ?pardes.TagHit = null };
+const MouseCell = struct { col: u16, row: u16, body_hit: ?pardes.Mouse.BodyHit = null, tag_hit: ?pardes.TagHit = null, rule_above: bool = false };
+
+/// How near a row's top edge a press is on the rule drawn there between two
+/// panes: the rule's 2 px and a pixel either side, in logical pixels (dp).
+const rule_grab_px: f32 = 3;
const WindowGeometry = struct {
window_w: f32,
window_h: f32,
@@ -1931,7 +1652,9 @@ fn windowCells(g: *const Gui) GridCells {
};
}
-fn windowPointToPixels(geometry: WindowGeometry, x: f32, y: f32) crt.Point {
+const Point = struct { x: f32, y: f32 };
+
+fn windowPointToPixels(geometry: WindowGeometry, x: f32, y: f32) Point {
return .{
.x = x * geometry.pixel_w / geometry.window_w,
.y = y * geometry.pixel_h / geometry.window_h,
@@ -1945,87 +1668,171 @@ test "high-density window coordinates map once to render pixels" {
.pixel_w = 1120,
.pixel_h = 720,
};
- try std.testing.expectEqual(crt.Point{ .x = 700, .y = 240 }, windowPointToPixels(geometry, 350, 120));
+ try std.testing.expectEqual(Point{ .x = 700, .y = 240 }, windowPointToPixels(geometry, 350, 120));
}
fn fixedCellLayout(g: *const Gui) CellLayout {
return .{ .w = @floatFromInt(g.cell_w), .h = @floatFromInt(g.cell_h), .x_off = 0, .y_off = 0 };
}
-fn compactTaglineLayout(g: *const Gui, origin_col: f32) CellLayout {
- const body_w: f32 = @floatFromInt(g.cell_w);
- const tag_w: f32 = @floatFromInt(g.tagline_width);
- return .{
- .w = tag_w,
- .h = @floatFromInt(g.cell_h),
- .x_off = origin_col * (body_w - tag_w),
- .y_off = 0,
- };
-}
-
-fn taglineLayoutForCell(g: *const Gui, col: u16) CellLayout {
- // Canonical tag cells are physical grips; text is drawn by TagLayer.
- return compactTaglineLayout(g, @floatFromInt(col));
-}
+const boxContains = pardes.animation.Box.contains;
-const boxContains = pardes.layout.Box.contains;
-
-const PaintBatch = struct {
- track: ?pardes.layout.Track = null,
+/// What one tier draws, or one track in tiers 2 and 3 (docs/render-pipeline.md
+/// §3.4), in this order: its cells, its images, then its decor.
+const Group = struct {
+ track: ?pardes.animation.Track = null,
cell_start: u32 = 0,
cell_count: u32 = 0,
image_start: u32 = 0,
image_count: u32 = 0,
+ decor_start: u32 = 0,
+ decor_count: u32 = 0,
+ /// The first `under_count` of the group's decor are drawn before its
+ /// cells, under them (a theme's tag plaques, whose cells let them show).
+ under_count: u32 = 0,
};
-const PaintPlan = struct {
- batches: [pardes.MAX_PANES * 2 + 1]PaintBatch = @splat(.{}),
- len: usize = 1,
+/// The frame's draw groups, bottom to top: tier 0 (the page and the panes
+/// standing still), a group for each track in paint order (tier 2 moving and
+/// opening, tier 3 closing), tier 4 (floating: the notices, then the guides
+/// and the debug box, which the core paints over them) and tier 5 (ink: the
+/// bar cursors; the pet and the touch overlay draw after it). Tier 1 is the
+/// focus lift, which does not exist yet.
+const Groups = struct {
+ items: [pardes.MAX_PANES * 2 + 4]Group = @splat(.{}),
+ /// Groups 1 through `tracks` are the tracks'.
+ tracks: usize = 0,
+ notices: usize = 1,
+ guides: usize = 2,
+ ink: usize = 3,
+ len: usize = 4,
};
-fn makePaintPlan(tracks: []const pardes.layout.Track, has_diff: bool) PaintPlan {
- var plan: PaintPlan = .{};
- for ([_]pardes.layout.Phase{ .moving, .opening, .closing }) |phase| {
- for (tracks) |track| {
- if (!track.active() or track.phase != phase) continue;
- if (track.effect.needsPreviousGrid() and !has_diff) continue;
- std.debug.assert(plan.len < plan.batches.len);
- plan.batches[plan.len].track = track;
- plan.len += 1;
- }
+fn makeGroups(tracks: []const pardes.animation.Track, has_diff: bool) Groups {
+ var groups: Groups = .{};
+ for (tracks) |track| {
+ if (!track.active()) continue;
+ if (track.effect.needsPreviousGrid() and !has_diff) continue;
+ std.debug.assert(groups.tracks < pardes.MAX_PANES * 2);
+ groups.tracks += 1;
+ groups.items[groups.tracks].track = track;
}
- return plan;
+ groups.notices = groups.tracks + 1;
+ groups.guides = groups.tracks + 2;
+ groups.ink = groups.tracks + 3;
+ groups.len = groups.tracks + 4;
+ return groups;
}
-fn paintBatchAt(plan: *const PaintPlan, col: u16, row: u16) usize {
- for (plan.batches[1..plan.len], 1..) |batch, index| {
- if (batch.track.?.phase == .closing) continue;
- if (boxContains(batch.track.?.to, col, row)) return index;
+/// The group of the track whose pane covers this cell, else tier 0.
+fn groupAt(groups: *const Groups, col: u16, row: u16) usize {
+ for (groups.items[1..][0..groups.tracks], 1..) |group, index| {
+ if (group.track.?.phase == .closing) continue;
+ if (boxContains(group.track.?.to, col, row)) return index;
}
return 0;
}
-fn paintBatchForSerial(plan: *const PaintPlan, serial: u32) usize {
- for (plan.batches[1..plan.len], 1..) |batch, index|
- if (batch.track.?.serial == serial) return index;
+fn groupOf(groups: *const Groups, serial: u32) usize {
+ for (groups.items[1..][0..groups.tracks], 1..) |group, index|
+ if (group.track.?.serial == serial) return index;
return 0;
}
-fn panelCellCoord(track: pardes.layout.Track, col: u16, row: u16) u32 {
+/// A notice floats over the panes and its pane's picture (tier 4) while
+/// nothing moves; while anything does it stays in its own pane's group, under
+/// whatever pane slides, opens or closes over it.
+fn noticeGroup(groups: *const Groups, layer: *const pardes.Layer) usize {
+ if (groups.tracks > 0) return groupAt(groups, layer.viewport.x, layer.viewport.y);
+ return groups.notices;
+}
+
+/// What draws a grid cell, marked once a frame from the layers and the
+/// regions (coverFrame), so the cell loops read it rather than search.
+const Cover = packed struct(u16) {
+ /// A layer draws it; the grid's copy is not drawn.
+ layer: bool = false,
+ /// Under a guide or the debug box: drawn from the grid over the panes.
+ floating: bool = false,
+ /// In a pane's grip, `grip_offset` cells from its left: the grip's
+ /// glyph is the cell that far to the left.
+ grip: bool = false,
+ grip_offset: u4 = 0,
+ /// In the focused pane's or column's tag rows.
+ focus: bool = false,
+ /// At a column's left edge, where a tag's anchor is inset.
+ anchor: bool = false,
+ /// In a dirty pane's grip.
+ dirty: bool = false,
+ /// In a pane's grip (not a column's).
+ pane_grip: bool = false,
+ /// In a grip's first row, where its button is.
+ grip_top: bool = false,
+ _: u4 = 0,
+};
+
+/// Marks the grid cells a body or tag layer covers, which the layers paint
+/// themselves, and what the regions say of the rest. Filling each rectangle
+/// once replaces scanning every layer for every cell, which was a third of
+/// the gui's CPU on a full screen of text.
+fn coverFrame(cover: []Cover, cols: u16, rows: u16, body_layers: []const pardes.Layer, tag_layers: []const pardes.Layer, regions: []const pardes.Region) void {
+ @memset(cover, .{});
+ const mark = struct {
+ fn rect(into: []Cover, width: u16, height: u16, r: pardes.Rect, comptime field: []const u8, value: anytype) void {
+ const right = @min(width, @as(u32, r.x) + r.w);
+ if (r.x >= right) return;
+ var y: u32 = r.y;
+ while (y < @min(height, @as(u32, r.y) + r.h)) : (y += 1)
+ for (into[y * width ..][r.x..right]) |*cell| {
+ @field(cell, field) = value;
+ };
+ }
+ };
+ for (body_layers) |*layer| {
+ if (layer.rows != 0) mark.rect(cover, cols, rows, layer.viewport, "layer", true);
+ }
+ for (tag_layers) |*layer| {
+ if (layer.rows != 0) mark.rect(cover, cols, rows, .{ .x = layer.viewport.x, .y = layer.viewport.y, .w = layer.viewport.w, .h = layer.rows }, "layer", true);
+ }
+ // The column bar's rows, which the focused column's tint spans.
+ var bar: ?pardes.Rect = null;
+ for (regions) |region| {
+ if (region.kind == .column_grip) bar = region.rect;
+ }
+ for (regions) |region| switch (region.kind) {
+ .grip, .column_grip => {
+ mark.rect(cover, cols, rows, region.rect, "grip", true);
+ for (0..@min(region.rect.w, 16)) |offset| mark.rect(cover, cols, rows, .{ .x = region.rect.x +| @as(u16, @intCast(offset)), .y = region.rect.y, .w = 1, .h = region.rect.h }, "grip_offset", @as(u4, @intCast(offset)));
+ if (region.kind == .grip and region.active) mark.rect(cover, cols, rows, region.rect, "focus", true);
+ if (region.dirty) mark.rect(cover, cols, rows, region.rect, "dirty", true);
+ if (region.kind == .grip) mark.rect(cover, cols, rows, region.rect, "pane_grip", true);
+ mark.rect(cover, cols, rows, .{ .x = region.rect.x, .y = region.rect.y, .w = region.rect.w, .h = @min(1, region.rect.h) }, "grip_top", true);
+ },
+ .tag => if (region.active) mark.rect(cover, cols, rows, region.rect, "focus", true),
+ .column => {
+ mark.rect(cover, cols, rows, .{ .x = region.rect.x, .y = 0, .w = 1, .h = rows }, "anchor", true);
+ if (region.active) if (bar) |b| mark.rect(cover, cols, rows, .{ .x = region.rect.x, .y = b.y, .w = region.rect.w, .h = b.h }, "focus", true);
+ },
+ .guide, .debug => mark.rect(cover, cols, rows, region.rect, "floating", true),
+ else => {},
+ };
+}
+
+fn panelCellCoord(track: pardes.animation.Track, col: u16, row: u16) u32 {
const source = track.contentBox();
const x0: u16 = @intFromFloat(@max(0.0, @floor(source.x)));
const y0: u16 = @intFromFloat(@max(0.0, @floor(source.y)));
return @as(u32, row -| y0) << 16 | @as(u32, col -| x0);
}
-fn panelGridSize(track: pardes.layout.Track) u32 {
+fn panelGridSize(track: pardes.animation.Track) u32 {
const source = track.contentBox();
const cols: u16 = @intFromFloat(@min(@as(f32, std.math.maxInt(u16)), @max(1.0, @ceil(source.w))));
const rows: u16 = @intFromFloat(@min(@as(f32, std.math.maxInt(u16)), @max(1.0, @ceil(source.h))));
return @as(u32, rows) << 16 | @as(u32, cols);
}
-fn ndcBox(box: pardes.layout.Box, layout: CellLayout, win_w: f32, win_h: f32) [4]f32 {
+fn ndcBox(box: pardes.animation.Box, layout: CellLayout, win_w: f32, win_h: f32) [4]f32 {
const px0 = layout.x_off + box.x * layout.w;
const py0 = layout.y_off + box.y * layout.h;
const px1 = px0 + box.w * layout.w;
@@ -2040,7 +1847,7 @@ fn ndcBox(box: pardes.layout.Box, layout: CellLayout, win_w: f32, win_h: f32) [4
fn setTransitionFields(
instance: anytype,
- track: ?pardes.layout.Track,
+ track: ?pardes.animation.Track,
layout: CellLayout,
win_w: f32,
win_h: f32,
@@ -2071,10 +1878,19 @@ fn setTransitionFields(
instance.present_y0 = presented[1];
instance.present_x1 = presented[2];
instance.present_y1 = presented[3];
- instance.effect = @intFromEnum(active.effect);
+ instance.effect = @backingInt(active.effect);
instance.progress_bits = @bitCast(active.amount());
instance.serial = active.serial;
instance.cell_coord = cell_coord;
+ // A vertical transition shows its pane only inside the box it grows
+ // into, in whole pixels.
+ if (@hasField(@TypeOf(instance.*), "clip_x0") and active.effect == .vertical) {
+ const box = active.contentBox();
+ instance.clip_x0 = std.math.clamp(@floor(box.x * layout.w), 0, win_w);
+ instance.clip_y0 = std.math.clamp(@floor(box.y * layout.h), 0, win_h);
+ instance.clip_x1 = std.math.clamp(@ceil((box.x + box.w) * layout.w), instance.clip_x0, win_w);
+ instance.clip_y1 = std.math.clamp(@ceil((box.y + box.h) * layout.h), instance.clip_y0, win_h);
+ }
}
pub const run = runNative;
@@ -2096,29 +1912,85 @@ fn runNative(init: std.process.Init, opts_in: pardes.Options, attach: ?[]const u
log.err("PARDES_TEST requires PARDES_TEST_CAPTURE_DIR", .{});
return error.SdlInit;
}
+ if (test_mode) if (env.get("PARDES_TEST_LATENCY")) |path| {
+ var path_buf: [4096]u8 = undefined;
+ if (std.fmt.bufPrintSentinel(&path_buf, "{s}", .{path}, 0)) |z|
+ latency_fd = libc.open(z, .{ .ACCMODE = .WRONLY, .CREAT = true, .TRUNC = true, .CLOEXEC = true }, @as(libc.mode_t, 0o644))
+ else |_| {}
+ };
+ // SDL frees with whichever functions are current, so they go in before
+ // its first call, while nothing of SDL's exists yet.
+ sdl_allocator = gpa;
+ if (!c.SDL_SetMemoryFunctions(sdl_heap.malloc, sdl_heap.calloc, sdl_heap.realloc, sdl_heap.free)) {
+ log.err("SDL_SetMemoryFunctions: {s}", .{c.SDL_GetError()});
+ return error.SdlInit;
+ }
_ = c.SDL_SetHint("SDL_JOYSTICK_HIDAPI", "1"); // SDL_HINT_JOYSTICK_HIDAPI
_ = c.SDL_SetHint("SDL_JOYSTICK_HIDAPI_STEAMDECK", "1"); // ..._STEAMDECK
if (!c.SDL_Init(c.SDL_INIT_VIDEO | c.SDL_INIT_GAMEPAD)) {
log.err("SDL_Init: {s}", .{c.SDL_GetError()});
return error.SdlInit;
}
- var win_flags: c.SDL_WindowFlags = c.SDL_WINDOW_RESIZABLE;
+ // SDL allocates from gpa (above), so what it still holds at exit is in a
+ // Debug build's leak report. The window, the GPU device and everything
+ // made on it go back first (the defers below run before this one). What
+ // is left is SDL 3.4.4's: its Vulkan backend never frees two 32-byte
+ // arrays per command buffer (VULKAN_INTERNAL_DestroyCommandPool; SDL's
+ // main branch frees them).
+ defer c.SDL_Quit();
+ // No title bar or frame from anyone: borderless asks the compositor for
+ // none (xdg-decoration's client side, which SDL then leaves undrawn).
+ var win_flags: c.SDL_WindowFlags = c.SDL_WINDOW_RESIZABLE | c.SDL_WINDOW_BORDERLESS;
if (!test_mode) win_flags |= c.SDL_WINDOW_HIGH_PIXEL_DENSITY;
+ // A test run renders to the capture texture; keep it off the desktop.
+ if (test_mode) win_flags |= c.SDL_WINDOW_HIDDEN;
const native_wayland = !test_mode and std.mem.eql(u8, std.mem.span(c.SDL_GetCurrentVideoDriver()), "wayland");
// Background-only opacity needs per-pixel alpha; whole-window compositor
// opacity would dim the text as well. SDL requires this flag at creation.
- const surface_opacity = config.gui_transparent or native_wayland;
+ const surface_opacity = native_wayland;
if (surface_opacity) win_flags |= c.SDL_WINDOW_TRANSPARENT;
- const window = c.SDL_CreateWindow("pardes", 1120, 720, win_flags) orelse {
+ // `--geometry=WxH[+X+Y]`, as X11 programs take it.
+ var want_w: c_int = 1120;
+ var want_h: c_int = 720;
+ var want_at: ?[2]c_int = null;
+ if (opts_in.geometry) |spec| geometry: {
+ const x_at = std.mem.indexOfScalar(u8, spec, 'x') orelse break :geometry;
+ const plus = std.mem.indexOfAnyPos(u8, spec, x_at, "+-") orelse spec.len;
+ want_w = std.math.clamp(std.fmt.parseInt(c_int, spec[0..x_at], 10) catch break :geometry, 200, 16384);
+ want_h = std.math.clamp(std.fmt.parseInt(c_int, spec[x_at + 1 .. plus], 10) catch break :geometry, 120, 16384);
+ if (plus == spec.len) break :geometry;
+ const second = std.mem.indexOfAnyPos(u8, spec, plus + 1, "+-") orelse break :geometry;
+ const gx = std.fmt.parseInt(c_int, spec[plus + @intFromBool(spec[plus] == '+') .. second], 10) catch break :geometry;
+ const gy = std.fmt.parseInt(c_int, spec[second + @intFromBool(spec[second] == '+') ..], 10) catch break :geometry;
+ want_at = .{ gx, gy };
+ }
+ const window = c.SDL_CreateWindow("pardes", want_w, want_h, win_flags) orelse {
log.err("SDL_CreateWindow: {s}", .{c.SDL_GetError()});
return error.SdlInit;
};
+ defer c.SDL_DestroyWindow(window);
+ if (want_at) |at| _ = c.SDL_SetWindowPosition(window, at[0], at[1]);
+ updateDisplayScale(window);
if (native_wayland) log.info("Wayland opacity: background-only transparent surface", .{});
- const arrow_cursor = c.SDL_CreateCursor(&p9_arrow_set, &p9_arrow_mask, 16, 16, 1, 1);
+ // On Linux the desktop's own cursor theme draws them (the compositor's
+ // cursor-shape protocol, else XCURSOR_THEME), at its size and scale:
+ // the arrow is its default, acme's box its move, as the plan9 theme
+ // has them. Elsewhere acme's bitmaps, at 16 pixels.
+ const themed_cursors = builtin.os.tag == .linux;
+ const arrow_cursor = if (themed_cursors)
+ c.SDL_CreateSystemCursor(c.SDL_SYSTEM_CURSOR_DEFAULT)
+ else
+ c.SDL_CreateCursor(&p9_arrow_set, &p9_arrow_mask, 16, 16, 1, 1);
defer if (arrow_cursor) |cursor| c.SDL_DestroyCursor(cursor);
const link_cursor = c.SDL_CreateSystemCursor(c.SDL_SYSTEM_CURSOR_POINTER);
defer if (link_cursor) |cursor| c.SDL_DestroyCursor(cursor);
+ // Its hot spot the middle, as acme's {-7, -7} offset puts it.
+ const box_cursor = if (themed_cursors)
+ c.SDL_CreateSystemCursor(c.SDL_SYSTEM_CURSOR_MOVE)
+ else
+ c.SDL_CreateCursor(&p9_box_set, &p9_box_mask, 16, 16, 7, 7);
+ defer if (box_cursor) |cursor| c.SDL_DestroyCursor(cursor);
if (arrow_cursor) |cur| {
_ = c.SDL_SetCursor(cur);
} else log.err("SDL_CreateCursor: {s}", .{c.SDL_GetError()});
@@ -2126,6 +1998,7 @@ fn runNative(init: std.process.Init, opts_in: pardes.Options, attach: ?[]const u
log.err("SDL_CreateGPUDevice: {s}", .{c.SDL_GetError()});
return error.SdlInit;
};
+ defer c.SDL_DestroyGPUDevice(device);
var soft_present = false;
var soft_renderer: ?*c.SDL_Renderer = null;
const force_soft = if (env.get("PARDES_SOFT_PRESENT")) |raw|
@@ -2172,23 +2045,36 @@ fn runNative(init: std.process.Init, opts_in: pardes.Options, attach: ?[]const u
else
c.SDL_GetGPUSwapchainTextureFormat(device, window);
+ font_allocator = gpa;
const font = c.ui_font_new(font_ttf.ptr, @intCast(font_ttf.len)) orelse {
log.err("ui_font_new failed", .{});
return error.FontInit;
};
- const px: f32 = 27.0;
- const scale = c.ui_font_scale_for_height(font, px);
+ // HarfBuzz's process-wide objects are made once and never freed: made
+ // from the default heap, they stay out of a Debug build's leak report.
+ font_allocator = std.heap.smp_allocator;
+ c.ui_font_prime(font);
+ font_allocator = gpa;
+ // A harness forcing a density (PARDES_TEST_SCALE) draws the text as a
+ // person on that display would size it, so its chrome is seen at the
+ // proportion it has there; PARDES_TEST_FONT_SCALE sizes the text alone
+ // (a density's text with 1x chrome: how it looked before dp). A live
+ // window keeps the size the user sets.
+ const font_scale: f32 = if (env.get("PARDES_TEST_FONT_SCALE")) |v| std.fmt.parseFloat(f32, v) catch display_scale else display_scale;
+ const px: f32 = if (test_mode) 27.0 * std.math.clamp(font_scale, 1, 4) else 27.0;
var cw: c_int = 10;
var chh: c_int = 20;
var asc: c_int = 16;
- c.ui_font_cell_metrics(font, scale, &cw, &chh, &asc);
+ c.ui_font_cell_metrics(font, px, &cw, &chh, &asc);
const cell_w: u32 = @intCast(@max(cw, 1));
const cell_h: u32 = @intCast(@max(chh, 1));
const tagline = taglineRaster(font, px, cell_w, cell_h, config.gui_tagline_font_percent);
if (test_mode) {
const cols = envU16(env, "PARDES_TEST_COLS") orelse 80;
const rows = envU16(env, "PARDES_TEST_ROWS") orelse 24;
- _ = c.SDL_SetWindowSize(window, @intCast(cols * cell_w), @intCast(rows * cell_h));
+ // PARDES_TEST_PAD: extra pixels past the grid, as a real window has.
+ const pad = envU16(env, "PARDES_TEST_PAD") orelse 0;
+ _ = c.SDL_SetWindowSize(window, @intCast(cols * cell_w + pad), @intCast(rows * cell_h + pad));
_ = c.SDL_SyncWindow(window);
}
@@ -2219,10 +2105,11 @@ fn runNative(init: std.process.Init, opts_in: pardes.Options, attach: ?[]const u
var ax_info = c.SDL_GPUTransferBufferCreateInfo{ .usage = c.SDL_GPU_TRANSFERBUFFERUSAGE_UPLOAD, .size = atlas_w * atlas_h, .props = 0 };
const atlas_xfer = c.SDL_CreateGPUTransferBuffer(device, &ax_info) orelse return error.GpuCreate;
- const pipeline = try makePipeline(device, swapchain_format);
+ const pipeline = try makePipeline(device, swapchain_format, frag_spv, 1, std.mem.zeroes(c.SDL_GPUColorTargetBlendState));
+ const pipeline_over = try makePipeline(device, swapchain_format, frag_spv, 1, premultipliedBlend());
+ const decor_pipeline = try makePipeline(device, swapchain_format, decor_frag_spv, 0, backgroundLayerBlend());
const overlay_pipeline = try makeOverlayPipeline(device, swapchain_format);
const image_pipeline = try makeImagePipeline(device, swapchain_format);
- const crt_pipeline = try makeCrtPipeline(device, swapchain_format);
const overlay_buffer_size: u32 = @intCast(max_overlay_vertices * @sizeOf(OverlayVertex));
var ovb_info = c.SDL_GPUBufferCreateInfo{ .usage = c.SDL_GPU_BUFFERUSAGE_VERTEX, .size = overlay_buffer_size, .props = 0 };
@@ -2246,12 +2133,14 @@ fn runNative(init: std.process.Init, opts_in: pardes.Options, attach: ?[]const u
.window = window,
.arrow_cursor = arrow_cursor,
.link_cursor = link_cursor,
+ .box_cursor = box_cursor,
.device = device,
.swapchain_format = swapchain_format,
.pipeline = pipeline,
+ .pipeline_over = pipeline_over,
+ .decor_pipeline = decor_pipeline,
.overlay_pipeline = overlay_pipeline,
.image_pipeline = image_pipeline,
- .crt_pipeline = crt_pipeline,
.atlas_tex = atlas_tex,
.atlas_sampler = atlas_sampler,
.linear_sampler = linear_sampler,
@@ -2264,8 +2153,7 @@ fn runNative(init: std.process.Init, opts_in: pardes.Options, attach: ?[]const u
.image_capacity = initial_image_capacity,
.font = font,
.px = px,
- .scale = scale,
- .tagline_scale = tagline.scale,
+ .tagline_px = tagline.px,
.tagline_percent = config.gui_tagline_font_percent,
.tagline_width = tagline.width,
.tagline_height = tagline.height,
@@ -2276,21 +2164,49 @@ fn runNative(init: std.process.Init, opts_in: pardes.Options, attach: ?[]const u
.atlas_stage = atlas_stage,
.glyphs = std.AutoHashMap(GlyphKey, Slot).init(gpa),
.capture = test_mode,
+ .capture_pad = if (test_mode) envU16(env, "PARDES_TEST_PAD") orelse 0 else 0,
+ .capture_series = test_mode and env.get("PARDES_TEST_SERIES") != null,
.capture_dir = capture_dir orelse "",
.soft_present = soft_present,
- .transparent = config.gui_transparent,
+ .demo = if (env.get("PARDES_FRAMES_DEMO")) |name| pardes.FrameStats.named(name) orelse &.{} else &.{},
+ .demo_name = env.get("PARDES_FRAMES_DEMO") orelse "",
+ .demo_next = if (env.get("PARDES_FRAMES_DEMO")) |name| (if (pardes.FrameStats.named(name) != null) @as(?usize, 0) else null) else null,
.surface_opacity = surface_opacity,
.soft_renderer = soft_renderer,
};
+ // The pipelines, textures and buffers the Gui holds, whatever they were
+ // regrown to; the image ones are released below.
+ defer {
+ c.SDL_ReleaseGPUGraphicsPipeline(device, g.pipeline);
+ c.SDL_ReleaseGPUGraphicsPipeline(device, g.pipeline_over);
+ c.SDL_ReleaseGPUGraphicsPipeline(device, g.decor_pipeline);
+ c.SDL_ReleaseGPUGraphicsPipeline(device, g.overlay_pipeline);
+ c.SDL_ReleaseGPUTexture(device, g.atlas_tex);
+ c.SDL_ReleaseGPUSampler(device, g.atlas_sampler);
+ c.SDL_ReleaseGPUSampler(device, g.linear_sampler);
+ c.SDL_ReleaseGPUTransferBuffer(device, g.atlas_xfer);
+ c.SDL_ReleaseGPUBuffer(device, g.overlay_vbuf);
+ c.SDL_ReleaseGPUTransferBuffer(device, g.overlay_vxfer);
+ if (g.vbuf) |buffer| c.SDL_ReleaseGPUBuffer(device, buffer);
+ if (g.vxfer) |transfer| c.SDL_ReleaseGPUTransferBuffer(device, transfer);
+ if (g.scene_tex) |texture| c.SDL_ReleaseGPUTexture(device, texture);
+ if (g.capture_tex) |texture| c.SDL_ReleaseGPUTexture(device, texture);
+ if (g.capture_xfer) |transfer| c.SDL_ReleaseGPUTransferBuffer(device, transfer);
+ if (g.gamepad) |pad| c.SDL_CloseGamepad(pad);
+ }
setGuiFontName(&g, "Adwaita Mono");
loadFallbackFonts(&g, gpa);
defer deinitFallbackFonts(&g, gpa);
defer g.glyphs.deinit();
+ defer g.words.deinit(gpa);
defer {
clearNativeImages(&g);
g.native_images.deinit(gpa);
g.presented_images.deinit(gpa);
g.prepared_images.deinit(gpa);
+ g.cover.deinit(gpa);
+ g.decor.deinit(gpa);
+ g.post.deinit(gpa, device);
}
defer c.SDL_ReleaseGPUTransferBuffer(device, g.image_vxfer);
defer c.SDL_ReleaseGPUBuffer(device, g.image_vbuf);
@@ -2298,9 +2214,13 @@ fn runNative(init: std.process.Init, opts_in: pardes.Options, attach: ?[]const u
defer if (g.font_bytes.len != 0) gpa.free(g.font_bytes); // set by Font, if it ran
defer c.ui_font_free(g.font);
defer gpa.free(g.scroll_edge); // grown on demand by stepScroll
- _ = c.ui_font_raster(font, scale, ' ', atlas_stage.ptr, @intCast(atlas_w), @intCast(cell_w), @intCast(cell_h), asc);
- g.pen_x = cell_w;
+ defer g.glide.deinit(gpa);
+ resetGlyphAtlas(&g);
+ // The window is dragged by the workspace tag's blank (hitTest): the
+ // compositor moves it, as it does a title bar.
+ if (!test_mode and !c.SDL_SetWindowHitTest(window, hitTest, &g))
+ log.warn("SDL_SetWindowHitTest: {s}", .{c.SDL_GetError()});
if (attach) |requested| return attachRequested(gpa, &g, requested);
var attached: ?detached_client.Client = null;
try localSession(init, &g, opts_in, test_mode, &attached);
@@ -2320,9 +2240,12 @@ fn localSession(
defer pardes.memory.deinit();
pardes.image.start(io, allocs.image); // stb_image allocator for image panes
if (comptime pardes.pdf_enabled) pardes.pdf.start(allocs.pdf);
+ // Pages render on lanes off the loop (pdf_view.workers).
+ if (comptime pardes.pdf_enabled) pardes.panes.Pdf.workers = io;
pardes.syntax.start(allocs.tree_sitter);
defer {
pardes.image.stop();
+ if (comptime pardes.pdf_enabled) pardes.panes.Pdf.dropKept();
if (comptime pardes.pdf_enabled) pardes.pdf.stop();
pardes.syntax.stop();
}
@@ -2341,27 +2264,33 @@ fn localSession(
var core = if (opts.load_path) |lp| blk: {
const bytes = try @import("../fs.zig").readFile(gpa, lp);
defer gpa.free(bytes);
- break :blk try pardes.Pardes.initFromDump(allocs.pardes, opts, bytes);
+ break :blk try pardes.dump.initFromDump(allocs.pardes, opts, bytes);
} else try pardes.Pardes.init(allocs.pardes, opts);
defer core.deinit();
+ g.hit_core = core;
+ defer g.hit_core = null;
+ core.windowed = true;
core.native_images = true;
+ core.native_image_patches = true;
observeGuiFont(g, core);
syncTaglineFont(g, core);
+ syncLigatures(g, core);
var prompt_rcs = host_io.Shell.prepare();
defer prompt_rcs.deinit();
var ptys: [pardes.MAX_PANES]?Pty = @splat(null);
var gens: [pardes.MAX_PANES]u32 = @splat(0);
- var lsp_workers: LspWorkers = .{};
var queue: Queue = .{
+ .io = io,
.gpa = gpa,
.lsp_allocator = allocs.lsp,
- .lsp_workers = &lsp_workers,
- .sdl_wake = true,
+ .wake_fn = sdlWake,
};
defer {
- lsp_workers.wait();
+ if (queue.lsp_task) |*task| task.future.cancel(io);
+ // Its worker may be waiting on the queue for room.
+ core.stream.cancelTask();
queue.deinit();
}
var pipe_tasks: PipeTasks = .{};
@@ -2400,14 +2329,22 @@ fn localSession(
.watches = &watches,
.fs = fs,
.test_mode = test_mode,
+ .test_clock = if (test_mode) host_io.testClock() else null,
+ .test_hz = if (std.c.getenv("PARDES_TEST_HZ")) |hz| @max(1, std.fmt.parseInt(u64, std.mem.span(hz), 10) catch 60) else 60,
};
defer shell.shutdownPtys();
+ defer shell.shaders.deinit(gpa, inotify_fd, &watches);
+ // A virtual clock never blinks: goldens and feel series hold still.
+ g.no_blink = shell.test_clock != null;
+ frame_probe = &core.frames;
+ frame_capture_dir = if (std.c.getenv("PARDES_FRAMES_CAPTURE")) |dir| std.mem.span(dir) else null;
const host = shell.host();
core.host = host;
while (core.nextEffect()) |e| core.perform(e);
- for (&ptys, 0..) |*slot, id| if (slot.*) |*pt|
- try spawnReader(gpa, pt, @intCast(id), gens[id], &queue);
+ for (&ptys, 0..) |*slot, id| if (slot.*) |*pt| {
+ pt.reader = try queue.startReader(.{ .handle = pt.fd, .flags = .{ .nonblocking = false } }, @intCast(id), gens[id]);
+ };
if (inotify_fd >= 0) {
watch_stop = try stopPipe();
watch_reader = try std.Thread.spawn(.{}, watchThread, .{ inotify_fd, watch_stop[0], &queue });
@@ -2418,10 +2355,13 @@ fn localSession(
if (test_mode) setStdinRaw() catch {};
shell.threads_ok = true;
- pardes.lsp.setStatusSink(&queue, lspStatusSink);
+ pardes.lsp.setStatusSink(&queue, Queue.lspStatus);
defer pardes.lsp.setStatusSink(null, null);
+ host_io.setExitWake(&queue, Queue.wakeForExit);
+ defer host_io.setExitWake(null, null);
while (!core.quit) {
+ pardes.turn.bump(&pardes.turn.restores);
try core.pump(host);
if (core.quit) break; // a session that ended does not restore into one
if (core.takeAttach()) |req| {
@@ -2439,12 +2379,12 @@ fn localSession(
}
}
if (core.takeRestore()) |rp| blk: {
- const bytes = filesystem.readRestore(gpa, rp) catch |err| {
+ const bytes = filesystem.readRestore(gpa, rp, core.settings.dump_dir.get()) catch |err| {
core.reportError(core.active, "Restore", err);
break :blk;
};
defer gpa.free(bytes);
- const nc = core.restore(bytes) catch |err| {
+ const nc = dump.restore(core, bytes, rp) catch |err| {
core.reportError(core.active, "Restore", err);
break :blk;
};
@@ -2464,14 +2404,18 @@ fn localSession(
g.presented_images.clearRetainingCapacity();
g.prepared_images.clearRetainingCapacity();
nc.native_images = true;
+ nc.native_image_patches = true;
nc.host = host;
- if (fs) |f| f.reset(core);
+ if (fs) |f| f.reset(nc);
+ nc.windowed = true;
core.deinit();
core = nc;
+ g.hit_core = nc;
shell.core = nc;
shell.surface = null;
observeGuiFont(g, core);
syncTaglineFont(g, core);
+ syncLigatures(g, core);
}
}
@@ -2564,6 +2508,7 @@ fn attachedLoop(gpa: std.mem.Allocator, g: *Gui, client: *detached_client.Client
in.post(.{ .paste = text });
},
.open_link => |url| look.openLink(url),
+ .post => dirty = true,
}
}
try link;
@@ -2579,32 +2524,27 @@ fn attachedLoop(gpa: std.mem.Allocator, g: *Gui, client: *detached_client.Client
geom = now;
try attachedResize(client, g, now.cols, now.rows);
}
- if (!dirty) continue;
+ // The session's chain, its files compiled there.
+ g.post.sync(gpa, g.device, g.swapchain_format, client.post.list(), client.post_key, null);
+ if (!dirty) {
+ // As a local window does: a chain that moves on its own redraws
+ // alone, once a refresh.
+ if (g.post.animating(client.post.animation) and g.scene_tex != null and
+ c.SDL_GetTicksNS() -| g.post.last_ns + std.time.ns_per_ms >= refreshNs(g)) redrawPost(g, gpa);
+ continue;
+ }
dirty = false;
paintAttached(g, gpa, client);
}
}
fn paintAttached(g: *Gui, gpa: std.mem.Allocator, client: *detached_client.Client) void {
- var surface: pardes.Surface = .{
- .cols = client.cols,
- .rows = client.rows,
- .cells = client.grid.items,
- .cursor = if (client.cursor) |cu| .{ .x = cu.x, .y = cu.y, .bar = cu.bar } else null,
- .pointer_shape = client.pointer_shape,
- .body_layers = client.body_layers,
- .tag_layers = client.tag_layers,
- };
- const chrome = frameChromeBg(&surface);
+ var surface = attachedSurface(client);
_ = renderFrame(
g,
gpa,
null,
&surface,
- null,
- chrome,
- chrome,
- .{},
false,
) catch |err| blk: {
log.err("render: {t}", .{err});
@@ -2612,17 +2552,70 @@ fn paintAttached(g: *Gui, gpa: std.mem.Allocator, client: *detached_client.Clien
};
}
-fn frameChromeBg(surface: *const pardes.Surface) [3]u8 {
- if (surface.rows == 0 or surface.cols == 0) return bg_default;
- for (surface.cells[0..surface.cols]) |cell| {
- if (cell.default or cell.style.font_role != .tagline) continue;
- return switch (cell.style.bg) {
- .default => bg_default,
- .index => |i| palColor(i),
- .rgb => |rgb| rgb,
- };
- }
- return bg_default;
+/// The session's frame as a surface: its cells, layers, regions and palette,
+/// so its chrome is drawn from them as a local one's is.
+fn attachedSurface(client: *const detached_client.Client) pardes.Surface {
+ var surface: pardes.Surface = .{
+ .cols = client.cols,
+ .rows = client.rows,
+ .cells = client.grid.items,
+ .cursor = if (client.cursor) |cu| .{ .x = cu.x, .y = cu.y, .bar = cu.bar } else null,
+ .pointer_shape = client.pointer_shape,
+ .body_layers = client.body_layers,
+ .tag_layers = client.tag_layers,
+ .chrome = client.chrome,
+ };
+ const placed = client.regions.items[0..@min(client.regions.items.len, surface.regions.len)];
+ @memcpy(surface.regions[0..placed.len], placed);
+ surface.nregions = @intCast(placed.len);
+ return surface;
+}
+
+test "an attached frontend draws the session's chrome from its frame alone" {
+ const gpa = std.testing.allocator;
+ const core = try pardes.Pardes.init(gpa, .{ .cols = 80, .rows = 24 });
+ defer core.deinit();
+ // A gui-shaped core, whose tags and notices are layers.
+ core.update(.{ .resize = .{ .cols = 80, .rows = 24, .row_metrics = .{ .body_w = 10, .body_h = 20, .tagline_w = 6, .tagline_h = 12 } } });
+ _ = try core.newShell(1, "");
+ try std.testing.expect(pardes.layout.splitColumn(core, 0, 1, false));
+ core.settings.focus_tint = true;
+ try std.testing.expect(core.executeBuiltinLine(0, "Msg a notice with a rule under it"));
+ core.sync();
+ // Past its slide into place, where its rule shows.
+ for (0..30) |_| core.update(.tick);
+ const s = try core.render(core.scratch.allocator());
+
+ const wire = @import("../detached/wire.zig");
+ var client: detached_client.Client = .{ .gpa = gpa };
+ defer client.deinit();
+ var welcome: [64]u8 = undefined;
+ try client.in.appendSlice(gpa, try wire.encodeServer(&welcome, .{ .welcome = .{ .slot = 0, .cols = s.cols, .rows = s.rows } }));
+ const out = try gpa.alloc(u8, wire.frameBound(s.cols, s.rows) + wire.layersBound(&s.body_layers, &s.tag_layers, s.regionList()));
+ defer gpa.free(out);
+ try client.in.appendSlice(gpa, try wire.encodeFrameLayers(out, s.cols, s.rows, null, s.pointer_shape, s.cells, &.{}, &s.body_layers, &s.tag_layers, s.regionList(), s.chrome));
+ _ = try client.next();
+ _ = try client.next();
+ const attached = attachedSurface(&client);
+
+ var g: Gui = undefined;
+ g.cell_w = 10;
+ g.cell_h = 20;
+ g.tagline_width = 6;
+ g.tagline_height = 12;
+ g.decor = .empty;
+ g.glide = .{};
+ g.scroll_pane = null;
+ g.scroll_lag = 0;
+ defer g.decor.deinit(gpa);
+ var groups = makeGroups(&.{}, false);
+ try buildDecor(&g, gpa, s, &groups, fixedCellLayout(&g), 800, 480, true);
+ const local = try gpa.dupe(CellInstance, g.decor.items);
+ defer gpa.free(local);
+ try std.testing.expect(local.len > 8);
+ try std.testing.expect(groups.items[groups.notices].decor_count != 0);
+ try buildDecor(&g, gpa, &attached, &groups, fixedCellLayout(&g), 800, 480, true);
+ try std.testing.expectEqualSlices(u8, std.mem.sliceAsBytes(local), std.mem.sliceAsBytes(g.decor.items));
}
fn runGrid(init: std.process.Init, opts_in: pardes.Options) !void {
@@ -2634,9 +2627,12 @@ fn runGrid(init: std.process.Init, opts_in: pardes.Options) !void {
defer pardes.memory.deinit();
pardes.image.start(io, allocs.image);
if (comptime pardes.pdf_enabled) pardes.pdf.start(allocs.pdf);
+ // Pages render on lanes off the loop (pdf_view.workers).
+ if (comptime pardes.pdf_enabled) pardes.panes.Pdf.workers = io;
pardes.syntax.start(allocs.tree_sitter);
defer {
pardes.image.stop();
+ if (comptime pardes.pdf_enabled) pardes.panes.Pdf.dropKept();
if (comptime pardes.pdf_enabled) pardes.pdf.stop();
pardes.syntax.stop();
}
@@ -2655,7 +2651,7 @@ fn runGrid(init: std.process.Init, opts_in: pardes.Options) !void {
const core = if (opts.load_path) |lp| blk: {
const bytes = try @import("../fs.zig").readFile(gpa, lp);
defer gpa.free(bytes);
- break :blk try pardes.Pardes.initFromDump(allocs.pardes, opts, bytes);
+ break :blk try pardes.dump.initFromDump(allocs.pardes, opts, bytes);
} else try pardes.Pardes.init(allocs.pardes, opts);
defer core.deinit();
if (opts.load_path == null)
@@ -2666,15 +2662,15 @@ fn runGrid(init: std.process.Init, opts_in: pardes.Options) !void {
var ptys: [pardes.MAX_PANES]?Pty = @splat(null);
var gens: [pardes.MAX_PANES]u32 = @splat(0);
- var lsp_workers: LspWorkers = .{};
var queue: Queue = .{
+ .io = io,
.gpa = gpa,
.lsp_allocator = allocs.lsp,
- .lsp_workers = &lsp_workers,
- .sdl_wake = false,
};
defer {
- lsp_workers.wait();
+ if (queue.lsp_task) |*task| task.future.cancel(io);
+ // Its worker may be waiting on the queue for room.
+ core.stream.cancelTask();
queue.deinit();
}
var pipe_tasks: PipeTasks = .{};
@@ -2700,11 +2696,14 @@ fn runGrid(init: std.process.Init, opts_in: pardes.Options) !void {
const host = shell.host();
core.host = host;
while (core.nextEffect()) |e| core.perform(e);
- for (&ptys, 0..) |*slot, id| if (slot.*) |*pt|
- try spawnReader(gpa, pt, @intCast(id), gens[id], &queue);
+ for (&ptys, 0..) |*slot, id| if (slot.*) |*pt| {
+ pt.reader = try queue.startReader(.{ .handle = pt.fd, .flags = .{ .nonblocking = false } }, @intCast(id), gens[id]);
+ };
shell.threads_ok = true;
- pardes.lsp.setStatusSink(&queue, lspStatusSink);
+ pardes.lsp.setStatusSink(&queue, Queue.lspStatus);
defer pardes.lsp.setStatusSink(null, null);
+ host_io.setExitWake(&queue, Queue.wakeForExit);
+ defer host_io.setExitWake(null, null);
setStdinRaw() catch {}; // stdin may be a pipe, not a pty — best effort
@@ -2736,6 +2735,9 @@ fn runGrid(init: std.process.Init, opts_in: pardes.Options) !void {
const StdinFeed = struct {
parser: vaxis.Parser = .{},
+ /// Inside the driver's bracketed paste: its keys are the paste's text.
+ in_paste: bool = false,
+ paste: std.ArrayList(u8) = .empty,
cache: vaxis.GraphemeCache = .{},
buf: [1024]u8 = undefined,
fill: usize = 0,
@@ -2758,13 +2760,17 @@ const StdinFeed = struct {
}
var fds = [_]posix.pollfd{.{ .fd = 0, .events = posix.POLL.IN, .revents = 0 }};
- _ = posix.poll(&fds, 16) catch return out;
+ pardes.turn.rest();
+ const polled = posix.poll(&fds, 16);
+ pardes.turn.wake();
+ _ = polled catch return out;
if ((fds[0].revents & posix.POLL.IN) == 0) {
if ((fds[0].revents & (posix.POLL.HUP | posix.POLL.ERR)) != 0) out.eof = true;
return out;
}
const rn = libc.read(0, f.buf[f.fill..].ptr, f.buf.len - f.fill);
if (rn < 0) return out;
+ if (rn > 0) latencyNote("R {d}\n", .{monoNs()});
if (rn == 0) {
out.eof = true;
return out;
@@ -2774,6 +2780,67 @@ const StdinFeed = struct {
var seq_start: usize = 0;
while (seq_start < len) {
+ // ESC]777;mouse;<down|up|motion>;<SDL button, 0 for none>;<x>;<y>[;<mods>]BEL
+ // ESC]777;mouse;wheel;<amount>;<x>;<y>[;<mods>]BEL
+ // A mouse event at window pixels, built as SDL would and run
+ // through dispatch, so a driver exercises the real pointer path
+ // (pixel to cell, tag and body hits). SGR mouse carries only cells.
+ const mouse_prefix = "\x1b]777;mouse;";
+ if (std.mem.startsWith(u8, f.buf[seq_start..len], mouse_prefix)) {
+ const body = f.buf[seq_start + mouse_prefix.len .. len];
+ const end = std.mem.indexOfScalar(u8, body, 0x07) orelse {
+ std.mem.copyForwards(u8, f.buf[0 .. len - seq_start], f.buf[seq_start..len]);
+ f.fill = len - seq_start;
+ break;
+ };
+ if (g) |gp| {
+ var parts = std.mem.splitScalar(u8, body[0..end], ';');
+ const kind = parts.next() orelse "";
+ const second = parts.next() orelse "";
+ const button = std.fmt.parseInt(u8, second, 10) catch 0;
+ const x = std.fmt.parseFloat(f32, parts.next() orelse "") catch 0;
+ const y = std.fmt.parseFloat(f32, parts.next() orelse "") catch 0;
+ // An optional fifth field holds modifiers as xterm
+ // counts them: shift 4, meta (alt) 8, ctrl 16.
+ const held = std.fmt.parseInt(u8, parts.next() orelse "0", 10) catch 0;
+ var sev = std.mem.zeroes(c.SDL_Event);
+ if (std.mem.eql(u8, kind, "wheel")) {
+ // ESC]777;mouse;wheel;<y, SDL's sign: up positive>;<x>;<y>BEL:
+ // a whole number is a mouse's notches, else a touchpad's.
+ const amount = std.fmt.parseFloat(f32, second) catch 0;
+ sev.type = c.SDL_EVENT_MOUSE_WHEEL;
+ sev.wheel.y = amount;
+ sev.wheel.integer_y = @intFromFloat(@trunc(amount));
+ sev.wheel.mouse_x = x;
+ sev.wheel.mouse_y = y;
+ } else if (std.mem.eql(u8, kind, "focus")) {
+ // ESC]777;mouse;focus;<1 gained, 0 lost>;0;0BEL
+ sev.type = if (button != 0) c.SDL_EVENT_WINDOW_FOCUS_GAINED else c.SDL_EVENT_WINDOW_FOCUS_LOST;
+ } else if (std.mem.eql(u8, kind, "motion")) {
+ sev.type = c.SDL_EVENT_MOUSE_MOTION;
+ sev.motion.x = x;
+ sev.motion.y = y;
+ sev.motion.state = if (button == 0 or button > 5) 0 else @as(u32, 1) << @intCast(button - 1);
+ } else {
+ sev.type = if (std.mem.eql(u8, kind, "down")) c.SDL_EVENT_MOUSE_BUTTON_DOWN else c.SDL_EVENT_MOUSE_BUTTON_UP;
+ sev.button.button = button;
+ sev.button.down = std.mem.eql(u8, kind, "down");
+ sev.button.x = x;
+ sev.button.y = y;
+ }
+ const before = c.SDL_GetModState();
+ var mods: c.SDL_Keymod = 0;
+ if (held & 4 != 0) mods |= c.SDL_KMOD_LSHIFT;
+ if (held & 8 != 0) mods |= c.SDL_KMOD_LALT;
+ if (held & 16 != 0) mods |= c.SDL_KMOD_LCTRL;
+ c.SDL_SetModState(mods);
+ dispatch(gp, in, &sev);
+ c.SDL_SetModState(before);
+ out.n_events += 1;
+ }
+ seq_start += mouse_prefix.len + end + 1;
+ continue;
+ }
const prefix = "\x1b]777;finger;";
if (std.mem.startsWith(u8, f.buf[seq_start..len], prefix)) {
const body = f.buf[seq_start + prefix.len .. len];
@@ -2782,23 +2849,14 @@ const StdinFeed = struct {
f.fill = len - seq_start;
break;
};
- if (parseFinger(body[0..end])) |finger_in| {
- var finger = finger_in;
+ if (parseFinger(body[0..end])) |finger| {
if (g) |gp| {
var wpw: c_int = 0;
var wph: c_int = 0;
_ = c.SDL_GetWindowSizeInPixels(gp.window, &wpw, &wph);
const win_w: f32 = @floatFromInt(@max(wpw, 1));
const win_h: f32 = @floatFromInt(@max(wph, 1));
- if (mapScenePoint(gp, finger.x * win_w, finger.y * win_h, win_w, win_h)) |m| {
- finger.x = m.x / win_w;
- finger.y = m.y / win_h;
- handleFinger(&gp.touch, in, finger, win_w, win_h, @floatFromInt(gp.cell_w), @floatFromInt(gp.cell_h), @floatFromInt(gp.tagline_width));
- } else {
- finger.kind = .cancel;
- handleFinger(&gp.touch, in, finger, win_w, win_h, @floatFromInt(gp.cell_w), @floatFromInt(gp.cell_h), @floatFromInt(gp.tagline_width));
- in.post(.pointer_leave);
- }
+ handleFinger(&gp.touch, in, finger, win_w, win_h, @floatFromInt(gp.cell_w), @floatFromInt(gp.cell_h), @floatFromInt(gp.tagline_width));
} else if (in.core) |core| {
handleFinger(&grid_touch, in, finger, @floatFromInt(core.screen_w), @floatFromInt(core.screen_h), 1, 1, 1);
}
@@ -2807,7 +2865,9 @@ const StdinFeed = struct {
seq_start += prefix.len + end + 1;
continue;
}
- if (len - seq_start < prefix.len and std.mem.startsWith(u8, prefix, f.buf[seq_start..len])) {
+ if ((len - seq_start < prefix.len and std.mem.startsWith(u8, prefix, f.buf[seq_start..len])) or
+ (len - seq_start < mouse_prefix.len and std.mem.startsWith(u8, mouse_prefix, f.buf[seq_start..len])))
+ {
std.mem.copyForwards(u8, f.buf[0 .. len - seq_start], f.buf[seq_start..len]);
f.fill = len - seq_start;
break;
@@ -2822,16 +2882,22 @@ const StdinFeed = struct {
seq_start += result.n;
const event = result.event orelse continue;
switch (event) {
- .key_press => |key| {
- var text: []const u8 = "";
- if (key.text) |t| text = f.cache.put(t);
- in.post(.{ .key = .{
- .cp = mapKey(effCp(key)),
- .text = text,
- .ctrl = key.mods.ctrl,
- .alt = key.mods.alt,
- .shift = key.mods.shift,
- } });
+ .key_press => |key| if (f.in_paste) {
+ // A newline reads as Ctrl-J, as the tty's paste has it.
+ const text = key.text orelse if (key.codepoint == vaxis.Key.enter or (key.mods.ctrl and key.codepoint == 'j')) "\n" else if (key.codepoint == vaxis.Key.tab) "\t" else "";
+ f.paste.appendSlice(gpa, text) catch {};
+ } else {
+ postKey(in, key, if (key.text) |t| f.cache.put(t) else "");
+ out.n_events += 1;
+ },
+ .paste_start => {
+ f.in_paste = true;
+ f.paste.clearRetainingCapacity();
+ },
+ .paste_end => {
+ f.in_paste = false;
+ if (f.paste.items.len > 0) in.post(.{ .paste = f.paste.items });
+ f.paste.clearAndFree(gpa);
out.n_events += 1;
},
.mouse => |m| {
@@ -2858,6 +2924,8 @@ const StdinFeed = struct {
.col = @intCast(@max(m.col, 0)),
.row = @intCast(@max(m.row, 0)),
.ctrl = m.mods.ctrl,
+ .shift = m.mods.shift,
+ .alt = m.mods.alt,
} });
out.n_events += 1;
}
@@ -2929,8 +2997,8 @@ fn setStdinRaw() !void {
term.lflag.ICANON = false;
term.lflag.IEXTEN = false;
term.lflag.ISIG = false;
- term.cc[@intFromEnum(posix.V.MIN)] = 1;
- term.cc[@intFromEnum(posix.V.TIME)] = 0;
+ term.cc[@backingInt(posix.V.MIN)] = 1;
+ term.cc[@backingInt(posix.V.TIME)] = 0;
try posix.tcsetattr(0, .NOW, term);
}
@@ -2980,6 +3048,81 @@ fn dumpGrid(gpa: std.mem.Allocator, surface: *pardes.Surface) !void {
_ = host_io.writeFd(1, frame);
}
+/// A key parsed from the stdin a test window reads, posted as the tty
+/// posts one (vaxis_input): F-keys, Insert and the keypad included. `text`
+/// is the key's text as the feed keeps it.
+fn postKey(in: *Input, key: vaxis.Key, text: []const u8) void {
+ var ev = vaxis_input.keyEvent(key);
+ ev.key.text = text;
+ in.post(ev);
+}
+
+test "the GUI's stdin keys reach a terminal pane as the tty's do: F5, Insert and the keypad's Up" {
+ const gpa = std.testing.allocator;
+ const core = try pardes.Pardes.init(gpa, .{ .tty_only = true });
+ defer core.deinit();
+ core.panes[0].?.body.mode = .tty;
+ while (core.nextEffect()) |_| {}
+ var in: Input = .{ .core = core };
+ var parser: vaxis.Parser = .{};
+ var bytes: []const u8 = "\x1b[15~\x1b[2~\x1b[57419u";
+ while (bytes.len > 0) {
+ const result = try parser.parse(bytes, gpa);
+ bytes = bytes[result.n..];
+ if (result.event) |event| switch (event) {
+ .key_press => |key| postKey(&in, key, key.text orelse ""),
+ else => {},
+ };
+ }
+ var written: std.Io.Writer.Allocating = .init(gpa);
+ defer written.deinit();
+ while (core.nextEffect()) |effect| {
+ if (effect == .write) try written.writer.writeAll(effect.write.bytes.slice());
+ }
+ try std.testing.expectEqualStrings("\x1b[15~\x1b[2~\x1b[A", written.written());
+}
+
+test "the window's function and editing keys reach a terminal as its cursor keys' mode and keyboard flags say" {
+ const gpa = std.testing.allocator;
+ const core = try pardes.Pardes.init(gpa, .{ .tty_only = true });
+ defer core.deinit();
+ core.panes[0].?.body.mode = .tty;
+ while (core.nextEffect()) |_| {}
+ var in: Input = .{ .core = core };
+ var written: std.Io.Writer.Allocating = .init(gpa);
+ defer written.deinit();
+ const Case = struct { modes: []const u8, sym: c.SDL_Keycode, mod: c.SDL_Keymod = 0, sent: []const u8 };
+ const cases = [_]Case{
+ .{ .modes = "", .sym = c.SDLK_UP, .sent = "\x1b[A" },
+ .{ .modes = "", .sym = c.SDLK_HOME, .sent = "\x1b[H" },
+ .{ .modes = "", .sym = c.SDLK_F1, .sent = "\x1bOP" },
+ .{ .modes = "", .sym = c.SDLK_F5, .sent = "\x1b[15~" },
+ .{ .modes = "", .sym = c.SDLK_F12, .mod = c.SDL_KMOD_LSHIFT, .sent = "\x1b[24;2~" },
+ .{ .modes = "", .sym = c.SDLK_INSERT, .sent = "\x1b[2~" },
+ // DECCKM: less, vim, htop.
+ .{ .modes = "\x1b[?1h", .sym = c.SDLK_UP, .sent = "\x1bOA" },
+ .{ .modes = "", .sym = c.SDLK_END, .sent = "\x1bOF" },
+ .{ .modes = "", .sym = c.SDLK_LEFT, .mod = c.SDL_KMOD_LCTRL, .sent = "\x1b[1;5D" },
+ // codex's kitty flags (>7u): Ctrl-C and Alt-a are unambiguous.
+ // (A bare Escape at a shell prompt is pardes's way out of raw input.)
+ .{ .modes = "\x1b[?1l\x1b[>7u", .sym = 'c', .mod = c.SDL_KMOD_LCTRL, .sent = "\x1b[99;5u" },
+ .{ .modes = "", .sym = 'a', .mod = c.SDL_KMOD_LALT, .sent = "\x1b[97;3u" },
+ // With event types asked for (2), an arrow says it is a press, as
+ // ghostty says it.
+ .{ .modes = "", .sym = c.SDLK_UP, .sent = "\x1b[1;1:1A" },
+ };
+ for (cases) |case| {
+ core.update(.{ .output = .{ .pane = 0, .bytes = case.modes } });
+ while (core.nextEffect()) |_| {}
+ keyDown(&in, case.sym, case.mod);
+ written.clearRetainingCapacity();
+ while (core.nextEffect()) |effect| {
+ if (effect == .write) try written.writer.writeAll(effect.write.bytes.slice());
+ }
+ try std.testing.expectEqualStrings(case.sent, written.written());
+ }
+}
+
const Input = struct {
core: ?*pardes.Pardes = null,
client: ?*detached_client.Client = null,
@@ -2991,7 +3134,7 @@ const Input = struct {
const client = in.client orelse return;
if (in.lost != null) return;
client.send(.{ .event = ev }) catch |err| switch (err) {
- error.Overlong, error.NoSpace => {},
+ error.Overlong, error.WriteFailed => {},
else => in.lost = err,
};
}
@@ -3003,8 +3146,39 @@ const Input = struct {
};
fn dispatch(g: *Gui, in: *Input, sev: *const c.SDL_Event) void {
+ // An input's time, for its latency to the frame that answers it
+ // (FrameStats): SDL's stamp, moved onto the monotonic clock.
+ switch (sev.type) {
+ c.SDL_EVENT_KEY_DOWN, c.SDL_EVENT_TEXT_INPUT, c.SDL_EVENT_MOUSE_BUTTON_DOWN, c.SDL_EVENT_MOUSE_WHEEL => {
+ g.input_seen = true;
+ if (frame_probe) |probe| probe.input(monoNs() -| (c.SDL_GetTicksNS() -| sev.common.timestamp));
+ },
+ else => {},
+ }
+ // What the post chain sees of the pointer and the focus.
+ switch (sev.type) {
+ c.SDL_EVENT_MOUSE_MOTION => {
+ const at = windowPointToPixels(windowGeometry(g.window), sev.motion.x, sev.motion.y);
+ g.post.mouse(at.x, at.y, null);
+ },
+ c.SDL_EVENT_MOUSE_BUTTON_DOWN, c.SDL_EVENT_MOUSE_BUTTON_UP => {
+ const at = windowPointToPixels(windowGeometry(g.window), sev.button.x, sev.button.y);
+ g.post.mouse(at.x, at.y, sev.button.down);
+ },
+ c.SDL_EVENT_WINDOW_DISPLAY_SCALE_CHANGED => {
+ updateDisplayScale(g.window);
+ // Underlines are drawn into the glyphs a logical pixel thick.
+ resetGlyphAtlas(g);
+ if (in.core) |core| core.needs_frame = true;
+ },
+ c.SDL_EVENT_WINDOW_FOCUS_GAINED => g.post.focus(true),
+ c.SDL_EVENT_WINDOW_FOCUS_LOST => g.post.focus(false),
+ else => {},
+ }
switch (sev.type) {
c.SDL_EVENT_QUIT, c.SDL_EVENT_WINDOW_CLOSE_REQUESTED => in.close(),
+ c.SDL_EVENT_WINDOW_FOCUS_GAINED => in.post(.{ .focus = true }),
+ c.SDL_EVENT_WINDOW_FOCUS_LOST => in.post(.{ .focus = false }),
c.SDL_EVENT_WINDOW_MOUSE_LEAVE => {
g.pointer_present = false;
g.pointer_mapped = false;
@@ -3074,17 +3248,12 @@ fn dispatch(g: *Gui, in: *Input, sev: *const c.SDL_Event) void {
};
g.pointer_mapped = true;
g.pointer_cell = mc;
- in.post(.{
- .mouse = .{
- .button = button,
- .kind = if (b.down) .press else .release,
- .col = mc.col,
- .row = mc.row,
- .tag_hit = mc.tag_hit,
- .body_hit = mc.body_hit,
- .ctrl = (c.SDL_GetModState() & c.SDL_KMOD_CTRL) != 0,
- },
- });
+ var ev = pointerMouse(button, if (b.down) .press else .release, mc, pointerMods());
+ // Let go past the window's edge (SDL follows a held button out
+ // of the window: Wayland's implicit grab, X11's capture).
+ const win = windowGeometry(g.window);
+ ev.outside = !b.down and (b.x < 0 or b.y < 0 or b.x >= win.window_w or b.y >= win.window_h);
+ in.post(.{ .mouse = ev });
},
c.SDL_EVENT_MOUSE_MOTION => {
const m = sev.motion;
@@ -3106,14 +3275,7 @@ fn dispatch(g: *Gui, in: *Input, sev: *const c.SDL_Event) void {
};
g.pointer_mapped = true;
g.pointer_cell = mc;
- in.post(.{ .mouse = .{
- .button = held orelse .none,
- .kind = if (held != null) .drag else .motion,
- .col = mc.col,
- .row = mc.row,
- .tag_hit = mc.tag_hit,
- .body_hit = mc.body_hit,
- } });
+ in.post(.{ .mouse = pointerMouse(held orelse .none, if (held != null) .drag else .motion, mc, pointerMods()) });
},
c.SDL_EVENT_MOUSE_WHEEL => {
const w = sev.wheel;
@@ -3128,54 +3290,11 @@ fn dispatch(g: *Gui, in: *Input, sev: *const c.SDL_Event) void {
};
g.pointer_mapped = true;
g.pointer_cell = mc;
- if (w.y != 0 and std.math.isFinite(w.y)) {
- if (in.core) |core| {
- const hit: ?usize = for (core.panes, 0..) |slot, i| {
- if (slot == null) continue;
- const r = core.rects[i];
- if (mc.col >= r.x and mc.col < r.x + r.w and mc.row >= r.y and mc.row < r.y + r.h) break i;
- } else null;
- if (g.scroll_pane) |old| if (hit == null or hit.? != old) {
- resetScroll(g);
- };
- if (hit) |id| {
- const pdf_target = if (comptime pardes.pdf_enabled)
- core.native_images and core.panes[id].?.pdfPage() != null
- else
- false;
- if (pdf_target) {
- resetScroll(g);
- in.post(.{ .pdf_scroll = .{
- .pane = @intCast(id),
- .delta_pixels = -w.y * @as(f32, @floatFromInt(g.cell_h)),
- } });
- } else {
- g.scroll_pane = id;
- g.scroll_col = mc.col;
- g.scroll_row = mc.row;
- g.scroll_delta = accumulateWheelDelta(g.scroll_delta, w.y);
- }
- }
- } else {
- g.scroll_delta = accumulateWheelDelta(g.scroll_delta, w.y);
- while (g.scroll_delta >= 1) : (g.scroll_delta -= 1)
- in.post(.{ .mouse = .{ .button = .wheel_down, .kind = .press, .col = mc.col, .row = mc.row, .tag_hit = mc.tag_hit, .body_hit = mc.body_hit } });
- while (g.scroll_delta <= -1) : (g.scroll_delta += 1)
- in.post(.{ .mouse = .{ .button = .wheel_up, .kind = .press, .col = mc.col, .row = mc.row, .tag_hit = mc.tag_hit, .body_hit = mc.body_hit } });
- }
- }
- if (w.x != 0) in.post(.{ .mouse = .{
- .button = if (w.x > 0) .wheel_right else .wheel_left,
- .kind = .press,
- .col = mc.col,
- .row = mc.row,
- .tag_hit = mc.tag_hit,
- .body_hit = mc.body_hit,
- } });
+ wheelAt(g, in, .{ .x = w.x, .y = w.y, .integer_y = w.integer_y, .mods = pointerMods() }, mc);
},
c.SDL_EVENT_FINGER_DOWN, c.SDL_EVENT_FINGER_MOTION, c.SDL_EVENT_FINGER_UP, c.SDL_EVENT_FINGER_CANCELED => {
const f = sev.tfinger;
- var finger: Finger = .{
+ const finger: Finger = .{
.kind = switch (sev.type) {
c.SDL_EVENT_FINGER_DOWN => .down,
c.SDL_EVENT_FINGER_MOTION => .motion,
@@ -3194,15 +3313,7 @@ fn dispatch(g: *Gui, in: *Input, sev: *const c.SDL_Event) void {
const win_h: f32 = @floatFromInt(@max(ph, 1));
const fcw: f32 = @floatFromInt(g.cell_w);
const fch: f32 = @floatFromInt(g.cell_h);
- if (mapScenePoint(g, finger.x * win_w, finger.y * win_h, win_w, win_h)) |m| {
- finger.x = m.x / win_w;
- finger.y = m.y / win_h;
- handleFinger(&g.touch, in, finger, win_w, win_h, fcw, fch, @floatFromInt(g.tagline_width));
- } else {
- finger.kind = .cancel;
- handleFinger(&g.touch, in, finger, win_w, win_h, fcw, fch, @floatFromInt(g.tagline_width));
- in.post(.pointer_leave);
- }
+ handleFinger(&g.touch, in, finger, win_w, win_h, fcw, fch, @floatFromInt(g.tagline_width));
},
c.SDL_EVENT_PINCH_BEGIN, c.SDL_EVENT_PINCH_UPDATE => in.post(.{ .pinch = sev.pinch.scale }),
c.SDL_EVENT_GAMEPAD_ADDED => {
@@ -3331,10 +3442,7 @@ fn dispatch(g: *Gui, in: *Input, sev: *const c.SDL_Event) void {
.cap_n => .{ .cp = 'N', .text = "N" },
.enter => .{ .cp = pardes.Key.enter },
.tab => .{ .cp = pardes.Key.tab },
- .tty_toggle => if (in.core) |core|
- .{ .cp = core.opts.tty_toggle, .ctrl = true }
- else
- .{ .cp = config.tty_toggle_alt[0].cp, .shift = true },
+ .tty_toggle => .{ .cp = if (in.core) |core| core.opts.tty_toggle else config.tty_toggle_default, .ctrl = true },
},
}),
.rumble => if (g.gamepad) |pad| {
@@ -3365,6 +3473,13 @@ fn keyDown(in: *Input, sym: c.SDL_Keycode, mod: c.SDL_Keymod) void {
c.SDLK_PAGEUP => pardes.Key.page_up,
c.SDLK_PAGEDOWN => pardes.Key.page_down,
c.SDLK_DELETE => pardes.Key.delete,
+ c.SDLK_INSERT => pardes.Key.insert,
+ c.SDLK_PRINTSCREEN => pardes.Key.print_screen,
+ c.SDLK_SCROLLLOCK => pardes.Key.scroll_lock,
+ c.SDLK_PAUSE => pardes.Key.pause,
+ c.SDLK_APPLICATION => pardes.Key.menu,
+ c.SDLK_F1...c.SDLK_F12 => pardes.Key.f1 + @as(u21, @intCast(sym - c.SDLK_F1)),
+ c.SDLK_F13...c.SDLK_F24 => pardes.Key.f1 + 12 + @as(u21, @intCast(sym - c.SDLK_F13)),
else => blk: {
if (!(ctrl or alt or gui_mod)) break :blk 0;
if (sym < 128 and sym >= ' ') break :blk @intCast(sym);
@@ -3390,9 +3505,11 @@ fn gridCellAtDimensions(
) MouseCell {
const row: u16 = @intFromFloat(@min(@floor(@max(y, 0) / @max(body_h, 1)), 10_000));
var point: MouseCell = .{ .col = @intFromFloat(@min(@floor(@max(x, 0) / @max(body_w, 1)), 10_000)), .row = row };
+ // On the rule over this row, which is where two panes meet if they do.
+ point.rule_above = row > 0 and @max(y, 0) - @as(f32, @floatFromInt(row)) * @max(body_h, 1) < dp(rule_grab_px);
if (core) |p| if (p.presentation.pointerFractional(p.screen_w, p.screen_h, x / @max(body_w, 1), y / @max(body_h, 1))) |mapped| {
for (p.surface.tagLayers()) |*layer| {
- if (layer.hitAt(mapped.x * body_w, mapped.y * body_h, body_w, body_h, tagline_w, @floatFromInt(p.row_metrics.tagline_h))) |hit| {
+ if (layer.tagHit(mapped.x * body_w, mapped.y * body_h, body_w, body_h, tagline_w, @floatFromInt(p.row_metrics.tagline_h))) |hit| {
point.tag_hit = hit;
break;
}
@@ -3404,19 +3521,19 @@ fn gridCellAtDimensions(
fn gridCellAtPixels(g: *const Gui, core: ?*const pardes.Pardes, x: f32, y: f32) MouseCell {
var point = gridCellAtDimensions(core, x, y, @floatFromInt(g.cell_w), @floatFromInt(g.cell_h), @floatFromInt(g.tagline_width));
if (core) |p| if (p.presentation.pointerFractional(p.screen_w, p.screen_h, x / @as(f32, @floatFromInt(g.cell_w)), y / @as(f32, @floatFromInt(g.cell_h)))) |mapped| for (p.surface.bodyLayers()) |*layer| {
- if (layer.hitAt(mapped.x * @as(f32, @floatFromInt(g.cell_w)), mapped.y * @as(f32, @floatFromInt(g.cell_h)), @floatFromInt(g.cell_w), @floatFromInt(g.cell_h), @floatFromInt(g.tagline_width), @floatFromInt(g.tagline_height))) |hit| {
+ if (layer.bodyHit(mapped.x * @as(f32, @floatFromInt(g.cell_w)), mapped.y * @as(f32, @floatFromInt(g.cell_h)), @floatFromInt(g.cell_w), @floatFromInt(g.cell_h), @floatFromInt(g.tagline_width), @floatFromInt(g.tagline_height))) |hit| {
point.body_hit = hit;
break;
}
};
if (core == null) if (g.attached_layers) |layers| for (layers) |*layer| {
- if (layer.hitAt(x, y, @floatFromInt(g.cell_w), @floatFromInt(g.cell_h), @floatFromInt(g.tagline_width), @floatFromInt(g.tagline_height))) |body_hit| {
+ if (layer.bodyHit(x, y, @floatFromInt(g.cell_w), @floatFromInt(g.cell_h), @floatFromInt(g.tagline_width), @floatFromInt(g.tagline_height))) |body_hit| {
point.body_hit = body_hit;
break;
}
};
if (core == null) if (g.attached_tag_layers) |layers| for (layers) |*layer| {
- if (layer.hitAt(x, y, @floatFromInt(g.cell_w), @floatFromInt(g.cell_h), @floatFromInt(g.tagline_width), @floatFromInt(g.tagline_height))) |hit| {
+ if (layer.tagHit(x, y, @floatFromInt(g.cell_w), @floatFromInt(g.cell_h), @floatFromInt(g.tagline_width), @floatFromInt(g.tagline_height))) |hit| {
point.tag_hit = hit;
break;
}
@@ -3451,9 +3568,10 @@ test "tagline pointer mapping retains physical grips and carries logical text co
try std.testing.expect(grip.tag_hit == null);
try std.testing.expectEqual(r.x + config.GUTTER - 1, grip.col);
- const body = gridCellAtDimensions(core, x, (@as(f32, @floatFromInt(tag_y + 1)) + 0.5) * body_h, body_w, body_h, tag_w);
+ const body_y = tag_y + core.panes[core.active].?.tag_rows; // a long tag wraps
+ const body = gridCellAtDimensions(core, x, (@as(f32, @floatFromInt(body_y)) + 0.5) * body_h, body_w, body_h, tag_w);
try std.testing.expectEqual(pixelCell(x, 10), body.col);
- try std.testing.expectEqual(tag_y + 1, body.row);
+ try std.testing.expectEqual(body_y, body.row);
try std.testing.expect(body.tag_hit == null);
const topbar = gridCellAtDimensions(core, 3.5 * tag_w, 0.5 * body_h, body_w, body_h, tag_w);
@@ -3462,20 +3580,145 @@ test "tagline pointer mapping retains physical grips and carries logical text co
try std.testing.expectEqual(pardes.TagKind.workspace, topbar.tag_hit.?.kind);
}
-fn mapScenePoint(g: *const Gui, x: f32, y: f32, w: f32, h: f32) ?crt.Point {
- return crt.mapScene(x, y, w, h, g.presented_scene.effects, g.presented_scene.time_seconds);
+test "a click at the window's corner lands in the corner cell with a post chain on" {
+ const core = try pardes.Pardes.init(std.testing.allocator, .{ .cols = 80, .rows = 24 });
+ defer core.deinit();
+ try std.testing.expect(core.settings.post.set(.crt, "", true));
+ var g: Gui = undefined;
+ g.cell_w = 10;
+ g.cell_h = 20;
+ g.tagline_width = 6;
+ g.tagline_height = 12;
+ const geometry: WindowGeometry = .{ .window_w = 400, .window_h = 240, .pixel_w = 800, .pixel_h = 480 };
+ const last = mouseCellWithGeometry(&g, core, 399.9, 239.9, geometry).?;
+ try std.testing.expectEqual(@as(u16, 79), last.col);
+ try std.testing.expectEqual(@as(u16, 23), last.row);
+ const first = mouseCellWithGeometry(&g, core, 0, 0, geometry).?;
+ try std.testing.expectEqual(@as(u16, 0), first.col);
+ try std.testing.expectEqual(@as(u16, 0), first.row);
+}
+
+/// Where a window point lands: the cell drawn under it. Input is identity:
+/// no post pass moves a pixel (the bundled Crt has no barrel), so a click
+/// is exactly where it looks.
+/// A wheel turned over grid cell `mc` (SDL's sign: up positive): the
+/// part of dispatch after the pointer is placed, so a test can turn it.
+fn wheelAt(g: *Gui, in: *Input, w: WheelTurn, mc: MouseCell) void {
+ if (w.y != 0 and std.math.isFinite(w.y)) {
+ if (in.core) |core| {
+ const hit: ?usize = for (core.panes, 0..) |slot, i| {
+ if (slot == null) continue;
+ const r = core.rects[i];
+ if (mc.col >= r.x and mc.col < r.x + r.w and mc.row >= r.y and mc.row < r.y + r.h) break i;
+ } else null;
+ if (g.scroll_pane) |old| if (hit == null or hit.? != old) {
+ resetScroll(g);
+ };
+ if (hit) |id| {
+ const pdf_target = if (comptime pardes.pdf_enabled)
+ core.native_images and core.panes[id].?.pdfPage() != null
+ else
+ false;
+ const pane = core.panes[id].?;
+ if (pdf_target) {
+ resetScroll(g);
+ in.post(.{ .pdf_scroll = .{
+ .pane = @intCast(id),
+ .delta_pixels = -w.y * @as(f32, @floatFromInt(g.cell_h)),
+ .glide = notchOf(w.y, w.integer_y) != null,
+ } });
+ } else if (!w.mods.shift and pane.isTerminal() and pardes.panes.terminal.ownsWheel(pane)) {
+ // The program's (codex, htop, less): every whole
+ // turn goes to it, no glide, for nothing of ours
+ // moves. Shift keeps the wheel pardes's.
+ resetScroll(g);
+ g.program_wheel = accumulateWheelDelta(g.program_wheel, w.y);
+ while (g.program_wheel >= 1) : (g.program_wheel -= 1)
+ in.post(.{ .mouse = .{ .button = .wheel_down, .kind = .press, .col = mc.col, .row = mc.row, .tag_hit = mc.tag_hit, .body_hit = mc.body_hit, .ctrl = w.mods.ctrl, .shift = w.mods.shift, .alt = w.mods.alt } });
+ while (g.program_wheel <= -1) : (g.program_wheel += 1)
+ in.post(.{ .mouse = .{ .button = .wheel_up, .kind = .press, .col = mc.col, .row = mc.row, .tag_hit = mc.tag_hit, .body_hit = mc.body_hit, .ctrl = w.mods.ctrl, .shift = w.mods.shift, .alt = w.mods.alt } });
+ } else {
+ g.scroll_pane = id;
+ g.scroll_col = mc.col;
+ g.scroll_row = mc.row;
+ // A mouse wheel's notch is a whole line and
+ // glides (G6); a touchpad's fraction moves the
+ // picture by itself, under the finger.
+ if (notchOf(w.y, w.integer_y)) |lines| {
+ g.scroll_notch +|= lines;
+ } else g.scroll_delta = accumulateWheelDelta(g.scroll_delta, w.y);
+ }
+ }
+ } else {
+ g.scroll_delta = accumulateWheelDelta(g.scroll_delta, w.y);
+ while (g.scroll_delta >= 1) : (g.scroll_delta -= 1)
+ in.post(.{ .mouse = .{ .button = .wheel_down, .kind = .press, .col = mc.col, .row = mc.row, .tag_hit = mc.tag_hit, .body_hit = mc.body_hit, .ctrl = w.mods.ctrl, .shift = w.mods.shift, .alt = w.mods.alt } });
+ while (g.scroll_delta <= -1) : (g.scroll_delta += 1)
+ in.post(.{ .mouse = .{ .button = .wheel_up, .kind = .press, .col = mc.col, .row = mc.row, .tag_hit = mc.tag_hit, .body_hit = mc.body_hit, .ctrl = w.mods.ctrl, .shift = w.mods.shift, .alt = w.mods.alt } });
+ }
+ }
+ if (w.x != 0) in.post(.{ .mouse = .{
+ .button = if (w.x > 0) .wheel_right else .wheel_left,
+ .kind = .press,
+ .col = mc.col,
+ .row = mc.row,
+ .tag_hit = mc.tag_hit,
+ .body_hit = mc.body_hit,
+ .ctrl = w.mods.ctrl,
+ .shift = w.mods.shift,
+ .alt = w.mods.alt,
+ } });
+}
+
+const WheelTurn = struct { x: f32 = 0, y: f32 = 0, integer_y: i32 = 0, mods: PointerMods = .{} };
+
+/// The modifiers held with a pointer event, as the core's Mouse carries them.
+const PointerMods = struct { ctrl: bool = false, shift: bool = false, alt: bool = false, super: bool = false };
+
+/// The core's Mouse for an SDL press, release or move over cell `mc`.
+fn pointerMouse(button: pardes.Mouse.Button, kind: pardes.Mouse.Kind, mc: MouseCell, mods: PointerMods) pardes.Mouse {
+ return .{
+ .button = button,
+ .kind = kind,
+ .col = mc.col,
+ .row = mc.row,
+ .tag_hit = mc.tag_hit,
+ .body_hit = mc.body_hit,
+ .rule_above = (kind == .press or kind == .release) and mc.rule_above,
+ .ctrl = mods.ctrl,
+ .shift = mods.shift,
+ .alt = mods.alt,
+ .super = mods.super,
+ };
+}
+
+fn pointerMods() PointerMods {
+ const m = c.SDL_GetModState();
+ return .{ .ctrl = (m & c.SDL_KMOD_CTRL) != 0, .shift = (m & c.SDL_KMOD_SHIFT) != 0, .alt = (m & c.SDL_KMOD_ALT) != 0, .super = (m & c.SDL_KMOD_GUI) != 0 };
}
fn mouseCellWithGeometry(g: *const Gui, core: ?*const pardes.Pardes, x: f32, y: f32, geometry: WindowGeometry) ?MouseCell {
const physical = windowPointToPixels(geometry, x, y);
- const mapped = mapScenePoint(g, physical.x, physical.y, geometry.pixel_w, geometry.pixel_h) orelse return null;
- return gridCellAtPixels(g, core, mapped.x, mapped.y);
+ return gridCellAtPixels(g, core, physical.x, physical.y);
}
fn mouseCell(g: *const Gui, core: ?*const pardes.Pardes, x: f32, y: f32) ?MouseCell {
return mouseCellWithGeometry(g, core, x, y, windowGeometry(g.window));
}
+/// SDL's hit test, asked as the pointer moves over the window: a blank cell
+/// of the workspace tag (tagline.workspaceBlank) is the window's to drag, as
+/// a title bar is. SDL gives the compositor a B1 press there (Wayland's
+/// xdg_toplevel.move, X11's _NET_WM_MOVERESIZE, macOS's own drag), so the
+/// press never reaches the core; B2 and B3 there still do.
+fn hitTest(_: ?*c.SDL_Window, area: [*c]const c.SDL_Point, data: ?*anyopaque) callconv(.c) c.SDL_HitTestResult {
+ const g: *Gui = @ptrCast(@alignCast(data orelse return c.SDL_HITTEST_NORMAL));
+ const core = g.hit_core orelse return c.SDL_HITTEST_NORMAL;
+ if (area == null) return c.SDL_HITTEST_NORMAL;
+ const mc = mouseCell(g, core, @floatFromInt(area.*.x), @floatFromInt(area.*.y)) orelse return c.SDL_HITTEST_NORMAL;
+ return if (pardes.tagline.workspaceBlank(core, mc.col, mc.row, mc.tag_hit)) c.SDL_HITTEST_DRAGGABLE else c.SDL_HITTEST_NORMAL;
+}
+
fn heldPointerButton(g: *const Gui) ?pardes.Mouse.Button {
const buttons = c.SDL_GetMouseState(null, null);
if ((buttons & c.SDL_BUTTON_LMASK) != 0 or g.deck.r2_held or g.deck.rpad_click) return .left;
@@ -3571,43 +3814,57 @@ const Shell = struct {
ptys: *[pardes.MAX_PANES]?Pty,
gens: *[pardes.MAX_PANES]u32,
queue: *Queue,
+ /// What drainQueue takes each wakeup, kept rather than rebuilt.
+ batch: MessageBatch = .{},
pipe_tasks: *PipeTasks,
inotify_fd: c_int,
watches: *file_watch.Table,
+ /// The post chain's files as SPIR-V.
+ shaders: ShaderBuild = .{},
threads_ok: bool = false,
test_mode: bool = false,
feed: StdinFeed = .{},
presented: bool = false,
+ skipped_presents: u8 = 0,
surface: ?*pardes.Surface = null,
- animation_clock: AnimationClock = .{},
saw_event: bool = false,
dump_err: ?anyerror = null,
retired_shells: [pardes.MAX_PANES]RetiredShell = @splat(.{}),
+ /// PARDES_TEST_CLOCK's virtual time (host_io.testClock), in test mode.
+ test_clock: ?u64 = null,
+ /// The display rate a virtual clock stands in for (PARDES_TEST_HZ).
+ test_hz: u64 = 60,
+ /// The tick a paced frame is sampled at (waitInput): the clock the
+ /// core is advanced to while anything moves.
+ paced_ns: ?u64 = null,
fn reap(s: *Shell) void {
- const now = shellClock();
- for (&s.retired_shells) |*child| reapShell(&child.pid, &child.kill_at, now);
+ const now = std.Io.Clock.awake.now(s.queue.io).toMilliseconds();
+ for (&s.retired_shells) |*child| host_io.reapRetired(&child.pid, &child.kill_at, now);
for (s.ptys) |*slot| if (slot.*) |*pt| if (pt.fd < 0) {
- reapShell(&pt.pid, &pt.kill_at, now);
+ host_io.reapRetired(&pt.pid, &pt.kill_at, now);
if (pt.pid == 0) slot.* = null;
};
}
+ fn closePaneShell(ctx: ?*anyopaque, pane: u8) void {
+ shellOf(ctx).closePty(pane);
+ }
+
fn closePty(s: *Shell, pane: u8) void {
const pt = if (s.ptys[pane]) |*pt| pt else return;
if (pt.fd < 0) return;
+ // Out of the queue first, which lets go a reader waiting for room
+ // in it; then its read is canceled (or, at its end, it is joined).
s.queue.cancelReader(pane, s.gens[pane]);
- if (pt.reader) |thread| {
- _ = host_io.writeFd(pt.stop[1], "x");
- thread.join();
+ if (pt.reader) |*reader| {
+ reader.cancel(s.queue.io); // the Io it was started on (startReader)
pt.reader = null;
- for (pt.stop) |fd| _ = libc.close(fd);
- pt.stop = .{ -1, -1 };
}
_ = libc.close(pt.fd);
pt.fd = -1;
- const now = shellClock();
- reapShell(&pt.pid, &pt.kill_at, now);
+ const now = std.Io.Clock.awake.now(s.queue.io).toMilliseconds();
+ host_io.reapRetired(&pt.pid, &pt.kill_at, now);
if (pt.pid == 0) {
s.ptys[pane] = null;
return;
@@ -3619,6 +3876,10 @@ const Shell = struct {
s.ptys[pane] = null;
return;
};
+ // No room to wait for it here: a slot kept for it would refuse the
+ // next shell spawned into this pane until it was reaped.
+ host_io.retireShell(pt.pid);
+ s.ptys[pane] = null;
}
fn stopPtys(s: *Shell) void {
@@ -3661,6 +3922,7 @@ const Shell = struct {
const vtable: pardes.Host.VTable = .{
.wait_input = waitInput,
+ .now = guiNow,
.present = present,
.post_present = postPresent,
.poll_frame = pollFrame,
@@ -3668,7 +3930,10 @@ const Shell = struct {
.pty_write = ptyWrite,
.pty_resize = ptyResize,
.pty_signal = ptySignal,
+ .close_pty = closePaneShell,
.tty_taken = ttyTaken,
+ .fg_name = fgName,
+ .kill_job = killJob,
.write_file = writeFile,
.write_dump = writeDump,
.watch_file = watchFile,
@@ -3679,11 +3944,14 @@ const Shell = struct {
.open_link = openLink,
.lsp = lsp,
.pipe = pipe,
+ .search = search,
+ .hand_over = handOver,
};
const grid_vtable: pardes.Host.VTable = vt: {
var v = vtable;
v.wait_input = null;
+ v.now = null;
v.poll_frame = gridPollFrame;
v.present = gridPresent;
v.post_present = gridPostPresent;
@@ -3692,9 +3960,22 @@ const Shell = struct {
break :vt v;
};
+ /// The command panes' exits, told once their output is in (host_io).
+ fn takeExits(s: *Shell) void {
+ host_io.takeExits(s.core, s.ptys, s, closeWatched);
+ }
+
+ fn closeWatched(s: *Shell, id: usize) void {
+ s.closePty(@intCast(id));
+ s.saw_event = true;
+ }
+
fn drainQueue(s: *Shell) void {
s.reconcilePtys();
- var msgs = s.queue.take();
+ // After this batch's output, which an exit is told behind.
+ defer s.takeExits();
+ s.queue.takeInto(&s.batch);
+ const msgs = &s.batch;
var check_files = false;
for (msgs.slice()) |m| switch (m) {
.output => |o| {
@@ -3704,14 +3985,34 @@ const Shell = struct {
s.saw_event = true;
},
.eof => |e| {
- if (s.gens[e.pane] == e.gen) {
- s.closePty(e.pane);
+ if (s.gens[e.pane] == e.gen) eof: {
if (e.failure) |err| {
+ s.closePty(e.pane);
if (s.core.panes[e.pane]) |pane| {
- pane.mode = .normal;
+ pane.body.mode = .normal;
s.core.reportError(e.pane, "terminal reader", err);
}
- } else s.core.update(.{ .eof = .{ .pane = e.pane } });
+ break :eof;
+ }
+ const pt = if (s.ptys[e.pane]) |*pt| pt else {
+ s.core.update(.{ .eof = .{ .pane = e.pane } });
+ break :eof;
+ };
+ // A command's pty stays open until its child has exited:
+ // closing it would hang up one that runs on without it.
+ // Its exit, if it came first, is told now its output is in.
+ if (pt.cmd.watched) {
+ host_io.commandEof(s.core, s.ptys, e.pane, s, closeWatched);
+ break :eof;
+ }
+ // Unwatched, a command's exit is read here, as its end,
+ // and a shell's, for a run waiting on it and the log.
+ const unwatched = if (s.core.panes[e.pane]) |pane| pane.command != null else false;
+ const status = host_io.exitStatus(pt.pid, 100);
+ if (status != null) pt.pid = 0; // reaped: no shell to retire
+ s.closePty(e.pane);
+ if (unwatched or status != null) s.core.update(.{ .exited = .{ .pane = e.pane, .status = status } });
+ s.core.update(.{ .eof = .{ .pane = e.pane } });
}
s.saw_event = true;
},
@@ -3738,14 +4039,32 @@ const Shell = struct {
s.saw_event = true;
s.pipe_tasks.finish(s.io, response_value.id);
},
+ .search => |b| {
+ s.core.update(.{ .search = b });
+ b.deinit(s.gpa);
+ s.saw_event = true;
+ },
+ .handed => |h| {
+ s.core.update(.{ .handed = .{ .seq = h.seq, .to = if (h.ok) h.words else "", .failure = if (h.ok) null else h.words } });
+ s.gpa.free(h.words);
+ s.saw_event = true;
+ },
.files_changed => check_files = true,
.fs_ready => {},
};
+ if (check_files) s.shaders.recheck();
if (check_files and file_watch.reloadChanged(s.core, s.io, s.gpa, s.watches))
s.queue.push(.files_changed);
}
};
+/// A post chain compile is done (ShaderBuild.zig): the loop's SDL wait ends.
+fn wakeSdl(_: ?*anyopaque) void {
+ var event = std.mem.zeroes(c.SDL_Event);
+ event.type = c.SDL_EVENT_USER;
+ _ = c.SDL_PushEvent(&event);
+}
+
fn wakeFs(ctx: ?*anyopaque) void {
const q: *Queue = @ptrCast(@alignCast(ctx.?));
q.push(.fs_ready);
@@ -3761,11 +4080,140 @@ fn waitInput(ctx: ?*anyopaque, timeout_ms: u32) void {
var in: Input = .{ .core = core };
if (s.gui) |g| {
var sev = std.mem.zeroes(c.SDL_Event);
- const ms: c_int = if (timeout_ms != 0) @intCast(timeout_ms) else 16;
- if (c.SDL_WaitEventTimeout(&sev, ms)) {
- dispatch(g, &in, &sev);
- while (c.SDL_PollEvent(&sev)) dispatch(g, &in, &sev);
+ // Idle is asleep until an event: SDL's own, and the user events the
+ // shell's queue raises for a terminal's output, a completion, a file
+ // system request. What the shell moves or times itself polls every
+ // frame: a smooth scroll, a gamepad's sticks, the test stdin feed,
+ // a post chain that moves on its own (ShaderAnimation),
+ // a retired shell waiting to be killed, a present to retry. A
+ // minimized window sleeps through the core's animation too: nothing
+ // shows it, and it is caught up at once when the window is back.
+ const retiring = for (s.retired_shells) |child| {
+ if (child.kill_at != 0) break true;
+ } else for (s.ptys) |slot| {
+ if (slot) |pt| if (pt.kill_at != 0) break true;
+ } else false;
+ const polls = g.scroll_lag != 0 or g.scroll_delta != 0 or g.scroll_notch != 0 or g.glide.moving() or g.gamepad != null or s.test_mode or core.needs_frame or retiring or
+ g.post.animating(core.settings.shader_animation);
+ const minimized = !s.test_mode and c.SDL_GetWindowFlags(g.window) & (c.SDL_WINDOW_MINIMIZED | c.SDL_WINDOW_OCCLUDED) != 0;
+ // A latency trace is fed on stdin, whose poll below paces the loop:
+ // waiting here too would make every tick cost two frames.
+ // A chain that moves on its own wakes once a display refresh.
+ const poll_ms: c_int = if (g.post.animating(core.settings.shader_animation))
+ @intCast(@max(1, refreshNs(g) / std.time.ns_per_ms))
+ else
+ 16;
+ const waited: c_int = if (latency_fd >= 0) 0 else if (minimized) -1 else if (timeout_ms != 0) @min(@as(c_int, @intCast(@min(timeout_ms, std.math.maxInt(c_int)))), if (polls) poll_ms else std.math.maxInt(c_int)) else if (polls) poll_ms else -1;
+ // The cursor's blink is the shell's to time (Chrome.cursor_idle_ms):
+ // a frame a loop through an edge, else a wake at the next one; none
+ // while the window is minimized or unfocused. A virtual clock never
+ // blinks, so goldens hold still.
+ const blink = if (s.test_clock != null or minimized) null else blinkNow(g, if (s.surface) |frame| &frame.chrome else null);
+ const blink_ms: ?c_int = if (blink) |b| (if (b.edge) 1 else if (b.next_ns) |next| @as(c_int, @intCast(@min(std.math.maxInt(c_int), next / std.time.ns_per_ms + 1))) else null) else null;
+ const blinked: c_int = if (blink_ms) |b| (if (waited < 0) b else @min(waited, b)) else waited;
+ // The timedemo's next step is a wake too.
+ var ms: c_int = if (demoDue(g)) |due| (if (blinked < 0) due else @min(blinked, due)) else blinked;
+ // While anything moves, frames are paced as a game's are: one a
+ // display refresh, on a grid of ticks a period apart, each sampled
+ // at its tick (guiNow), however early or late the loop got there.
+ // Input that comes between two ticks is acted on as it comes (the
+ // core's state is never held back) and drawn at the next tick. Not
+ // paced, the loop ran as fast as it could present (the soft present
+ // has no vsync), ~230 frames a second on a 60 Hz display, and the
+ // compositor showed whichever was newest at each refresh: motion
+ // sampled at random phase, uneven steps, a judder in every scroll.
+ // ponytail: the period is the display mode's refresh and the grid's
+ // phase is our own, not the display's (no vblank time to read on the
+ // soft present); a 59.94 Hz display drifts a tick every 17 s. The
+ // upgrade: the presentation feedback protocol's timestamps.
+ const paced = s.test_clock == null and latency_fd < 0 and !s.test_mode and !minimized and core.continuous();
+ var tick: u64 = 0;
+ if (paced) {
+ const period = refreshNs(g);
+ const now = c.SDL_GetTicksNS();
+ // A motion from rest draws at once; one under way, at its next
+ // tick, skipping (never bunching) the ticks a slow frame missed.
+ tick = if (g.pace_ns != 0 and now -| g.pace_ns < 2 * period) g.pace_ns + period else now;
+ if (tick < now) tick += (now - tick) / period * period;
+ // Waited out polling, below.
+ ms = 0;
+ }
+ g.input_seen = false;
+ // The wait is the 9P connections' turn with the core.
+ pardes.turn.rest();
+ const got = c.SDL_WaitEventTimeout(&sev, ms);
+ pardes.turn.wake();
+ // A virtual clock: while a render-time animation moves, each loop
+ // is a presented frame and moves it by one display frame
+ // (PARDES_TEST_HZ), events or not, as a real display's present
+ // would; otherwise a wait that ran out moves it exactly to the
+ // core's wake.
+ // Through an edge, or woken for the next: the shell redraws the last
+ // frame with the new alpha, no core render (§5.5 level B).
+ if (blink_ms != null and (blink.?.edge or !got)) g.blink_due = true;
+ if (s.test_clock) |*virtual| {
+ if (core.continuous()) {
+ const display = virtual.* + std.time.ns_per_s / s.test_hz;
+ virtual.* = if (core.nextWake()) |due| @max(virtual.*, @min(due, display)) else display;
+ } else if (timeout_ms != 0 and (!got or !core.needs_frame)) {
+ // A wait that ran out, or one a stray event cut short while
+ // nothing owes a frame: time moves to the core's wake all
+ // the same, so a steady trickle of events (a pty's, the
+ // test feed's) cannot hold a virtual clock still forever.
+ virtual.* = @max(virtual.*, core.nextWake() orelse virtual.*);
+ }
+ }
+ if (got) {
+ // A run of queued motions is one move to its last position (the
+ // handler reads only absolute x/y and held buttons): acting on
+ // each would repeat hover and selection work the next undoes.
+ var motion: ?c.SDL_Event = null;
+ while (true) {
+ if (sev.type == c.SDL_EVENT_MOUSE_MOTION) {
+ motion = sev;
+ } else {
+ if (motion) |*m| dispatch(g, &in, m);
+ motion = null;
+ dispatch(g, &in, &sev);
+ }
+ if (!c.SDL_PollEvent(&sev)) break;
+ }
+ if (motion) |*m| dispatch(g, &in, m);
+ }
+ runDemo(g, &in, core);
+ // Paced: what came before the tick is in; wait out the rest of it,
+ // unless an input came: its frame is drawn at once (the paced loop
+ // never adds a tick to an input's latency), and the ticks after it
+ // run from it. A stream's repeat too: the picture it moves is on
+ // the stream's straight line wherever it is sampled, so drawing it
+ // between two ticks costs no evenness, and holding it to the tick
+ // cost a held key 7 ms of latency.
+ if (paced and g.input_seen) tick = c.SDL_GetTicksNS();
+ // The tick is waited out polling, not asleep, as a game's frame
+ // limiter spins: asleep between 60 Hz frames, the CPU's clock fell
+ // (intel_pstate, 4.9 GHz down toward 0.8) and every frame, an
+ // input's first among them, took 2-5x as long: input-to-present p50
+ // 1.9 ms spinning against 7-8 ms asleep (docs/next-anim.md).
+ // ponytail: a core while something moves (~250 ms a scroll); a
+ // sleep to a millisecond short of the tick if the power matters more.
+ while (paced and !g.input_seen) {
+ if (tick -| c.SDL_GetTicksNS() < 50 * std.time.ns_per_us) break;
+ pardes.turn.rest();
+ const more = c.SDL_PollEvent(&sev);
+ pardes.turn.wake();
+ if (more) {
+ dispatch(g, &in, &sev);
+ while (c.SDL_PollEvent(&sev)) dispatch(g, &in, &sev);
+ } else {
+ // The events asked for every 100 µs, the core busy between.
+ const until = c.SDL_GetTicksNS() + 100 * std.time.ns_per_us;
+ while (c.SDL_GetTicksNS() < @min(until, tick)) std.atomic.spinLoopHint();
+ }
+ runDemo(g, &in, core);
+ if (g.input_seen) tick = c.SDL_GetTicksNS();
}
+ s.paced_ns = if (paced) tick else null;
+ if (paced) g.pace_ns = tick;
}
if (s.test_mode) {
const r = s.feed.pump(s.gpa, &in, s.gui) catch {
@@ -3785,7 +4233,7 @@ fn pollFrame(ctx: ?*anyopaque) void {
const s = shellOf(ctx);
s.reconcilePtys();
const core = s.core;
- if (s.fs) |f| if (f.tick(core).pending) s.queue.push(.fs_ready);
+ if (s.fs) |f| if (f.tick().pending) s.queue.push(.fs_ready);
const g = s.gui orelse {
if (core.settings.window_opacity_pending) {
var unchanged_opacity: u8 = 100;
@@ -3794,7 +4242,9 @@ fn pollFrame(ctx: ?*anyopaque) void {
return;
};
syncWindowOpacity(g, core);
+ core.frames.period_ns = refreshNs(g);
syncTaglineFont(g, core);
+ syncLigatures(g, core);
if (core.takeFontRequest()) |path| blk: {
const bytes = filesystem.readFile(s.gpa, path) catch {
core.rejectFont();
@@ -3820,6 +4270,144 @@ fn pollFrame(ctx: ?*anyopaque) void {
const geom = windowCells(g);
if (updateCoreResize(core, geom.cols, geom.rows, g.cell_w, g.cell_h, g.tagline_width, g.tagline_height)) resetScroll(g);
stepScroll(g, core, s.gpa);
+ _ = s.shaders.sync(s.gpa, s.io, core, s.inotify_fd, s.watches, .{ .call = wakeSdl });
+ {
+ var passes: [Post.max]ShaderBuild.Pass = undefined;
+ g.post.sync(s.gpa, g.device, g.swapchain_format, s.shaders.view(&core.settings.post, &passes), s.shaders.revision, core);
+ }
+ if (s.test_mode) writeTestStatus(g, core, s.presented);
+ // Between the core's frames, a chain that moves on its own redraws
+ // alone, once a refresh of the display the window is on (a millisecond
+ // early is on time: the wait that paces it is in whole milliseconds).
+ if (g.post.animating(core.settings.shader_animation) and !core.needs_frame and s.presented and
+ c.SDL_GetTicksNS() -| g.post.last_ns + std.time.ns_per_ms >= refreshNs(g)) redrawPost(g, s.gpa);
+ // A blink edge: the last frame again, the cursor's alpha moved on.
+ if (g.blink_due and !core.needs_frame and s.presented) if (s.surface) |frame| {
+ g.blink_due = false;
+ blink_redraws += 1;
+ s.presented = renderFrame(g, s.gpa, core, frame, core.settings.debug) catch false;
+ };
+}
+
+/// Frames drawn for a blink alone, with no core render (tests, tracing).
+var blink_redraws: u64 = 0;
+
+/// PARDES_FRAMES_CAPTURE's directory, and how many frames it has.
+var frame_capture_dir: ?[]const u8 = null;
+var frame_capture_count: u32 = 0;
+
+fn captureSeries(dir: []const u8, pixels: []const u8, w: u32, h: u32) void {
+ var path_buf: [4096]u8 = undefined;
+ const path = std.fmt.bufPrintSentinel(&path_buf, "{s}/{d:0>6}.bgra", .{ dir, frame_capture_count }, 0) catch return;
+ const fd = libc.open(path, .{ .ACCMODE = .WRONLY, .CREAT = true, .TRUNC = true }, @as(libc.mode_t, 0o644));
+ if (fd < 0) return;
+ _ = libc.write(fd, pixels.ptr, pixels.len);
+ _ = libc.close(fd);
+ const times = std.fmt.bufPrintSentinel(&path_buf, "{s}/times.txt", .{dir}, 0) catch return;
+ const tf = libc.open(times, .{ .ACCMODE = .WRONLY, .CREAT = true, .APPEND = true }, @as(libc.mode_t, 0o644));
+ if (tf < 0) return;
+ var line_buf: [96]u8 = undefined;
+ const line = std.fmt.bufPrint(&line_buf, "{d} {d} {d} {d}\n", .{ frame_capture_count, monoNs(), w, h }) catch "";
+ _ = libc.write(tf, line.ptr, line.len);
+ _ = libc.close(tf);
+ frame_capture_count += 1;
+}
+
+/// The core's frame probe (FrameStats), for the latency of the inputs the
+/// shell reads and the zones its own work goes in; null in tests.
+var frame_probe: ?*pardes.FrameStats = null;
+
+/// How long until the timedemo's next step, ms; null when none runs.
+fn demoDue(g: *const Gui) ?c_int {
+ const next = g.demo_next orelse return null;
+ if (g.demo_start_ns == 0 or next >= g.demo.len) return 0;
+ const at = g.demo_start_ns + @as(u64, g.demo[next].at_ms) * std.time.ns_per_ms;
+ return @intCast(@min(std.math.maxInt(c_int), (at -| monoNs()) / std.time.ns_per_ms));
+}
+
+/// PARDES_FRAMES_DEMO: the steps of FrameStats.demo whose time has come,
+/// through the paths the window's own wheel and keys take, over the
+/// focused pane's body; its clock starts at the first loop. Its end
+/// ends the session (PARDES_FRAMES has the timings then).
+fn runDemo(g: *Gui, in: *Input, core: *pardes.Pardes) void {
+ const steps = g.demo;
+ var next = g.demo_next orelse return;
+ const now = monoNs();
+ if (g.demo_start_ns == 0) {
+ g.demo_start_ns = now;
+ core.frames.demo_ns = now;
+ core.frames.demo_name = g.demo_name;
+ }
+ defer g.demo_next = next;
+ while (next < steps.len and g.demo_start_ns + @as(u64, steps[next].at_ms) * std.time.ns_per_ms <= now) : (next += 1) {
+ const r = core.rects[core.active];
+ if (steps[next].act != .phase) g.input_seen = true;
+ switch (steps[next].act) {
+ .wheel => |notches| {
+ core.frames.input(now);
+ wheelAt(g, in, .{ .y = @floatFromInt(-notches), .integer_y = -notches }, .{ .col = r.x + r.w / 2, .row = r.y + r.h / 2 });
+ },
+ .touch => |lines| {
+ core.frames.input(now);
+ wheelAt(g, in, .{ .y = -lines }, .{ .col = r.x + r.w / 2, .row = r.y + r.h / 2 });
+ },
+ .key => |key| {
+ core.frames.input(now);
+ in.post(.{ .key = key });
+ },
+ .phase => {},
+ .click => |click| {
+ core.frames.input(now);
+ const pane = core.panes[core.active] orelse continue;
+ const top = core.bodyTop(pane, r);
+ const row: u16 = top + @as(u16, @intFromFloat(click.at * @as(f32, @floatFromInt(r.h -| pane.tag_rows -| 1))));
+ const col: u16 = if (click.rail) r.x else r.x + config.GUTTER + 4;
+ for ([_]pardes.Mouse.Kind{ .press, .release }) |kind| in.post(.{ .mouse = .{ .button = click.button, .kind = kind, .col = col, .row = row } });
+ },
+ .rail_wheel => |notches| {
+ core.frames.input(now);
+ wheelAt(g, in, .{ .y = @floatFromInt(-notches), .integer_y = -notches }, .{ .col = r.x, .row = r.y + r.h / 2 });
+ },
+ .paste => |text| {
+ core.frames.input(now);
+ in.post(.{ .paste = text });
+ },
+ .exec => |line| {
+ core.frames.input(now);
+ var newest: u32 = 0;
+ for (core.panes) |slot| if (slot) |pane| {
+ newest = @max(newest, pane.serial);
+ };
+ _ = pardes.exec.executeFrom(core, core.active, line, false);
+ // What it opened is what the next steps scroll.
+ for (core.panes, 0..) |slot, id| if (slot) |pane| if (pane.serial > newest) {
+ core.active = id;
+ core.needs_frame = true;
+ };
+ },
+ .end => in.close(),
+ }
+ }
+}
+
+/// The blink now, from the frame's time since input and how long ago it
+/// arrived; null where nothing blinks (off, idle, an unfocused window).
+fn blinkNow(g: *const Gui, chrome: ?*const pardes.Chrome) ?pardes.animation.Blink {
+ const frame = chrome orelse return null;
+ if (g.no_blink or frame.cursor_glide & 2 == 0 or frame.cursor_idle_ms == std.math.maxInt(u32)) return null;
+ if (c.SDL_GetWindowFlags(g.window) & c.SDL_WINDOW_INPUT_FOCUS == 0) return null;
+ const since = @as(u64, frame.cursor_idle_ms) * std.time.ns_per_ms + (monoNs() -| g.frame_arrival_ns);
+ // Relative to now: `next_ns` is how long until the next edge.
+ const b = pardes.animation.Blink.at(since, 0);
+ return .{ .alpha = b.alpha, .edge = b.edge, .next_ns = if (b.next_ns) |next| next -| since else null };
+}
+
+/// One refresh of the display the window is on, in ns; a frame of the
+/// core's where the display does not say.
+fn refreshNs(g: *const Gui) u64 {
+ const mode = c.SDL_GetCurrentDisplayMode(c.SDL_GetDisplayForWindow(g.window)) orelse return pardes.animation.frame_ns;
+ if (!(mode.*.refresh_rate > 1)) return pardes.animation.frame_ns;
+ return @intFromFloat(@as(f64, std.time.ns_per_s) / mode.*.refresh_rate);
}
fn finishWindowOpacity(core: *pardes.Pardes, applied: *u8, failure: ?[]const u8) void {
@@ -3876,25 +4464,26 @@ fn present(ctx: ?*anyopaque, surface: *const pardes.Surface) void {
const s = shellOf(ctx);
const core = s.core;
const g = s.gui orelse return;
+ frame_started_ns = monoNs();
const frame = @constCast(surface);
s.surface = frame;
- const scene_requested = core.settings.scene_effects.crt or
- core.settings.scene_effects.ripple or core.settings.scene_effects.glitch;
+ g.frame_arrival_ns = monoNs();
+ const scene_requested = g.post.ready();
if (!scene_requested) g.scene_failures = 0;
s.presented = renderFrame(
g,
s.gpa,
core,
frame,
- core.theme().bg,
- config.gui_topbar_pane_border_rgb orelse core.chromeTheme().border,
- core.chromeTheme().tag_bg,
- core.settings.scene_effects,
core.settings.debug,
) catch |err| blk: {
log.err("render: {t}", .{err});
break :blk false;
};
+ // A skipped swapchain image would otherwise hide this input's frame until
+ // the next event. A few retries only: a minimized window never gets one.
+ s.skipped_presents = if (s.presented) 0 else s.skipped_presents +| 1;
+ if (!s.presented and s.skipped_presents <= 3) core.present_skipped = true;
if (g.scene_target_failed) {
g.scene_failures +|= 1;
log.err("scene target unavailable (attempt {d}/3)", .{g.scene_failures});
@@ -3908,26 +4497,30 @@ fn present(ctx: ?*anyopaque, surface: *const pardes.Surface) void {
fn postPresent(ctx: ?*anyopaque) void {
const s = shellOf(ctx);
const g = s.gui orelse return;
+ // No image (a minimized window) shows no tracks; time still passes and
+ // the pump advances it all the same.
if (!s.presented) return;
const frame = s.surface orelse return;
refreshPresentedPointer(g, s.core);
- finishPresentedAnimationFrame(
- &s.animation_clock,
- s.core,
- frame.panelTracks(),
- c.SDL_GetTicksNS(),
- );
+ s.core.acknowledgePanelPresentation(frame.panelTracks());
+}
+
+fn guiNow(ctx: ?*anyopaque) u64 {
+ const s = shellOf(ctx);
+ return s.test_clock orelse s.paced_ns orelse c.SDL_GetTicksNS();
}
fn gridPollFrame(ctx: ?*anyopaque) void {
const s = shellOf(ctx);
s.reconcilePtys();
if (s.fs) |f| {
- if (f.tick(s.core).count != 0) s.saw_event = true;
+ if (f.tick().count != 0) s.saw_event = true;
}
pollCwds(s.core, s.ptys);
- if (s.core.animationActive()) {
- s.core.update(.tick);
+ // Grid time is virtual: each poll moves it straight to the core's
+ // next wake, a frame at a time while anything moves.
+ if (s.core.nextWake()) |due| {
+ s.core.advance(due);
s.saw_event = true;
}
}
@@ -3952,17 +4545,29 @@ fn gridPostPresent(ctx: ?*anyopaque) void {
fn spawnPane(ctx: ?*anyopaque, pane: u8, cwd: []const u8) void {
const s = shellOf(ctx);
s.reap();
+ // The new shell starts before a running one goes: one that cannot
+ // start leaves the running one be (pty/ctl's exec).
+ const running = s.ptys[pane] != null;
+ const child = host_io.forkShell(s.core, pane, s.prompt_rcs, s.core.shellBin(), cwd, s.core.screen_h, s.core.screen_w, s.fs) catch |err| {
+ if (running) return s.core.restartFailed(pane, err);
+ return s.core.shellFailed(pane, err);
+ };
s.closePty(pane);
- if (s.ptys[pane] != null) return s.core.reportError(pane, "shell", error.WorkersBusy);
+ if (s.ptys[pane] != null) {
+ _ = libc.close(child.file.handle);
+ host_io.retireShell(child.pid);
+ return s.core.reportError(pane, "shell", error.WorkersBusy);
+ }
s.gens[pane] +%= 1;
- const child = host_io.forkShell(s.core, pane, s.prompt_rcs, s.core.shellBin(), cwd, s.core.screen_h, s.core.screen_w, s.fs) catch |err| return s.core.reportError(pane, "shell", err);
- const pt: Pty = .{ .fd = child.file.handle, .pid = child.pid, .serial = s.core.panes[pane].?.serial };
+ const command = s.core.panes[pane].?.command != null;
+ const pt: Pty = .{ .fd = child.file.handle, .pid = child.pid, .serial = s.core.panes[pane].?.serial, .cmd = .{ .watched = command and host_io.watchExit(child.pid), .fd = child.file.handle } };
s.ptys[pane] = pt;
var lbuf: [pardes.memory.limits.host_path_cap + 1]u8 = undefined;
if (host_io.shellCwd(pt.pid, &lbuf)) |wd| s.core.setCwd(pane, wd);
- if (s.threads_ok) spawnReader(s.gpa, &s.ptys[pane].?, pane, s.gens[pane], s.queue) catch |err| {
+ if (!s.threads_ok) return;
+ s.ptys[pane].?.reader = s.queue.startReader(.{ .handle = pt.fd, .flags = .{ .nonblocking = false } }, pane, s.gens[pane]) catch |err| {
s.closePty(pane);
- s.core.reportError(pane, "terminal reader", err);
+ return s.core.reportError(pane, "terminal reader", err);
};
}
@@ -3977,14 +4582,15 @@ fn ptyResize(ctx: ?*anyopaque, pane: u8, cols: u16, rows: u16) void {
const s = shellOf(ctx);
if (s.ptys[pane]) |pt| {
if (pt.fd < 0) return;
- const ws: posix.winsize = .{ .row = rows, .col = cols, .xpixel = 0, .ypixel = 0 };
+ const ws = host_io.ptyWinsize(s.core, cols, rows);
_ = posix.system.ioctl(pt.fd, TIOCSWINSZ, @intFromPtr(&ws));
}
}
fn ptySignal(ctx: ?*anyopaque, pane: u8, sig: pardes.PtySignal) void {
const s = shellOf(ctx);
- if (s.ptys[pane]) |pt| if (pt.fd >= 0) host_io.signalTty(pt.pid, pt.fd, sig);
+ // A command whose exit is recorded is reaped: its group may be another's.
+ if (s.ptys[pane]) |pt| if (pt.fd >= 0 and !pt.cmd.exited) host_io.signalTty(pt.pid, pt.fd, sig, pt.cmd.watched);
}
fn ttyTaken(ctx: ?*anyopaque, pane: u8) bool {
@@ -3994,27 +4600,27 @@ fn ttyTaken(ctx: ?*anyopaque, pane: u8) bool {
return host_io.ttyTaken(pt.pid, pt.fd);
}
+fn fgName(ctx: ?*anyopaque, pane: u8, buf: []u8) ?[]const u8 {
+ const s = shellOf(ctx);
+ const pt = s.ptys[pane] orelse return null;
+ if (pt.fd < 0) return null;
+ return host_io.foregroundName(pt.pid, pt.fd, buf);
+}
+
+fn killJob(ctx: ?*anyopaque, pane: u8) bool {
+ const s = shellOf(ctx);
+ const pt = s.ptys[pane] orelse return false;
+ if (pt.fd < 0) return false;
+ return host_io.killJob(pt.pid, pt.fd);
+}
+
fn writeFile(ctx: ?*anyopaque, pane: u8, path: []const u8, bytes: []const u8) void {
const s = shellOf(ctx);
- filesystem.write(s.core, path, bytes) catch |err|
- return s.core.saveFailed(pane, "save", err);
- if (s.core.panes[pane]) |pane_state| if (pane_state.file) |f| {
- if (std.mem.eql(u8, f.path, path))
- if (s.watches[pane]) |*w| if (w.serial == pane_state.serial) switch (w.generation) {
- .text => w.generation = .{ .text = std.hash.Wyhash.hash(0, bytes) },
- .pdf => {},
- };
- };
- var mbuf: [256]u8 = undefined;
- s.core.setMessage(pane, message.stamp(&mbuf, "saved", path));
+ host_io.writeFile(s.core, s.watches, pane, path, bytes);
}
fn writeDump(ctx: ?*anyopaque, bytes: []const u8) void {
- const s = shellOf(ctx);
- var pbuf: [1024:0]u8 = undefined;
- const path = pardes.dump.outPath(&pbuf) orelse return;
- filesystem.write(s.core, path, bytes) catch |err| return s.core.reportError(0, "dump", err);
- s.core.setLastDump(path);
+ host_io.writeDump(shellOf(ctx).core, bytes);
}
fn watchFile(ctx: ?*anyopaque, pane: u8, _: []const u8, on: bool, mode: pardes.WatchMode) void {
@@ -4038,18 +4644,11 @@ fn watchTheme(ctx: ?*anyopaque, generation: u32, on: bool) void {
fn dumpThemes(ctx: ?*anyopaque, pane: u8) void {
const s = shellOf(ctx);
- const config_dir = s.core.opts.config_dir orelse return;
- const out_dir = config.User.dumpThemes(s.io, s.gpa, config_dir, pardes.themes) catch |err| {
- s.core.reportError(pane, "dump themes", err);
- return;
- };
- defer s.gpa.free(out_dir);
- var mbuf: [256]u8 = undefined;
- s.core.setMessage(pane, message.stamp(&mbuf, "dumped themes", out_dir));
+ host_io.dumpThemes(s.core, s.io, s.gpa, pane);
}
fn putClipboard(gpa: std.mem.Allocator, text: []const u8) void {
- const z = gpa.dupeZ(u8, text) catch return;
+ const z = gpa.dupeSentinel(u8, text, 0) catch return;
defer gpa.free(z);
_ = c.SDL_SetClipboardText(z.ptr);
}
@@ -4082,12 +4681,10 @@ test "the headless grid host round-trips a yank back as a paste" {
var ptys: [pardes.MAX_PANES]?Pty = @splat(null);
var gens: [pardes.MAX_PANES]u32 = @splat(0);
- var lsp_workers: LspWorkers = .{};
var queue: Queue = .{
+ .io = std.testing.io,
.gpa = gpa,
.lsp_allocator = gpa,
- .lsp_workers = &lsp_workers,
- .sdl_wake = false,
};
defer queue.deinit();
var pipe_tasks: PipeTasks = .{};
@@ -4115,7 +4712,7 @@ test "the headless grid host round-trips a yank back as a paste" {
core.update(.{ .key = .{ .cp = ' ' } });
core.update(.{ .key = .{ .cp = 'y' } });
while (core.nextEffect()) |e| core.perform(e);
- const yanked = core.yank orelse return error.MissingYank;
+ const yanked = core.registers.text(core.gpa, '+') orelse return error.MissingYank;
try std.testing.expect(yanked.len > 0);
const before = pane.file.?.content.len;
@@ -4127,6 +4724,39 @@ test "the headless grid host round-trips a yank back as a paste" {
try std.testing.expectEqual(before + yanked.len, pane.file.?.content.len);
}
+test "the clipboard pasted into a terminal reaches its pty as xterm pastes: bracketed when asked, no ESC[201~ smuggled through" {
+ if (comptime !pardes.panes.terminal.enabled) return error.SkipZigTest;
+ const gpa = std.testing.allocator;
+ const core = try pardes.Pardes.init(gpa, .{ .cols = 60, .rows = 16, .tty_only = true });
+ defer core.deinit();
+ var shell: Shell = undefined;
+ shell.core = core;
+ var sent: std.ArrayList(u8) = .empty;
+ defer sent.deinit(gpa);
+ const take = struct {
+ fn f(core_: *pardes.Pardes, out: *std.ArrayList(u8)) ![]const u8 {
+ out.clearRetainingCapacity();
+ while (core_.nextEffect()) |effect| {
+ if (effect == .write and effect.write.pane == 0) try out.appendSlice(std.testing.allocator, effect.write.bytes.slice());
+ }
+ return out.items;
+ }
+ }.f;
+ _ = try take(core, &sent);
+ // The clipboard is SDL's own with no display to hold one.
+ _ = c.SDL_SetHint(c.SDL_HINT_VIDEO_DRIVER, "dummy");
+ defer _ = c.SDL_ResetHint(c.SDL_HINT_VIDEO_DRIVER);
+ if (!c.SDL_InitSubSystem(c.SDL_INIT_VIDEO)) return error.SkipZigTest;
+ defer c.SDL_QuitSubSystem(c.SDL_INIT_VIDEO);
+ putClipboard(gpa, "ls\x1b[201~; rm -rf ~\nx");
+ readClipboard(&shell);
+ try std.testing.expectEqualStrings("ls [201~; rm -rf ~\rx", try take(core, &sent));
+ core.update(.{ .output = .{ .pane = 0, .bytes = "\x1b[?2004h" } });
+ _ = try take(core, &sent);
+ readClipboard(&shell);
+ try std.testing.expectEqualStrings("\x1b[200~ls [201~; rm -rf ~\nx\x1b[201~", try take(core, &sent));
+}
+
fn openLink(ctx: ?*anyopaque, url: []const u8) void {
_ = ctx;
look.openLink(url); // desktop browser
@@ -4134,44 +4764,80 @@ fn openLink(ctx: ?*anyopaque, url: []const u8) void {
fn lsp(ctx: ?*anyopaque, req: host_io.Lsp.Request) void {
const s = shellOf(ctx);
- if (s.threads_ok) return spawnLsp(s.core, s.queue, req);
+ if (s.threads_ok) return s.queue.startLsp(s.core, req);
s.core.update(.{ .lsp_resp = .{ .id = req.id, .rows = null } });
s.core.reportError(req.pane, "lsp", error.WorkersUnavailable);
}
fn pipe(ctx: ?*anyopaque, id: u32) void {
const s = shellOf(ctx);
- if (s.threads_ok) return spawnPipe(s.core, s.io, s.gpa, s.queue, s.pipe_tasks, id);
+ if (s.threads_ok) return selection_pipe.start(s.io, s.gpa, s.core, s.pipe_tasks, id, s.queue, Queue.pushPipe);
s.core.update(.{ .pipe_resp = .{ .id = id, .success = false, .outputs = &.{} } });
s.core.reportError(s.core.active, "pipe", error.WorkersUnavailable);
}
+fn search(ctx: ?*anyopaque, gen: u32) void {
+ const s = shellOf(ctx);
+ if (s.threads_ok) return pardes.Stream.start(s.io, s.gpa, s.core, gen, s.queue, Queue.pushSearch);
+ pardes.Stream.runHere(s.core, gen);
+}
+
+/// Handover `seq`'s dump to its file, and a worker to carry it to another
+/// window (Handover.start). A new window is as big as this one, and where
+/// the pointer let go of it when the display lets a window say where it
+/// goes (X11; on Wayland the compositor places it).
+fn handOver(ctx: ?*anyopaque, seq: u32, bytes: []const u8) void {
+ const s = shellOf(ctx);
+ const Handover = pardes.Handover;
+ const path = Handover.dumpPath(s.gpa, seq) catch |err| return s.core.update(.{ .handed = .{ .seq = seq, .failure = @errorName(err) } });
+ const fd = libc.open(path, .{ .ACCMODE = .WRONLY, .CREAT = true, .TRUNC = true, .CLOEXEC = true }, @as(libc.mode_t, 0o600));
+ const written = fd >= 0 and host_io.writeFd(fd, bytes);
+ if (fd >= 0) _ = libc.close(fd);
+ if (!written) {
+ _ = libc.unlink(path);
+ s.gpa.free(path);
+ return s.core.update(.{ .handed = .{ .seq = seq, .failure = "cannot write its dump" } });
+ }
+ const job = s.gpa.create(Handover.Job) catch {
+ _ = libc.unlink(path);
+ s.gpa.free(path);
+ return s.core.update(.{ .handed = .{ .seq = seq, .failure = "out of memory" } });
+ };
+ job.* = .{ .gpa = s.gpa, .seq = seq, .path = path, .post = Queue.pushHanded, .post_ctx = s.queue };
+ if (s.fs) |f| {
+ job.own_len = @min(f.path().len, job.own.len);
+ @memcpy(job.own[0..job.own_len], f.path()[0..job.own_len]);
+ }
+ if (s.gui) |g| {
+ var w: c_int = 0;
+ var h: c_int = 0;
+ _ = c.SDL_GetWindowSize(g.window, &w, &h);
+ var gx: f32 = 0;
+ var gy: f32 = 0;
+ _ = c.SDL_GetGlobalMouseState(&gx, &gy);
+ const placed = !std.mem.eql(u8, std.mem.span(c.SDL_GetCurrentVideoDriver()), "wayland");
+ const geometry = (if (placed)
+ std.fmt.bufPrint(&job.geometry, "{d}x{d}+{d}+{d}", .{ w, h, @as(i32, @intFromFloat(gx)) - 40, @as(i32, @intFromFloat(gy)) - 10 })
+ else
+ std.fmt.bufPrint(&job.geometry, "{d}x{d}", .{ w, h })) catch "";
+ job.geometry_len = geometry.len;
+ }
+ s.core.handover.start(s.io, job) catch |err| {
+ _ = libc.unlink(path);
+ s.gpa.free(path);
+ s.gpa.destroy(job);
+ return s.core.update(.{ .handed = .{ .seq = seq, .failure = @errorName(err) } });
+ };
+}
+
fn pollCwds(core: *pardes.Pardes, ptys: *[pardes.MAX_PANES]?Pty) void {
for (ptys, 0..) |slot, id| if (slot) |pt| {
if (pt.fd < 0) continue;
var lbuf: [pardes.memory.limits.host_path_cap + 1]u8 = undefined;
- if (host_io.shellCwd(pt.pid, &lbuf)) |cwd| core.setCwd(id, cwd);
+ if (host_io.ttyCwd(pt.pid, pt.fd, core.settings.shell.effective.get(), &lbuf)) |cwd| core.setCwd(id, cwd);
};
}
-fn shellClock() i64 {
- var ts: libc.timespec = undefined;
- if (libc.clock_gettime(.MONOTONIC, &ts) != 0) return 0;
- return @as(i64, ts.sec) * std.time.ms_per_s + @divTrunc(ts.nsec, std.time.ns_per_ms);
-}
-
-fn reapShell(pid: *libc.pid_t, kill_at: *i64, now: i64) void {
- if (pid.* <= 0) return;
- const result = libc.waitpid(pid.*, null, libc.W.NOHANG);
- if (result > 0 or (result < 0 and libc.errno(result) == .CHILD)) {
- pid.* = 0;
- kill_at.* = 0;
- } else if (kill_at.* != 0 and now >= kill_at.*) {
- _ = libc.kill(pid.*, libc.SIG.KILL);
- kill_at.* = 0;
- }
-}
-
fn accumulateWheelDelta(pending: f32, raw_y: f32) f32 {
if (!std.math.isFinite(raw_y)) return pending;
const next = pending - raw_y;
@@ -4248,14 +4914,573 @@ test "fractional scroll reversals preserve signed distance" {
try std.testing.expect(reverse.lag >= 0 and reverse.lag < 1);
}
+/// A mouse wheel's step as whole lines (down positive), or null for a
+/// touchpad's fraction, which follows the finger as it is.
+fn notchOf(raw_y: f32, integer_y: i32) ?i32 {
+ if (!std.math.isFinite(raw_y) or integer_y == 0 or raw_y != @round(raw_y)) return null;
+ return @intFromFloat(std.math.clamp(-raw_y, -64, 64));
+}
+
+test "a wheel's notch is whole lines, a touchpad's fraction is not" {
+ try std.testing.expectEqual(@as(?i32, 1), notchOf(-1, -1));
+ try std.testing.expectEqual(@as(?i32, -3), notchOf(3, 3));
+ try std.testing.expectEqual(@as(?i32, null), notchOf(-0.25, 0));
+ try std.testing.expectEqual(@as(?i32, null), notchOf(-1.5, -1));
+ try std.testing.expectEqual(@as(?i32, null), notchOf(std.math.nan(f32), 1));
+}
+
+test "a click over codex in a terminal reaches its pty with its modifiers; Shift swaps B1 to pardes and B2 to the program" {
+ if (comptime !pardes.panes.terminal.enabled) return error.SkipZigTest;
+ const gpa = std.testing.allocator;
+ const core = try pardes.Pardes.init(gpa, .{ .cols = 60, .rows = 16, .tty_only = true });
+ defer core.deinit();
+ var frame: std.heap.ArenaAllocator = .init(gpa);
+ defer frame.deinit();
+ _ = try core.render(frame.allocator());
+ var in: Input = .{ .core = core };
+ var sent: std.ArrayList(u8) = .empty;
+ defer sent.deinit(gpa);
+ const take = struct {
+ fn f(core_: *pardes.Pardes, out: *std.ArrayList(u8)) ![]const u8 {
+ out.clearRetainingCapacity();
+ while (core_.nextEffect()) |effect| {
+ if (effect == .write and effect.write.pane == 0) try out.appendSlice(std.testing.allocator, effect.write.bytes.slice());
+ }
+ return out.items;
+ }
+ }.f;
+ _ = try take(core, &sent);
+ const pane = core.panes[0].?;
+ const r = core.rects[0];
+ const mc: MouseCell = .{ .col = r.x + config.GUTTER + 5, .row = core.bodyTop(pane, r) + 3 };
+ const next: MouseCell = .{ .col = mc.col + 1, .row = mc.row };
+ core.update(.{ .output = .{ .pane = 0, .bytes = "\x1b[?1049h\x1b[?1000h\x1b[?1002h\x1b[?1003h\x1b[?1006h" } });
+ _ = try take(core, &sent);
+ in.post(.{ .mouse = pointerMouse(.none, .motion, mc, .{}) });
+ try std.testing.expectEqualStrings("\x1b[<35;6;4M", try take(core, &sent));
+ in.post(.{ .mouse = pointerMouse(.left, .press, mc, .{ .ctrl = true }) });
+ try std.testing.expectEqualStrings("\x1b[<16;6;4M", try take(core, &sent));
+ in.post(.{ .mouse = pointerMouse(.left, .drag, next, .{}) });
+ try std.testing.expectEqualStrings("\x1b[<32;7;4M", try take(core, &sent));
+ in.post(.{ .mouse = pointerMouse(.left, .release, next, .{}) });
+ try std.testing.expectEqualStrings("\x1b[<0;7;4m", try take(core, &sent));
+ // Shift-B1 is pardes's select; B2 is pardes's execute and Shift-B2
+ // the program's, reported without the Shift.
+ in.post(.{ .mouse = pointerMouse(.left, .press, mc, .{ .shift = true }) });
+ in.post(.{ .mouse = pointerMouse(.left, .release, mc, .{ .shift = true }) });
+ try std.testing.expectEqualStrings("", try take(core, &sent));
+ in.post(.{ .mouse = pointerMouse(.middle, .press, mc, .{}) });
+ in.post(.{ .mouse = pointerMouse(.middle, .release, mc, .{}) });
+ try std.testing.expectEqualStrings("", try take(core, &sent));
+ in.post(.{ .mouse = pointerMouse(.middle, .press, mc, .{ .shift = true }) });
+ in.post(.{ .mouse = pointerMouse(.middle, .release, mc, .{ .shift = true }) });
+ try std.testing.expectEqualStrings("\x1b[<1;6;4M\x1b[<1;6;4m", try take(core, &sent));
+}
+
+test "a wheel over codex in a terminal reaches its pty as the mouse reports it asked for" {
+ if (comptime !pardes.panes.terminal.enabled) return error.SkipZigTest;
+ const gpa = std.testing.allocator;
+ const core = try pardes.Pardes.init(gpa, .{ .cols = 60, .rows = 16, .tty_only = true });
+ defer core.deinit();
+ var frame: std.heap.ArenaAllocator = .init(gpa);
+ defer frame.deinit();
+ _ = try core.render(frame.allocator());
+ var g: Gui = undefined;
+ g.scroll_pane = null;
+ g.scroll_delta = 0;
+ g.scroll_lag = 0;
+ g.scroll_edge_len = 0;
+ g.scroll_notch = 0;
+ g.program_wheel = 0;
+ g.glide = .{};
+ defer g.glide.deinit(gpa);
+ g.cell_h = 20;
+ var in: Input = .{ .core = core };
+ var sent: std.ArrayList(u8) = .empty;
+ defer sent.deinit(gpa);
+ const Sent = struct {
+ fn take(core_: *pardes.Pardes, out: *std.ArrayList(u8)) ![]const u8 {
+ out.clearRetainingCapacity();
+ while (core_.nextEffect()) |effect| {
+ if (effect == .write and effect.write.pane == 0) try out.appendSlice(std.testing.allocator, effect.write.bytes.slice());
+ }
+ return out.items;
+ }
+ };
+ _ = try Sent.take(core, &sent);
+ const pane = core.panes[0].?;
+ const r = core.rects[0];
+ const mc: MouseCell = .{ .col = r.x + config.GUTTER + 5, .row = core.bodyTop(pane, r) + 3 };
+ // What codex 0.159's chat sets on start.
+ core.update(.{ .output = .{ .pane = 0, .bytes = "\x1b[?2004h\x1b[>7u\x1b[?1004h\x1b[?1049h\x1b[?1007l\x1b[?1000h\x1b[?1002h\x1b[?1003h\x1b[?1006h" } });
+ _ = try Sent.take(core, &sent);
+ // A notch up, then a fast turn of three down: each its report, none
+ // left behind for a glide.
+ wheelAt(&g, &in, .{ .y = 1, .integer_y = 1 }, mc);
+ try std.testing.expectEqualStrings("\x1b[<64;6;4M", try Sent.take(core, &sent));
+ wheelAt(&g, &in, .{ .y = -3, .integer_y = -3 }, mc);
+ try std.testing.expectEqualStrings(std.mem.asBytes(&@as([3][10]u8, @splat("\x1b[<65;6;4M".*))), try Sent.take(core, &sent));
+ try std.testing.expectEqual(@as(i32, 0), g.scroll_notch);
+ try std.testing.expect(g.scroll_pane == null);
+ // A touchpad's fractions add up to a turn.
+ wheelAt(&g, &in, .{ .y = 0.5 }, mc);
+ try std.testing.expectEqualStrings("", try Sent.take(core, &sent));
+ wheelAt(&g, &in, .{ .y = 0.5 }, mc);
+ try std.testing.expectEqualStrings("\x1b[<64;6;4M", try Sent.take(core, &sent));
+ // Alt is meta, 8; Shift keeps the turn pardes's own, a glide.
+ wheelAt(&g, &in, .{ .y = 1, .integer_y = 1, .mods = .{ .alt = true } }, mc);
+ try std.testing.expectEqualStrings("\x1b[<72;6;4M", try Sent.take(core, &sent));
+ wheelAt(&g, &in, .{ .y = 1, .integer_y = 1, .mods = .{ .shift = true } }, mc);
+ try std.testing.expectEqualStrings("", try Sent.take(core, &sent));
+ try std.testing.expectEqual(@as(i32, -1), g.scroll_notch);
+ stepGlide(&g, core, gpa);
+ try std.testing.expectEqualStrings("", try Sent.take(core, &sent));
+ resetScroll(&g);
+ // Its sign-in screen: mouse off, alternate scroll on, so arrow keys.
+ core.update(.{ .output = .{ .pane = 0, .bytes = "\x1b[?1006l\x1b[?1003l\x1b[?1002l\x1b[?1000l\x1b[?1007h" } });
+ _ = try Sent.take(core, &sent);
+ wheelAt(&g, &in, .{ .y = -1, .integer_y = -1 }, mc);
+ try std.testing.expectEqualStrings("\x1b[B", try Sent.take(core, &sent));
+ // Back on the main screen a shell's wheel is ours: a notch to glide,
+ // nothing to the pty.
+ core.update(.{ .output = .{ .pane = 0, .bytes = "\x1b[?1049l" } });
+ _ = try Sent.take(core, &sent);
+ wheelAt(&g, &in, .{ .y = 1, .integer_y = 1 }, mc);
+ try std.testing.expectEqualStrings("", try Sent.take(core, &sent));
+ try std.testing.expectEqual(@as(i32, -1), g.scroll_notch);
+}
+
+const Glide = pardes.glide.Glide;
+
+/// Feeds a wheel's notches to the core, then steps the glide (Glide.step)
+/// and asks for frames while it moves.
+fn stepGlide(g: *Gui, core: *pardes.Pardes, gpa: std.mem.Allocator) void {
+ const glide = &g.glide;
+ // The glide runs on the core's continuous path: frames every loop, and
+ // a virtual clock carried on.
+ defer core.shell_continuous = glide.moving() or g.sel_glow.fading or g.hover_glow.fading;
+ const notch = g.scroll_notch;
+ g.scroll_notch = 0;
+ var wheeled: ?usize = null;
+ if (notch != 0) wheel: {
+ const id = g.scroll_pane orelse break :wheel;
+ const pane = core.panes[id] orelse {
+ resetScroll(g);
+ break :wheel;
+ };
+ const r = core.rects[id];
+ if (r.h <= pane.tag_rows or r.w <= config.GUTTER) {
+ resetScroll(g);
+ break :wheel;
+ }
+ var left = notch;
+ while (left != 0) {
+ const down = left > 0;
+ left += if (down) -1 else 1;
+ const was = pane.scroll();
+ // Shift: pardes's own scroll, never a program's wheel.
+ core.update(.{ .mouse = .{ .button = if (down) .wheel_down else .wheel_up, .kind = .press, .col = g.scroll_col, .row = g.scroll_row, .shift = true } });
+ if (pane.scroll() == was) break;
+ wheeled = id;
+ }
+ if (wheeled != null) core.needs_frame = true;
+ }
+ // Not a view a touchpad is moving by the pixel.
+ const direct: ?usize = if (g.scroll_lag != 0 or g.scroll_delta != 0) g.scroll_pane else null;
+ glide.step(core, gpa, wheeled, direct);
+}
+
+/// The glide's picture: the pane's body rows moved by the offset, and in
+/// the gap it opens the rows that left, as `emitScrollRows` draws a
+/// touchpad's fraction.
+fn emitGlideRows(g: *Gui, instances: [*]CellInstance, base: u32, surface: *pardes.Surface, layout: CellLayout, win_w: f32, win_h: f32, page: Ground, held: u16) u32 {
+ const glide = &g.glide;
+ for (surface.panelTracks()) |track|
+ if (track.active() and track.pane == glide.pane) return 0;
+ const r = glide.rect;
+ const bh = glide.body_h;
+ const bw = glide.bw();
+ const x0 = r.x + config.GUTTER;
+ const y0 = glide.body_y;
+ if (bw == 0 or bh == 0 or x0 + bw > surface.cols or y0 + bh > surface.rows) return 0;
+ // The scissor the shifted rows are drawn in is the scroll's.
+ g.scroll_rect = r;
+ g.scroll_body_y = y0;
+ g.scroll_body_h = bh;
+ var shifted = layout;
+ shifted.y_off -= glide.follow.offset * layout.h;
+ const kept = holdContext(g, surface, glide.pane, held, bh, layout);
+ shifted.y_off += kept.lift;
+ var n: u32 = 0;
+ // Only the rows the scissor shows: lagging a body or more, every body
+ // row is past the edge, and drawing them all was twice the frame's
+ // instances for the length of a long glide.
+ const lag: u16 = @intFromFloat(@min(@floor(@abs(glide.follow.offset)), @as(f32, @floatFromInt(bh))));
+ var row = y0 + kept.rows + if (glide.follow.offset > 0) lag else 0;
+ const row_end = y0 + bh - if (glide.follow.offset < 0) lag else 0;
+ while (row < row_end) : (row += 1) {
+ const line = surface.cells[@as(usize, row) * surface.cols ..][0..surface.cols];
+ const row_cursor: ?usize = if (surface.cursor) |cu| if (cu.y == row) cu.x else null else null;
+ var col = x0;
+ while (col < x0 + bw) : (col += 1) {
+ // No caret among the moving rows: it is drawn from its own
+ // springs (the quad), never carried by the text's glide.
+ emitInstance(g, instances, base + n, col, row, shifted, win_w, win_h, null, cellFontRole(surface.at(col, row)), line, col, row_cursor, false, false, page);
+ n += 1;
+ }
+ }
+ // The gap: rows past the top while the picture lags a move down, past
+ // the bottom for one up; as many as it opens.
+ const gap: u16 = @intFromFloat(@min(@ceil(@abs(glide.follow.offset)), @as(f32, @floatFromInt(@as(u32, bh) * Glide.reach))));
+ const nkept = if (glide.follow.offset < 0) glide.nabove else glide.nbelow;
+ const rows = if (glide.follow.offset < 0) glide.above else glide.below;
+ for (0..@min(gap, nkept)) |i| {
+ const cells = rows[i * bw ..][0..bw];
+ // Row -1 - i above the body, or bh + i below it, in grid rows.
+ const at_row: i32 = if (glide.follow.offset < 0) @as(i32, y0) - 1 - @as(i32, @intCast(i)) else @as(i32, y0) + bh + @as(i32, @intCast(i));
+ var at = shifted;
+ // emitInstance takes an unsigned row: move the layout instead.
+ at.y_off += @as(f32, @floatFromInt(at_row - @as(i32, y0))) * layout.h;
+ for (0..bw) |c_i| {
+ emitInstance(g, instances, base + n, x0 + @as(u16, @intCast(c_i)), y0, at, win_w, win_h, null, cellFontRole(&cells[c_i]), cells, c_i, null, false, false, page);
+ n += 1;
+ }
+ }
+ return n;
+}
+
+test "a notch scrolls the core at once and the picture glides after it, a wrapped line's rows at a time" {
+ const gpa = std.testing.allocator;
+ const core = try pardes.Pardes.init(gpa, .{ .cols = 80, .rows = 24 });
+ defer core.deinit();
+ // Lines of two rows each at this width, numbered so no two rows match.
+ var text: std.ArrayList(u8) = .empty;
+ defer text.deinit(gpa);
+ for (0..60) |i| {
+ try text.print(gpa, "{d:0>4} ", .{i});
+ try text.appendNTimes(gpa, 'a' + @as(u8, @intCast(i % 26)), 100);
+ try text.append(gpa, '\n');
+ }
+ _ = try core.setTestFile(text.items);
+ core.settings.motion = .smooth;
+ var arena: std.heap.ArenaAllocator = .init(gpa);
+ defer arena.deinit();
+ const ms = std.time.ns_per_ms;
+ var now: u64 = std.time.ns_per_s;
+ core.advance(now);
+ var s = try core.render(arena.allocator());
+ var g: Gui = undefined;
+ g.glide = .{};
+ defer g.glide.deinit(gpa);
+ g.scroll_delta = 0;
+ g.scroll_lag = 0;
+ g.scroll_edge_len = 0;
+ const r = core.rects[core.active];
+ g.scroll_pane = core.active;
+ g.scroll_col = r.x + 10;
+ g.scroll_row = r.y + r.h - 2;
+ const body_y = core.bodyTop(core.panes[core.active].?, r);
+ const row_before = try gpa.dupe(pardes.Cell, s.cells[@as(usize, body_y + 1) * s.cols + r.x + config.GUTTER ..][0 .. r.w - config.GUTTER]);
+ defer gpa.free(row_before);
+ // The loop has seen the view once (stepGlide finds a view that moved).
+ stepGlide(&g, core, gpa);
+ // One notch down: the core is a line on at once.
+ g.scroll_notch = 1;
+ const scrolled = core.panes[core.active].?.scroll();
+ stepGlide(&g, core, gpa);
+ try std.testing.expectEqual(scrolled + 1, core.panes[core.active].?.scroll());
+ try std.testing.expect(g.glide.pending);
+ // On the core's continuous path while it moves: frames every loop.
+ try std.testing.expect(core.shell_continuous and core.continuous());
+ _ = arena.reset(.retain_capacity);
+ s = try core.render(arena.allocator());
+ g.glide.measure(gpa, s);
+ // Its two rows: the picture two rows behind, the rows that left kept,
+ // nearest first.
+ try std.testing.expectApproxEqAbs(@as(f32, -2), g.glide.follow.offset, 1e-4);
+ try std.testing.expectEqual(@as(u16, 2), g.glide.nabove);
+ try std.testing.expect(pardes.glide.sameRow(g.glide.above[0 .. r.w - config.GUTTER], row_before));
+ // Frame by frame it comes back, never past, and settles.
+ var frames: usize = 0;
+ while (g.glide.moving()) : (frames += 1) {
+ now += 7 * ms;
+ core.advance(now);
+ stepGlide(&g, core, gpa);
+ try std.testing.expect(g.glide.follow.offset <= 1e-4);
+ if (frames > 200) return error.NeverSettled;
+ }
+ try std.testing.expect(frames > 5);
+ try std.testing.expectEqual(@as(f32, 0), g.glide.follow.offset);
+ try std.testing.expect(!core.shell_continuous);
+ // Motion off: a notch lands at once.
+ core.settings.motion = .off;
+ g.scroll_notch = 1;
+ stepGlide(&g, core, gpa);
+ try std.testing.expect(!g.glide.pending and !g.glide.moving());
+}
+
+test "a wheel's caret rides with its line, the text's own glide, never a spring of its own" {
+ if (!pardes.builtins.capabilities.lift) return error.SkipZigTest;
+ const gpa = std.testing.allocator;
+ const core = try pardes.Pardes.init(gpa, .{ .cols = 80, .rows = 24 });
+ defer core.deinit();
+ var text: std.ArrayList(u8) = .empty;
+ defer text.deinit(gpa);
+ for (0..200) |i| try text.print(gpa, "line {d}\n", .{i});
+ _ = try core.setTestFile(text.items);
+ core.settings.motion = .smooth;
+ core.settings.cursor_blink = false;
+ var arena: std.heap.ArenaAllocator = .init(gpa);
+ defer arena.deinit();
+ var now: u64 = std.time.ns_per_s;
+ core.advance(now);
+ for ("10G") |ch| core.update(.{ .key = .{ .cp = ch, .text = &.{ch} } });
+ _ = try core.render(arena.allocator());
+ now += std.time.ns_per_s;
+ core.advance(now);
+ _ = arena.reset(.retain_capacity);
+ var s = try core.render(arena.allocator());
+ var g: Gui = undefined;
+ g.glide = .{};
+ defer g.glide.deinit(gpa);
+ g.scroll_delta = 0;
+ g.scroll_lag = 0;
+ g.scroll_edge_len = 0;
+ const r = core.rects[core.active];
+ g.scroll_pane = core.active;
+ g.scroll_col = r.x + 10;
+ g.scroll_row = r.y + r.h - 2;
+ stepGlide(&g, core, gpa);
+ const before: f32 = @floatFromInt(s.cursor.?.y);
+ g.scroll_notch = 1;
+ stepGlide(&g, core, gpa);
+ var frames: usize = 0;
+ while (true) : (frames += 1) {
+ now += 7 * std.time.ns_per_ms;
+ core.advance(now);
+ _ = arena.reset(.retain_capacity);
+ s = try core.render(arena.allocator());
+ if (g.glide.pending) g.glide.measure(gpa, s);
+ if (frames == 0) {
+ try std.testing.expect(g.glide.caret_rides);
+ // Where its line is drawn: on the row it was on, the cell a row up.
+ try std.testing.expectApproxEqAbs(before, caretRow(&g, s).?, 1e-3);
+ }
+ // Always exactly with its line, the cell less the text's offset.
+ try std.testing.expectApproxEqAbs(@as(f32, @floatFromInt(s.cursor.?.y)) - g.glide.follow.offset, caretRow(&g, s).?, 1e-3);
+ if (!g.glide.moving()) break;
+ stepGlide(&g, core, gpa);
+ if (frames > 200) return error.NeverSettled;
+ }
+ try std.testing.expectEqual(@as(f32, @floatFromInt(s.cursor.?.y)), caretRow(&g, s).?);
+}
+
+/// The scripted scroll sequence of the glide tests: a frame a 60 Hz
+/// refresh, as the paced loop draws them (waitInput, then stepGlide, the
+/// core's render and the frame's measure), an input on the frames `script`
+/// names; each frame's picture offset and the core's first line.
+const GlideRun = struct {
+ const Step = struct { frame: usize, key: pardes.Key };
+ offsets: [600]f32 = undefined,
+ lines: [600]i64 = undefined,
+ carets: [600]f32 = undefined,
+ cells: [600]f32 = undefined,
+ frames: usize = 0,
+
+ fn play(seq: *GlideRun, g: *Gui, core: *pardes.Pardes, gpa: std.mem.Allocator, arena: *std.heap.ArenaAllocator, script: []const Step, frames: usize) !void {
+ var now: u64 = core.now_ns;
+ var next: usize = 0;
+ for (0..frames) |frame| {
+ while (next < script.len and script[next].frame == frame) : (next += 1) core.update(.{ .key = script[next].key });
+ now += std.time.ns_per_s / 60;
+ core.advance(now);
+ stepGlide(g, core, gpa);
+ _ = arena.reset(.retain_capacity);
+ const s = try core.render(arena.allocator());
+ if (g.glide.pending) g.glide.measure(gpa, s);
+ if (g.glide.moving()) g.glide.advance(g.glide.now_ns, g.glide.motion);
+ seq.offsets[frame] = g.glide.follow.offset;
+ seq.lines[frame] = @intCast(core.panes[core.active].?.file.?.scroll);
+ seq.carets[frame] = caretRow(g, s) orelse -1;
+ seq.cells[frame] = if (s.cursor) |cu| @floatFromInt(cu.y) else -1;
+ }
+ seq.frames = frames;
+ }
+
+ /// The caret's invariants over the run: while its cell stays and it is
+ /// on it, it does not move a pixel; it only ever closes on its cell (a
+ /// twentieth of a row of play for a jump's bow); it lands within half a
+ /// second of its last change.
+ fn checkCaret(seq: *const GlideRun) !void {
+ var changed: usize = 0;
+ for (1..seq.frames) |k| {
+ if (seq.cells[k] < 0 or seq.cells[k - 1] < 0) continue;
+ if (seq.cells[k] != seq.cells[k - 1]) changed = k;
+ if (seq.cells[k] == seq.cells[k - 1] and seq.carets[k - 1] == seq.cells[k - 1]) try std.testing.expectEqual(seq.carets[k - 1], seq.carets[k]);
+ try std.testing.expect(@abs(seq.carets[k] - seq.cells[k]) <= @abs(seq.carets[k - 1] - seq.cells[k]) + 0.05);
+ if (k - changed == 30) try std.testing.expectEqual(seq.cells[k], seq.carets[k]);
+ }
+ }
+
+ /// Frames from `from` until the picture is still: the scroll's glide.
+ fn settle(seq: *const GlideRun, from: usize) usize {
+ var k = from;
+ while (k < seq.frames and seq.offsets[k] != 0) k += 1;
+ return k - from;
+ }
+};
+
+test "every scroll glides on one law: a half page, a page, the far jumps, a run of them retargeting, and Motion off lands at once" {
+ const gpa = std.testing.allocator;
+ const core = try pardes.Pardes.init(gpa, .{ .cols = 100, .rows = 40 });
+ defer core.deinit();
+ var text: std.ArrayList(u8) = .empty;
+ defer text.deinit(gpa);
+ // Numbered lines no two alike, short enough never to wrap.
+ for (0..3000) |i| try text.print(gpa, "{d:0>5} line {d} of the long file\n", .{ i, i * 7 % 13 });
+ _ = try core.setTestFile(text.items);
+ core.settings.motion = .smooth;
+ var arena: std.heap.ArenaAllocator = .init(gpa);
+ defer arena.deinit();
+ core.advance(std.time.ns_per_s);
+ _ = try core.render(arena.allocator());
+ var g: Gui = undefined;
+ g.glide = .{};
+ defer g.glide.deinit(gpa);
+ g.scroll_notch = 0;
+ g.scroll_pane = null;
+ g.scroll_delta = 0;
+ g.scroll_lag = 0;
+ g.scroll_edge_len = 0;
+ g.sel_glow = .{};
+ g.hover_glow = .{};
+ const body_h: f32 = @floatFromInt(core.rects[core.active].h - core.panes[core.active].?.tag_rows);
+ const ctrl = struct {
+ fn key(cp: u21) pardes.Key {
+ return .{ .cp = cp, .ctrl = true };
+ }
+ };
+ const script = [_]GlideRun.Step{
+ .{ .frame = 2, .key = ctrl.key('d') },
+ .{ .frame = 40, .key = ctrl.key('f') },
+ .{ .frame = 80, .key = .{ .cp = 'g', .text = "g" } },
+ .{ .frame = 80, .key = .{ .cp = 'e', .text = "e" } },
+ .{ .frame = 120, .key = .{ .cp = 'g', .text = "g" } },
+ .{ .frame = 120, .key = .{ .cp = 'g', .text = "g" } },
+ // Faster than they settle: each adds to the glide under way.
+ .{ .frame = 160, .key = ctrl.key('d') },
+ .{ .frame = 165, .key = ctrl.key('d') },
+ .{ .frame = 170, .key = ctrl.key('d') },
+ .{ .frame = 175, .key = ctrl.key('d') },
+ };
+ var seq: GlideRun = .{};
+ try seq.play(&g, core, gpa, &arena, &script, 240);
+ try seq.checkCaret();
+ // Every one moves the picture on the frame it is drawn in, and the
+ // picture lags by what the core moved (a far jump, by one body).
+ var longest: usize = 0;
+ var shortest: usize = std.math.maxInt(usize);
+ for ([_]usize{ 2, 40, 80, 120 }) |at| {
+ const moved: f32 = @floatFromInt(@abs(seq.lines[at] - seq.lines[at - 1]));
+ try std.testing.expect(moved >= 1);
+ const lag = @abs(seq.offsets[at]);
+ try std.testing.expect(lag > 0.5 * @min(moved, body_h));
+ try std.testing.expect(lag <= @min(moved, body_h) + 1e-3);
+ // Settles on the same law whatever the distance: a few frames for
+ // a half page, not many more for a jump of 3000 lines.
+ const frames = seq.settle(at);
+ longest = @max(longest, frames);
+ shortest = @min(shortest, frames);
+ try std.testing.expect(frames >= 8 and frames <= 24);
+ }
+ try std.testing.expect(longest - shortest <= 5);
+ // Readable: never more than a quarter of a body a frame once it moves.
+ for (1..seq.frames) |k| {
+ if (seq.lines[k] != seq.lines[k - 1]) continue;
+ try std.testing.expect(@abs(seq.offsets[k] - seq.offsets[k - 1]) <= body_h / 4 + 1e-3);
+ }
+ // The seq of half pages: one glide, never at rest between them, and
+ // done as soon after the last as one half page alone takes.
+ for (160..180) |k| try std.testing.expect(seq.offsets[k] != 0);
+ try std.testing.expect(seq.settle(175) <= seq.settle(2) + 4);
+ // Motion off: the same scroll lands at once.
+ core.settings.motion = .off;
+ var off: GlideRun = .{};
+ try off.play(&g, core, gpa, &arena, &.{.{ .frame = 1, .key = ctrl.key('u') }}, 10);
+ try std.testing.expect(off.lines[1] != off.lines[0]);
+ for (off.offsets[0..off.frames]) |offset| try std.testing.expectEqual(@as(f32, 0), offset);
+}
+
+test "a held key moves the view at the stream's own rate, never a bounce a line, and settles once it stops" {
+ const gpa = std.testing.allocator;
+ const core = try pardes.Pardes.init(gpa, .{ .cols = 100, .rows = 40 });
+ defer core.deinit();
+ var text: std.ArrayList(u8) = .empty;
+ defer text.deinit(gpa);
+ for (0..3000) |i| try text.print(gpa, "{d:0>5} line {d} of the long file\n", .{ i, i * 7 % 13 });
+ _ = try core.setTestFile(text.items);
+ core.settings.motion = .smooth;
+ var arena: std.heap.ArenaAllocator = .init(gpa);
+ defer arena.deinit();
+ core.advance(std.time.ns_per_s);
+ _ = try core.render(arena.allocator());
+ var g: Gui = undefined;
+ g.glide = .{};
+ defer g.glide.deinit(gpa);
+ g.scroll_notch = 0;
+ g.scroll_pane = null;
+ g.scroll_delta = 0;
+ g.scroll_lag = 0;
+ g.scroll_edge_len = 0;
+ g.sel_glow = .{};
+ g.hover_glow = .{};
+ // j held from the top: a repeat every second frame, the view following
+ // a line a repeat once the caret is at its last rows.
+ var script: [48]GlideRun.Step = undefined;
+ for (&script, 0..) |*step, i| step.* = .{ .frame = 20 + 2 * i, .key = .{ .cp = 'j', .text = "j" } };
+ var seq: GlideRun = .{};
+ try seq.play(&g, core, gpa, &arena, &script, 200);
+ // Inside the stream the picture moves every frame by about the same
+ // step: an input's rows over its spacing, not a spring's ease to each.
+ var least: f32 = std.math.inf(f32);
+ var most: f32 = 0;
+ for (90..110) |k| {
+ const step = (@as(f32, @floatFromInt(seq.lines[k])) + seq.offsets[k]) - (@as(f32, @floatFromInt(seq.lines[k - 1])) + seq.offsets[k - 1]);
+ least = @min(least, step);
+ most = @max(most, step);
+ }
+ try std.testing.expect(seq.lines[89] > 0 and least > 0.4 and most < 0.6);
+ // The caret stays on its row, the text moving under it: not a pixel's
+ // wobble (the glide's fractional lag never reaches it).
+ for (90..110) |k| try std.testing.expectEqual(seq.carets[89], seq.carets[k]);
+ // It comes to rest once the keys stop, never past its mark.
+ for (110..200) |k| try std.testing.expect(seq.offsets[k] <= 0);
+ try std.testing.expectEqual(@as(f32, 0), seq.offsets[199]);
+ // Ctrl-d held, then PageDown held: the caret keeps its row the whole
+ // way, the pages moving under it.
+ var pages: [40]GlideRun.Step = undefined;
+ for (&pages, 0..) |*step, i| step.* = .{ .frame = 10 + 2 * i, .key = if (i < 20) .{ .cp = 'd', .ctrl = true } else .{ .cp = pardes.Key.page_down } };
+ var held: GlideRun = .{};
+ try held.play(&g, core, gpa, &arena, &pages, 100);
+ try held.checkCaret();
+ try seq.checkCaret();
+ // (The first of each may move it, one ease: from the last row to where
+ // a half page keeps it, and from there to a page's.)
+ for (30..50) |k| try std.testing.expectEqual(held.carets[30], held.carets[k]);
+ for (70..90) |k| try std.testing.expectEqual(held.carets[70], held.carets[k]);
+}
+
fn resetScroll(g: *Gui) void {
g.scroll_pane = null;
g.scroll_delta = 0;
g.scroll_lag = 0;
g.scroll_edge_len = 0;
+ g.scroll_notch = 0;
+ g.glide.stop();
}
fn stepScroll(g: *Gui, core: *pardes.Pardes, gpa: std.mem.Allocator) void {
+ stepGlide(g, core, gpa);
const id = g.scroll_pane orelse return;
const pane = core.panes[id] orelse {
resetScroll(g);
@@ -4264,27 +5489,30 @@ fn stepScroll(g: *Gui, core: *pardes.Pardes, gpa: std.mem.Allocator) void {
const queued_delta = g.scroll_delta;
g.scroll_delta = 0;
if (queued_delta == 0) {
- if (g.scroll_lag == 0) resetScroll(g);
+ if (g.scroll_lag == 0 and g.scroll_notch == 0 and !g.glide.moving()) resetScroll(g);
return;
}
const r = core.rects[id];
- if (r.h <= pardes.BOX_H) {
+ if (r.h <= pane.tag_rows) {
resetScroll(g);
return;
}
- const delta = boundScrollDelta(g.scroll_lag, queued_delta, r.h - pardes.BOX_H);
+ const delta = boundScrollDelta(g.scroll_lag, queued_delta, r.h - pane.tag_rows);
const st = applyScrollDelta(g.scroll_lag, delta);
var left = st.rows;
while (left != 0) {
const down = left > 0;
left += if (down) -1 else 1;
const was = pane.scroll();
- core.update(.{ .mouse = .{
- .button = if (down) .wheel_down else .wheel_up,
- .kind = .press,
- .col = g.scroll_col,
- .row = g.scroll_row,
- } });
+ core.update(.{
+ .mouse = .{
+ .button = if (down) .wheel_down else .wheel_up,
+ .kind = .press,
+ .col = g.scroll_col,
+ .row = g.scroll_row,
+ .shift = true, // pardes's own scroll, never a program's wheel
+ },
+ });
if (pane.scroll() == was) {
resetScroll(g);
return;
@@ -4292,14 +5520,15 @@ fn stepScroll(g: *Gui, core: *pardes.Pardes, gpa: std.mem.Allocator) void {
}
g.scroll_lag = st.lag;
g.scroll_rect = r;
- const body_y = if (core.settings.tag_bottom) r.y else r.y + pardes.BOX_H;
+ const body_y = core.bodyTop(pane, r);
g.scroll_body_y = body_y;
+ g.scroll_body_h = r.h -| pane.tag_rows;
if (st.rows != 0) {
const s = &core.surface;
g.scroll_edge_len = 0;
- if (r.w > config.GUTTER and r.h > pardes.BOX_H and r.x + r.w <= s.cols) {
+ if (r.w > config.GUTTER and r.h > pane.tag_rows and r.x + r.w <= s.cols) {
const bw = r.w - config.GUTTER;
- const bh = r.h - pardes.BOX_H;
+ const bh = g.scroll_body_h;
const k: u16 = @intCast(@min(@abs(st.rows), @as(i32, bh)));
const srow = body_y + (if (st.rows > 0) k - 1 else bh - k);
if (srow < s.rows) {
@@ -4317,29 +5546,35 @@ fn stepScroll(g: *Gui, core: *pardes.Pardes, gpa: std.mem.Allocator) void {
if (g.scroll_lag == 0) resetScroll(g);
}
-fn emitScrollRows(g: *Gui, instances: [*]CellInstance, base: u32, surface: *pardes.Surface, layout: CellLayout, win_w: f32, win_h: f32, page: Ground) u32 {
+fn emitScrollRows(g: *Gui, instances: [*]CellInstance, base: u32, surface: *pardes.Surface, layout: CellLayout, win_w: f32, win_h: f32, page: Ground, held: u16) u32 {
+ g.scroll_held_px = 0;
+ if (g.glide.follow.offset != 0) return emitGlideRows(g, instances, base, surface, layout, win_w, win_h, page, held);
const scroll_pane = g.scroll_pane orelse return 0;
if (g.scroll_lag == 0) return 0;
for (surface.panelTracks()) |track|
if (track.active() and track.pane == scroll_pane) return 0;
const r = g.scroll_rect;
- if (r.w <= config.GUTTER or r.h <= pardes.BOX_H) return 0;
+ const bh = g.scroll_body_h;
+ if (r.w <= config.GUTTER or bh == 0) return 0;
const x0 = r.x + config.GUTTER;
const y0 = g.scroll_body_y;
const bw = r.w - config.GUTTER;
- const bh = r.h - pardes.BOX_H;
if (x0 + bw > surface.cols or y0 + bh > surface.rows) return 0; // resized under us
var shifted = layout;
shifted.y_off -= g.scroll_lag * layout.h;
+ const kept = holdContext(g, surface, scroll_pane, held, bh, layout);
+ shifted.y_off += kept.lift;
const cursor_idx: u32 = if (surface.cursor) |cu| @as(u32, cu.y) * surface.cols + cu.x else std.math.maxInt(u32);
const cursor_bar = if (surface.cursor) |cu| cu.bar else false;
var n: u32 = 0;
- var row = y0;
+ var row = y0 + kept.rows;
while (row < y0 + bh) : (row += 1) {
+ const line = surface.cells[@as(usize, row) * surface.cols ..][0..surface.cols];
+ const row_cursor: ?usize = if (surface.cursor) |cu| if (cu.y == row) cu.x else null else null;
var col = x0;
while (col < x0 + bw) : (col += 1) {
const sidx: u32 = @as(u32, row) * surface.cols + col;
- emitInstance(g, instances, base + n, col, row, shifted, win_w, win_h, null, cellFontRole(surface.at(col, row)), surface.at(col, row), false, sidx == cursor_idx and !cursor_bar, page);
+ emitInstance(g, instances, base + n, col, row, shifted, win_w, win_h, null, cellFontRole(surface.at(col, row)), line, col, row_cursor, false, sidx == cursor_idx and !cursor_bar, page);
n += 1;
}
}
@@ -4347,19 +5582,59 @@ fn emitScrollRows(g: *Gui, instances: [*]CellInstance, base: u32, surface: *pard
const erow: u16 = if (g.scroll_lag > 0) y0 + bh else y0 - 1;
var i: u16 = 0;
while (i < bw) : (i += 1) {
- emitInstance(g, instances, base + n, x0 + i, erow, shifted, win_w, win_h, null, cellFontRole(&g.scroll_edge[i]), &g.scroll_edge[i], false, false, page);
+ emitInstance(g, instances, base + n, x0 + i, erow, shifted, win_w, win_h, null, cellFontRole(&g.scroll_edge[i]), g.scroll_edge[0..bw], i, null, false, false, page);
n += 1;
}
}
return n;
}
+/// A scrolling body's tree-sitter context rows hold still: the shifted
+/// rows start under them and are clipped below their band, and where a
+/// body layer stacks them at the tagline's height (TreeContextTagStyle)
+/// the rows under them are drawn up to meet them, where the layer has them.
+fn holdContext(g: *Gui, surface: *const pardes.Surface, id: usize, held: u16, bh: u16, layout: CellLayout) struct { rows: u16, lift: f32 } {
+ const rows = @min(held, bh);
+ const layered = id < surface.body_layers.len and surface.body_layers[id].rows != 0 and surface.body_layers[id].context_rows != 0;
+ const row_px = if (layered) std.math.clamp(@as(f32, @floatFromInt(g.tagline_height)), 1, @max(1, layout.h)) else layout.h;
+ g.scroll_held_px = @as(f32, @floatFromInt(rows)) * row_px;
+ return .{ .rows = rows, .lift = @as(f32, @floatFromInt(rows)) * (row_px - layout.h) };
+}
+
+test "a scroll's shifted rows start under the context rows, and its scissor below their band" {
+ var surface: pardes.Surface = .{};
+ var g: Gui = undefined;
+ g.tagline_height = 12;
+ g.scroll_rect = .{ .x = 0, .y = 0, .w = 40, .h = 20 };
+ g.scroll_body_y = 1;
+ g.scroll_body_h = 19;
+ const layout: CellLayout = .{ .w = 10, .h = 20, .x_off = 0, .y_off = 0 };
+ // On the grid, three body-high rows are held, and nothing moves up.
+ const grid = holdContext(&g, &surface, 0, 3, 19, layout);
+ try std.testing.expectEqual(@as(u16, 3), grid.rows);
+ try std.testing.expectEqual(@as(f32, 0), grid.lift);
+ const clip = scrollScissor(&g, layout, 400, 400);
+ try std.testing.expectEqual(@as(c_int, 20 + 3 * 20), clip.y);
+ try std.testing.expectEqual(@as(c_int, 16 * 20), clip.h);
+ // In a body layer they are tagline-high: the rows under them move up
+ // by what each is shorter, to where the layer draws them.
+ surface.body_layers[0].rows = 30;
+ surface.body_layers[0].context_rows = 3;
+ const layered = holdContext(&g, &surface, 0, 3, 19, layout);
+ try std.testing.expectEqual(@as(f32, 3 * (12 - 20)), layered.lift);
+ try std.testing.expectEqual(@as(c_int, 20 + 3 * 12), scrollScissor(&g, layout, 400, 400).y);
+ // None held: the whole body moves.
+ surface.body_layers[0].rows = 0;
+ try std.testing.expectEqual(@as(u16, 0), holdContext(&g, &surface, 0, 0, 19, layout).rows);
+ try std.testing.expectEqual(@as(c_int, 20), scrollScissor(&g, layout, 400, 400).y);
+}
+
fn scrollScissor(g: *const Gui, layout: CellLayout, sw: u32, sh: u32) c.SDL_Rect {
const r = g.scroll_rect;
const px = layout.x_off + @as(f32, @floatFromInt(r.x + config.GUTTER)) * layout.w;
- const py = layout.y_off + @as(f32, @floatFromInt(g.scroll_body_y)) * layout.h;
+ const py = layout.y_off + @as(f32, @floatFromInt(g.scroll_body_y)) * layout.h + g.scroll_held_px;
const pw = @as(f32, @floatFromInt(r.w - config.GUTTER)) * layout.w;
- const ph = @as(f32, @floatFromInt(r.h - pardes.BOX_H)) * layout.h;
+ const ph = @max(0, @as(f32, @floatFromInt(g.scroll_body_h)) * layout.h - g.scroll_held_px);
const x0 = std.math.clamp(@as(i32, @intFromFloat(@floor(px))), 0, @as(i32, @intCast(sw)));
const y0 = std.math.clamp(@as(i32, @intFromFloat(@floor(py))), 0, @as(i32, @intCast(sh)));
const x1 = std.math.clamp(@as(i32, @intFromFloat(@ceil(px + pw))), x0, @as(i32, @intCast(sw)));
@@ -4423,7 +5698,7 @@ fn snapshotContainsPlacement(g: *const Gui, current: pardes.ImagePlace) bool {
return false;
}
-fn placeIntersectsBox(place: SavedImagePlace, box: pardes.layout.Box) bool {
+fn placeIntersectsBox(place: SavedImagePlace, box: pardes.animation.Box) bool {
const x0: f32 = @floatFromInt(place.x);
const y0: f32 = @floatFromInt(place.y);
const x1: f32 = @floatFromInt(@as(u32, place.x) + place.w);
@@ -4515,6 +5790,23 @@ fn uploadNativeTexture(
const byte_len = validImageBytes(place) orelse return error.BadImage;
const key = place.cacheKey();
if (g.native_images.contains(key)) return;
+ if (comptime pardes.pdf_enabled) if (place.patch) |patch| patch: {
+ // The core changed only these rows since a revision we still hold:
+ // write them into that texture rather than sending the whole page.
+ var base = key;
+ base.revision = patch.from;
+ if (patch.y + patch.h > place.ih) break :patch;
+ const texture = g.native_images.get(base) orelse break :patch;
+ const row = place.iw * 4;
+ try uploadTextureRows(g, cmd, texture, place.rgba[patch.y * row ..][0 .. patch.h * row], place.iw, patch.y, patch.h);
+ try g.native_images.put(gpa, key, texture);
+ _ = g.native_images.remove(base);
+ // A transition snapshot of the last frame follows its texture.
+ for (g.presented_images.items) |*saved| if (saved.key.eql(base)) {
+ saved.key = key;
+ };
+ return;
+ };
var tex_info = std.mem.zeroes(c.SDL_GPUTextureCreateInfo);
tex_info.type = c.SDL_GPU_TEXTURETYPE_2D;
@@ -4527,47 +5819,59 @@ fn uploadNativeTexture(
tex_info.sample_count = c.SDL_GPU_SAMPLECOUNT_1;
const texture = c.SDL_CreateGPUTexture(g.device, &tex_info) orelse return error.GpuCreate;
errdefer c.SDL_ReleaseGPUTexture(g.device, texture);
+ try uploadTextureRows(g, cmd, texture, place.rgba[0..byte_len], place.iw, 0, place.ih);
+ try g.native_images.put(gpa, key, texture);
+}
+/// Copy `rows` rows of RGBA, `width` pixels each, into `texture` at row `y`.
+fn uploadTextureRows(
+ g: *Gui,
+ cmd: *c.SDL_GPUCommandBuffer,
+ texture: *c.SDL_GPUTexture,
+ rgba: []const u8,
+ width: usize,
+ y: usize,
+ rows: usize,
+) !void {
var xf_info = c.SDL_GPUTransferBufferCreateInfo{
.usage = c.SDL_GPU_TRANSFERBUFFERUSAGE_UPLOAD,
- .size = byte_len,
+ .size = @intCast(rgba.len),
.props = 0,
};
const transfer = c.SDL_CreateGPUTransferBuffer(g.device, &xf_info) orelse return error.GpuCreate;
defer c.SDL_ReleaseGPUTransferBuffer(g.device, transfer);
const mapped: [*]u8 = @ptrCast(c.SDL_MapGPUTransferBuffer(g.device, transfer, false) orelse return error.GpuMap);
- @memcpy(mapped[0..byte_len], place.rgba);
+ @memcpy(mapped[0..rgba.len], rgba);
c.SDL_UnmapGPUTransferBuffer(g.device, transfer);
const copy = c.SDL_BeginGPUCopyPass(cmd);
const src = c.SDL_GPUTextureTransferInfo{
.transfer_buffer = transfer,
.offset = 0,
- .pixels_per_row = @intCast(place.iw),
- .rows_per_layer = @intCast(place.ih),
+ .pixels_per_row = @intCast(width),
+ .rows_per_layer = @intCast(rows),
};
const dst = c.SDL_GPUTextureRegion{
.texture = texture,
.mip_level = 0,
.layer = 0,
.x = 0,
- .y = 0,
+ .y = @intCast(y),
.z = 0,
- .w = @intCast(place.iw),
- .h = @intCast(place.ih),
+ .w = @intCast(width),
+ .h = @intCast(rows),
.d = 1,
};
c.SDL_UploadToGPUTexture(copy, &src, &dst, false);
c.SDL_EndGPUCopyPass(copy);
- try g.native_images.put(gpa, key, texture);
}
fn appendPreparedImage(
g: *Gui,
gpa: std.mem.Allocator,
place: SavedImagePlace,
- track: ?pardes.layout.Track,
- clip: ?pardes.layout.Box,
+ track: ?pardes.animation.Track,
+ clip: ?pardes.animation.Box,
old_layer: bool,
) void {
const texture = g.native_images.get(place.key) orelse return;
@@ -4642,7 +5946,7 @@ fn prepareNativeImages(
gpa: std.mem.Allocator,
cmd: *c.SDL_GPUCommandBuffer,
surface: *pardes.Surface,
- plan: *PaintPlan,
+ groups: *Groups,
sw: u32,
sh: u32,
) bool {
@@ -4668,9 +5972,9 @@ fn prepareNativeImages(
}
g.prepared_images.clearRetainingCapacity();
- for (plan.batches[0..plan.len], 0..) |*batch, batch_index| {
- batch.image_start = std.math.cast(u32, g.prepared_images.items.len) orelse return false;
- const track = batch.track;
+ for (groups.items[0..groups.len], 0..) |*group, group_index| {
+ group.image_start = std.math.cast(u32, g.prepared_images.items.len) orelse return false;
+ const track = group.track;
if (track) |active| {
if (active.phase == .closing) {
@@ -4690,7 +5994,7 @@ fn prepareNativeImages(
for (surface.images[0..surface.nimages]) |maybe| {
const current = maybe orelse continue;
if (validImageBytes(current) == null or
- paintBatchForSerial(plan, current.serial) != batch_index) continue;
+ groupOf(groups, current.serial) != group_index) continue;
const saved = SavedImagePlace.from(current);
const current_track = if (track) |active| switch (active.effect) {
.dissolve => if (snapshotContainsPlacement(g, current)) null else active,
@@ -4699,7 +6003,7 @@ fn prepareNativeImages(
appendPreparedImage(g, gpa, saved, current_track, null, false);
}
}
- if (batch_index == 0) for (plan.batches[1..plan.len]) |tracked| {
+ if (group_index == 0) for (groups.items[1..][0..groups.tracks]) |tracked| {
const active = tracked.track.?;
if (active.effect != .vertical or active.phase != .opening) continue;
for (g.presented_images.items) |saved| {
@@ -4708,7 +6012,7 @@ fn prepareNativeImages(
}
};
const image_end = std.math.cast(u32, g.prepared_images.items.len) orelse return false;
- batch.image_count = image_end - batch.image_start;
+ group.image_count = image_end - group.image_start;
}
const capacity = std.math.cast(u32, g.prepared_images.items.len) orelse return false;
@@ -4756,7 +6060,7 @@ fn imageScissor(
};
}
-fn panelBoxScissor(g: *const Gui, box: pardes.layout.Box, max_w: u32, max_h: u32) c.SDL_Rect {
+fn panelBoxScissor(g: *const Gui, box: pardes.animation.Box, max_w: u32, max_h: u32) c.SDL_Rect {
const x0: i32 = @intFromFloat(@floor(box.x * @as(f32, @floatFromInt(g.cell_w))));
const y0: i32 = @intFromFloat(@floor(box.y * @as(f32, @floatFromInt(g.cell_h))));
const x1: i32 = @intFromFloat(@ceil((box.x + box.w) * @as(f32, @floatFromInt(g.cell_w))));
@@ -4777,11 +6081,10 @@ fn drawNativeImagesGpu(
g: *Gui,
rp: ?*c.SDL_GPURenderPass,
surface: *pardes.Surface,
- plan: *const PaintPlan,
- batch_index: usize,
+ batch: Group,
+ whole: c.SDL_Rect,
) void {
const pass = rp orelse return;
- const batch = plan.batches[batch_index];
c.SDL_BindGPUGraphicsPipeline(pass, g.image_pipeline);
const max_w = @as(u32, surface.cols) * g.cell_w;
const max_h = @as(u32, surface.rows) * g.cell_h;
@@ -4800,12 +6103,8 @@ fn drawNativeImagesGpu(
idx += 1;
}
std.debug.assert(idx == batch.image_start + batch.image_count);
- const whole = c.SDL_Rect{
- .x = 0,
- .y = 0,
- .w = @intCast(@as(u32, surface.cols) * g.cell_w),
- .h = @intCast(@as(u32, surface.rows) * g.cell_h),
- };
+ // Back to the whole target: what draws after a picture may run on past
+ // the grid, as a rule and a band do.
c.SDL_SetGPUScissor(pass, &whole);
}
@@ -4814,103 +6113,129 @@ fn renderFrame(
gpa: std.mem.Allocator,
core: ?*const pardes.Pardes,
surface: *pardes.Surface,
- theme_bg: ?[3]u8,
- topbar_pane_border_rgb: [3]u8,
- tagline_rgb: [3]u8,
- scene_effects: pardes.layout.SceneEffect,
debug_on: bool,
) !bool {
if (surface.pointer_shape != g.pointer_shape) {
g.pointer_shape = surface.pointer_shape;
- const cursor = if (g.pointer_shape == .link) g.link_cursor else g.arrow_cursor orelse c.SDL_GetDefaultCursor();
+ const cursor = switch (g.pointer_shape) {
+ .link => g.link_cursor,
+ .box => g.box_cursor orelse g.arrow_cursor,
+ else => g.arrow_cursor orelse c.SDL_GetDefaultCursor(),
+ };
if (cursor) |value| _ = c.SDL_SetCursor(value);
}
g.scene_target_failed = false;
+ g.words.memo = .{}; // positional, and this frame's cells are new
const cmd = c.SDL_AcquireGPUCommandBuffer(g.device) orelse return false;
var command_consumed = false;
defer if (!command_consumed) {
_ = c.SDL_SubmitGPUCommandBuffer(cmd);
};
- var sw: u32 = 0;
- var sh: u32 = 0;
- var target: *c.SDL_GPUTexture = undefined;
- if (g.capture) {
- sw = @as(u32, surface.cols) * g.cell_w;
- sh = @as(u32, surface.rows) * g.cell_h;
- if (sw == 0 or sh == 0) {
- command_consumed = true;
- _ = c.SDL_SubmitGPUCommandBuffer(cmd);
- return false;
- }
- try ensureCaptureTexture(g, sw, sh);
- target = g.capture_tex.?;
- } else if (g.soft_present) {
- var pw: c_int = 0;
- var ph: c_int = 0;
- if (!c.SDL_GetWindowSizeInPixels(g.window, &pw, &ph) or pw <= 0 or ph <= 0) {
- command_consumed = true;
- _ = c.SDL_SubmitGPUCommandBuffer(cmd);
- return false;
- }
- sw = @intCast(pw);
- sh = @intCast(ph);
- try ensureCaptureTexture(g, sw, sh);
- target = g.capture_tex.?;
- } else {
- var swap_tex: ?*c.SDL_GPUTexture = null;
- if (!c.SDL_AcquireGPUSwapchainTexture(cmd, g.window, &swap_tex, &sw, &sh)) {
- command_consumed = true;
- _ = c.SDL_SubmitGPUCommandBuffer(cmd);
- return false;
- }
- target = swap_tex orelse { // swapchain busy: skip the frame
- command_consumed = true;
- _ = c.SDL_SubmitGPUCommandBuffer(cmd);
- return false;
- };
- }
+ const frame_target = try acquireTarget(g, cmd, @as(u32, surface.cols) * g.cell_w + g.capture_pad, @as(u32, surface.rows) * g.cell_h + g.capture_pad) orelse {
+ command_consumed = true;
+ _ = c.SDL_SubmitGPUCommandBuffer(cmd);
+ return false;
+ };
+ const target = frame_target.texture;
+ const sw = frame_target.w;
+ const sh = frame_target.h;
const win_w: f32 = @floatFromInt(sw);
const win_h: f32 = @floatFromInt(sh);
- var scene_on = scene_effects.crt or scene_effects.ripple or scene_effects.glitch;
+ // The post chain runs from the scene texture, over a local frame or an
+ // attached session's alike.
+ var scene_on = g.post.ready();
if (scene_on) ensureSceneTexture(g, sw, sh) catch {
g.scene_target_failed = true;
scene_on = false;
};
const scene: *c.SDL_GPUTexture = if (scene_on) g.scene_tex.? else target;
+ // The frame's CPU side: groups, decor, cover and every instance, up to
+ // their upload.
+ const build_zone = tracy.zone(@src(), "gui frame build");
+ const probe_build = monoNs();
+ var building = true;
+ defer if (building) build_zone.end();
const layout = fixedCellLayout(g);
- var paint_plan = makePaintPlan(surface.panelTracks(), surface.hasPanelDiff());
- var overlay_count = buildOverlay(
- g,
- core,
- surface,
- layout,
- sw,
- sh,
- topbar_pane_border_rgb,
- tagline_rgb,
- paint_plan.len == 1,
- debug_on,
- );
+ const chrome = &surface.chrome;
+ // G6: what the scroll just done moved the pane's rows by, measured on
+ // this frame against the last (the glide follows it from there).
+ if (g.glide.pending) g.glide.measure(gpa, surface);
+ g.sel_glow.now_ns = if (core) |p| p.now_ns else c.SDL_GetTicksNS();
+ // Off, or while panes move, no glow and nothing fading.
+ if (surface.chrome.fx & 1 == 0 or surface.panelTracks().len != 0) g.sel_glow = .{ .now_ns = g.sel_glow.now_ns };
+ g.hover_glow.now_ns = g.sel_glow.now_ns;
+ if (surface.chrome.fx & 2 == 0 or surface.panelTracks().len != 0) g.hover_glow = .{ .now_ns = g.sel_glow.now_ns };
+ if (g.glide.moving()) g.glide.advance(g.glide.now_ns, g.glide.motion);
+ cell_decor = CellDecor.of(chrome);
+ plaque_through_len = 0;
+ // G13: a body's dots follow its text at a quarter of its speed: its
+ // first line, and a glide's picture offset, in rows.
+ if (chrome.fx & 8 != 0 and chrome.decor_dots != null) for (surface.regionList()) |region| {
+ if (region.kind != .body or cell_decor.nbodies == cell_decor.bodies.len) continue;
+ var rows: f32 = @floatFromInt(region.line);
+ if (g.glide.moving() and g.glide.pane == region.owner) rows += g.glide.follow.offset;
+ const period = cell_decor.uniforms[4];
+ cell_decor.bodies[cell_decor.nbodies] = bodyPixels(region, layout);
+ cell_decor.shifts[cell_decor.nbodies] = @mod(-rows * layout.h * 0.25, period);
+ cell_decor.nbodies += 1;
+ };
+ // Plaques need an opaque window: with WindowOpacity under 100 the cells
+ // are drawn as they are, and the plaques not at all.
+ cell_decor.plaques_off = backgroundOpacity(g.applied_window_opacity) < 1;
+ if (chrome.decor_box_border != null and !cell_decor.plaques_off) {
+ cell_decor.grounds = .{ chrome.tag_bg, chrome.tag_focus_bg };
+ for (surface.regionList()) |region| {
+ if (region.kind != .tag and region.kind != .column_tag and region.kind != .workspace_tag) continue;
+ if (cell_decor.nplaques == cell_decor.plaques.len) break;
+ const plaque = plaqueBox(g, chrome, surface.regionList(), region, layout, win_w, win_h) orelse continue;
+ cell_decor.plaques[cell_decor.nplaques] = plaque.band;
+ cell_decor.nplaques += 1;
+ }
+ }
+ var groups = makeGroups(surface.panelTracks(), surface.hasPanelDiff());
+ // While panes move the cells' cursors are not drawn; the focused one is
+ // the overlay's quad, riding with its pane (draw.glideCursor), as it is
+ // while it glides or blinks. One or the other every frame (none only at
+ // a blink's off half).
+ const blink_alpha: f32 = if (blinkNow(g, chrome)) |b| b.alpha else 1;
+ // While a glide moves the text, the caret is its quad, drawn from its
+ // own springs, not a cell of the moving rows.
+ const quad_mode = chrome.cursor_glide & 2 != 0 and (chrome.cursor_glide & 1 != 0 or blink_alpha < 1 or g.glide.follow.offset != 0);
+ g.cursor_quad_alpha = if (quad_mode) chrome.cursor_alpha * blink_alpha else 0;
+ // The probe's view of this frame's motion (FrameStats.Frame).
+ if (core) |p| {
+ const probe = &@constCast(p).frames;
+ // A focused PDF's strip is the core's (pdf_view.draw).
+ const pdf_focus = if (p.panes[p.active]) |pane| pane.hasPdf() else false;
+ if (!pdf_focus) probe.scroll = g.glide.follow.offset;
+ probe.caret = caretRow(g, surface) orelse 0;
+ }
+ const cursors_shown = groups.tracks == 0 and !quad_mode;
+ var overlay_count = buildOverlay(g, core, surface, sw, sh, debug_on);
if (overlay_count != 0 and !uploadOverlayGpu(g, cmd, overlay_count))
overlay_count = 0;
- if (!prepareNativeImages(g, gpa, cmd, surface, &paint_plan, sw, sh)) {
+ if (!prepareNativeImages(g, gpa, cmd, surface, &groups, sw, sh)) {
g.prepared_images.clearRetainingCapacity();
- for (paint_plan.batches[0..paint_plan.len]) |*batch| {
- batch.image_start = 0;
- batch.image_count = 0;
+ for (groups.items[0..groups.len]) |*group| {
+ group.image_start = 0;
+ group.image_count = 0;
}
}
const cells: u32 = @as(u32, surface.cols) * surface.rows;
+ try g.cover.resize(gpa, @as(usize, cells) * 2);
+ const covered = g.cover.items[0..cells];
+ coverFrame(covered, surface.cols, surface.rows, surface.bodyLayers(), surface.tagLayers(), surface.regionList());
+ // Only a panel transition paints the grid under the layers it leaves.
+ const previous_covered = g.cover.items[cells..];
+ if (groups.tracks != 0)
+ coverFrame(previous_covered, surface.cols, surface.rows, surface.previous_body_layers, surface.previous_tag_layers, surface.previous_regions);
+ try buildDecor(g, gpa, surface, &groups, layout, win_w, win_h, cursors_shown);
- const page = ground(theme_bg, g.transparent);
+ const page: Ground = .opaqueRgb(chrome.page orelse bg_default);
const background_opacity = backgroundOpacity(g.applied_window_opacity);
- const tagline_base = pardes.Cell{
- .style = .{ .bg = .{ .rgb = tagline_rgb }, .font_role = .tagline },
- .default = false,
- };
var color_target = std.mem.zeroes(c.SDL_GPUColorTargetInfo);
color_target.texture = scene;
color_target.clear_color = if (page.clear) .{ .r = 0, .g = 0, .b = 0, .a = 0 } else .{
@@ -4927,28 +6252,21 @@ fn renderFrame(
while (row < surface.rows) : (row += 1) {
var col: u16 = 0;
while (col < surface.cols) : (col += 1) {
- if (bodyLayerAt(surface, col, row) != null or tagLayerIn(surface.tagLayers(), col, row) != null) continue;
- const batch_index = paintBatchAt(&paint_plan, col, row);
- const track = paint_plan.batches[batch_index].track;
- const data_effect = if (track) |active|
- active.effect == .dissolve
- else
- false;
- const data_diff = data_effect and gripCellChanged(surface, col, row);
- const logical_idx: u32 = @as(u32, row) * surface.cols + col;
+ const at = @as(usize, row) * surface.cols + col;
+ if (covered[at].layer and !covered[at].floating) continue;
+ const group_index = if (covered[at].floating) groups.guides else groupAt(&groups, col, row);
+ const track = groups.items[group_index].track;
+ const data_effect = if (track) |active| active.effect == .dissolve else false;
+ const data_diff = data_effect and gripCellChanged(surface, covered, previous_covered, col, row);
const instance_count = if (data_diff)
- cellInstanceCount(&surface.previous_cells[logical_idx]) + cellInstanceCount(surface.at(col, row))
+ cellInstanceCount(&surface.previous_cells[at]) + cellInstanceCount(&surface.cells[at])
else
- cellInstanceCount(surface.at(col, row));
- paint_plan.batches[batch_index].cell_count = std.math.add(
- u32,
- paint_plan.batches[batch_index].cell_count,
- instance_count,
- ) catch return error.GpuCapacity;
+ cellInstanceCount(&surface.cells[at]);
+ groups.items[group_index].cell_count = std.math.add(u32, groups.items[group_index].cell_count, instance_count) catch return error.GpuCapacity;
}
}
- for (paint_plan.batches[1..paint_plan.len]) |*batch| {
- const track = batch.track.?;
+ for (groups.items[1..][0..groups.tracks]) |*group| {
+ const track = group.track.?;
const duplicate_under = track.effect == .vertical and track.phase == .opening;
if (!duplicate_under and track.phase != .closing) continue;
row = 0;
@@ -4956,33 +6274,29 @@ fn renderFrame(
var col: u16 = 0;
while (col < surface.cols) : (col += 1) {
if (!boxContains(track.contentBox(), col, row)) continue;
- if (bodyLayerIn(surface.previous_body_layers, col, row) != null or tagLayerIn(surface.previous_tag_layers, col, row) != null) continue;
- const destination = if (duplicate_under) &paint_plan.batches[0] else batch;
- const logical_idx: u32 = @as(u32, row) * surface.cols + col;
- destination.cell_count = std.math.add(
- u32,
- destination.cell_count,
- cellInstanceCount(&surface.previous_cells[logical_idx]),
- ) catch return error.GpuCapacity;
+ const at = @as(usize, row) * surface.cols + col;
+ if (previous_covered[at].layer) continue;
+ const destination = if (duplicate_under) &groups.items[0] else group;
+ destination.cell_count = std.math.add(u32, destination.cell_count, cellInstanceCount(&surface.previous_cells[at])) catch return error.GpuCapacity;
}
}
}
for (surface.bodyLayers()) |*layer| {
if (layer.rows == 0) continue;
- const batch = &paint_plan.batches[paintBatchAt(&paint_plan, layer.viewport.x, layer.viewport.y)];
+ const group = &groups.items[groupAt(&groups, layer.viewport.x, layer.viewport.y)];
const bottom = @as(f32, @floatFromInt(layer.viewport.y + layer.viewport.h)) * layout.h;
for (0..layer.rows) |lr| {
if (layer.rowTop(@intCast(lr), layout.h, @floatFromInt(g.tagline_height)) >= bottom) break;
- batch.cell_count += layer.cols + @as(u32, if (lr < layer.context_rows) 1 else 0) + @as(u32, @intFromBool(layer.hasContextBorderAfter(lr)));
+ group.cell_count += layer.cols + @as(u32, if (lr < layer.context_rows) 1 else 0) + @as(u32, @intFromBool(layer.hasContextBorderAfter(lr)));
}
}
- for (paint_plan.batches[1..paint_plan.len], 1..) |batch, batch_index| {
- const track = batch.track.?;
+ for (groups.items[1..][0..groups.tracks], 1..) |group, index| {
+ const track = group.track.?;
const under = track.effect == .vertical and track.phase == .opening;
if (!under and track.phase != .closing and track.effect != .dissolve) continue;
for (surface.previous_body_layers) |*layer| {
if (layer.rows == 0 or layer.serial != track.serial) continue;
- const destination = if (under) &paint_plan.batches[0] else &paint_plan.batches[batch_index];
+ const destination = &groups.items[if (under) 0 else index];
const bottom = @as(f32, @floatFromInt(layer.viewport.y + layer.viewport.h)) * layout.h;
for (0..layer.rows) |lr| {
if (layer.rowTop(@intCast(lr), layout.h, @floatFromInt(g.tagline_height)) >= bottom) break;
@@ -4991,29 +6305,30 @@ fn renderFrame(
}
}
for (surface.tagLayers()) |*layer| {
- if (layer.cols == 0) continue;
- const batch = &paint_plan.batches[paintBatchAt(&paint_plan, layer.viewport.x, layer.viewport.y)];
- batch.cell_count += tagLayerCellCount(g, layer) + 1;
+ if (layer.rows == 0) continue;
+ const group_index = if (layer.kind == .notice) noticeGroup(&groups, layer) else groupAt(&groups, layer.viewport.x, layer.viewport.y);
+ groups.items[group_index].cell_count += (tagLayerCellCount(g, layer) + 1) * layer.rows;
}
- for (paint_plan.batches[1..paint_plan.len], 1..) |batch, batch_index| {
- const track = batch.track.?;
+ for (groups.items[1..][0..groups.tracks], 1..) |group, index| {
+ const track = group.track.?;
const under = track.effect == .vertical and track.phase == .opening;
if (!under and track.phase != .closing and track.effect != .dissolve) continue;
for (surface.previous_tag_layers) |*layer| {
- if (layer.cols == 0 or layer.kind != .pane or layer.serial != track.serial) continue;
- const destination = if (under) &paint_plan.batches[0] else &paint_plan.batches[batch_index];
- destination.cell_count += tagLayerCellCount(g, layer) + 1;
+ if (layer.rows == 0 or layer.kind != .pane or layer.serial != track.serial) continue;
+ groups.items[if (under) 0 else index].cell_count += (tagLayerCellCount(g, layer) + 1) * layer.rows;
}
}
- var cell_next: [pardes.MAX_PANES * 2 + 1]u32 = @splat(0);
+ var cell_next: [pardes.MAX_PANES * 2 + 4]u32 = @splat(0);
var cell_total: u32 = 0;
- for (paint_plan.batches[0..paint_plan.len], 0..) |*batch, batch_index| {
- batch.cell_start = cell_total;
- cell_next[batch_index] = cell_total;
- cell_total = std.math.add(u32, cell_total, batch.cell_count) catch return error.GpuCapacity;
+ for (groups.items[0..groups.len], 0..) |*group, index| {
+ group.cell_start = cell_total;
+ cell_next[index] = cell_total;
+ cell_total = std.math.add(u32, cell_total, group.cell_count) catch return error.GpuCapacity;
}
- if (cell_total != 0) {
- const capacity = std.math.add(u32, cell_total, cells) catch return error.GpuCapacity;
+ const decor_len: u32 = @intCast(g.decor.items.len);
+ if (cell_total != 0 or decor_len != 0) {
+ // The shifted rows of a scroll: its body, and a glide's rows past it.
+ const capacity = std.math.add(u32, cell_total, 2 * cells + decor_len) catch return error.GpuCapacity;
try ensureVbuf(g, capacity);
const vptr: [*]u8 = @ptrCast(c.SDL_MapGPUTransferBuffer(g.device, g.vxfer.?, false) orelse {
@@ -5026,89 +6341,99 @@ fn renderFrame(
const cursor_bar = if (surface.cursor) |cu| cu.bar else false;
row = 0;
while (row < surface.rows) : (row += 1) {
+ const line = surface.cells[@as(usize, row) * surface.cols ..][0..surface.cols];
+ const line_cover = covered[@as(usize, row) * surface.cols ..][0..surface.cols];
+ const line_cursor: ?usize = if (surface.cursor) |cu| if (cu.y == row) cu.x else null else null;
var col: u16 = 0;
while (col < surface.cols) : (col += 1) {
- if (bodyLayerAt(surface, col, row) != null or tagLayerIn(surface.tagLayers(), col, row) != null) continue;
- const batch_index = paintBatchAt(&paint_plan, col, row);
- const track = paint_plan.batches[batch_index].track;
- const logical_idx: u32 = @as(u32, row) * surface.cols + col;
- const data_effect = if (track) |active|
- active.effect == .dissolve
- else
- false;
- const data_diff = data_effect and gripCellChanged(surface, col, row);
- if (data_diff) {
- emitSurfaceCell(
- g,
- core,
- instances,
- &cell_next[batch_index],
- col,
- row,
- layout,
- win_w,
- win_h,
- track,
- &surface.previous_cells[logical_idx],
- &tagline_base,
- paneGripCell(surface.previous_tag_layers, surface.previous_cells, surface.cols, col, row),
- true,
- false,
- page,
- );
- }
+ const at = @as(usize, row) * surface.cols + col;
+ if (covered[at].layer and !covered[at].floating) continue;
+ const group_index = if (covered[at].floating) groups.guides else groupAt(&groups, col, row);
+ const track = groups.items[group_index].track;
+ const data_effect = if (track) |active| active.effect == .dissolve else false;
+ const data_diff = data_effect and gripCellChanged(surface, covered, previous_covered, col, row);
+ // The new cell, then (a dissolve) the old one fading out over
+ // it, as the old layers come after the new ones.
emitSurfaceCell(
g,
- core,
+ chrome,
instances,
- &cell_next[batch_index],
+ &cell_next[group_index],
col,
row,
layout,
win_w,
win_h,
if (data_effect and !data_diff) null else track,
- surface.at(col, row),
- &tagline_base,
- paneGripCell(surface.tagLayers(), surface.cells, surface.cols, col, row),
+ line,
+ line_cover,
+ col,
+ line_cursor,
+ false,
+ cursors_shown and at == cursor_idx and !cursor_bar and bodyLayerAt(surface, col, row) == null,
+ page,
+ );
+ if (data_diff) emitSurfaceCell(
+ g,
+ chrome,
+ instances,
+ &cell_next[group_index],
+ col,
+ row,
+ layout,
+ win_w,
+ win_h,
+ track,
+ surface.previous_cells[@as(usize, row) * surface.cols ..][0..surface.cols],
+ previous_covered[@as(usize, row) * surface.cols ..][0..surface.cols],
+ col,
+ null,
+ true,
false,
- paint_plan.len == 1 and logical_idx == cursor_idx and !cursor_bar and bodyLayerAt(surface, col, row) == null,
page,
);
}
}
+ // Body layers first: a notice chip over a tree-sitter context band
+ // is a tag layer, and instances paint in emission order.
+ for (surface.bodyLayers()) |*layer| {
+ if (layer.rows == 0) continue;
+ const group_index = groupAt(&groups, layer.viewport.x, layer.viewport.y);
+ emitBodyLayer(g, instances, &cell_next[group_index], layer, win_w, win_h, groups.items[group_index].track, page, cursors_shown, false, chrome.topbar_rule);
+ }
for (surface.tagLayers()) |*layer| {
- if (layer.cols == 0) continue;
- const batch_index = paintBatchAt(&paint_plan, layer.viewport.x, layer.viewport.y);
- emitTagLayer(g, instances, &cell_next[batch_index], layer, win_w, win_h, paint_plan.batches[batch_index].track, page, paint_plan.len == 1, false);
+ if (layer.rows == 0) continue;
+ const track_index = groupAt(&groups, layer.viewport.x, layer.viewport.y);
+ // A notice floats over the panes, moving with its own.
+ const group_index = if (layer.kind == .notice) noticeGroup(&groups, layer) else track_index;
+ const start = cell_next[group_index];
+ emitTagLayer(g, instances, &cell_next[group_index], layer, win_w, win_h, groups.items[track_index].track, page, cursors_shown, false);
+ // A notice dropping past its row (a flavour's overshoot) stays
+ // inside its pane's body.
+ if (layer.kind == .notice and layer.slide > 0) if (bodyBottom(surface, layer.id, layout)) |bottom| {
+ for (instances[start..cell_next[group_index]]) |*instance| clipInstance(instance, .{ -1e9, -1e9, 1e9, bottom }, win_w, win_h);
+ };
}
- for (paint_plan.batches[1..paint_plan.len], 1..) |batch, batch_index| {
- const track = batch.track.?;
+ for (groups.items[1..][0..groups.tracks], 1..) |group, index| {
+ const track = group.track.?;
const under = track.effect == .vertical and track.phase == .opening;
if (!under and track.phase != .closing and track.effect != .dissolve) continue;
for (surface.previous_tag_layers) |*layer| {
- if (layer.cols == 0 or layer.kind != .pane or layer.serial != track.serial) continue;
- const destination: usize = if (under) 0 else batch_index;
- emitTagLayer(g, instances, &cell_next[destination], layer, win_w, win_h, if (under) null else track, page, false, track.effect == .dissolve);
+ if (layer.rows == 0 or layer.kind != .pane or layer.serial != track.serial) continue;
+ emitTagLayer(g, instances, &cell_next[if (under) 0 else index], layer, win_w, win_h, if (under) null else track, page, false, track.effect == .dissolve);
}
}
- for (surface.bodyLayers()) |*layer| {
- if (layer.rows == 0) continue;
- const batch_index = paintBatchAt(&paint_plan, layer.viewport.x, layer.viewport.y);
- emitBodyLayer(g, instances, &cell_next[batch_index], layer, win_w, win_h, paint_plan.batches[batch_index].track, page, paint_plan.len == 1, false, topbar_pane_border_rgb);
- }
- for (paint_plan.batches[1..paint_plan.len], 1..) |batch, batch_index| {
- const track = batch.track.?;
+ for (groups.items[1..][0..groups.tracks], 1..) |group, index| {
+ const track = group.track.?;
const under = track.effect == .vertical and track.phase == .opening;
if (!under and track.phase != .closing and track.effect != .dissolve) continue;
for (surface.previous_body_layers) |*layer| {
if (layer.rows == 0 or layer.serial != track.serial) continue;
- const destination: usize = if (under) 0 else batch_index;
- emitBodyLayer(g, instances, &cell_next[destination], layer, win_w, win_h, if (under) null else track, page, false, track.effect == .dissolve, topbar_pane_border_rgb);
+ emitBodyLayer(g, instances, &cell_next[if (under) 0 else index], layer, win_w, win_h, if (under) null else track, page, false, track.effect == .dissolve, chrome.topbar_rule);
}
}
- for (paint_plan.batches[1..paint_plan.len], 1..) |batch, batch_index| {
- const track = batch.track.?;
+ for (groups.items[1..][0..groups.tracks], 1..) |group, index| {
+ const track = group.track.?;
const duplicate_under = track.effect == .vertical and track.phase == .opening;
if (!duplicate_under and track.phase != .closing) continue;
row = 0;
@@ -5116,23 +6441,22 @@ fn renderFrame(
var col: u16 = 0;
while (col < surface.cols) : (col += 1) {
if (!boxContains(track.contentBox(), col, row)) continue;
- if (bodyLayerIn(surface.previous_body_layers, col, row) != null or tagLayerIn(surface.previous_tag_layers, col, row) != null) continue;
- const logical_idx: u32 = @as(u32, row) * surface.cols + col;
- const destination: usize = if (duplicate_under) 0 else batch_index;
+ if (previous_covered[@as(usize, row) * surface.cols + col].layer) continue;
emitSurfaceCell(
g,
- core,
+ chrome,
instances,
- &cell_next[destination],
+ &cell_next[if (duplicate_under) 0 else index],
col,
row,
layout,
win_w,
win_h,
if (duplicate_under) null else track,
- &surface.previous_cells[logical_idx],
- &tagline_base,
- paneGripCell(surface.previous_tag_layers, surface.previous_cells, surface.cols, col, row),
+ surface.previous_cells[@as(usize, row) * surface.cols ..][0..surface.cols],
+ previous_covered[@as(usize, row) * surface.cols ..][0..surface.cols],
+ col,
+ null,
false,
false,
page,
@@ -5140,119 +6464,175 @@ fn renderFrame(
}
}
}
- for (paint_plan.batches[0..paint_plan.len], 0..) |batch, batch_index|
- std.debug.assert(cell_next[batch_index] == batch.cell_start + batch.cell_count);
- shifted = emitScrollRows(g, instances, cell_total, surface, layout, win_w, win_h, page);
+ for (groups.items[0..groups.len], 0..) |group, index|
+ std.debug.assert(cell_next[index] == group.cell_start + group.cell_count);
+ // The body's context rows, which its scroll leaves where they are.
+ const scrolling: ?usize = if (g.glide.follow.offset != 0) g.glide.pane else g.scroll_pane;
+ const held: u16 = if (core) |p| if (scrolling) |id| if (p.panes[id]) |pane| pane.context_rows else 0 else 0 else 0;
+ shifted = emitScrollRows(g, instances, cell_total, surface, layout, win_w, win_h, page, held);
+ // Over a theme's plaques a see-through cell with no ink blends to
+ // the plaque under it, so it draws nothing: its quad goes, and the
+ // cells are drawn unblended (a third of the GPU's frame at 4K)
+ // unless one see-through cell does have ink, or the page itself is
+ // see-through.
+ if (cell_decor.nplaques != 0) {
+ const space_u = @as(f32, @floatFromInt(g.space_slot.u)) / @as(f32, @floatFromInt(atlas_w));
+ const space_v = @as(f32, @floatFromInt(g.space_slot.v)) / @as(f32, @floatFromInt(atlas_h));
+ if (page.clear or plaque_through_len > plaque_through.len) cell_decor.inked_clear = true;
+ for (plaque_through[0..@min(plaque_through_len, plaque_through.len)]) |at| {
+ const instance = &instances[at];
+ // A grip's button takes its cell's ground back (emitSurfaceCell).
+ if (instance.effect & clear_bg_bit == 0) continue;
+ if (instance.u0 == space_u and instance.v0 == space_v) {
+ instance.x1 = instance.x0;
+ instance.y1 = instance.y0;
+ } else cell_decor.inked_clear = true;
+ }
+ }
+ @memcpy(instances[cell_total + shifted ..][0..decor_len], g.decor.items);
c.SDL_UnmapGPUTransferBuffer(g.device, g.vxfer.?);
- if (g.atlas_dirty) uploadAtlas(g, cmd);
+ if (g.atlas_dirty_top < g.atlas_dirty_bottom) uploadAtlas(g, cmd);
const copy = c.SDL_BeginGPUCopyPass(cmd);
const src = c.SDL_GPUTransferBufferLocation{ .transfer_buffer = g.vxfer.?, .offset = 0 };
- const dst = c.SDL_GPUBufferRegion{ .buffer = g.vbuf.?, .offset = 0, .size = (cell_total + shifted) * @sizeOf(CellInstance) };
+ const dst = c.SDL_GPUBufferRegion{ .buffer = g.vbuf.?, .offset = 0, .size = (cell_total + shifted + decor_len) * @sizeOf(CellInstance) };
c.SDL_UploadToGPUBuffer(copy, &src, &dst, false);
c.SDL_EndGPUCopyPass(copy);
}
+ build_zone.end();
+ building = false;
+ if (frame_probe) |probe| probe.zone(.gui_build, probe_build);
const rp = c.SDL_BeginGPURenderPass(cmd, &color_target, 1, null);
pushLayerOpacity(cmd, rp, background_opacity);
const whole = c.SDL_Rect{ .x = 0, .y = 0, .w = @intCast(sw), .h = @intCast(sh) };
- for (paint_plan.batches[0..paint_plan.len], 0..) |batch, batch_index| {
- const has_shifted = batch_index == 0 and shifted != 0;
- if ((batch.cell_count != 0 or has_shifted) and g.vbuf != null) {
- c.SDL_BindGPUGraphicsPipeline(rp, g.pipeline);
+ const decor_base = cell_total + shifted;
+ for (groups.items[0..groups.len], 0..) |group, index| {
+ if (group.under_count != 0 and g.vbuf != null) {
+ c.SDL_BindGPUGraphicsPipeline(rp, g.decor_pipeline);
+ pushLayerOpacity(cmd, rp, background_opacity);
+ const binding = c.SDL_GPUBufferBinding{ .buffer = g.vbuf.?, .offset = (decor_base + group.decor_start) * @sizeOf(CellInstance) };
+ c.SDL_BindGPUVertexBuffers(rp, 0, &binding, 1);
+ c.SDL_DrawGPUPrimitives(rp, 6, group.under_count, 0, 0);
+ }
+ const has_shifted = index == 0 and shifted != 0;
+ if ((group.cell_count != 0 or has_shifted) and g.vbuf != null) {
+ // Blended over what is under: a theme's plaques show through
+ // blank tag cells; a dissolve's old cells fade over its new.
+ const dissolving = if (group.track) |active| active.effect == .dissolve else false;
+ c.SDL_BindGPUGraphicsPipeline(rp, if (cell_decor.inked_clear or dissolving) g.pipeline_over else g.pipeline);
const samp_binding = c.SDL_GPUTextureSamplerBinding{ .texture = g.atlas_tex, .sampler = g.atlas_sampler };
c.SDL_BindGPUFragmentSamplers(rp, 0, &samp_binding, 1);
- if (batch.cell_count != 0) {
- const panel_clipped = if (batch.track) |active| active.effect == .vertical else false;
- if (panel_clipped) {
- const clip = panelBoxScissor(g, batch.track.?.contentBox(), sw, sh);
- c.SDL_SetGPUScissor(rp, &clip);
- }
- const binding = c.SDL_GPUBufferBinding{
- .buffer = g.vbuf.?,
- .offset = batch.cell_start * @sizeOf(CellInstance),
- };
+ if (group.cell_count != 0) {
+ const binding = c.SDL_GPUBufferBinding{ .buffer = g.vbuf.?, .offset = group.cell_start * @sizeOf(CellInstance) };
c.SDL_BindGPUVertexBuffers(rp, 0, &binding, 1);
- c.SDL_DrawGPUPrimitives(rp, 6, batch.cell_count, 0, 0);
- if (panel_clipped) c.SDL_SetGPUScissor(rp, &whole);
+ c.SDL_DrawGPUPrimitives(rp, 6, group.cell_count, 0, 0);
}
if (has_shifted) {
const clip = scrollScissor(g, layout, sw, sh);
c.SDL_SetGPUScissor(rp, &clip);
- const binding = c.SDL_GPUBufferBinding{
- .buffer = g.vbuf.?,
- .offset = cell_total * @sizeOf(CellInstance),
- };
+ const binding = c.SDL_GPUBufferBinding{ .buffer = g.vbuf.?, .offset = cell_total * @sizeOf(CellInstance) };
c.SDL_BindGPUVertexBuffers(rp, 0, &binding, 1);
c.SDL_DrawGPUPrimitives(rp, 6, shifted, 0, 0);
c.SDL_SetGPUScissor(rp, &whole);
}
}
- if (batch.image_count != 0)
- drawNativeImagesGpu(g, rp, surface, &paint_plan, batch_index);
+ if (group.image_count != 0) drawNativeImagesGpu(g, rp, surface, group, whole);
+ if (group.decor_count > group.under_count and g.vbuf != null) {
+ c.SDL_BindGPUGraphicsPipeline(rp, g.decor_pipeline);
+ // Ink keeps its colour at any WindowOpacity.
+ pushLayerOpacity(cmd, rp, if (index == groups.ink) 1 else background_opacity);
+ const binding = c.SDL_GPUBufferBinding{ .buffer = g.vbuf.?, .offset = (decor_base + group.decor_start + group.under_count) * @sizeOf(CellInstance) };
+ c.SDL_BindGPUVertexBuffers(rp, 0, &binding, 1);
+ c.SDL_DrawGPUPrimitives(rp, 6, group.decor_count - group.under_count, 0, 0);
+ }
}
drawOverlayGpu(g, cmd, rp, overlay_count);
c.SDL_EndGPURenderPass(rp);
- var rendered_scene: crt.Frame = .{};
if (scene_on) {
- var crt_target = std.mem.zeroes(c.SDL_GPUColorTargetInfo);
- crt_target.texture = target;
- crt_target.load_op = c.SDL_GPU_LOADOP_DONT_CARE;
- crt_target.store_op = c.SDL_GPU_STOREOP_STORE;
- const crt_pass = c.SDL_BeginGPURenderPass(cmd, &crt_target, 1, null);
- c.SDL_BindGPUGraphicsPipeline(crt_pass, g.crt_pipeline);
- const samp_binding = c.SDL_GPUTextureSamplerBinding{ .texture = g.scene_tex.?, .sampler = g.linear_sampler };
- c.SDL_BindGPUFragmentSamplers(crt_pass, 0, &samp_binding, 1);
- const now_ns = c.SDL_GetTicksNS();
- const time_wrap_ns: u64 = 4096 * std.time.ns_per_s;
- const time_seconds: f32 = @floatCast(
- @as(f64, @floatFromInt(now_ns % time_wrap_ns)) / @as(f64, std.time.ns_per_s),
- );
- rendered_scene = .{
- .effects = .{
- .crt = scene_effects.crt,
- .ripple = scene_effects.ripple,
- .glitch = scene_effects.glitch,
- },
- .time_seconds = time_seconds,
- };
- const crt_uniforms = [8]f32{
- time_seconds,
- @floatFromInt((now_ns / (std.time.ns_per_s / 60)) % 65_536),
- @floatFromInt(sw),
- @floatFromInt(sh),
- @floatFromInt(@intFromBool(scene_effects.crt)),
- @floatFromInt(@intFromBool(scene_effects.ripple)),
- @floatFromInt(@intFromBool(scene_effects.glitch)),
- 0,
+ var boxes: [max_cursors]CursorBox = undefined;
+ const cursors = if (cursors_shown) cursorBoxes(g, surface, layout, win_h, &boxes) else 0;
+ var spare: [Post.max_spare][4]f32 = undefined;
+ g.post.describe(.{
+ .cursor = if (cursors > 0) boxes[0] else null,
+ .spare = spare[0..postSpare(surface, layout, &spare)],
+ .background = chrome.page orelse bg_default,
+ .foreground = chrome.fg orelse fg_default,
+ .selection_foreground = if (core) |p| p.theme().sel_fg else chrome.sel_fg,
+ .selection_background = if (core) |p| p.theme().sel_bg else chrome.sel_bg,
+ });
+ const chain_zone = tracy.zone(@src(), "post chain");
+ defer chain_zone.end();
+ g.post.scale = display_scale;
+ g.post.draw(g.device, cmd, g.linear_sampler, g.swapchain_format, g.scene_tex.?, target, sw, sh, c.SDL_GetTicksNS(), background_opacity >= 1) catch {
+ g.scene_target_failed = true;
};
- c.SDL_PushGPUFragmentUniformData(cmd, 0, &crt_uniforms, @sizeOf(@TypeOf(crt_uniforms)));
- c.SDL_DrawGPUPrimitives(crt_pass, 3, 1, 0, 0);
- c.SDL_EndGPURenderPass(crt_pass);
}
+ command_consumed = true;
+ const shown = try finishFrame(g, gpa, cmd, frame_target, if (groups.tracks != 0) groups.items[1].track.?.frame else null);
+ if (shown and groups.tracks == 0) rememberPresentedImages(g, gpa, surface);
+ return shown;
+}
+
+const Target = struct { texture: *c.SDL_GPUTexture, w: u32, h: u32 };
+
+/// What this frame draws into: the capture texture in test mode (the grid's
+/// size plus PARDES_TEST_PAD) or with a soft presenter, else the swapchain's
+/// image; null when there is none to be had this time.
+fn acquireTarget(g: *Gui, cmd: *c.SDL_GPUCommandBuffer, capture_w: u32, capture_h: u32) !?Target {
if (g.capture) {
- command_consumed = true;
- try captureFrame(g, gpa, cmd, target, sw, sh);
- g.presented_scene = rendered_scene;
- if (paint_plan.len == 1) rememberPresentedImages(g, gpa, surface);
+ if (capture_w == 0 or capture_h == 0) return null;
+ try ensureCaptureTexture(g, capture_w, capture_h);
+ return .{ .texture = g.capture_tex.?, .w = capture_w, .h = capture_h };
+ }
+ if (g.soft_present) {
+ var pw: c_int = 0;
+ var ph: c_int = 0;
+ if (!c.SDL_GetWindowSizeInPixels(g.window, &pw, &ph) or pw <= 0 or ph <= 0) return null;
+ try ensureCaptureTexture(g, @intCast(pw), @intCast(ph));
+ return .{ .texture = g.capture_tex.?, .w = @intCast(pw), .h = @intCast(ph) };
+ }
+ var swap_tex: ?*c.SDL_GPUTexture = null;
+ var sw: u32 = 0;
+ var sh: u32 = 0;
+ if (!c.SDL_AcquireGPUSwapchainTexture(cmd, g.window, &swap_tex, &sw, &sh)) return null;
+ // A busy swapchain skips the frame.
+ return .{ .texture = swap_tex orelse return null, .w = sw, .h = sh };
+}
+
+/// Submits the frame: captured, handed to the soft presenter, or presented.
+fn finishFrame(g: *Gui, gpa: std.mem.Allocator, cmd: *c.SDL_GPUCommandBuffer, target: Target, transition: ?u16) !bool {
+ if (g.capture) {
+ try captureFrame(g, gpa, cmd, target.texture, target.w, target.h, transition);
return true;
}
if (g.soft_present) {
- command_consumed = true;
- try softPresentFrame(g, cmd, target, sw, sh);
- g.presented_scene = rendered_scene;
- if (paint_plan.len == 1) rememberPresentedImages(g, gpa, surface);
+ try softPresentFrame(g, cmd, target.texture, target.w, target.h);
return true;
}
- command_consumed = true;
- const submitted = c.SDL_SubmitGPUCommandBuffer(cmd);
- if (submitted) {
- g.presented_scene = rendered_scene;
- if (paint_plan.len == 1) rememberPresentedImages(g, gpa, surface);
+ return c.SDL_SubmitGPUCommandBuffer(cmd);
+}
+
+/// Redraw level A (docs §5.5): the post chain alone, over the frame the core
+/// last drew, for a pass that moves on its own. No core render, no cell.
+fn redrawPost(g: *Gui, gpa: std.mem.Allocator) void {
+ const scene = g.scene_tex orelse return;
+ const cmd = c.SDL_AcquireGPUCommandBuffer(g.device) orelse return;
+ const target = (acquireTarget(g, cmd, g.scene_tex_w, g.scene_tex_h) catch null) orelse {
+ _ = c.SDL_SubmitGPUCommandBuffer(cmd);
+ return;
+ };
+ // A window the retained frame no longer fits waits for the core's.
+ if (target.w != g.scene_tex_w or target.h != g.scene_tex_h) {
+ _ = c.SDL_SubmitGPUCommandBuffer(cmd);
+ return;
}
- return submitted;
+ const zone = tracy.zone(@src(), "post chain redraw");
+ g.post.draw(g.device, cmd, g.linear_sampler, g.swapchain_format, scene, target.texture, target.w, target.h, c.SDL_GetTicksNS(), backgroundOpacity(g.applied_window_opacity) >= 1) catch {};
+ zone.end();
+ _ = finishFrame(g, gpa, cmd, target, null) catch {};
}
const ResolvedCell = struct {
@@ -5266,44 +6646,24 @@ const ResolvedCell = struct {
const topbarPaneBorderPixels = pardes.topbarPaneBorderPixels;
const taglineBandOffset = pardes.taglineBandOffset;
-fn topbarPaneBorderHeight(surface: *const pardes.Surface, cell_h: u32, tagline_h: u32) ?u32 {
- if (surface.rows <= pardes.TOPBAR_H) return null;
- const height = topbarPaneBorderPixels(cell_h, tagline_h);
- if (height == 0) return null;
- const base = @as(usize, pardes.TOPBAR_H) * surface.cols;
- for (surface.cells[base..][0..surface.cols]) |cell|
- if (!cell.default and cell.style.font_role == .tagline) return height;
- return null;
-}
-
-fn bottomTaglinePresent(surface: *const pardes.Surface) bool {
- if (surface.rows == 0) return false;
- const base = @as(usize, surface.rows - 1) * surface.cols;
- for (surface.cells[base..][0..surface.cols]) |cell|
- if (!cell.default and cell.style.font_role == .tagline) return true;
- return false;
-}
-
-test "tagline bands face the topbar rule and Tagbottom faces the window edge" {
+test "tagline bands center in their cells and Tagbottom faces the window edge" {
const cell_h: u32 = 20;
const tagline_h: u32 = 16;
const canvas_h: f32 = 200;
- const border = topbarPaneBorderPixels(cell_h, tagline_h);
- try std.testing.expectEqual(@as(u32, 1), border);
- try std.testing.expectEqual(@as(u32, 4), taglineBandOffset(0, canvas_h, cell_h, tagline_h, true));
- try std.testing.expectEqual(@as(u32, 2), taglineBandOffset(0, canvas_h, cell_h, tagline_h, false));
- try std.testing.expectEqual(@as(u32, 1), taglineBandOffset(1, canvas_h, cell_h, tagline_h, true));
- try std.testing.expectEqual(@as(u32, 2), taglineBandOffset(1, canvas_h, cell_h, tagline_h, false));
- try std.testing.expectEqual(@as(u32, 2), taglineBandOffset(5, canvas_h, cell_h, tagline_h, true));
- try std.testing.expectEqual(@as(u32, 4), taglineBandOffset(9, canvas_h, cell_h, tagline_h, true));
+ // Workspace, column and pane rows alike: text lines up across bands.
+ for ([_]u16{ 0, 1, 2, 5, 8 }) |row|
+ try std.testing.expectEqual(@as(u32, 2), taglineBandOffset(row, canvas_h, cell_h, tagline_h));
+ try std.testing.expectEqual(@as(u32, 4), taglineBandOffset(9, canvas_h, cell_h, tagline_h));
}
-fn resolveCell(g: *Gui, cell: *const pardes.Cell, role: pardes.FontRole, is_cursor: bool, page: Ground) ResolvedCell {
+/// The colours and atlas slot of `line[at]`. `cursor` is where the cursor sits
+/// in `line`, block or bar: shaping breaks around it.
+fn resolveCell(g: *Gui, line: []const pardes.Cell, at: usize, cursor: ?usize, role: pardes.FontRole, is_cursor: bool, page: Ground) ResolvedCell {
+ const cell = &line[at];
var fg = fg_default;
var bg = page.rgb;
var clear_bg = page.clear;
var reverse = is_cursor;
- var blank = false;
if (!cell.default) {
const st = cell.style;
fg = switch (st.fg) {
@@ -5326,8 +6686,8 @@ fn resolveCell(g: *Gui, cell: *const pardes.Cell, role: pardes.FontRole, is_curs
if (st.invisible) {
fg = bg;
// With a translucent background, painting bg-colored glyphs at
- // full opacity would expose text that the terminal concealed.
- blank = true;
+ // full opacity would expose text that the terminal concealed, so
+ // cellSlot draws a concealed cell blank.
}
if (st.dim) for (&fg) |*ch| {
ch.* = @intCast(@as(u16, ch.*) * 6 / 10);
@@ -5338,10 +6698,8 @@ fn resolveCell(g: *Gui, cell: *const pardes.Cell, role: pardes.FontRole, is_curs
clear_bg = false;
}
- const cp = if (blank) ' ' else cellCodepoint(cell);
- const decoration = GlyphDecoration.fromCell(cell);
return .{
- .slot = if (cp == ' ' and !decoration.drawsBlank()) g.space_slot else ensureGlyph(g, cp, role, decoration),
+ .slot = cellSlot(g, line, at, cursor, role),
.fg = fg,
.bg = bg,
.role = role,
@@ -5356,10 +6714,11 @@ fn cellFontRole(cell: *const pardes.Cell) pardes.FontRole {
test "concealed terminal text emits no ink on opaque or transparent ground" {
var g: Gui = undefined;
g.space_slot = .{ .u = 0, .v = 0 };
+ g.words = .{};
var cell: pardes.Cell = .{ .default = false, .style = .{ .invisible = true, .ul = .single } };
cell.text[0] = 'X';
for ([_]Ground{ .opaqueRgb(bg_default), .{ .rgb = bg_default, .clear = true } }) |page| {
- const resolved = resolveCell(&g, &cell, .body, false, page);
+ const resolved = resolveCell(&g, (&cell)[0..1], 0, null, .body, false, page);
try std.testing.expectEqualDeep(g.space_slot, resolved.slot);
try std.testing.expectEqual(page.rgb, resolved.bg);
}
@@ -5369,74 +6728,153 @@ fn cellInstanceCount(cell: *const pardes.Cell) u32 {
return if (cellFontRole(cell) == .tagline) 2 else 1;
}
-fn taglineBaseRgb(core: *const pardes.Pardes, col: u16, row: u16) [3]u8 {
- const chrome = core.chromeTheme();
- if (!core.settings.focus_tint) return chrome.tag_bg;
- if (row >= pardes.TOPBAR_H and row < pardes.TOPBAR_H + core.columnBarHeight()) {
- for (0..core.ncol) |column| for (core.col_panes[column][0..core.col_n[column]]) |id| {
- if (id != core.active) continue;
- const x = core.col_x[column];
- if (col >= x and col - x < core.col_w[column]) return chrome.tag_active_bg;
- };
+fn tagLayerIn(layers: []const pardes.Layer, col: u16, row: u16) ?*const pardes.Layer {
+ for (layers) |*layer| {
+ const r = layer.viewport;
+ if (layer.rows > 0 and row >= r.y and row - r.y < layer.rows and col >= r.x and col - r.x < r.w) return layer;
}
- const r = core.rects[core.active];
- const tag_y = if (core.settings.tag_bottom) r.y + r.h -| pardes.BOX_H else r.y;
- return if (r.h > 0 and row == tag_y and col >= r.x and col - r.x < r.w) chrome.tag_active_bg else chrome.tag_bg;
+ return null;
+}
+
+fn expectCoverIsScan(cover: []const Cover, cols: u16, rows: u16, body_layers: []const pardes.Layer, tag_layers: []const pardes.Layer) !void {
+ for (0..rows) |row| for (0..cols) |col| {
+ const scan = bodyLayerIn(body_layers, @intCast(col), @intCast(row)) != null or tagLayerIn(tag_layers, @intCast(col), @intCast(row)) != null;
+ try std.testing.expectEqual(scan, cover[row * cols + col].layer);
+ };
}
-test "compact column and pane underlays share focus tint without tinting the global tag" {
- const core = try pardes.Pardes.init(std.testing.allocator, .{ .cols = 120, .rows = 24 });
+test "the layer cover is the per-cell layer scan, over a core's layouts and random layers" {
+ // A gui-shaped core: its tagline is narrower and shorter than the body,
+ // so tags and notices are layers.
+ const core = try pardes.Pardes.init(std.testing.allocator, .{ .cols = 97, .rows = 31 });
defer core.deinit();
- _ = try core.newShell(1, "");
+ core.update(.{ .resize = .{ .cols = 97, .rows = 31, .row_metrics = .{ .body_w = 10, .body_h = 20, .tagline_w = 7, .tagline_h = 13 } } });
+ for (1..4) |id| _ = try core.newShell(id, "");
try std.testing.expect(pardes.layout.splitColumn(core, 0, 1, false));
- pardes.test_api.sync(core);
- core.active = 1;
- const active = core.rects[1];
- const inactive = core.rects[0];
- const chrome = core.chromeTheme();
- try std.testing.expectEqual(chrome.tag_bg, taglineBaseRgb(core, active.x, 0));
- try std.testing.expectEqual(chrome.tag_active_bg, taglineBaseRgb(core, active.x, pardes.TOPBAR_H));
- try std.testing.expectEqual(chrome.tag_bg, taglineBaseRgb(core, inactive.x, pardes.TOPBAR_H));
- try std.testing.expectEqual(chrome.tag_active_bg, taglineBaseRgb(core, active.x, active.y));
- core.settings.focus_tint = false;
- try std.testing.expectEqual(chrome.tag_bg, taglineBaseRgb(core, active.x, pardes.TOPBAR_H));
+ pardes.layout.insert(core, 1, 1, 2);
+ pardes.layout.insert(core, 0, 1, 3);
+ var cover: [97 * 31]Cover = undefined;
+ var notices = false;
+ for (0..32) |step| {
+ core.settings.tag_bottom = step & 1 != 0;
+ if (step & 3 == 0) try std.testing.expect(core.executeBuiltinLine(2, "Collapse"));
+ core.leader_on = step & 4 != 0;
+ if (step & 8 != 0) {
+ try std.testing.expect(core.executeBuiltinLine(0, "Msg a message chip over the body"));
+ try std.testing.expect(core.executeBuiltinLine(3, "Msg another"));
+ }
+ const s = try core.render(core.scratch.allocator());
+ try std.testing.expectEqual(@as(usize, cover.len), @as(usize, s.cols) * s.rows);
+ @memset(&cover, .{ .layer = true, .floating = true, .grip = true, .focus = true }); // what an earlier frame left
+ coverFrame(&cover, s.cols, s.rows, s.bodyLayers(), s.tagLayers(), s.regionList());
+ try expectCoverIsScan(&cover, s.cols, s.rows, s.bodyLayers(), s.tagLayers());
+ // A grip's cells know their way to its glyph, and the focused
+ // pane's tag rows are the focused ones.
+ for (s.regionList()) |region| {
+ if (region.kind != .grip) continue;
+ for (0..region.rect.w) |offset| {
+ const cell = cover[@as(usize, region.rect.y) * s.cols + region.rect.x + offset];
+ try std.testing.expect(cell.grip);
+ try std.testing.expectEqual(offset, cell.grip_offset);
+ try std.testing.expectEqual(region.owner == core.active, cell.focus);
+ }
+ }
+ for (s.tagLayers()) |layer| notices = notices or (layer.rows != 0 and layer.kind == .notice);
+ }
+ try std.testing.expect(notices);
+
+ // Random layers: overlapping, empty, past the grid's right and bottom
+ // edges, and at the top of u16, where x + w overflows it.
+ const gen = struct {
+ fn coordinate(random: std.Random, limit: u16) u16 {
+ if (random.uintLessThan(u8, 12) == 0) return std.math.maxInt(u16) - random.uintLessThan(u16, 3);
+ return random.uintAtMost(u16, limit + 3);
+ }
+ fn rect(random: std.Random, cols: u16, rows: u16) pardes.Rect {
+ return .{ .x = coordinate(random, cols), .y = coordinate(random, rows), .w = coordinate(random, cols), .h = coordinate(random, rows / 2) };
+ }
+ };
+ var prng = std.Random.DefaultPrng.init(0x6c61796572);
+ const random = prng.random();
+ var body: [pardes.MAX_PANES]pardes.Layer = undefined;
+ var tag: [pardes.MAX_TAG_LAYERS]pardes.Layer = undefined;
+ var grid: [64 * 40]Cover = undefined;
+ for (0..3000) |_| {
+ const cols = random.intRangeAtMost(u16, 1, 64);
+ const rows = random.intRangeAtMost(u16, 1, 40);
+ const empty = random.intRangeAtMost(u8, 2, 5); // about one layer in `empty` is empty
+ for (&body) |*layer| layer.* = .{ .rows = @intFromBool(random.uintLessThan(u8, empty) != 0), .viewport = gen.rect(random, cols, rows) };
+ for (&tag) |*layer| layer.* = .{ .rows = @intFromBool(random.uintLessThan(u8, empty) != 0), .viewport = gen.rect(random, cols, rows) };
+ const bodies = body[0..random.uintAtMost(usize, body.len)];
+ const tags = tag[0..random.uintAtMost(usize, tag.len)];
+ const cells = grid[0 .. @as(usize, cols) * rows];
+ @memset(cells, .{ .layer = random.boolean() });
+ coverFrame(cells, cols, rows, bodies, tags, &.{});
+ try expectCoverIsScan(cells, cols, rows, bodies, tags);
+ }
}
-fn tagLayerIn(layers: []const pardes.TagLayer, col: u16, row: u16) ?*const pardes.TagLayer {
- for (layers) |*layer| {
- const r = layer.viewport;
- if (layer.cols > 0 and row == r.y and col >= r.x and col - r.x < r.w) return layer;
+/// The bottom of pane `owner`'s body, in window pixels.
+fn bodyBottom(surface: *const pardes.Surface, owner: u16, layout: CellLayout) ?f32 {
+ for (surface.regionList()) |region| {
+ if (region.kind == .body and region.owner == owner) return @as(f32, @floatFromInt(region.rect.y + region.rect.h)) * layout.h;
}
return null;
}
-fn tagLayerCellCount(g: *const Gui, layer: *const pardes.TagLayer) u32 {
+fn tagLayerCellCount(g: *const Gui, layer: *const pardes.Layer) u32 {
const pixels = @as(u32, layer.viewport.w) * g.cell_w;
return @min(layer.cols, (pixels + g.tagline_width - 1) / g.tagline_width);
}
-fn emitTagLayer(g: *Gui, instances: [*]CellInstance, next: *u32, layer: *const pardes.TagLayer, win_w: f32, win_h: f32, track: ?pardes.layout.Track, page: Ground, show_cursor: bool, old_layer: bool) void {
+fn emitTagLayer(g: *Gui, instances: [*]CellInstance, next: *u32, layer: *const pardes.Layer, win_w: f32, win_h: f32, track: ?pardes.animation.Track, page: Ground, show_cursor: bool, old_layer: bool) void {
const bw: f32 = @floatFromInt(g.cell_w);
const bh: f32 = @floatFromInt(g.cell_h);
const tw: f32 = @floatFromInt(g.tagline_width);
const left = @as(f32, @floatFromInt(layer.viewport.x)) * bw;
const right = left + @as(f32, @floatFromInt(layer.viewport.w)) * bw;
const background: pardes.Cell = .{ .default = false, .style = .{ .bg = .{ .rgb = layer.bg } } };
- emitInstance(g, instances, next.*, 0, layer.viewport.y, .{ .w = right - left, .h = bh, .x_off = left, .y_off = 0 }, win_w, win_h, track, .body, &background, old_layer, false, page);
- next.* += 1;
- for (0..tagLayerCellCount(g, layer)) |col| {
- const cursor = if (layer.cursor) |cu| show_cursor and !cu.bar and cu.col == col else false;
- emitInstance(g, instances, next.*, @intCast(col), layer.viewport.y, .{ .w = tw, .h = bh, .x_off = left, .y_off = 0 }, win_w, win_h, track, .tagline, &layer.cells[col], old_layer, cursor, page);
- clipInstanceRight(&instances[next.*], right, win_w);
+ // A band sliding into place is drawn offset and cut at its row's top, so
+ // it comes out from under whatever is above it.
+ const slide = layer.slide * bh;
+ // A window is rarely a whole number of cells wide: a band that ends at
+ // the last column runs on through the leftover pixels to the edge.
+ const band_right = if (win_w - right < bw) @max(right, win_w) else right;
+ // A row to each line, each a grid row with the tagline's glyphs.
+ for (0..layer.rows) |index| {
+ const y = layer.viewport.y + @as(u16, @intCast(index));
+ const top = @as(f32, @floatFromInt(y)) * bh;
+ emitInstance(g, instances, next.*, 0, y, .{ .w = band_right - left, .h = bh, .x_off = left, .y_off = slide }, win_w, win_h, track, .body, (&background)[0..1], 0, null, old_layer, false, page);
+ // A theme's plaque is drawn under the band: the band's own ground
+ // lets it show (tagPlaques).
+ if (cell_decor.nplaques != 0 and cell_decor.inPlaque(left + 0.5, top + 0.5)) plaqueThrough(instances, next.*);
+ if (slide != 0) clipInstanceTop(&instances[next.*], top, win_h);
next.* += 1;
+ const cells = layer.cells[index * layer.cols ..][0..layer.cols];
+ const line_cursor: ?usize = if (layer.cursor) |cu| (if (cu.y == index) cu.x else null) else null;
+ for (0..tagLayerCellCount(g, layer)) |col| {
+ const cursor = if (layer.cursor) |cu| show_cursor and !cu.bar and cu.x == col and cu.y == index else false;
+ emitInstance(g, instances, next.*, @intCast(col), y, .{ .w = tw, .h = bh, .x_off = left, .y_off = slide }, win_w, win_h, track, .tagline, cells, col, line_cursor, old_layer, cursor, page);
+ clipInstanceRight(&instances[next.*], right, win_w);
+ if (slide != 0) clipInstanceTop(&instances[next.*], top, win_h);
+ next.* += 1;
+ }
}
}
-fn bodyLayerAt(surface: *const pardes.Surface, col: u16, row: u16) ?*const pardes.BodyLayer {
+fn clipInstanceTop(instance: *CellInstance, top: f32, win_h: f32) void {
+ const limit = 1 - top / win_h * 2;
+ if (instance.y0 <= limit) return;
+ const fraction = std.math.clamp((limit - instance.y1) / (instance.y0 - instance.y1), 0, 1);
+ instance.v0 = instance.v1 + (instance.v0 - instance.v1) * fraction;
+ instance.y0 = @max(instance.y1, limit);
+}
+
+fn bodyLayerAt(surface: *const pardes.Surface, col: u16, row: u16) ?*const pardes.Layer {
return bodyLayerIn(surface.bodyLayers(), col, row);
}
-fn bodyLayerIn(layers: []const pardes.BodyLayer, col: u16, row: u16) ?*const pardes.BodyLayer {
+fn bodyLayerIn(layers: []const pardes.Layer, col: u16, row: u16) ?*const pardes.Layer {
for (layers) |*layer| {
const r = layer.viewport;
if (layer.rows > 0 and col >= r.x and col - r.x < r.w and row >= r.y and row - r.y < r.h) return layer;
@@ -5460,7 +6898,7 @@ fn clipBodyInstance(instance: *CellInstance, bottom: f32, win_h: f32) void {
instance.y1 = limit;
}
-fn emitBodyLayer(g: *Gui, instances: [*]CellInstance, next: *u32, layer: *const pardes.BodyLayer, win_w: f32, win_h: f32, track: ?pardes.layout.Track, page: Ground, show_cursor: bool, old_layer: bool, border_rgb: [3]u8) void {
+fn emitBodyLayer(g: *Gui, instances: [*]CellInstance, next: *u32, layer: *const pardes.Layer, win_w: f32, win_h: f32, track: ?pardes.animation.Track, page: Ground, show_cursor: bool, old_layer: bool, border_rgb: [3]u8) void {
const bw: f32 = @floatFromInt(g.cell_w);
const bh: f32 = @floatFromInt(g.cell_h);
const tw: f32 = @floatFromInt(g.tagline_width);
@@ -5479,17 +6917,18 @@ fn emitBodyLayer(g: *Gui, instances: [*]CellInstance, next: *u32, layer: *const
if (header) {
var background: pardes.Cell = .{ .default = false, .style = layer.cells[index * layer.cols].style };
background.style.font_role = .body;
- emitInstance(g, instances, next.*, 0, 0, .{ .w = @as(f32, @floatFromInt(layer.viewport.w)) * bw, .h = height, .x_off = left, .y_off = top }, win_w, win_h, track, .body, &background, old_layer, false, page);
+ emitInstance(g, instances, next.*, 0, 0, .{ .w = @as(f32, @floatFromInt(layer.viewport.w)) * bw, .h = height, .x_off = left, .y_off = top }, win_w, win_h, track, .body, (&background)[0..1], 0, null, old_layer, false, page);
clipBodyInstance(&instances[next.*], bottom, win_h);
clipInstanceRight(&instances[next.*], right, win_w);
next.* += 1;
}
+ const line = layer.cells[index * layer.cols ..][0..layer.cols];
+ const line_cursor: ?usize = if (layer.cursor) |cu| if (cu.y == row) cu.x else null else null;
for (0..layer.cols) |col| {
if (left + @as(f32, @floatFromInt(col)) * width >= right) break;
- const cell = &layer.cells[index * layer.cols + col];
const cursor = if (layer.cursor) |cu| show_cursor and !cu.bar and cu.x == col and cu.y == row else false;
- const glyph_top = top - (if (header) @as(f32, @floatFromInt(taglineBandOffset(0, win_h, g.cell_h, g.tagline_height, true))) else 0);
- emitInstance(g, instances, next.*, 0, 0, .{ .w = width, .h = height, .x_off = left + @as(f32, @floatFromInt(col)) * width, .y_off = glyph_top }, win_w, win_h, track, role, cell, old_layer, cursor, page);
+ const glyph_top = top - (if (header) @as(f32, @floatFromInt(taglineBandOffset(0, win_h, g.cell_h, g.tagline_height))) else 0);
+ emitInstance(g, instances, next.*, 0, 0, .{ .w = width, .h = height, .x_off = left + @as(f32, @floatFromInt(col)) * width, .y_off = glyph_top }, win_w, win_h, track, role, line, col, line_cursor, old_layer, cursor, page);
clipBodyInstance(&instances[next.*], bottom, win_h);
clipInstanceRight(&instances[next.*], right, win_w);
next.* += 1;
@@ -5501,7 +6940,7 @@ fn emitBodyLayer(g: *Gui, instances: [*]CellInstance, next: *u32, layer: *const
.h = 1,
.x_off = left,
.y_off = top + height - 1,
- }, win_w, win_h, track, .body, &border, old_layer, false, page);
+ }, win_w, win_h, track, .body, (&border)[0..1], 0, null, old_layer, false, page);
clipBodyInstance(&instances[next.*], bottom, win_h);
clipInstanceRight(&instances[next.*], right, win_w);
next.* += 1;
@@ -5509,38 +6948,84 @@ fn emitBodyLayer(g: *Gui, instances: [*]CellInstance, next: *u32, layer: *const
}
}
-const GripCell = struct { cell: *const pardes.Cell, offset: u16 };
-
-fn gripCellChanged(surface: *const pardes.Surface, col: u16, row: u16) bool {
+/// A dissolving cell changes with its grip's glyph, which is the cell its
+/// grip offset to the left, in this frame's grip or the last one's.
+fn gripCellChanged(surface: *const pardes.Surface, covered: []const Cover, previous_covered: []const Cover, col: u16, row: u16) bool {
if (surface.panelCellChanged(col, row)) return true;
- if (paneGripCell(surface.tagLayers(), surface.cells, surface.cols, col, row)) |grip| {
- if (surface.panelCellChanged(col - grip.offset, row)) return true;
- }
- if (paneGripCell(surface.previous_tag_layers, surface.previous_cells, surface.cols, col, row)) |grip| {
- if (surface.panelCellChanged(col - grip.offset, row)) return true;
- }
+ const at = @as(usize, row) * surface.cols + col;
+ for ([_]Cover{ covered[at], previous_covered[at] }) |cover|
+ if (cover.grip and surface.panelCellChanged(col -| cover.grip_offset, row)) return true;
return false;
}
-fn paneGripCell(layers: []const pardes.TagLayer, cells: []const pardes.Cell, cols: u16, col: u16, row: u16) ?GripCell {
- const at = @as(usize, row) * cols + col;
- if (at >= cells.len or cells[at].default or cells[at].style.font_role != .tagline) return null;
- for (layers) |layer| {
- if (layer.cols == 0 or layer.kind != .pane or layer.viewport.x < pardes.TAG_TEXT_INSET or layer.viewport.y != row) continue;
- const x = layer.viewport.x - pardes.TAG_TEXT_INSET;
- if (col < x or col - x >= config.GUTTER) continue;
- const index = @as(usize, row) * cols + x;
- if (index >= cells.len) return null;
- const cell = &cells[index];
- if (cell.default or cell.printableAscii() == ' ' or cell.style.invisible) return null;
- return .{ .cell = cell, .offset = col - x };
+fn anchorInset(g: *const Gui, row: u16, win_h: f32) u32 {
+ return taglineBandOffset(row, win_h, g.cell_h, g.tagline_height);
+}
+
+/// acme's Scrollwid column at a pane's or column's left edge, in window
+/// pixels: where its button sits over its scrollbar, one width for both
+/// (`rail_px` at acme's 17px font, scaled with the tagline, and always
+/// short of the cell so the text keeps a gap), right of the column's rule.
+fn scrollColumn(g: *const Gui, chrome: *const pardes.Chrome, col: u16, layout: CellLayout) [2]f32 {
+ const rule: f32 = if (col == 0) 0 else rulePx(chrome);
+ const x0 = @round(@as(f32, @floatFromInt(col)) * layout.w + rule);
+ const scaled: f32 = @round(@as(f32, @floatFromInt(@max(1, chrome.rail_px))) * @as(f32, @floatFromInt(g.tagline_height)) / 17);
+ // The rail and the grip are GUTTER cells wide; the text starts after.
+ const w = std.math.clamp(scaled, dp(4), @max(dp(4), @floor(layout.w * @as(f32, @floatFromInt(config.GUTTER))) - rule - dp(3)));
+ return .{ x0, x0 + w };
+}
+
+/// acme's button for the grip whose first cell is (col, row), in window
+/// pixels: the scroll column wide, its tag row tall, from the rule above to
+/// the rule below, so button and scrollbar read as one strip.
+fn gripButton(g: *const Gui, chrome: *const pardes.Chrome, col: u16, row: u16, layout: CellLayout, win_h: f32) [4]f32 {
+ _ = win_h;
+ const x = scrollColumn(g, chrome, col, layout);
+ const y0 = @round(@as(f32, @floatFromInt(row)) * layout.h);
+ return .{ x[0], y0, x[1], @round(@as(f32, @floatFromInt(row + 1)) * layout.h) };
+}
+
+/// A pane's button fill, from its region's state, not the grid's cells
+/// (which are drawn for cell shells): dirty, focused, or the tag's ground.
+fn gripFill(chrome: *const pardes.Chrome, focus: bool, dirty: bool) [3]u8 {
+ if (dirty) return chrome.grip_dirty;
+ return if (focus) chrome.grip_focus_ring else chrome.tag_bg;
+}
+
+fn inkOn(bg: [3]u8) [3]u8 {
+ const lum = (@as(u16, bg[0]) * 3 + @as(u16, bg[1]) * 6 + @as(u16, bg[2])) / 10;
+ return if (lum > 140) .{ 0x00, 0x00, 0x00 } else .{ 0xff, 0xff, 0xff };
+}
+
+/// Cuts an instance's quad to a pixel rectangle, its atlas window with it so
+/// the glyph neither moves nor stretches; nothing left, an empty quad.
+fn clipInstance(instance: *CellInstance, r: [4]f32, win_w: f32, win_h: f32) void {
+ const x0 = (instance.x0 + 1) / 2 * win_w;
+ const x1 = (instance.x1 + 1) / 2 * win_w;
+ const y0 = (1 - instance.y0) / 2 * win_h;
+ const y1 = (1 - instance.y1) / 2 * win_h;
+ const left = @max(0, r[0] - x0);
+ const right = @max(0, x1 - r[2]);
+ const top = @max(0, r[1] - y0);
+ const bottom = @max(0, y1 - r[3]);
+ if (x1 - right <= x0 + left or y1 - bottom <= y0 + top) {
+ instance.x1 = instance.x0;
+ instance.y1 = instance.y0;
+ return;
}
- return null;
+ instance.x0 += left / win_w * 2;
+ instance.u0 += left / atlas_w;
+ instance.x1 -= right / win_w * 2;
+ instance.u1 -= right / atlas_w;
+ instance.y0 -= top / win_h * 2;
+ instance.v0 += top / atlas_h;
+ instance.y1 += bottom / win_h * 2;
+ instance.v1 -= bottom / atlas_h;
}
fn emitSurfaceCell(
g: *Gui,
- core: ?*const pardes.Pardes,
+ chrome: *const pardes.Chrome,
instances: [*]CellInstance,
next: *u32,
col: u16,
@@ -5548,49 +7033,247 @@ fn emitSurfaceCell(
body_layout: CellLayout,
win_w: f32,
win_h: f32,
- track: ?pardes.layout.Track,
- cell: *const pardes.Cell,
- tagline_base: *const pardes.Cell,
- grip: ?GripCell,
+ track: ?pardes.animation.Track,
+ line: []const pardes.Cell,
+ line_cover: []const Cover,
+ at: usize,
+ cursor: ?usize,
old_layer: bool,
is_cursor: bool,
page: Ground,
) void {
- const role = cellFontRole(cell);
+ const role = cellFontRole(&line[at]);
if (role == .tagline) {
- var band_base = tagline_base.*;
- if (core) |p| band_base.style.bg = .{ .rgb = taglineBaseRgb(p, col, row) };
+ const here = line_cover[at];
+ const band_base: pardes.Cell = .{
+ .style = .{ .bg = .{ .rgb = if (here.focus) chrome.tag_focus_bg else chrome.tag_bg }, .font_role = .tagline },
+ .default = false,
+ };
// The smaller font changes the ink, not the chrome's coverage. Painting
// this underlay at tagline height leaves page-colored gutters between
// adjacent workspace, column and pane tags at TaglineSize < 100.
- emitInstance(g, instances, next.*, col, row, body_layout, win_w, win_h, track, .body, &band_base, old_layer, false, page);
+ emitInstance(g, instances, next.*, col, row, body_layout, win_w, win_h, track, .body, (&band_base)[0..1], 0, null, old_layer, false, page);
+ // Over a theme's plaque the underlay lets it show (tagPlaques),
+ // in a grip's cell too where the plaque reaches into it past the
+ // button (which is drawn over the cells).
+ const cell_x = @as(f32, @floatFromInt(col)) * body_layout.w + body_layout.x_off;
+ const cell_y = @as(f32, @floatFromInt(row)) * body_layout.h + body_layout.y_off + 0.5;
+ if (cell_decor.nplaques != 0 and cell_decor.inPlaque(if (here.grip) cell_x + body_layout.w - 0.5 else cell_x + 0.5, cell_y))
+ plaqueThrough(instances, next.*);
next.* += 1;
// Tag glyphs keep their font size inside a full physical-width grip.
- emitInstance(g, instances, next.*, col, row, body_layout, win_w, win_h, track, .tagline, cell, old_layer, is_cursor, page);
- if (grip) |indicator| {
- const cached = cachedGlyph(g, cellCodepoint(indicator.cell), .tagline, GlyphDecoration.fromCell(indicator.cell), true);
+ // A pane's grip cells are the cell shells' form (a dirty `*`): the
+ // button draws its own glyph over a blank of them.
+ var blank = line[at];
+ blank.text[0] = ' ';
+ blank.len = 1;
+ if (here.pane_grip)
+ emitInstance(g, instances, next.*, col, row, body_layout, win_w, win_h, track, .tagline, (&blank)[0..1], 0, null, old_layer, false, page)
+ else
+ emitInstance(g, instances, next.*, col, row, body_layout, win_w, win_h, track, .tagline, line, at, cursor, old_layer, is_cursor, page);
+ // A grip's glyph is the cell at its left edge, and a blank one is
+ // no glyph: its marks are decor.
+ const glyph = &line[at - @min(here.grip_offset, at)];
+ const grip = here.grip and here.grip_top and !glyph.default and glyph.printableAscii() != ' ' and !glyph.style.invisible;
+ const offset: u16 = if (grip) @min(here.grip_offset, at) else 0;
+ // An anchor starts at its column's rule: its left edge is inset by
+ // its top margin so the band frames it on the left as above and
+ // below, and its mark moves right by half that to stay centered.
+ const inset: u32 = if (line_cover[at - offset].anchor) anchorInset(g, row, win_h) else 0;
+ // A grip is acme's button: its fill is this cell's ground, cut to
+ // the button (and a dirty one's inset a pixel inside its ring, so
+ // the ring reads round it), its glyph centered in it.
+ const button = if (here.grip and here.grip_top) gripButton(g, chrome, col - @min(here.grip_offset, @as(u16, @intCast(at))), row, body_layout, win_h) else null;
+ if (grip) {
+ // A grip is one glyph centered across the gutter, not text: it is
+ // looked up by its codepoint's glyph, never shaped.
+ const drawn = glyphForCodepoint(g, cellCodepoint(glyph));
+ const cached = cachedGlyph(g, .{ .face = drawn.face, .glyph = drawn.glyph, .role = .tagline, .decoration = GlyphDecoration.fromCell(glyph), .centered = true });
const slot = cached orelse g.space_slot;
- const offset: u32 = if (cached != null) @as(u32, indicator.offset) * g.cell_w else 0;
- const resolved = resolveCell(g, indicator.cell, .tagline, false, page);
- instances[next.*].fr = @as(f32, @floatFromInt(resolved.fg[0])) / 255;
- instances[next.*].fg = @as(f32, @floatFromInt(resolved.fg[1])) / 255;
- instances[next.*].fb = @as(f32, @floatFromInt(resolved.fg[2])) / 255;
- instances[next.*].u0 = @as(f32, @floatFromInt(slot.u + offset)) / atlas_w;
+ const b = button.?;
+ const center = (b[0] + b[2]) / 2 - @as(f32, @floatFromInt(col - offset)) * body_layout.w;
+ const shift: f32 = if (cached != null) @as(f32, @floatFromInt(@as(u32, offset) * g.cell_w)) + @as(f32, @floatFromInt(config.GUTTER * g.cell_w)) / 2 - center else 0;
+ const resolved = resolveCell(g, glyph[0..1], 0, null, .tagline, false, page);
+ const ink = if (here.pane_grip) inkOn(gripFill(chrome, here.focus, here.dirty)) else resolved.fg;
+ instances[next.*].fr = @as(f32, @floatFromInt(ink[0])) / 255;
+ instances[next.*].fg = @as(f32, @floatFromInt(ink[1])) / 255;
+ instances[next.*].fb = @as(f32, @floatFromInt(ink[2])) / 255;
+ instances[next.*].u0 = (@as(f32, @floatFromInt(slot.u)) + shift) / atlas_w;
instances[next.*].v0 = @as(f32, @floatFromInt(slot.v)) / atlas_h;
instances[next.*].v1 = @as(f32, @floatFromInt(slot.v + g.tagline_height)) / atlas_h;
}
instances[next.*].u1 = instances[next.*].u0 + @as(f32, @floatFromInt(g.cell_w)) / atlas_w;
+ if (button) |b| {
+ // acme's button fills its tag row from the rule above to the rule
+ // below: the underlay is its fill, cut to its columns; a pane's
+ // from its region's state, not the grid's cell form (whose dirty
+ // `*` is the cell shells'), a column's its cell's own ground.
+ const base = &instances[next.* - 1];
+ const own: [3]f32 = .{ instances[next.*].br, instances[next.*].bg, instances[next.*].bb };
+ if (here.pane_grip) {
+ const fill = gripFill(chrome, here.focus, here.dirty);
+ base.br = @as(f32, @floatFromInt(fill[0])) / 255;
+ base.bg = @as(f32, @floatFromInt(fill[1])) / 255;
+ base.bb = @as(f32, @floatFromInt(fill[2])) / 255;
+ } else {
+ base.br = own[0];
+ base.bg = own[1];
+ base.bb = own[2];
+ }
+ base.effect &= ~clear_bg_bit;
+ clipInstance(base, .{ b[0], -1e9, b[2], 1e9 }, win_w, win_h);
+ // Over it, only its own glyph; the band round it and the ring
+ // are decor (gripDecor).
+ if (here.pane_grip and !grip) {
+ instances[next.*].u0 = @as(f32, @floatFromInt(g.space_slot.u)) / atlas_w;
+ instances[next.*].u1 = instances[next.*].u0 + @as(f32, @floatFromInt(g.cell_w)) / atlas_w;
+ instances[next.*].v0 = @as(f32, @floatFromInt(g.space_slot.v)) / atlas_h;
+ instances[next.*].v1 = @as(f32, @floatFromInt(g.space_slot.v + g.tagline_height)) / atlas_h;
+ }
+ // Its ground is the fill again (a see-through ground would be
+ // written, not blended, in an opaque window).
+ instances[next.*].br = base.br;
+ instances[next.*].bg = base.bg;
+ instances[next.*].bb = base.bb;
+ instances[next.*].effect &= ~clear_bg_bit;
+ clipInstance(&instances[next.*], b, win_w, win_h);
+ } else if (inset > 0) {
+ instances[next.*].x0 += @as(f32, @floatFromInt(inset)) / win_w * 2;
+ instances[next.*].u0 += @as(f32, @floatFromInt(inset)) / atlas_w;
+ }
next.* += 1;
return;
}
- emitInstance(g, instances, next.*, col, row, body_layout, win_w, win_h, track, role, cell, old_layer, is_cursor, page);
+ emitInstance(g, instances, next.*, col, row, body_layout, win_w, win_h, track, role, line, at, cursor, old_layer, is_cursor, page);
next.* += 1;
}
-test "small tagline fonts leave no background gutters between adjacent tags" {
- const core = try pardes.Pardes.init(std.testing.allocator, .{ .cols = 80, .rows = 24 });
+test "every pixel of a grip column is band, button or ring, and the button sits over the scrollbar" {
+ const gpa = std.testing.allocator;
+ const core = try pardes.Pardes.init(gpa, .{ .cols = 60, .rows = 20 });
defer core.deinit();
+ const pane = try core.setTestFile(std.mem.asBytes(&@as([60][5]u8, @splat("text\n".*))));
+ pane.tag.own = try gpa.dupe(u8, "second\nthird");
+ core.newScratchBelow(0);
+ for ([_]struct { w: u32, h: u32, tag: u32 }{ .{ .w = 10, .h = 20, .tag = 12 }, .{ .w = 17, .h = 35, .tag = 30 }, .{ .w = 9, .h = 19, .tag = 15 }, .{ .w = 12, .h = 24, .tag = 24 } }) |m| for ([_]bool{ false, true }) |bottom| for ([_]usize{ 0, 1 }) |focus| for ([_]bool{ false, true }) |dirty| {
+ core.settings.tag_bottom = bottom;
+ core.active = focus;
+ pane.file.?.revision = pane.file.?.saved_revision + @intFromBool(dirty);
+ core.sync();
+ const s = try core.render(core.scratch.allocator());
+ var g: Gui = undefined;
+ g.words = .{};
+ g.decor = .empty;
+ g.glide = .{};
+ g.scroll_pane = null;
+ g.scroll_lag = 0;
+ defer g.decor.deinit(gpa);
+ g.cell_w = m.w;
+ g.cell_h = m.h;
+ g.tagline_width = m.w;
+ g.tagline_height = m.tag;
+ g.space_slot = .{ .u = 0, .v = 0 };
+ const layout = fixedCellLayout(&g);
+ const win_w: f32 = @floatFromInt(60 * m.w);
+ const win_h: f32 = @floatFromInt(20 * m.h);
+ const cover = try gpa.alloc(Cover, @as(usize, s.cols) * s.rows);
+ defer gpa.free(cover);
+ coverFrame(cover, s.cols, s.rows, s.bodyLayers(), s.tagLayers(), s.regionList());
+ var groups = makeGroups(&.{}, false);
+ try buildDecor(&g, gpa, s, &groups, layout, win_w, win_h, true);
+ const grip = s.region(.grip, 0).?;
+ // The grip column's pixels, band first, then its cells, then decor.
+ const x_px: u32 = grip.rect.x * m.w;
+ const w_px: u32 = config.GUTTER * m.w;
+ const y_px: u32 = grip.rect.y * m.h;
+ const h_px: u32 = grip.rect.h * m.h;
+ const pixels = try gpa.alloc(?[3]f32, w_px * h_px);
+ defer gpa.free(pixels);
+ @memset(pixels, null);
+ const paint = struct {
+ fn quad(into: []?[3]f32, x0n: f32, y0n: f32, x1n: f32, y1n: f32, rgb: [3]f32, ww: f32, wh: f32, ox: u32, oy: u32, pw: u32, ph: u32) void {
+ const px0: i64 = @intFromFloat(@round((x0n + 1) / 2 * ww));
+ const px1: i64 = @intFromFloat(@round((x1n + 1) / 2 * ww));
+ const py0: i64 = @intFromFloat(@round((1 - y0n) / 2 * wh));
+ const py1: i64 = @intFromFloat(@round((1 - y1n) / 2 * wh));
+ var y = @max(py0, oy);
+ while (y < @min(py1, oy + ph)) : (y += 1) {
+ var x = @max(px0, ox);
+ while (x < @min(px1, ox + pw)) : (x += 1) into[@intCast((y - oy) * pw + (x - ox))] = rgb;
+ }
+ }
+ };
+ var instances: [4]CellInstance = undefined;
+ for (0..grip.rect.h) |line| for (0..config.GUTTER) |dx| {
+ const col: u16 = grip.rect.x + @as(u16, @intCast(dx));
+ const row: u16 = grip.rect.y + @as(u16, @intCast(line));
+ const at = @as(usize, row) * s.cols;
+ var next: u32 = 0;
+ emitSurfaceCell(&g, &s.chrome, &instances, &next, col, row, layout, win_w, win_h, null, s.cells[at..][0..s.cols], cover[at..][0..s.cols], col, null, false, false, Ground.opaqueRgb(bg_default));
+ for (instances[0..next]) |i| paint.quad(pixels, i.x0, i.y0, i.x1, i.y1, .{ i.br, i.bg, i.bb }, win_w, win_h, x_px, y_px, w_px, h_px);
+ };
+ for (g.decor.items) |i| if (i.fr >= 1 and i.clip_x1 < i.clip_x0) paint.quad(pixels, i.x0, i.y0, i.x1, i.y1, .{ i.br, i.bg, i.bb }, win_w, win_h, x_px, y_px, w_px, h_px);
+ const rgb = struct {
+ fn of(v: [3]u8) [3]f32 {
+ return .{ @as(f32, @floatFromInt(v[0])) / 255, @as(f32, @floatFromInt(v[1])) / 255, @as(f32, @floatFromInt(v[2])) / 255 };
+ }
+ }.of;
+ const chrome = &s.chrome;
+ const band = if (focus == 0) chrome.tag_focus_bg else chrome.tag_bg;
+ // Band, fills, rings, the rules between stacked panes and under the
+ // tag, and the mode marks' ink (the grip's first cell's).
+ const ink = inkOn(gripFill(chrome, grip.active, grip.dirty));
+ const allowed = [_][3]f32{ rgb(band), rgb(core.chromeTheme().box), rgb(pardes.draw.boxDirty(core)), rgb(chrome.grip_border), rgb(chrome.grip_focus_ring), rgb(chrome.border), rgb(ink), rgb(chrome.tag_rule orelse mixRgb(chrome.tag_bg, chrome.page orelse bg_default)) };
+ for (pixels, 0..) |pixel, n| {
+ const got = pixel orelse return error.TestUnpaintedGripPixel;
+ const known = for (allowed) |a| {
+ if (std.meta.eql(a, got)) break true;
+ } else false;
+ // Under the first row there is no button: band and rules only.
+ if (n / w_px >= m.h and n / w_px < h_px - 1 and !std.meta.eql(got, rgb(band)) and !std.meta.eql(got, rgb(chrome.border)))
+ return error.TestButtonUnderFirstRow;
+ if (!known) std.debug.print("sliver {any} at {d},{d} of {d}x{d} (metrics {d}x{d}/{d}, bottom {}, focus {d}, dirty {}) page {any}\n", .{ got, n % w_px, n / w_px, w_px, h_px, m.w, m.h, m.tag, bottom, focus, dirty, s.chrome.page });
+ try std.testing.expect(known);
+ }
+ // The rule under the tag runs unbroken across the grip column.
+ if (!bottom) for (pixels[(h_px - 1) * w_px ..][0..w_px]) |pixel|
+ try std.testing.expectEqual(rgb(chrome.tag_rule orelse mixRgb(chrome.tag_bg, chrome.page orelse bg_default)), pixel.?);
+ // The button's edges are the scrollbar's.
+ const button = gripButton(&g, chrome, grip.rect.x, grip.rect.y, layout, win_h);
+ const column = scrollColumn(&g, chrome, s.region(.rail, 0).?.rect.x, layout);
+ try std.testing.expectEqual(column[0], button[0]);
+ try std.testing.expectEqual(column[1], button[2]);
+ };
+ pane.file.?.revision = pane.file.?.saved_revision;
+}
+
+test "a rising pane past its mark stays inside its box" {
+ // Bouncy, a vertical rise at its highest overshoot: drawn past its box,
+ // clipped to it.
+ var g: Gui = undefined;
+ g.cell_w = 10;
+ g.cell_h = 20;
+ var track: pardes.animation.Track = .{ .serial = 3, .phase = .opening, .effect = .vertical, .motion = @backingInt(pardes.animation.Motion.Flavour.bouncy) + 1, .frame_count = 20, .from = .{ .x = 0, .y = 10, .w = 40, .h = 10 }, .to = .{ .x = 0, .y = 0, .w = 40, .h = 10 } };
+ var peak: u16 = 0;
+ var highest: f32 = 1e9;
+ while (track.frame < track.frames()) : (track.frame += 1) {
+ if (track.presented().y < highest) {
+ highest = track.presented().y;
+ peak = track.frame;
+ }
+ }
+ track.frame = peak;
+ try std.testing.expect(track.presented().y < 0);
+ var instance: CellInstance = std.mem.zeroes(CellInstance);
+ setTransitionFields(&instance, track, fixedCellLayout(&g), 800, 480, 0);
+ try std.testing.expectEqual(@as(f32, 0), instance.clip_y0);
+ try std.testing.expectEqual(@as(f32, 200), instance.clip_y1);
+}
+
+test "small tagline fonts leave no background gutters between adjacent tags" {
+ const chrome: pardes.Chrome = .{};
var g: Gui = undefined;
+ g.words = .{};
g.cell_w = 10;
g.cell_h = 20;
g.tagline_width = 8;
@@ -5600,7 +7283,8 @@ test "small tagline fonts leave no background gutters between adjacent tags" {
var instances: [6]CellInstance = undefined;
var next: u32 = 0;
for (0..3) |row| {
- emitSurfaceCell(&g, core, &instances, &next, 0, @intCast(row), fixedCellLayout(&g), 800, 480, null, &cell, &cell, null, false, false, Ground.opaqueRgb(bg_default));
+ // Column 1: past the anchor's inset edge at the column's left.
+ emitSurfaceCell(&g, &chrome, &instances, &next, 1, @intCast(row), fixedCellLayout(&g), 800, 480, null, (&cell)[0..1], &.{.{}}, 0, null, false, false, Ground.opaqueRgb(bg_default));
const base = instances[row * 2];
const ink = instances[row * 2 + 1];
try std.testing.expectApproxEqAbs(@as(f32, 20.0 / 480.0 * 2), base.y0 - base.y1, 0.0001);
@@ -5610,8 +7294,15 @@ test "small tagline fonts leave no background gutters between adjacent tags" {
try std.testing.expectApproxEqAbs(@as(f32, 10) / atlas_w, ink.u1 - ink.u0, 0.0001);
if (row > 0) try std.testing.expectApproxEqAbs(instances[(row - 1) * 2].y1, base.y0, 0.0001);
}
+ // Column 0 is an anchor's edge: its ink is inset by the band's margin
+ // (2 px here) and its underlay still covers the whole cell.
+ next = 0;
+ emitSurfaceCell(&g, &chrome, &instances, &next, 0, 1, fixedCellLayout(&g), 800, 480, null, (&cell)[0..1], &.{.{ .anchor = true }}, 0, null, false, false, Ground.opaqueRgb(bg_default));
+ try std.testing.expectApproxEqAbs(@as(f32, 10.0 / 800.0 * 2), instances[0].x1 - instances[0].x0, 0.0001);
+ try std.testing.expectApproxEqAbs(@as(f32, 8.0 / 800.0 * 2), instances[1].x1 - instances[1].x0, 0.0001);
+ try std.testing.expectApproxEqAbs(@as(f32, 8) / atlas_w, instances[1].u1 - instances[1].u0, 0.0001);
next = 0;
- emitSurfaceCell(&g, null, &instances, &next, 0, 2, fixedCellLayout(&g), 800, 480, null, &cell, &cell, null, true, false, Ground.opaqueRgb(bg_default));
+ emitSurfaceCell(&g, &chrome, &instances, &next, 0, 2, fixedCellLayout(&g), 800, 480, null, (&cell)[0..1], &.{.{}}, 0, null, true, false, Ground.opaqueRgb(bg_default));
try std.testing.expectEqual(@as(u32, 2), next);
try std.testing.expectApproxEqAbs(@as(f32, 16.0 / 480.0 * 2), instances[1].y0 - instances[1].y1, 0.0001);
}
@@ -5625,14 +7316,16 @@ fn emitInstance(
layout: CellLayout,
win_w: f32,
win_h: f32,
- track: ?pardes.layout.Track,
+ track: ?pardes.animation.Track,
role: pardes.FontRole,
- cell: *const pardes.Cell,
+ line: []const pardes.Cell,
+ at: usize,
+ cursor: ?usize,
old_layer: bool,
is_cursor: bool,
page: Ground,
) void {
- const resolved = resolveCell(g, cell, role, is_cursor, page);
+ const resolved = resolveCell(g, line, at, cursor, role, is_cursor, page);
const px0 = layout.x_off + @as(f32, @floatFromInt(col)) * layout.w;
const visual_h: f32 = if (resolved.role == .tagline)
@@ -5640,7 +7333,7 @@ fn emitInstance(
else
layout.h;
const band_offset: f32 = if (resolved.role == .tagline)
- @floatFromInt(taglineBandOffset(row, win_h, g.cell_h, g.tagline_height, true))
+ @floatFromInt(taglineBandOffset(row, win_h, g.cell_h, g.tagline_height))
else
0;
const py0 = layout.y_off + @as(f32, @floatFromInt(row)) * layout.h + band_offset;
@@ -5694,21 +7387,176 @@ fn emitInstance(
// A block cursor is foreground UI ink, even though its color is carried
// in the reversed cell background. Keep it visible at WindowOpacity 0.
if (is_cursor) instances[idx].effect |= opaque_bg_bit;
+ // The theme's ornament (cell_decor): dots on the page's own ground, a
+ // shadow under a file name's letters. Never on a cursor.
+ if (!is_cursor) {
+ // A blank cell on a tag's ground inside a plaque: the plaque shows.
+ if (cell_decor.nplaques != 0 and resolved.role == .tagline and cellCodepoint(&line[at]) == ' ' and
+ (std.mem.eql(u8, &resolved.bg, &cell_decor.grounds[0]) or std.mem.eql(u8, &resolved.bg, &cell_decor.grounds[1])) and
+ (cell_decor.inPlaque(px0 + 0.5, py0 + 0.5) or cell_decor.inPlaque(px0 + layout.w - 0.5, py0 + 0.5)))
+ plaqueThrough(instances, idx);
+ if (cell_decor.dots) |dotted| {
+ if (!resolved.clear_bg and std.mem.eql(u8, &resolved.bg, &dotted)) {
+ instances[idx].effect |= dotted_bit;
+ // G13: the dots under a body move with its text, a quarter
+ // as far; the serial slot carries it (the shader reads it
+ // as the dots' offset alone).
+ instances[idx].serial = @bitCast(cell_decor.parallaxAt(px0 + 0.5, py0 + 0.5));
+ }
+ }
+ if (cell_decor.title) |inks| {
+ if (resolved.role == .tagline and (std.mem.eql(u8, &resolved.fg, &inks[0]) or std.mem.eql(u8, &resolved.fg, &inks[1]))) instances[idx].effect |= title_bit;
+ }
+ }
}
test "block cursor alone overrides transparent cell background" {
var g: Gui = undefined;
+ g.words = .{};
g.cell_w = 10;
g.cell_h = 20;
g.space_slot = .{ .u = 0, .v = 0 };
const cell: pardes.Cell = .{};
var instances: [2]CellInstance = undefined;
for ([_]bool{ false, true }, 0..) |cursor, i| {
- emitInstance(&g, &instances, @intCast(i), 0, 0, fixedCellLayout(&g), 800, 480, null, .body, &cell, false, cursor, Ground.opaqueRgb(bg_default));
+ emitInstance(&g, &instances, @intCast(i), 0, 0, fixedCellLayout(&g), 800, 480, null, .body, (&cell)[0..1], 0, null, false, cursor, Ground.opaqueRgb(bg_default));
try std.testing.expectEqual(cursor, instances[i].effect & opaque_bg_bit != 0);
}
}
+test "lapis dots only the page's own ground and shadows only a file name, never a cursor" {
+ var g: Gui = undefined;
+ g.words = .{};
+ g.cell_w = 10;
+ g.cell_h = 20;
+ g.tagline_width = 8;
+ g.tagline_height = 16;
+ g.space_slot = .{ .u = 0, .v = 0 };
+ const page: [3]u8 = .{ 0x0a, 0x10, 0x30 };
+ const name: [3]u8 = .{ 0xe8, 0xc4, 0x6a };
+ var chrome: pardes.Chrome = .{ .page = page, .decor_dots = .{ 1, 2, 3 }, .decor_dot_alpha = 0x22, .decor_title = .{ 4, 5, 6 }, .name_ink = name, .active_name_ink = name };
+ cell_decor = CellDecor.of(&chrome);
+ defer cell_decor = .{};
+ const on_page: pardes.Cell = .{ .default = false, .style = .{ .fg = .{ .rgb = .{ 200, 200, 200 } }, .bg = .{ .rgb = page } } };
+ const selected: pardes.Cell = .{ .default = false, .style = .{ .fg = .{ .rgb = .{ 0, 0, 0 } }, .bg = .{ .rgb = name } } };
+ const title: pardes.Cell = .{ .default = false, .style = .{ .fg = .{ .rgb = name }, .bg = .{ .rgb = .{ 0x0f, 0x1a, 0x4a } }, .font_role = .tagline } };
+ const plain_tag: pardes.Cell = .{ .default = false, .style = .{ .fg = .{ .rgb = .{ 0x9a, 0xa6, 0xd9 } }, .bg = .{ .rgb = .{ 0x0f, 0x1a, 0x4a } }, .font_role = .tagline } };
+ var instances: [1]CellInstance = undefined;
+ const Case = struct { cell: pardes.Cell, role: pardes.FontRole, cursor: bool, dotted: bool, shadowed: bool };
+ for ([_]Case{
+ .{ .cell = on_page, .role = .body, .cursor = false, .dotted = true, .shadowed = false },
+ .{ .cell = on_page, .role = .body, .cursor = true, .dotted = false, .shadowed = false },
+ .{ .cell = selected, .role = .body, .cursor = false, .dotted = false, .shadowed = false },
+ .{ .cell = title, .role = .tagline, .cursor = false, .dotted = false, .shadowed = true },
+ .{ .cell = title, .role = .tagline, .cursor = true, .dotted = false, .shadowed = false },
+ .{ .cell = plain_tag, .role = .tagline, .cursor = false, .dotted = false, .shadowed = false },
+ }) |case| {
+ emitInstance(&g, &instances, 0, 0, 0, fixedCellLayout(&g), 800, 480, null, case.role, (&case.cell)[0..1], 0, null, false, case.cursor, Ground.opaqueRgb(page));
+ try std.testing.expectEqual(case.dotted, instances[0].effect & dotted_bit != 0);
+ try std.testing.expectEqual(case.shadowed, instances[0].effect & title_bit != 0);
+ }
+ // A theme without decor marks nothing.
+ chrome = .{ .page = page };
+ cell_decor = CellDecor.of(&chrome);
+ emitInstance(&g, &instances, 0, 0, 0, fixedCellLayout(&g), 800, 480, null, .body, (&on_page)[0..1], 0, null, false, false, Ground.opaqueRgb(page));
+ try std.testing.expectEqual(@as(u32, 0), instances[0].effect & (dotted_bit | title_bit));
+}
+
+test "lapis plaques stay in their tag's band, clear of every grip; only the focused one is striped" {
+ const gpa = std.testing.allocator;
+ const core = try pardes.Pardes.init(gpa, .{ .cols = 80, .rows = 24 });
+ defer core.deinit();
+ _ = try core.newShell(1, "");
+ try std.testing.expect(pardes.layout.splitColumn(core, 0, 1, false));
+ try std.testing.expect(core.executeBuiltinLine(0, "Theme lapis"));
+ for (0..40) |_| core.update(.tick);
+ core.sync();
+ const s = try core.render(core.scratch.allocator());
+ try std.testing.expect(s.chrome.decor_box_border != null and s.chrome.decor_checker != null and s.chrome.decor_dots != null and s.chrome.decor_title != null);
+ var g: Gui = undefined;
+ g.decor = .empty;
+ g.glide = .{};
+ g.scroll_pane = null;
+ g.scroll_lag = 0;
+ defer g.decor.deinit(gpa);
+ g.cell_w = 16;
+ g.cell_h = 32;
+ g.tagline_width = 12;
+ g.tagline_height = 22;
+ display_scale = 1;
+ var groups = makeGroups(&.{}, false);
+ try buildDecor(&g, gpa, s, &groups, fixedCellLayout(&g), 1280, 768, true);
+ const layout = fixedCellLayout(&g);
+ const under = g.decor.items[groups.items[0].decor_start..][0..groups.items[0].under_count];
+ try std.testing.expect(under.len != 0);
+ var stripes: usize = 0;
+ var shadows: usize = 0;
+ for (under) |item| {
+ const r: [4]f32 = .{ (item.x0 + 1) / 2 * 1280, (1 - item.y0) / 2 * 768, (item.x1 + 1) / 2 * 1280, (1 - item.y1) / 2 * 768 };
+ // Inside one tag's band, whole: never on a body, a grip or the
+ // next pane. A box stacked under another tag's lays its top frame
+ // over their shared edge, its own width up into the band above.
+ const home = for (s.regionList()) |region| {
+ if (region.kind != .tag and region.kind != .column_tag and region.kind != .workspace_tag) continue;
+ const band = plaqueBox(&g, &s.chrome, s.regionList(), region, layout, 1280, 768) orelse continue;
+ if (r[0] >= band.band[0] - 0.01 and r[1] >= band.band[1] - band.border - 0.01 and r[2] <= band.band[2] + 0.01 and r[3] <= band.band[3] + 0.01) break region;
+ } else return error.PlaqueOutsideItsBand;
+ // Clear of every grip's button: a plaque starts flush against it,
+ // in the gap between it and the text.
+ for (s.regionList()) |grip| {
+ if (grip.kind != .grip and grip.kind != .column_grip) continue;
+ const column = scrollColumn(&g, &s.chrome, grip.rect.x, layout);
+ const gx0 = column[0];
+ const gx1 = column[1];
+ const gy0 = @as(f32, @floatFromInt(grip.rect.y)) * 32;
+ const gy1 = @as(f32, @floatFromInt(grip.rect.y + grip.rect.h)) * 32;
+ try std.testing.expect(r[2] <= gx0 + 0.01 or r[0] >= gx1 - 0.01 or r[3] <= gy0 + 0.01 or r[1] >= gy1 - 0.01);
+ }
+ if (item.effect & checker_bit != 0) {
+ try std.testing.expect(home.kind == .tag and home.active);
+ stripes += 1;
+ }
+ const rgb: [3]u8 = .{ @intFromFloat(@round(item.br * 255)), @intFromFloat(@round(item.bg * 255)), @intFromFloat(@round(item.bb * 255)) };
+ if (std.mem.eql(u8, &rgb, &s.chrome.decor_box_shadow.?)) shadows += 1;
+ }
+ try std.testing.expectEqual(@as(usize, 1), stripes);
+ try std.testing.expect(shadows >= 2);
+ // Stacked boxes share an edge and line up: a column's box spans its
+ // first pane's across, runs down to the edge that pane's frame lies
+ // over, and no shadow reaches the next column.
+ var stacks: usize = 0;
+ for (s.regionList()) |column| {
+ if (column.kind != .column_tag) continue;
+ const upper = plaqueBox(&g, &s.chrome, s.regionList(), column, layout, 1280, 768).?;
+ for (s.regionList()) |tag| {
+ if (tag.kind != .tag or tag.rect.y != column.rect.y + column.rect.h or tag.rect.x + tag.rect.w != column.rect.x + column.rect.w) continue;
+ const lower = plaqueBox(&g, &s.chrome, s.regionList(), tag, layout, 1280, 768).?;
+ try std.testing.expectEqual(upper.box[0], lower.box[0]);
+ // Flush against the grips' buttons, which line up too.
+ const grip = for (s.regionList()) |part| {
+ if (part.kind == .grip and part.owner == tag.owner) break part;
+ } else unreachable;
+ try std.testing.expectEqual(scrollColumn(&g, &s.chrome, grip.rect.x, layout)[1], lower.box[0]);
+ try std.testing.expectEqual(upper.box[2], lower.box[2]);
+ try std.testing.expectEqual(upper.band[3], upper.box[3]);
+ try std.testing.expectEqual(lower.band[1] - lower.border, lower.box[1]);
+ try std.testing.expectEqual(@as(f32, 0), upper.shadow[1]);
+ if (lower.band[2] < 1280) try std.testing.expect(lower.box[2] + lower.shadow[0] < lower.band[2]);
+ stacks += 1;
+ }
+ }
+ try std.testing.expectEqual(@as(usize, 2), stacks);
+ // The scroll track is chequered.
+ var checkers: usize = 0;
+ for (g.decor.items[groups.items[0].decor_start + groups.items[0].under_count ..]) |item| checkers += @intFromBool(item.effect & checker_bit != 0);
+ try std.testing.expect(checkers >= 1);
+ // No other theme draws any of it.
+ try std.testing.expect(core.executeBuiltinLine(0, "Theme forge"));
+ for (0..40) |_| core.update(.tick);
+ const plain = try core.render(core.scratch.allocator());
+ try std.testing.expect(plain.chrome.decor_box_border == null and plain.chrome.decor_checker == null and plain.chrome.decor_dots == null and plain.chrome.decor_title == null);
+}
+
fn cellCodepoint(cell: *const pardes.Cell) u32 {
const grapheme = cell.grapheme();
return if (cell.default or grapheme.len == 0) ' ' else firstCp(grapheme);
@@ -5722,24 +7570,28 @@ test "insert cursor overlays without replacing the character beneath it" {
};
try std.testing.expectEqual(@as(u32, 'x'), cellCodepoint(&cell));
- var vertices: [6]OverlayVertex = undefined;
- var builder: OverlayBuilder = .{
- .vertices = &vertices,
- .win_w = 100,
- .win_h = 100,
- };
- addCursorBar(&builder, 2, 3, true, 8, .{
- .x_off = 0,
- .y_off = 0,
- .w = 10,
- .h = 20,
- }, .{ 32, 48, 64 });
- try std.testing.expectEqual(@as(usize, 6), builder.len);
- try std.testing.expectApproxEqAbs(@as(f32, -0.32), vertices[0].y, 0.0001);
- try std.testing.expectApproxEqAbs(@as(f32, -0.48), vertices[2].y, 0.0001);
- try std.testing.expectApproxEqAbs(@as(f32, 32.0 / 255.0), vertices[0].r, 0.0001);
- for (vertices) |vertex| try std.testing.expectEqual(@as(u32, 1), vertex.ink);
- try std.testing.expect(!builder.ink);
+ // A bar at a tag cell: tagline-tall, centered in its row, in the
+ // cell's ink, drawn as decor over it.
+ var cells: [25]pardes.Cell = @splat(.{});
+ cells[3 * 5 + 2] = .{ .default = false, .style = .{ .fg = .{ .rgb = .{ 32, 48, 64 } }, .font_role = .tagline } };
+ const surface: pardes.Surface = .{ .cols = 5, .rows = 5, .cells = &cells, .cursor = .{ .x = 2, .y = 3, .bar = true } };
+ var g: Gui = undefined;
+ g.decor = .empty;
+ g.glide = .{};
+ g.scroll_pane = null;
+ g.scroll_lag = 0;
+ defer g.decor.deinit(std.testing.allocator);
+ g.cell_w = 10;
+ g.cell_h = 20;
+ g.tagline_width = 8;
+ g.tagline_height = 8;
+ try cursorDecor(&g, std.testing.allocator, &surface, fixedCellLayout(&g), 100, 100);
+ try std.testing.expectEqual(@as(usize, 1), g.decor.items.len);
+ const bar = g.decor.items[0];
+ try std.testing.expectApproxEqAbs(@as(f32, -0.32), bar.y0, 0.0001);
+ try std.testing.expectApproxEqAbs(@as(f32, -0.48), bar.y1, 0.0001);
+ try std.testing.expectApproxEqAbs(@as(f32, 32.0 / 255.0), bar.br, 0.0001);
+ try std.testing.expectEqual(@as(f32, 1), bar.fr);
}
fn palColor(idx: u8) [3]u8 {
@@ -5755,16 +7607,15 @@ fn firstCp(s: []const u8) u32 {
}
fn refitFont(g: *Gui, core: ?*pardes.Pardes) void {
- g.scale = c.ui_font_scale_for_height(g.font, g.px);
var cw: c_int = 10;
var chh: c_int = 20;
var asc: c_int = 16;
- c.ui_font_cell_metrics(g.font, g.scale, &cw, &chh, &asc);
+ c.ui_font_cell_metrics(g.font, g.px, &cw, &chh, &asc);
g.cell_w = @intCast(@max(cw, 1));
g.cell_h = @intCast(@max(chh, 1));
g.ascent = @intCast(@max(asc, 1));
const tagline = taglineRaster(g.font, g.px, g.cell_w, g.cell_h, g.tagline_percent);
- g.tagline_scale = tagline.scale;
+ g.tagline_px = tagline.px;
g.tagline_width = tagline.width;
g.tagline_baseline = tagline.baseline;
g.tagline_height = tagline.height;
@@ -5779,14 +7630,27 @@ fn refitFont(g: *Gui, core: ?*pardes.Pardes) void {
resetScroll(g);
}
+// The first cell of the cleared atlas stays blank: the space slot.
fn resetGlyphAtlas(g: *Gui) void {
g.glyphs.clearRetainingCapacity();
+ g.words.clear();
@memset(g.atlas_stage, 0);
- _ = c.ui_font_raster(g.font, g.scale, ' ', g.atlas_stage.ptr, @intCast(atlas_w), @intCast(g.cell_w), @intCast(g.cell_h), g.ascent);
g.space_slot = .{ .u = 0, .v = 0 };
g.pen_x = g.cell_w;
g.pen_y = 0;
- g.atlas_dirty = true;
+ g.atlas_dirty_top = 0;
+ g.atlas_dirty_bottom = atlas_h;
+}
+
+/// A changed Ligatures setting drops what was resolved under the old one: the
+/// per-codepoint cells (which say whether a cell is shaped) and the shaped
+/// words. The atlas keeps its glyphs, plain and strip alike; the plain ones
+/// draw either way, and the strips come back into use when ligatures do.
+/// The frame this runs before redraws every cell with the new setting.
+fn syncLigatures(g: *Gui, core: *pardes.Pardes) void {
+ if (core.settings.ligatures == g.words.ligatures) return;
+ g.words.clear();
+ g.words.ligatures = core.settings.ligatures;
}
fn syncTaglineFont(g: *Gui, core: *pardes.Pardes) void {
@@ -5794,7 +7658,7 @@ fn syncTaglineFont(g: *Gui, core: *pardes.Pardes) void {
if (percent == g.tagline_percent) return;
g.tagline_percent = percent;
const tagline = taglineRaster(g.font, g.px, g.cell_w, g.cell_h, percent);
- g.tagline_scale = tagline.scale;
+ g.tagline_px = tagline.px;
g.tagline_width = tagline.width;
g.tagline_baseline = tagline.baseline;
g.tagline_height = tagline.height;
@@ -5803,36 +7667,379 @@ fn syncTaglineFont(g: *Gui, core: *pardes.Pardes) void {
_ = updateCoreResize(core, geom.cols, geom.rows, g.cell_w, g.cell_h, g.tagline_width, g.tagline_height);
}
-fn ensureGlyph(g: *Gui, cp: u32, role: pardes.FontRole, decoration: GlyphDecoration) Slot {
- return cachedGlyph(g, cp, role, decoration, false) orelse g.space_slot;
+/// What text draws, so a frame does not work it out again. `cells` is the
+/// atlas slot of a codepoint no ligature can touch (`shape_slot` for one that
+/// is shaped with its word); `map` is the atlas slot of every cell of a word
+/// holding one, found by the word's text. Bounded: past `max_cells` word cells
+/// it starts over, and the next frames look up what they show again (the
+/// glyphs stay in the atlas).
+const Words = struct {
+ cells: std.AutoHashMapUnmanaged(CellKey, Slot) = .empty,
+ map: std.AutoHashMapUnmanaged(u64, Word) = .empty,
+ /// Every word's codepoints and slots, end to end; a Word indexes both.
+ text: std.ArrayListUnmanaged(u32) = .empty,
+ slots: std.ArrayListUnmanaged(Slot) = .empty,
+ shaped: std.ArrayListUnmanaged(c.UIShapedCell) = .empty,
+ /// The Ligatures setting. Off, no cell is shaped, so each draws its own
+ /// glyph, as in a font without ligatures. It lives here because every
+ /// cell and word above was resolved under it (`syncLigatures`).
+ ligatures: bool = true,
+ /// The word the last cell was in, so the rest of it costs a compare. It
+ /// is positional, so every frame forgets it: the cells change under it.
+ memo: Memo = .{},
+
+ const max_cells = 1 << 17;
+ const CellKey = packed struct(u64) { cp: u21, role: pardes.FontRole, decoration: GlyphDecoration, _: u30 = 0 };
+ const shape_slot: Slot = .{ .u = std.math.maxInt(u32), .v = std.math.maxInt(u32) };
+ const Word = struct { start: u32, len: u32, decoration: GlyphDecoration };
+ const Memo = struct {
+ line: ?[*]const pardes.Cell = null,
+ len: usize = 0,
+ start: usize = 0,
+ end: usize = 0,
+ cursor: ?usize = null,
+ slots: usize = 0,
+ };
+
+ fn clear(w: *Words) void {
+ w.cells.clearRetainingCapacity();
+ w.map.clearRetainingCapacity();
+ w.text.clearRetainingCapacity();
+ w.slots.clearRetainingCapacity();
+ w.memo = .{};
+ }
+
+ fn deinit(w: *Words, gpa: std.mem.Allocator) void {
+ w.cells.deinit(gpa);
+ w.map.deinit(gpa);
+ w.text.deinit(gpa);
+ w.slots.deinit(gpa);
+ w.shaped.deinit(gpa);
+ }
+};
+
+/// What decides where a word ends, for one cell. A concealed cell is a space.
+const WordCell = struct { cp: u32, decoration: GlyphDecoration, role: pardes.FontRole };
+
+fn wordCell(cell: *const pardes.Cell) WordCell {
+ return .{
+ .cp = if (!cell.default and cell.style.invisible) ' ' else cellCodepoint(cell),
+ .decoration = GlyphDecoration.fromCell(cell),
+ .role = cellFontRole(cell),
+ };
+}
+
+/// Whether a word ends between `a`, cell `i`, and `b`, cell `i + 1`: at a
+/// space, a decoration or role change, either side of the cursor (Ghostty's
+/// rule: the cell being edited shows its own glyph, so a ligature under the
+/// cursor comes apart), and inside f|i, f|l and s|t, whose typographic
+/// ligatures do not belong on a grid (Ghostty again). Colours never end a
+/// word: a ligature spans a syntax colour change or a selection edge, and each
+/// cell tints its own slice.
+fn wordBreak(a: WordCell, b: WordCell, i: usize, cursor: ?usize) bool {
+ if (a.cp == ' ' or b.cp == ' ') return true;
+ // A rule is drawn by hand (ruleArms), never a slice of a shaped word.
+ if (ruleArms(a.cp) != null or ruleArms(b.cp) != null) return true;
+ if (cursor) |at| if (at == i or at == i + 1) return true;
+ if (a.role != b.role or !std.meta.eql(a.decoration, b.decoration)) return true;
+ return (a.cp == 'f' and (b.cp == 'i' or b.cp == 'l')) or (a.cp == 's' and b.cp == 't');
+}
+
+/// The atlas slot `line[at]` draws: blank for a plain space (or concealed
+/// text), its own glyph when no ligature could replace that glyph (every
+/// cell, in a font without ligatures or with Ligatures off), else its slice
+/// of the word around it, shaped once and cached by the word's text. The
+/// cells of a word being walked cost a compare. Taglines are not shaped: they are drawn at two pitches
+/// (tagline_width in a tag layer, a whole cell in the grid), and a strip would
+/// not line up in one of them.
+fn cellSlot(g: *Gui, line: []const pardes.Cell, at: usize, cursor: ?usize, role: pardes.FontRole) Slot {
+ const words = &g.words;
+ const memo = words.memo;
+ if (memo.line == line.ptr and memo.len == line.len and memo.cursor == cursor and at >= memo.start and at < memo.end and role == .body)
+ return words.slots.items[memo.slots + at - memo.start];
+ var here = wordCell(&line[at]);
+ // An underlined or struck-out space is a glyph of its own: it draws its line.
+ if (here.cp == ' ' and !here.decoration.drawsBlank()) return g.space_slot;
+ if (ruleArms(here.cp) != null)
+ return cachedGlyph(g, .{ .face = 0, .glyph = here.cp, .role = role, .rule = true }) orelse g.space_slot;
+ const gpa = g.glyphs.allocator;
+ const cell_key: Words.CellKey = .{ .cp = @intCast(here.cp), .role = role, .decoration = here.decoration };
+ const known = words.cells.getOrPut(gpa, cell_key) catch return g.space_slot;
+ if (!known.found_existing) {
+ const drawn = glyphForCodepoint(g, here.cp);
+ const font = if (drawn.face == 0) g.font else g.fallbacks[drawn.face - 1].?.face;
+ known.value_ptr.* = if (role == .body and words.ligatures and c.ui_font_substitutes(font, drawn.glyph) != 0)
+ Words.shape_slot
+ else
+ cachedGlyph(g, .{ .face = drawn.face, .glyph = drawn.glyph, .role = role, .decoration = here.decoration }) orelse g.space_slot;
+ }
+ const plain = known.value_ptr.*;
+ if (!std.meta.eql(plain, Words.shape_slot)) return plain;
+
+ if (words.text.items.len > Words.max_cells) words.clear();
+ var start = at;
+ while (start > 0) {
+ const before = wordCell(&line[start - 1]);
+ if (wordBreak(before, here, start - 1, cursor)) break;
+ start -= 1;
+ here = before;
+ }
+ // The word's text goes on the end of `text`: a new word keeps it there,
+ // a known one gives it back.
+ const text_start = words.text.items.len;
+ var end = start;
+ while (true) {
+ words.text.append(gpa, here.cp) catch return g.space_slot;
+ end += 1;
+ if (end == line.len) break;
+ const next = wordCell(&line[end]);
+ if (wordBreak(here, next, end - 1, cursor)) break;
+ here = next;
+ }
+ const text = words.text.items[text_start..];
+ const decoration = here.decoration;
+ const hash = std.hash.Wyhash.hash(@as(u5, @bitCast(decoration)), std.mem.sliceAsBytes(text));
+ if (words.map.get(hash)) |word| {
+ if (word.len == text.len and std.meta.eql(word.decoration, decoration) and
+ std.mem.eql(u32, words.text.items[word.start..][0..word.len], text))
+ {
+ words.text.shrinkRetainingCapacity(text_start);
+ words.memo = .{ .line = line.ptr, .len = line.len, .start = start, .end = end, .cursor = cursor, .slots = word.start };
+ return words.slots.items[word.start + at - start];
+ }
+ }
+
+ // A new word (a hash collision takes the map entry over). Runs of one
+ // face are shaped in that face; fallback faces shape like the primary.
+ const probe_shape = monoNs();
+ defer if (frame_probe) |probe| {
+ probe.zone(.gui_shape, probe_shape);
+ probe.shaped +|= 1;
+ };
+ const n = text.len;
+ words.slots.ensureUnusedCapacity(gpa, n) catch {
+ words.text.shrinkRetainingCapacity(text_start);
+ return g.space_slot;
+ };
+ words.shaped.resize(gpa, n) catch {
+ words.text.shrinkRetainingCapacity(text_start);
+ return g.space_slot;
+ };
+ const shaped = words.shaped.items;
+ var run_start: usize = 0;
+ var face = glyphForCodepoint(g, text[0]).face;
+ while (run_start < n) {
+ var run_end = run_start + 1;
+ var next_face = face;
+ while (run_end < n) : (run_end += 1) {
+ next_face = glyphForCodepoint(g, text[run_end]).face;
+ if (next_face != face) break;
+ }
+ const run_font = if (face == 0) g.font else g.fallbacks[face - 1].?.face;
+ c.ui_font_shape(run_font, g.px, @intCast(g.cell_w), text[run_start..].ptr, @intCast(run_end - run_start), shaped[run_start..].ptr);
+ for (shaped[run_start..run_end]) |cell| {
+ const key: GlyphKey = .{ .face = face, .glyph = cell.glyph, .role = .body, .decoration = decoration, .lead = @intCast(cell.lead), .span = @intCast(cell.span) };
+ const slot: Slot = if (cachedGlyph(g, key)) |strip| .{ .u = strip.u + g.cell_w * cell.slice, .v = strip.v } else g.space_slot;
+ words.slots.appendAssumeCapacity(slot);
+ }
+ run_start = run_end;
+ face = next_face;
+ }
+ words.map.put(gpa, hash, .{ .start = @intCast(text_start), .len = @intCast(n), .decoration = decoration }) catch {};
+ words.memo = .{ .line = line.ptr, .len = line.len, .start = start, .end = end, .cursor = cursor, .slots = text_start };
+ return words.slots.items[text_start + at - start];
+}
+
+/// A Gui that can shape and rasterize `font` at `px`, and nothing else. From
+/// here on the fonts allocate from std.testing.allocator (the caller puts
+/// font_allocator back), so the test counts what they leak.
+fn textTestGui(font: *c.UIFont, px: f32) !Gui {
+ c.ui_font_prime(font);
+ font_allocator = std.testing.allocator;
+ var g: Gui = undefined;
+ g.font = font;
+ g.fallback_count = 0;
+ g.px = px;
+ var cw: c_int = 0;
+ var ch: c_int = 0;
+ c.ui_font_cell_metrics(font, px, &cw, &ch, &g.ascent);
+ g.cell_w = @intCast(cw);
+ g.cell_h = @intCast(ch);
+ const tag = taglineRaster(font, px, g.cell_w, g.cell_h, 82);
+ g.tagline_px = tag.px;
+ g.tagline_width = tag.width;
+ g.tagline_height = tag.height;
+ g.tagline_baseline = tag.baseline;
+ g.atlas_stage = try std.testing.allocator.alloc(u8, atlas_w * atlas_h);
+ g.glyphs = std.AutoHashMap(GlyphKey, Slot).init(std.testing.allocator);
+ g.words = .{};
+ resetGlyphAtlas(&g);
+ return g;
+}
+
+fn textTestLine(comptime text: []const u8) [text.len]pardes.Cell {
+ var line: [text.len]pardes.Cell = @splat(.{ .default = false });
+ for (&line, text) |*cell, byte| cell.text[0] = byte;
+ return line;
}
-fn cachedGlyph(g: *Gui, cp: u32, role: pardes.FontRole, decoration: GlyphDecoration, centered: bool) ?Slot {
- const key: GlyphKey = .{ .codepoint = cp, .role = role, .decoration = decoration, .centered = centered };
- const slot_w = g.cell_w * @as(u32, if (centered) config.GUTTER else 1);
+test "a ligature draws across its cells, one slice each, and comes apart under the cursor" {
+ const bytes = try filesystem.readFile(std.testing.allocator, "assets/MapleMono-NF-Regular.ttf");
+ defer std.testing.allocator.free(bytes);
+ const font = c.ui_font_new(bytes.ptr, @intCast(bytes.len)) orelse return error.FontInit;
+ defer c.ui_font_free(font);
+ var g = try textTestGui(font, 27);
+ defer font_allocator = std.heap.smp_allocator;
+ defer std.testing.allocator.free(g.atlas_stage);
+ defer g.glyphs.deinit();
+ defer g.words.deinit(std.testing.allocator);
+
+ const line = textTestLine("a->b");
+ var slots: [4]Slot = undefined;
+ for (&slots, 0..) |*slot, i| slot.* = cellSlot(&g, &line, i, null, .body);
+ // `->` is one glyph strip two cells wide: each cell samples its own half.
+ try std.testing.expectEqual(slots[1].v, slots[2].v);
+ try std.testing.expectEqual(slots[1].u + g.cell_w, slots[2].u);
+ var strips: usize = 0;
+ var it = g.glyphs.iterator();
+ while (it.next()) |entry| if (entry.key_ptr.span == 2) {
+ strips += 1;
+ try std.testing.expectEqual(@as(u4, 1), entry.key_ptr.lead);
+ try std.testing.expectEqual(slots[1], entry.value_ptr.*);
+ };
+ try std.testing.expectEqual(@as(usize, 1), strips);
+ // The arrow runs through the seam: both halves carry ink at it.
+ const seam = g.atlas_stage[@as(usize, slots[2].v) * atlas_w ..];
+ var left_ink: usize = 0;
+ var right_ink: usize = 0;
+ for (0..g.cell_h) |y| {
+ left_ink += seam[y * atlas_w + slots[2].u - 1];
+ right_ink += seam[y * atlas_w + slots[2].u];
+ }
+ try std.testing.expect(left_ink > 0 and right_ink > 0);
+ // `a` and `b` are their plain glyphs.
+ try std.testing.expectEqual(g.glyphs.get(.{ .face = 0, .glyph = c.ui_font_glyph(font, 'a'), .role = .body }).?, slots[0]);
+ try std.testing.expectEqual(g.glyphs.get(.{ .face = 0, .glyph = c.ui_font_glyph(font, 'b'), .role = .body }).?, slots[3]);
+
+ // A second line with the same word reuses the shaped slots.
+ const again = textTestLine("a->b");
+ const text_len = g.words.text.items.len;
+ for (0..4) |i| try std.testing.expectEqual(slots[i], cellSlot(&g, &again, i, null, .body));
+ try std.testing.expectEqual(text_len, g.words.text.items.len);
+
+ // The cursor on either half shows plain `-` and `>`.
+ const plain_minus = cachedGlyph(&g, .{ .face = 0, .glyph = c.ui_font_glyph(font, '-'), .role = .body }).?;
+ const plain_greater = cachedGlyph(&g, .{ .face = 0, .glyph = c.ui_font_glyph(font, '>'), .role = .body }).?;
+ for ([_]usize{ 1, 2 }) |cursor| {
+ try std.testing.expectEqual(plain_minus, cellSlot(&g, &line, 1, cursor, .body));
+ try std.testing.expectEqual(plain_greater, cellSlot(&g, &line, 2, cursor, .body));
+ }
+ // A tagline is never shaped.
+ try std.testing.expectEqual(c.ui_font_glyph(font, '-'), (try glyphKeyAt(&g, cellSlot(&g, &line, 1, null, .tagline))).glyph);
+}
+
+test "Ligatures off draws a ligature as its cells' own glyphs, and on shapes it again" {
+ const bytes = try filesystem.readFile(std.testing.allocator, "assets/MapleMono-NF-Regular.ttf");
+ defer std.testing.allocator.free(bytes);
+ const font = c.ui_font_new(bytes.ptr, @intCast(bytes.len)) orelse return error.FontInit;
+ defer c.ui_font_free(font);
+ var g = try textTestGui(font, 27);
+ defer font_allocator = std.heap.smp_allocator;
+ defer std.testing.allocator.free(g.atlas_stage);
+ defer g.glyphs.deinit();
+ defer g.words.deinit(std.testing.allocator);
+ const core = try pardes.Pardes.init(std.testing.allocator, .{ .cols = 80, .rows = 24 });
+ defer core.deinit();
+
+ const text = "a->b";
+ const line = textTestLine(text);
+ var shaped: [text.len]Slot = undefined;
+ for (&shaped, 0..) |*slot, i| slot.* = cellSlot(&g, &line, i, null, .body);
+ try std.testing.expectEqual(shaped[1].u + g.cell_w, shaped[2].u);
+
+ // Off, every cell is the slot the per-glyph path gives its codepoint.
+ try std.testing.expect(core.executeBuiltinLine(core.active, "Ligatures off"));
+ syncLigatures(&g, core);
+ for (text, 0..) |byte, i| {
+ const plain = cachedGlyph(&g, .{ .face = 0, .glyph = c.ui_font_glyph(font, byte), .role = .body }).?;
+ try std.testing.expectEqual(plain, cellSlot(&g, &line, i, null, .body));
+ }
+ try std.testing.expect(!std.meta.eql(shaped[1], cellSlot(&g, &line, 1, null, .body)));
+
+ // On again, the arrow is its strip once more.
+ try std.testing.expect(core.executeBuiltinLine(core.active, "Ligatures on"));
+ syncLigatures(&g, core);
+ for (shaped, 0..) |slot, i| try std.testing.expectEqual(slot, cellSlot(&g, &line, i, null, .body));
+}
+
+fn glyphKeyAt(g: *Gui, slot: Slot) !GlyphKey {
+ var it = g.glyphs.iterator();
+ while (it.next()) |entry| if (std.meta.eql(entry.value_ptr.*, slot)) return entry.key_ptr.*;
+ return error.NoGlyph;
+}
+
+test "a font without ligatures draws every cell as its own glyph, exactly as before shaping" {
+ const font = c.ui_font_new(font_ttf.ptr, @intCast(font_ttf.len)).?;
+ defer c.ui_font_free(font);
+ var g = try textTestGui(font, 18);
+ defer font_allocator = std.heap.smp_allocator;
+ defer std.testing.allocator.free(g.atlas_stage);
+ defer g.glyphs.deinit();
+ defer g.words.deinit(std.testing.allocator);
+ const text = "a->b != c => d <= e |> www == :: 0x1F";
+ var line = textTestLine(text);
+ line[3].style.bold = true; // a style change inside a word
+ var expected: [64 * 64]u8 = undefined;
+ for (line, 0..) |cell, i| {
+ if (text[i] == ' ') continue;
+ const slot = cellSlot(&g, &line, i, null, .body);
+ const key = try glyphKeyAt(&g, slot);
+ try std.testing.expectEqual(c.ui_font_glyph(font, text[i]), key.glyph);
+ try std.testing.expectEqual(@as(u4, 1), key.span);
+ _ = c.ui_font_raster(font, 18, key.glyph, @intFromBool(cell.style.bold), &expected, 64, @intCast(g.cell_w), @intCast(g.cell_h), 0, @intCast(g.cell_w), g.ascent);
+ for (0..g.cell_h) |y|
+ try std.testing.expectEqualSlices(u8, expected[y * 64 ..][0..g.cell_w], g.atlas_stage[(slot.v + y) * atlas_w + slot.u ..][0..g.cell_w]);
+ }
+}
+
+/// The atlas slot of `key`, rasterized on first use. A strip is `span` cells
+/// wide (a grip glyph GUTTER cells, centered); a cell samples its slice of it.
+/// Null when the atlas is full.
+fn cachedGlyph(g: *Gui, key: GlyphKey) ?Slot {
if (g.glyphs.get(key)) |s| return s;
+ const slot_w = g.cell_w * @as(u32, if (key.centered) config.GUTTER else key.span);
if (g.pen_x + slot_w > atlas_w) {
g.pen_x = 0;
g.pen_y += g.cell_h;
}
if (g.pen_y + g.cell_h > atlas_h) return null; // atlas full: fall back
+ const probe_raster = monoNs();
+ defer if (frame_probe) |probe| {
+ probe.zone(.gui_raster, probe_raster);
+ probe.rastered +|= 1;
+ };
const s = Slot{ .u = g.pen_x, .v = g.pen_y };
const out = g.atlas_stage.ptr + @as(usize, s.v) * atlas_w + s.u;
- const face = fontForCodepoint(g, cp);
- const scale = if (role == .tagline) g.tagline_scale else g.scale;
- const baseline = if (role == .tagline) g.tagline_baseline else g.ascent;
- const raster_w = if (centered) slot_w else if (role == .tagline) g.tagline_width else g.cell_w;
- const raster_h = if (role == .tagline) g.tagline_height else g.cell_h;
- if (centered) {
- _ = c.ui_font_raster_centered(face, scale, @intCast(cp), out, @intCast(atlas_w), @intCast(raster_w), @intCast(raster_h));
+ const face = if (key.face == 0) g.font else g.fallbacks[key.face - 1].?.face;
+ const px = if (key.role == .tagline) g.tagline_px else g.px;
+ const baseline = if (key.role == .tagline) g.tagline_baseline else g.ascent;
+ const cell_w = if (key.role == .tagline) g.tagline_width else g.cell_w;
+ const raster_w = if (key.centered) slot_w else cell_w * key.span;
+ const raster_h = if (key.role == .tagline) g.tagline_height else g.cell_h;
+ const bold = @intFromBool(key.decoration.bold);
+ if (key.rule) {
+ drawRule(out, atlas_w, raster_w, raster_h, ruleArms(key.glyph).?);
+ } 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, scale, @intCast(cp), out, @intCast(atlas_w), @intCast(raster_w), @intCast(raster_h), baseline);
+ _ = 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);
}
- decorateGlyph(out, atlas_w, raster_w, raster_h, baseline, decoration);
- if (centered) centerGlyphInk(out, raster_w, raster_h);
+ decorateLine(out, atlas_w, raster_w, raster_h, baseline, key.decoration);
+ if (key.centered) centerGlyphInk(out, raster_w, raster_h);
+ g.atlas_dirty_top = @min(g.atlas_dirty_top, s.v);
+ g.atlas_dirty_bottom = @max(g.atlas_dirty_bottom, s.v + raster_h);
g.glyphs.put(key, s) catch return null;
g.pen_x += slot_w;
- g.atlas_dirty = true;
return s;
}
@@ -5868,23 +8075,25 @@ test "pane indicator cached ink centers bearings styles and sizes" {
defer std.testing.allocator.free(g.atlas_stage);
g.glyphs = std.AutoHashMap(GlyphKey, Slot).init(std.testing.allocator);
defer g.glyphs.deinit();
+ g.words = .{};
for ([_]f32{ 13, 27, 40 }) |px| {
- g.scale = c.ui_font_scale_for_height(font, px);
+ g.px = px;
var cw: c_int = 0;
var ch: c_int = 0;
- c.ui_font_cell_metrics(font, g.scale, &cw, &ch, &g.ascent);
+ c.ui_font_cell_metrics(font, px, &cw, &ch, &g.ascent);
g.cell_w = @intCast(cw);
g.cell_h = @intCast(ch);
for ([_]u8{ 40, 82, 100 }) |percent| {
const tag = taglineRaster(font, px, g.cell_w, g.cell_h, percent);
g.tagline_width = tag.width;
g.tagline_height = tag.height;
- g.tagline_scale = tag.scale;
+ g.tagline_px = tag.px;
g.tagline_baseline = tag.baseline;
resetGlyphAtlas(&g);
try std.testing.expectEqual(@as(usize, 0), g.glyphs.count());
for ([_]u32{ '^', '$', 'j' }) |cp| for ([_]bool{ false, true }) |bold| {
- const slot = cachedGlyph(&g, cp, .tagline, .{ .bold = bold }, true).?;
+ const key: GlyphKey = .{ .face = 0, .glyph = c.ui_font_glyph(font, @intCast(cp)), .role = .tagline, .decoration = .{ .bold = bold }, .centered = true };
+ const slot = cachedGlyph(&g, key).?;
const bounds = inkBounds(g.atlas_stage[@as(usize, slot.v) * atlas_w + slot.u ..], atlas_w, g.cell_w * config.GUTTER, tag.height).?;
const center_x: isize = @intCast(bounds.min_x + bounds.max_x);
const center_y: isize = @intCast(bounds.min_y + bounds.max_y);
@@ -5892,7 +8101,7 @@ test "pane indicator cached ink centers bearings styles and sizes" {
try std.testing.expect(@abs(center_y - @as(isize, @intCast(tag.height - 1))) <= 1);
const count = g.glyphs.count();
const pen = g.pen_x;
- try std.testing.expectEqualDeep(slot, cachedGlyph(&g, cp, .tagline, .{ .bold = bold }, true).?);
+ try std.testing.expectEqualDeep(slot, cachedGlyph(&g, key).?);
try std.testing.expectEqual(count, g.glyphs.count());
try std.testing.expectEqual(pen, g.pen_x);
};
@@ -5900,7 +8109,7 @@ test "pane indicator cached ink centers bearings styles and sizes" {
}
resetGlyphAtlas(&g);
g.pen_y = atlas_h;
- try std.testing.expectEqual(@as(?Slot, null), cachedGlyph(&g, '^', .tagline, .{}, true));
+ try std.testing.expectEqual(@as(?Slot, null), cachedGlyph(&g, .{ .face = 0, .glyph = c.ui_font_glyph(font, '^'), .role = .tagline, .centered = true }));
}
test "pane indicator halves share dissolve changes and safe exhausted atlas" {
@@ -5908,19 +8117,32 @@ test "pane indicator halves share dissolve changes and safe exhausted atlas" {
cells[0].text[0] = '$';
var previous = cells;
previous[0].text[0] = '^';
- var layers = [_]pardes.TagLayer{.{ .kind = .pane, .serial = 1, .viewport = .{ .x = pardes.TAG_TEXT_INSET, .y = 0, .w = 3, .h = 1 }, .cols = 3 }};
var diffs: [12]pardes.PanelCellDiff = @splat(.unchanged);
diffs[0] = pardes.PanelCellDiff.between(&previous[0], &cells[0]);
- var surface: pardes.Surface = .{ .cols = 6, .rows = 2, .cells = &cells, .previous_cells = &previous, .previous_tag_layers = &layers, .cell_diffs = &diffs };
- surface.tag_layers[0] = layers[0];
- try std.testing.expect(gripCellChanged(&surface, 0, 0));
- try std.testing.expect(gripCellChanged(&surface, 1, 0));
- try std.testing.expect(!gripCellChanged(&surface, 2, 0));
- try std.testing.expect(paneGripCell(surface.tagLayers(), &cells, 6, 2, 0) == null);
- layers[0].kind = .column;
- try std.testing.expect(paneGripCell(&layers, &cells, 6, 0, 0) == null);
+ const surface: pardes.Surface = .{ .cols = 6, .rows = 2, .cells = &cells, .previous_cells = &previous, .cell_diffs = &diffs };
+ // A grip two cells wide at the top left, in both frames.
+ const grip = [_]pardes.Region{.{ .kind = .grip, .serial = 1, .rect = .{ .x = 0, .y = 0, .w = 2, .h = 1 } }};
+ var cover: [12]Cover = undefined;
+ var previous_cover: [12]Cover = undefined;
+ coverFrame(&cover, 6, 2, &.{}, &.{}, &grip);
+ coverFrame(&previous_cover, 6, 2, &.{}, &.{}, &grip);
+ try std.testing.expect(gripCellChanged(&surface, &cover, &previous_cover, 0, 0));
+ try std.testing.expect(gripCellChanged(&surface, &cover, &previous_cover, 1, 0));
+ try std.testing.expect(!gripCellChanged(&surface, &cover, &previous_cover, 2, 0));
+ try std.testing.expect(!cover[2].grip);
+ // A column's grip is a button too, cut the same way (it has no glyph).
+ coverFrame(&cover, 6, 2, &.{}, &.{}, &.{.{ .kind = .column_grip, .rect = .{ .x = 0, .y = 0, .w = 2, .h = 1 } }});
+ try std.testing.expect(cover[0].grip);
+ coverFrame(&cover, 6, 2, &.{}, &.{}, &grip);
+ const chrome: pardes.Chrome = .{};
+ const font = c.ui_font_new(font_ttf.ptr, @intCast(font_ttf.len)).?;
+ defer c.ui_font_free(font);
var g: Gui = undefined;
+ g.font = font;
+ g.fallback_count = 0;
+ g.px = 20;
+ g.tagline_px = 16;
g.cell_w = 10;
g.cell_h = 20;
g.tagline_width = 8;
@@ -5930,11 +8152,13 @@ test "pane indicator halves share dissolve changes and safe exhausted atlas" {
g.pen_y = atlas_h;
g.glyphs = std.AutoHashMap(GlyphKey, Slot).init(std.testing.allocator);
defer g.glyphs.deinit();
+ g.words = .{};
+ defer g.words.deinit(std.testing.allocator);
for ([_]bool{ false, true }) |old| {
var instances: [4]CellInstance = undefined;
var next: u32 = 0;
for (0..2) |col| {
- emitSurfaceCell(&g, null, &instances, &next, @intCast(col), 0, fixedCellLayout(&g), 100, 100, null, &cells[col], &cells[2], .{ .cell = &cells[0], .offset = @intCast(col) }, old, false, Ground.opaqueRgb(bg_default));
+ emitSurfaceCell(&g, &chrome, &instances, &next, @intCast(col), 0, fixedCellLayout(&g), 100, 100, null, cells[0..6], cover[0..6], col, null, old, false, Ground.opaqueRgb(bg_default));
try std.testing.expectEqual(@as(f32, 0), instances[col * 2 + 1].u0);
try std.testing.expectEqual(old, instances[col * 2 + 1].effect & old_layer_bit != 0);
}
@@ -5942,51 +8166,63 @@ test "pane indicator halves share dissolve changes and safe exhausted atlas" {
}
}
-// Decorations 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.
-fn decorateGlyph(out: [*]u8, stride: usize, width: usize, height: usize, baseline: i32, decoration: GlyphDecoration) void {
+// 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: GlyphDecoration) void {
if (width == 0 or height == 0) return;
- if (decoration.bold) {
- // A fractional one-pixel embolden preserves counters at small UI sizes.
- // Right-to-left traversal reads the original left neighbour each time.
- for (0..height) |y| {
- var x = width - 1;
- while (x > 0) : (x -= 1) {
- const previous = out[y * stride + x - 1];
- const target = &out[y * stride + x];
- target.* = @max(target.*, @as(u8, @intCast(@as(u16, previous) * 3 / 4)));
- }
- }
- }
+ // A line is a logical pixel thick, its dots and waves as long: the same
+ // weight at any density (dp).
+ const t: usize = @intFromFloat(dp(1));
if (decoration.underline != .off) {
const base: usize = @intCast(@max(0, baseline));
- const row = @min(base + 1, height - 1);
+ const row = @min(base + 1, height -| t);
for (0..width) |x| {
- switch (decoration.underline) {
+ const top = switch (decoration.underline) {
.off => unreachable,
- .single => out[row * stride + x] = 255,
+ .single => row,
.double => {
- const upper = @min(base + 1, height -| 3);
- out[upper * stride + x] = 255;
- out[@min(upper + 2, height - 1) * stride + x] = 255;
- },
- .curly => out[(row -| @as(usize, if (x % 4 < 2) 1 else 0)) * stride + x] = 255,
- .dotted => if (x % 3 == 0) {
- out[row * stride + x] = 255;
- },
- .dashed => if (x % 6 < 4) {
- out[row * stride + x] = 255;
+ 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 - 1, @as(usize, @intCast(@max(0, baseline))) * 2 / 3);
- @memset(out[row * stride ..][0..width], 255);
+ 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);
}
}
+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).?);
+ // ┼: 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).?);
+ 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;
@@ -6001,7 +8237,7 @@ test "glyph decorations render spaces and stay inside their atlas slot" {
}) |decoration| {
var mask: [stride * (height + 1)]u8 = @splat(0xa5);
for (0..height) |y| @memset(mask[y * stride ..][0..width], 0);
- decorateGlyph(&mask, stride, width, height, 5, decoration);
+ decorateLine(&mask, stride, width, height, 5, decoration);
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);
@@ -6011,18 +8247,69 @@ test "glyph decorations render spaces and stay inside their atlas slot" {
try std.testing.expect(!GlyphDecoration.fromCell(&hidden).drawsBlank());
}
+/// Uploads only the atlas rows drawn into since the last upload. Glyphs fill
+/// the atlas pen-style, a band of rows at a time, so new glyphs are a band a
+/// cell or two tall, not the whole 4 MB texture. The band sits at the same
+/// offset in the transfer buffer as in the stage, and the texture keeps the
+/// rows outside it.
fn uploadAtlas(g: *Gui, cmd: *c.SDL_GPUCommandBuffer) void {
+ const top = g.atlas_dirty_top;
+ const rows = g.atlas_dirty_bottom - top;
const ptr = c.SDL_MapGPUTransferBuffer(g.device, g.atlas_xfer, false) orelse return;
const dst: [*]u8 = @ptrCast(ptr);
- @memcpy(dst[0 .. atlas_w * atlas_h], g.atlas_stage);
+ @memcpy(dst[top * atlas_w ..][0 .. rows * atlas_w], g.atlas_stage[top * atlas_w ..][0 .. rows * atlas_w]);
c.SDL_UnmapGPUTransferBuffer(g.device, g.atlas_xfer);
const copy = c.SDL_BeginGPUCopyPass(cmd);
- const src = c.SDL_GPUTextureTransferInfo{ .transfer_buffer = g.atlas_xfer, .offset = 0, .pixels_per_row = atlas_w, .rows_per_layer = atlas_h };
- const dstregion = c.SDL_GPUTextureRegion{ .texture = g.atlas_tex, .mip_level = 0, .layer = 0, .x = 0, .y = 0, .z = 0, .w = atlas_w, .h = atlas_h, .d = 1 };
+ const src = c.SDL_GPUTextureTransferInfo{ .transfer_buffer = g.atlas_xfer, .offset = top * atlas_w, .pixels_per_row = atlas_w, .rows_per_layer = rows };
+ const dstregion = c.SDL_GPUTextureRegion{ .texture = g.atlas_tex, .mip_level = 0, .layer = 0, .x = 0, .y = top, .z = 0, .w = atlas_w, .h = rows, .d = 1 };
c.SDL_UploadToGPUTexture(copy, &src, &dstregion, false);
c.SDL_EndGPUCopyPass(copy);
- g.atlas_dirty = false;
+ g.atlas_dirty_top = atlas_h;
+ g.atlas_dirty_bottom = 0;
+}
+
+test "the atlas's dirty rows hold every row a new glyph draws into, and a reset dirties them all" {
+ const font = c.ui_font_new(font_ttf.ptr, @intCast(font_ttf.len)).?;
+ defer c.ui_font_free(font);
+ var g = try textTestGui(font, 18);
+ defer font_allocator = std.heap.smp_allocator;
+ defer std.testing.allocator.free(g.atlas_stage);
+ defer g.glyphs.deinit();
+ defer g.words.deinit(std.testing.allocator);
+ // The texture as uploadAtlas 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) resetGlyphAtlas(&g); // a font change
+ // Plain glyphs, strips, taglines, grip glyphs and decorations.
+ for (0..25) |_| {
+ glyph += 1;
+ const span: u4 = @intCast(1 + glyph % 3);
+ _ = cachedGlyph(&g, .{
+ .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,
+ }) orelse return error.AtlasFull;
+ }
+ for (0..atlas_h) |row| {
+ const stage = g.atlas_stage[row * atlas_w ..][0..atlas_w];
+ const uploaded = texture[row * atlas_w ..][0..atlas_w];
+ if (row >= g.atlas_dirty_top and row < g.atlas_dirty_bottom)
+ @memcpy(uploaded, stage)
+ else
+ try std.testing.expect(std.mem.eql(u8, stage, uploaded));
+ }
+ g.atlas_dirty_top = atlas_h;
+ g.atlas_dirty_bottom = 0;
+ }
+ try std.testing.expect(g.pen_y >= 2 * g.cell_h);
}
fn ensureVbuf(g: *Gui, cells: u32) !void {
@@ -6048,10 +8335,12 @@ fn ensureVbuf(g: *Gui, cells: u32) !void {
g.vbuf_cells = capacity;
}
-fn makePipeline(device: *c.SDL_GPUDevice, color_format: c.SDL_GPUTextureFormat) !*c.SDL_GPUGraphicsPipeline {
+/// A pipeline over cell instances: the cells' own (ui.frag, the atlas, no
+/// blending) or the decor's (decor.frag, blended like the overlay).
+fn makePipeline(device: *c.SDL_GPUDevice, color_format: c.SDL_GPUTextureFormat, frag: []const u8, samplers: u32, blend: c.SDL_GPUColorTargetBlendState) !*c.SDL_GPUGraphicsPipeline {
const vs = try makeShader(device, vert_spv, c.SDL_GPU_SHADERSTAGE_VERTEX, 0, 0);
defer c.SDL_ReleaseGPUShader(device, vs);
- const fs = try makeShader(device, frag_spv, c.SDL_GPU_SHADERSTAGE_FRAGMENT, 1, 1);
+ const fs = try makeShader(device, frag, c.SDL_GPU_SHADERSTAGE_FRAGMENT, samplers, 1);
defer c.SDL_ReleaseGPUShader(device, fs);
var vbuf_desc = c.SDL_GPUVertexBufferDescription{
@@ -6068,8 +8357,9 @@ fn makePipeline(device: *c.SDL_GPUDevice, color_format: c.SDL_GPUTextureFormat)
.{ .location = 4, .buffer_slot = 0, .format = c.SDL_GPU_VERTEXELEMENTFORMAT_FLOAT4, .offset = @offsetOf(CellInstance, "panel_x0") },
.{ .location = 5, .buffer_slot = 0, .format = c.SDL_GPU_VERTEXELEMENTFORMAT_FLOAT4, .offset = @offsetOf(CellInstance, "present_x0") },
.{ .location = 6, .buffer_slot = 0, .format = c.SDL_GPU_VERTEXELEMENTFORMAT_UINT4, .offset = @offsetOf(CellInstance, "effect") },
+ .{ .location = 7, .buffer_slot = 0, .format = c.SDL_GPU_VERTEXELEMENTFORMAT_FLOAT4, .offset = @offsetOf(CellInstance, "clip_x0") },
};
- var col_desc = c.SDL_GPUColorTargetDescription{ .format = color_format, .blend_state = std.mem.zeroes(c.SDL_GPUColorTargetBlendState) };
+ var col_desc = c.SDL_GPUColorTargetDescription{ .format = color_format, .blend_state = blend };
var info = std.mem.zeroes(c.SDL_GPUGraphicsPipelineCreateInfo);
info.vertex_shader = vs;
@@ -6088,6 +8378,20 @@ fn makePipeline(device: *c.SDL_GPUDevice, color_format: c.SDL_GPUTextureFormat)
return c.SDL_CreateGPUGraphicsPipeline(device, &info) orelse error.GpuCreate;
}
+/// Premultiplied over: an opaque cell writes itself exactly, a see-through
+/// one only its ink.
+fn premultipliedBlend() c.SDL_GPUColorTargetBlendState {
+ var blend = std.mem.zeroes(c.SDL_GPUColorTargetBlendState);
+ blend.src_color_blendfactor = c.SDL_GPU_BLENDFACTOR_ONE;
+ 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_ONE;
+ 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 backgroundLayerBlend() c.SDL_GPUColorTargetBlendState {
var blend = std.mem.zeroes(c.SDL_GPUColorTargetBlendState);
blend.src_color_blendfactor = c.SDL_GPU_BLENDFACTOR_SRC_ALPHA;
@@ -6186,25 +8490,7 @@ fn makeImagePipeline(device: *c.SDL_GPUDevice, color_format: c.SDL_GPUTextureFor
return c.SDL_CreateGPUGraphicsPipeline(device, &info) orelse error.GpuCreate;
}
-fn makeCrtPipeline(device: *c.SDL_GPUDevice, color_format: c.SDL_GPUTextureFormat) !*c.SDL_GPUGraphicsPipeline {
- const vs = try makeShader(device, crt_vert_spv, c.SDL_GPU_SHADERSTAGE_VERTEX, 0, 0);
- defer c.SDL_ReleaseGPUShader(device, vs);
- const fs = try makeShader(device, crt_frag_spv, c.SDL_GPU_SHADERSTAGE_FRAGMENT, 1, 1);
- defer c.SDL_ReleaseGPUShader(device, fs);
-
- var col_desc = c.SDL_GPUColorTargetDescription{ .format = color_format, .blend_state = std.mem.zeroes(c.SDL_GPUColorTargetBlendState) };
- var info = std.mem.zeroes(c.SDL_GPUGraphicsPipelineCreateInfo);
- info.vertex_shader = vs;
- info.fragment_shader = fs;
- info.primitive_type = c.SDL_GPU_PRIMITIVETYPE_TRIANGLELIST;
- 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;
-}
-
-fn makeShader(device: *c.SDL_GPUDevice, code: []const u8, stage: c.SDL_GPUShaderStage, n_samplers: u32, n_uniform_buffers: u32) !*c.SDL_GPUShader {
+pub 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;
@@ -6330,21 +8616,31 @@ fn softPresentFrame(g: *Gui, cmd: *c.SDL_GPUCommandBuffer, target: *c.SDL_GPUTex
const fence = c.SDL_SubmitGPUCommandBufferAndAcquireFence(cmd) orelse return error.GpuSubmit;
defer c.SDL_ReleaseGPUFence(g.device, fence);
var fences = [_]*c.SDL_GPUFence{fence};
+ const probe_wait = monoNs();
if (!c.SDL_WaitForGPUFences(g.device, true, &fences, 1)) return error.GpuSubmit;
+ if (frame_probe) |probe| probe.zone(.gui_wait, probe_wait);
const mapped = c.SDL_MapGPUTransferBuffer(g.device, xfer, false) orelse return error.GpuMap;
defer c.SDL_UnmapGPUTransferBuffer(g.device, xfer);
const texture = try ensureSoftTexture(g, sw, sh);
const renderer = g.soft_renderer orelse return error.GpuCreate;
+ const probe_upload = monoNs();
+ defer if (frame_probe) |probe| probe.zone(.gui_upload, probe_upload);
if (!c.SDL_UpdateTexture(texture, null, mapped, @intCast(sw * bpp))) return error.GpuMap;
+ // PARDES_FRAMES_CAPTURE: every presented frame's pixels as they went
+ // out, and when, for a recording at the frames' own times (the
+ // samples of docs/next-anim.md). One write a frame; nothing else.
+ if (frame_capture_dir) |dir| captureSeries(dir, @as([*]const u8, @ptrCast(mapped))[0..size], sw, sh);
// The cell shader already produced premultiplied backgrounds with opaque
// foreground ink. Copy that alpha unchanged; never modulate the full frame.
_ = c.SDL_SetRenderDrawBlendMode(renderer, c.SDL_BLENDMODE_NONE);
- _ = c.SDL_SetRenderDrawColor(renderer, 0, 0, 0, if (g.transparent or g.surface_opacity) 0 else 255);
+ _ = c.SDL_SetRenderDrawColor(renderer, 0, 0, 0, if (g.surface_opacity) 0 else 255);
_ = c.SDL_RenderClear(renderer);
_ = c.SDL_RenderTexture(renderer, texture, null, null);
+ const probe_flip = monoNs();
_ = c.SDL_RenderPresent(renderer);
+ if (frame_probe) |probe| probe.zone(.gui_flip, probe_flip);
}
fn backgroundOpacity(percent: u8) f32 {
@@ -6361,7 +8657,30 @@ test "background opacity retains exact endpoints and percentage precision" {
}
}
-fn captureFrame(g: *Gui, gpa: std.mem.Allocator, cmd: *c.SDL_GPUCommandBuffer, target: *c.SDL_GPUTexture, sw: u32, sh: u32) !void {
+/// PARDES_TEST_LATENCY trace for an external driver, CLOCK_MONOTONIC ns:
+/// `R t` when stdin input is read, `F start fence submit` per captured frame
+/// (present entry, the GPU fence of that frame, and its submission: submit -
+/// start is the frame's CPU cost). Nothing is written without it.
+var latency_fd: c_int = -1;
+var frame_started_ns: u64 = 0;
+
+fn monoNs() u64 {
+ var ts: libc.timespec = undefined;
+ if (libc.clock_gettime(.MONOTONIC, &ts) != 0) return 0;
+ return @as(u64, @intCast(ts.sec)) * std.time.ns_per_s + @as(u64, @intCast(ts.nsec));
+}
+
+fn latencyNote(comptime fmt: []const u8, args: anytype) void {
+ if (latency_fd < 0) return;
+ var buf: [64]u8 = undefined;
+ const line = std.fmt.bufPrint(&buf, fmt, args) catch return;
+ _ = libc.write(latency_fd, line.ptr, line.len);
+}
+
+/// Writes the frame to latest.ppm in the capture directory, and a panel
+/// transition's frame `transition` to transition-<frame>.ppm too, so a test
+/// can hold one partway (test/gui_golden.py).
+fn captureFrame(g: *Gui, gpa: std.mem.Allocator, cmd: *c.SDL_GPUCommandBuffer, target: *c.SDL_GPUTexture, sw: u32, sh: u32, transition: ?u16) !void {
const size = c.SDL_CalculateGPUTextureFormatSize(g.swapchain_format, sw, sh, 1);
if (size == 0) {
_ = c.SDL_SubmitGPUCommandBuffer(cmd);
@@ -6384,19 +8703,54 @@ fn captureFrame(g: *Gui, gpa: std.mem.Allocator, cmd: *c.SDL_GPUCommandBuffer, t
c.SDL_DownloadFromGPUTexture(copy, &src, &dst);
c.SDL_EndGPUCopyPass(copy);
+ const submit_ns = monoNs();
const fence = c.SDL_SubmitGPUCommandBufferAndAcquireFence(cmd) orelse return error.GpuSubmit;
defer c.SDL_ReleaseGPUFence(g.device, fence);
var fences = [_]*c.SDL_GPUFence{fence};
if (!c.SDL_WaitForGPUFences(g.device, true, &fences, 1)) return error.GpuSubmit;
+ latencyNote("F {d} {d} {d}\n", .{ frame_started_ns, monoNs(), submit_ns });
const mapped = c.SDL_MapGPUTransferBuffer(g.device, xfer, false) orelse return error.GpuMap;
defer c.SDL_UnmapGPUTransferBuffer(g.device, xfer);
const pixels: [*]const u8 = @ptrCast(mapped);
- try writeCapturePpm(g, gpa, pixels[0..size], sw, sh);
+ try writeCapturePpm(g, gpa, pixels[0..size], sw, sh, "latest");
+ var name: [24]u8 = undefined;
+ // unreachable below: "transition-" or "frame-" and a u32 fit 24
+ if (transition) |frame| try writeCapturePpm(g, gpa, pixels[0..size], sw, sh, std.fmt.bufPrint(&name, "transition-{d}", .{frame}) catch unreachable);
+ if (g.capture_series) try writeCapturePpm(g, gpa, pixels[0..size], sw, sh, std.fmt.bufPrint(&name, "frame-{d:0>5}", .{g.captured}) catch unreachable);
+ g.captured +%= 1;
}
-fn writeCapturePpm(g: *Gui, gpa: std.mem.Allocator, pixels: []const u8, width: u32, height: u32) !void {
+/// A test window's state for a harness (test/gui_golden.py), in the
+/// capture directory's `status`: "<loop step> <frames captured> <idle>".
+/// Idle is 1 once the frame last captured is the one that stays: nothing
+/// owes a frame, nothing moves, nothing waits on a clock. A harness that
+/// sees a step past the one it acted on, idle, has its frame, however slow
+/// the machine is.
+var test_status_step: u64 = 0;
+fn writeTestStatus(g: *const Gui, core: *const pardes.Pardes, presented: bool) void {
+ test_status_step +%= 1;
if (g.capture_dir.len == 0) return;
+ const idle = presented and !core.needs_frame and !core.continuous() and core.nextWake() == null and
+ !g.glide.moving() and g.scroll_lag == 0 and g.scroll_delta == 0 and g.scroll_notch == 0;
+ var line_buf: [64]u8 = undefined;
+ // What keeps it busy, after: owes a frame, moves, waits, not shown.
+ const line = std.fmt.bufPrint(&line_buf, "{d} {d} {d} {d}{d}{d}{d}\n", .{ test_status_step, g.captured, @intFromBool(idle), @intFromBool(core.needs_frame), @intFromBool(core.continuous()), @intFromBool(core.nextWake() != null), @intFromBool(!presented) }) catch return;
+ var tmp_buf: [4096]u8 = undefined;
+ var final_buf: [4096]u8 = undefined;
+ const tmp_path = std.fmt.bufPrintSentinel(&tmp_buf, "{s}/status.tmp", .{g.capture_dir}, 0) catch return;
+ const final_path = std.fmt.bufPrintSentinel(&final_buf, "{s}/status", .{g.capture_dir}, 0) catch return;
+ const fd = libc.open(tmp_path, .{ .ACCMODE = .WRONLY, .CREAT = true, .TRUNC = true }, @as(libc.mode_t, 0o644));
+ if (fd < 0) return;
+ _ = libc.write(fd, line.ptr, line.len);
+ _ = libc.close(fd);
+ _ = libc.rename(tmp_path, final_path);
+}
+
+fn writeCapturePpm(g: *Gui, gpa: std.mem.Allocator, pixels: []const u8, width: u32, height: u32, name: []const u8) !void {
+ // A latency trace times frames, and an 8 MB file write per frame would
+ // stall the loop it is timing.
+ if (g.capture_dir.len == 0 or latency_fd >= 0) return;
const bpp = c.SDL_GPUTextureFormatTexelBlockSize(g.swapchain_format);
if (bpp != 4) return error.UnsupportedCaptureFormat;
const bgr = switch (g.swapchain_format) {
@@ -6407,8 +8761,8 @@ fn writeCapturePpm(g: *Gui, gpa: std.mem.Allocator, pixels: []const u8, width: u
var tmp_buf: [4096]u8 = undefined;
var final_buf: [4096]u8 = undefined;
- const tmp_path = std.fmt.bufPrintSentinel(&tmp_buf, "{s}/latest.ppm.tmp", .{g.capture_dir}, 0) catch return error.CapturePathTooLong;
- const final_path = std.fmt.bufPrintSentinel(&final_buf, "{s}/latest.ppm", .{g.capture_dir}, 0) catch return error.CapturePathTooLong;
+ const tmp_path = std.fmt.bufPrintSentinel(&tmp_buf, "{s}/{s}.ppm.tmp", .{ g.capture_dir, name }, 0) catch return error.CapturePathTooLong;
+ const final_path = std.fmt.bufPrintSentinel(&final_buf, "{s}/{s}.ppm", .{ g.capture_dir, name }, 0) catch return error.CapturePathTooLong;
const fd = libc.open(tmp_path, .{ .ACCMODE = .WRONLY, .CREAT = true, .TRUNC = true }, @as(libc.mode_t, 0o644));
if (fd < 0) return error.CaptureWriteFailed;
@@ -6434,151 +8788,1868 @@ fn writeCapturePpm(g: *Gui, gpa: std.mem.Allocator, pixels: []const u8, width: u
if (libc.rename(tmp_path, final_path) != 0) return error.CaptureWriteFailed;
}
-fn addCursorBar(
- builder: *OverlayBuilder,
- x: u16,
- y: u16,
- bar: bool,
- visual_height: f32,
- layout: CellLayout,
- rgb: [3]u8,
-) void {
- if (!bar) return;
- const previous_ink = builder.ink;
- builder.ink = true;
- defer builder.ink = previous_ink;
- const x0 = layout.x_off + @as(f32, @floatFromInt(x)) * layout.w;
- const height = std.math.clamp(visual_height, 1.0, layout.h);
- const y0 = layout.y_off + @as(f32, @floatFromInt(y)) * layout.h +
- @as(f32, @floatFromInt(taglineBandOffset(y, builder.win_h, @intFromFloat(layout.h), @intFromFloat(height), true)));
- builder.addRect(
- x0,
- y0,
- x0 + @max(1.0, layout.w / 8.0),
- y0 + height,
- .{
- .r = @as(f32, @floatFromInt(rgb[0])) / 255.0,
- .g = @as(f32, @floatFromInt(rgb[1])) / 255.0,
- .b = @as(f32, @floatFromInt(rgb[2])) / 255.0,
- .a = 1.0,
+/// One flat, hard-edged rectangle of decor, in window pixels: clipped to the
+/// window and dropped when empty, as the triangle overlay drew it, and moved
+/// by `track` as its pane's cells are.
+fn addDecor(g: *Gui, gpa: std.mem.Allocator, x0_in: f32, y0_in: f32, x1_in: f32, y1_in: f32, rgb: [3]u8, alpha: f32, track: ?pardes.animation.Track, win_w: f32, win_h: f32) !void {
+ const x0 = std.math.clamp(@min(x0_in, x1_in), 0.0, win_w);
+ const x1 = std.math.clamp(@max(x0_in, x1_in), 0.0, win_w);
+ const y0 = std.math.clamp(@min(y0_in, y1_in), 0.0, win_h);
+ const y1 = std.math.clamp(@max(y0_in, y1_in), 0.0, win_h);
+ if (x1 <= x0 or y1 <= y0) return;
+ // decor.frag.glsl reads the colour from the ground and the coverage
+ // from the ink's red.
+ var instance: CellInstance = .{
+ .x0 = (x0 / win_w) * 2.0 - 1.0,
+ .y0 = 1.0 - (y0 / win_h) * 2.0,
+ .x1 = (x1 / win_w) * 2.0 - 1.0,
+ .y1 = 1.0 - (y1 / win_h) * 2.0,
+ .u0 = 0,
+ .v0 = 0,
+ .u1 = 0,
+ .v1 = 0,
+ .fr = alpha,
+ .fg = 0,
+ .fb = 0,
+ .br = @as(f32, @floatFromInt(rgb[0])) / 255.0,
+ .bg = @as(f32, @floatFromInt(rgb[1])) / 255.0,
+ .bb = @as(f32, @floatFromInt(rgb[2])) / 255.0,
+ };
+ setTransitionFields(&instance, track, fixedCellLayout(g), win_w, win_h, 0);
+ try g.decor.append(gpa, instance);
+}
+
+/// A checker (decor.frag.glsl): squares of `px` window pixels in `a` and
+/// `b` from the quad's corner (lapis's scroll track); `stripes`, bands of
+/// `px` across it instead (lapis's focused title bar), `a` first.
+fn addChecker(g: *Gui, gpa: std.mem.Allocator, x0: f32, y0: f32, x1: f32, y1: f32, a: [3]u8, b: [3]u8, px: f32, track: ?pardes.animation.Track, win_w: f32, win_h: f32) !void {
+ return addPattern(g, gpa, x0, y0, x1, y1, a, b, px, false, track, win_w, win_h);
+}
+
+fn addPattern(g: *Gui, gpa: std.mem.Allocator, x0: f32, y0: f32, x1: f32, y1: f32, a: [3]u8, b: [3]u8, px: f32, stripes: bool, track: ?pardes.animation.Track, win_w: f32, win_h: f32) !void {
+ const first = g.decor.items.len;
+ try addDecor(g, gpa, x0, y0, x1, y1, a, 1, track, win_w, win_h);
+ if (g.decor.items.len == first) return;
+ const instance = &g.decor.items[first];
+ instance.u0 = px;
+ instance.u1 = px;
+ instance.v0 = if (stripes) 1 else 0;
+ instance.v1 = if (stripes) 1 else 0;
+ instance.fr = @as(f32, @floatFromInt(b[0])) / 255.0;
+ instance.fg = @as(f32, @floatFromInt(b[1])) / 255.0;
+ instance.fb = @as(f32, @floatFromInt(b[2])) / 255.0;
+ instance.effect |= checker_bit;
+}
+
+/// How a lift of 0 to 1 stands off the page: the shadow's blur and offset
+/// in cell heights, and its darkest, where it leaves the caster's edge.
+/// Within §8.2's budget: sigma 0.4-0.8 cell, at most 30% darker at the edge.
+const Shadow = struct {
+ // A key light above: the drop is most of the blur, so the shadow hangs
+ // below and to the right and barely reaches over the caster's top.
+ const sigma: f32 = 0.42;
+ const drop: f32 = 0.34;
+ const side: f32 = 0.1;
+ const strength: f32 = 0.42;
+};
+
+/// A soft rectangle around `caster` (window pixels), blurred by `sigma`
+/// and moved by (dx, dy): black is a shadow, a light colour a rim or a
+/// glow. The caster's own rectangle is left alone, and `track` moves it all
+/// as its caster moves.
+fn addSoft(g: *Gui, gpa: std.mem.Allocator, caster: [4]f32, sigma_in: f32, dx: f32, dy: f32, strength: f32, rgb: [3]u8, track: ?pardes.animation.Track, win_w: f32, win_h: f32) !void {
+ if (strength <= 0.002) return;
+ const sigma = @max(0.5, sigma_in);
+ const x0 = caster[0] + dx - 3 * sigma;
+ const y0 = caster[1] + dy - 3 * sigma;
+ const x1 = caster[2] + dx + 3 * sigma;
+ const y1 = caster[3] + dy + 3 * sigma;
+ const w = x1 - x0;
+ const ht = y1 - y0;
+ if (w <= 0 or ht <= 0) return;
+ // In the quad's own 0..1 space (decor.frag.glsl): sigma per axis, the
+ // caster's offset from its shadow, the strength.
+ var instance: CellInstance = .{
+ .x0 = (x0 / win_w) * 2.0 - 1.0,
+ .y0 = 1.0 - (y0 / win_h) * 2.0,
+ .x1 = (x1 / win_w) * 2.0 - 1.0,
+ .y1 = 1.0 - (y1 / win_h) * 2.0,
+ .u0 = sigma / w,
+ .v0 = sigma / ht,
+ .u1 = sigma / w,
+ .v1 = sigma / ht,
+ .fr = strength,
+ .fg = dx / w,
+ .fb = dy / ht,
+ .br = @as(f32, @floatFromInt(rgb[0])) / 255,
+ .bg = @as(f32, @floatFromInt(rgb[1])) / 255,
+ .bb = @as(f32, @floatFromInt(rgb[2])) / 255,
+ };
+ setTransitionFields(&instance, track, fixedCellLayout(g), win_w, win_h, 0);
+ instance.effect |= soft_shadow_bit;
+ try g.decor.append(gpa, instance);
+}
+
+/// How far each lift style may go on this theme without its text falling
+/// below min(its contrast, 4.5): a shadow darkens, the others lighten.
+const LiftCeilings = struct {
+ shadow: f32,
+ white: f32,
+ /// A rim is light on a dark page and shade on a light one, where light
+ /// would not show.
+ rim: [3]u8,
+
+ /// Over the text on the page, and over a selection's text on its own
+ /// ground: the lower of the two.
+ fn of(chrome: *const pardes.Chrome) LiftCeilings {
+ const fg = chrome.fg orelse fg_default;
+ const bg = chrome.page orelse bg_default;
+ return .{
+ .shadow = @min(shadowCeiling(fg, bg), shadowCeiling(chrome.sel_fg, chrome.sel_bg)),
+ .white = @min(lightenCeiling(fg, bg, .{ 255, 255, 255 }), lightenCeiling(chrome.sel_fg, chrome.sel_bg, .{ 255, 255, 255 })),
+ .rim = if (luminance(bg) < 0.18) .{ 255, 255, 255 } else .{ 0, 0, 0 },
+ };
+ }
+};
+
+/// What stands a lifted part off the page, `lift` 0 to 1 (a pane's spring,
+/// a notice's 1), in the style chosen: a soft shadow, or a rim along the
+/// top of the focused pane's tag rows (`rim_edge`, a pane's only:
+/// never a notice's).
+fn addLift(g: *Gui, gpa: std.mem.Allocator, style: pardes.config.Runtime.LiftStyle, ceilings: LiftCeilings, caster: [4]f32, rim_edge: ?[3]f32, bodies: []const [4]f32, lift: f32, track: ?pardes.animation.Track, win_w: f32, win_h: f32) !void {
+ if (lift <= 0.001) return;
+ const h: f32 = @floatFromInt(g.cell_h);
+ // The core sends `auto` already resolved (draw.liftStyle).
+ const shadow = switch (style) {
+ .off => return,
+ .shadow, .auto => true,
+ .rim => false,
+ };
+ if (shadow) {
+ // Nothing of a shadow may touch a focus indicator (docs/effects.md):
+ // it falls on pane bodies and rails, never a tag, a grip or a header.
+ const first = g.decor.items.len;
+ try addSoft(g, gpa, caster, Shadow.sigma * h * lift, Shadow.side * h * lift, Shadow.drop * h * lift, @min(Shadow.strength * lift, ceilings.shadow), .{ 0, 0, 0 }, track, win_w, win_h);
+ try clipToBodies(g, gpa, first, bodies);
+ }
+ // A hairline just above the focused tag rows, never on them: it adds to
+ // the indicator without changing its colour.
+ if (style == .rim) if (rim_edge) |edge| {
+ const light = ceilings.rim[0] == 255;
+ const alpha = @min(Lift.rim * lift, if (light) ceilings.white else ceilings.shadow);
+ try addDecor(g, gpa, edge[0], edge[2] - dp(1), edge[1], edge[2], ceilings.rim, alpha, track, win_w, win_h);
+ };
+}
+
+/// A rim's strength, in the §8.2 budget for coloured light.
+const Lift = struct {
+ const rim: f32 = 0.35;
+};
+
+/// A body region in window pixels.
+fn bodyPixels(region: pardes.Region, layout: CellLayout) [4]f32 {
+ return .{
+ @as(f32, @floatFromInt(region.rect.x)) * layout.w,
+ @as(f32, @floatFromInt(region.rect.y)) * layout.h,
+ @as(f32, @floatFromInt(region.rect.x + region.rect.w)) * layout.w,
+ @as(f32, @floatFromInt(region.rect.y + region.rect.h)) * layout.h,
+ };
+}
+
+/// Replaces the decor from `first` on with a copy per pane body it reaches,
+/// each clipped to that body (and to what a vertical transition already
+/// clipped it to): the lift then never reaches a tag, a grip or a header.
+fn clipToBodies(g: *Gui, gpa: std.mem.Allocator, first: usize, bodies: []const [4]f32) !void {
+ const added = g.decor.items.len - first;
+ if (added == 0) return;
+ var own: [8]CellInstance = undefined;
+ const n = @min(added, own.len);
+ @memcpy(own[0..n], g.decor.items[first..][0..n]);
+ g.decor.shrinkRetainingCapacity(first);
+ for (own[0..n]) |instance| for (bodies) |body| {
+ var copy = instance;
+ const vertical = copy.clip_x1 >= copy.clip_x0;
+ copy.clip_x0 = if (vertical) @max(copy.clip_x0, body[0]) else body[0];
+ copy.clip_y0 = if (vertical) @max(copy.clip_y0, body[1]) else body[1];
+ copy.clip_x1 = if (vertical) @min(copy.clip_x1, body[2]) else body[2];
+ copy.clip_y1 = if (vertical) @min(copy.clip_y1, body[3]) else body[3];
+ if (copy.clip_x1 <= copy.clip_x0 or copy.clip_y1 <= copy.clip_y0) continue;
+ try g.decor.append(gpa, copy);
+ };
+}
+
+/// Like shadowCeiling for a light colour laid over at `a` (sRGB blend, as
+/// the decor pipeline blends a colour that is not black): the largest `a`
+/// that keeps text and page apart by min(their contrast, 4.5).
+fn lightenCeiling(fg: [3]u8, bg: [3]u8, rgb: [3]u8) f32 {
+ const contrast = pardes.colors.contrast;
+ const blend = struct {
+ fn of(under: [3]u8, over: [3]u8, a: f32) [3]u8 {
+ var out: [3]u8 = undefined;
+ for (&out, under, over) |*o, x, y| o.* = @intFromFloat(@round(@as(f32, @floatFromInt(x)) * (1 - a) + @as(f32, @floatFromInt(y)) * a));
+ return out;
+ }
+ }.of;
+ const target = @min(contrast(fg, bg), 4.5);
+ var lo: f32 = 0;
+ var hi: f32 = 1;
+ for (0..24) |_| {
+ const mid = (lo + hi) / 2;
+ if (contrast(blend(fg, rgb, mid), blend(bg, rgb, mid)) >= target - 1e-3) lo = mid else hi = mid;
+ }
+ return lo;
+}
+
+const luminance = pardes.colors.relativeLuminance;
+
+/// How dark a shadow may make the page and its text, both together, before
+/// the pair drops below its own contrast or 4.5, whichever is lower (§8.2):
+/// darkening in linear light by k leaves (k L1 + .05) / (k L2 + .05).
+fn shadowCeiling(fg: [3]u8, bg: [3]u8) f32 {
+ const a = luminance(fg);
+ const b = luminance(bg);
+ const light = @max(a, b);
+ const dark = @min(a, b);
+ const target = @min((light + 0.05) / (dark + 0.05), 4.5);
+ const room = light - target * dark;
+ if (room <= 0) return 0;
+ return std.math.clamp(1 - 0.05 * (target - 1) / room, 0, 1);
+}
+
+test "a rim never lightens a native theme's text below its contrast or 4.5" {
+ for (pardes.themes) |theme| {
+ const fg = theme.fg orelse fg_default;
+ const bg = theme.bg orelse bg_default;
+ for ([_][3]u8{.{ 255, 255, 255 }}) |light| {
+ const a = @min(Lift.rim, lightenCeiling(fg, bg, light));
+ const blend = struct {
+ fn of(under: [3]u8, over: [3]u8, t: f32) [3]u8 {
+ var out: [3]u8 = undefined;
+ for (&out, under, over) |*o, x, y| o.* = @intFromFloat(@round(@as(f32, @floatFromInt(x)) * (1 - t) + @as(f32, @floatFromInt(y)) * t));
+ return out;
+ }
+ }.of;
+ const ratio = pardes.colors.contrast;
+ try std.testing.expect(ratio(blend(fg, light, a), blend(bg, light, a)) >= @min(ratio(fg, bg), 4.5) - 2e-3);
+ }
+ }
+}
+
+test "a lift never touches a tag, a grip or a header, on a light theme or a dark one" {
+ const gpa = std.testing.allocator;
+ for ([_][]const u8{ "forge", "daybreak" }) |name| {
+ const core = try pardes.Pardes.init(gpa, .{ .cols = 80, .rows = 24 });
+ defer core.deinit();
+ core.update(.{ .resize = .{ .cols = 80, .rows = 24, .row_metrics = .{ .body_w = 10, .body_h = 20, .tagline_w = 6, .tagline_h = 12 } } });
+ _ = try core.newShell(1, "");
+ try std.testing.expect(pardes.layout.splitColumn(core, 0, 1, false));
+ var line: [64]u8 = undefined;
+ try std.testing.expect(core.executeBuiltinLine(0, try std.fmt.bufPrint(&line, "Theme {s}", .{name})));
+ for (0..40) |_| core.update(.tick);
+ for (std.enums.values(pardes.config.Runtime.LiftStyle)) |style| {
+ core.settings.lift = style;
+ try std.testing.expect(core.executeBuiltinLine(0, "Msg a floating notice"));
+ core.advance(core.now_ns + 2 * std.time.ns_per_s);
+ core.sync();
+ const s = try core.render(core.scratch.allocator());
+ core.advance(core.now_ns + 2 * std.time.ns_per_s);
+ const settled = try core.render(core.scratch.allocator());
+ _ = s;
+ // The focus indicator itself: the focused pane's tag is not the
+ // others' colour, whatever the lift.
+ var active: ?[3]u8 = null;
+ var other: ?[3]u8 = null;
+ for (settled.tagLayers()) |layer| if (layer.rows != 0 and layer.kind == .pane) {
+ if (layer.id == core.active) active = layer.bg else other = layer.bg;
+ };
+ try std.testing.expect(!std.mem.eql(u8, &active.?, &other.?));
+ var g: Gui = undefined;
+ g.cell_w = 10;
+ g.cell_h = 20;
+ g.tagline_width = 6;
+ g.tagline_height = 12;
+ g.decor = .empty;
+ g.glide = .{};
+ g.scroll_pane = null;
+ g.scroll_lag = 0;
+ defer g.decor.deinit(gpa);
+ var groups = makeGroups(&.{}, false);
+ try buildDecor(&g, gpa, settled, &groups, fixedCellLayout(&g), 800, 480, true);
+ var lifted: usize = 0;
+ for (g.decor.items) |item| {
+ if (item.clip_x1 < item.clip_x0) continue;
+ lifted += 1;
+ // Inside a body or a rail, all of it.
+ const inside = for (settled.regionList()) |region| {
+ if (region.kind != .body and region.kind != .rail) continue;
+ const r = bodyPixels(region, fixedCellLayout(&g));
+ if (item.clip_x0 >= r[0] and item.clip_y0 >= r[1] and item.clip_x1 <= r[2] and item.clip_y1 <= r[3]) break true;
+ } else false;
+ try std.testing.expect(inside);
+ }
+ const light_page = std.mem.eql(u8, name, "daybreak");
+ try std.testing.expectEqual(style == .shadow or (style == .auto and light_page), lifted != 0);
+ // A rim is one hairline, just above the focused pane's tag row.
+ var rims: usize = 0;
+ for (g.decor.items) |item| {
+ if (item.clip_x1 >= item.clip_x0) continue;
+ const top = (1 - item.y0) / 2 * 480;
+ const height = (item.y0 - item.y1) / 2 * 480;
+ const on_active_tag = for (settled.regionList()) |region| {
+ if (region.kind == .tag and region.owner == core.active and @abs(top + 1 - @as(f32, @floatFromInt(region.rect.y)) * 20) < 0.01 and @abs(height - 1) < 0.01) break true;
+ } else false;
+ // Not the rule under a column bar, which may run there too.
+ rims += @intFromBool(on_active_tag and item.fr < 1);
+ }
+ try std.testing.expectEqual(@as(usize, @intFromBool(style == .rim)), rims);
+ }
+ }
+}
+
+test "a shadow never darkens a native theme's text below its contrast or 4.5" {
+ var shaded: usize = 0;
+ for (pardes.themes) |theme| {
+ const fg = theme.fg orelse fg_default;
+ const bg = theme.bg orelse bg_default;
+ const ceiling = shadowCeiling(fg, bg);
+ const k = 1 - @min(Shadow.strength, ceiling);
+ const light = @max(luminance(fg), luminance(bg));
+ const dark = @min(luminance(fg), luminance(bg));
+ const before = (light + 0.05) / (dark + 0.05);
+ const after = (k * light + 0.05) / (k * dark + 0.05);
+ try std.testing.expect(after >= @min(before, 4.5) - 1e-3);
+ shaded += @intFromBool(ceiling > 0.05);
+ }
+ // And most themes have room for one.
+ try std.testing.expect(shaded * 2 > pardes.themes.len);
+}
+
+/// The frame's decor, group by group (docs/render-pipeline.md §3.4), all of it
+/// read from the regions and the palette: the page's rules and the still
+/// panes' rails, rules and grip marks in tier 0, a moving or closing pane's
+/// in its track's group, notice rules in tier 4, bar cursors in tier 5.
+fn buildDecor(g: *Gui, gpa: std.mem.Allocator, surface: *const pardes.Surface, groups: *Groups, layout: CellLayout, win_w: f32, win_h: f32, cursors_shown: bool) !void {
+ g.decor.clearRetainingCapacity();
+ const chrome = &surface.chrome;
+ const regions = surface.regionList();
+ const ceilings = LiftCeilings.of(chrome);
+ var current_buf: [pardes.MAX_PANES][4]f32 = undefined;
+ var ncurrent: usize = 0;
+ for (regions) |part| if ((part.kind == .body or part.kind == .rail) and ncurrent < current_buf.len) {
+ current_buf[ncurrent] = bodyPixels(part, layout);
+ ncurrent += 1;
+ };
+ const current_bodies = current_buf[0..ncurrent];
+ const lift_style = std.enums.fromInt(pardes.config.Runtime.LiftStyle, chrome.lift_style) orelse .off;
+ const notice_lift = for (regions) |region| {
+ if (region.kind == .notice) break region.lift;
+ } else 0;
+ for (groups.items[0..groups.len], 0..) |*group, index| {
+ group.decor_start = @intCast(g.decor.items.len);
+ defer group.decor_count = @as(u32, @intCast(g.decor.items.len)) - group.decor_start;
+ // Under the cells: a theme's tag plaques, this group's panes' (and
+ // the column and workspace tags with the still ones).
+ if (index <= groups.tracks) {
+ const closing = if (group.track) |active| active.phase == .closing else false;
+ try tagPlaques(g, gpa, if (closing) surface.previous_regions else regions, groups, index, chrome, layout, win_w, win_h, group.track);
+ }
+ group.under_count = @as(u32, @intCast(g.decor.items.len)) - group.decor_start;
+ // The grips' buttons before any rule: the rules over their rows cut
+ // them, and the band round them never covers a rule.
+ if (index <= groups.tracks) {
+ const closing = if (group.track) |active| active.phase == .closing else false;
+ try gripDecor(g, gpa, if (closing) surface.previous_regions else regions, if (closing) surface.previous_cells else surface.cells, groups, index, chrome, layout, surface.cols, surface.rows, win_w, win_h, group.track);
+ }
+ if (index == 0) {
+ const top = for (regions) |region| {
+ if (region.kind == .workspace_tag) break region.rect.h;
+ } else 0;
+ // The workspace tag is ruled off from the tags right under it.
+ const tag_under = for (regions) |region| switch (region.kind) {
+ .grip, .tag, .column_grip, .column_tag => if (region.rect.y == top) break true,
+ else => {},
+ } else false;
+ // As wide as the other rules, where the tagline leaves the room.
+ const height: u32 = @intFromFloat(@max(1, @min(rulePx(chrome), @as(f32, @floatFromInt((g.cell_h -| g.tagline_height) * 2)))));
+ if (top != 0 and top < surface.rows and tag_under and height != 0) {
+ const y0: f32 = @floatFromInt(top * g.cell_h - height / 2);
+ try addDecor(g, gpa, 0, y0, win_w, y0 + @as(f32, @floatFromInt(height)), chrome.topbar_rule, 1, null, win_w, win_h);
+ }
+ // The column bar is ruled off from the panes under it.
+ for (regions) |bar| {
+ if (bar.kind != .column_grip) continue;
+ const y = @as(f32, @floatFromInt(bar.rect.y + bar.rect.h)) * layout.h;
+ try addDecor(g, gpa, 0, y - rulePx(chrome), win_w, y, chrome.border, 1, null, win_w, win_h);
+ break;
+ }
+ // A tag on the last row runs on through the pixels under the grid.
+ const grid_bottom = @as(f32, @floatFromInt(surface.rows)) * layout.h;
+ const tag_last = for (regions) |region| switch (region.kind) {
+ .grip, .tag, .column_grip, .column_tag, .workspace_tag => if (region.rect.h != 0 and region.rect.y + region.rect.h == surface.rows) break true,
+ else => {},
+ } else false;
+ if (grid_bottom < win_h and tag_last) try addDecor(g, gpa, 0, grid_bottom, win_w, win_h, chrome.tag_bg, 1, null, win_w, win_h);
+ }
+ if (index <= groups.tracks) {
+ const track = group.track;
+ // A closing pane is gone: its chrome is the last frame's.
+ const closing = if (track) |active| active.phase == .closing else false;
+ const placed = if (closing) surface.previous_regions else regions;
+ // Where a lift may fall: pane bodies, never tags (addLift).
+ var body_buf: [pardes.MAX_PANES][4]f32 = undefined;
+ var nbodies: usize = 0;
+ for (placed) |part| if ((part.kind == .body or part.kind == .rail) and nbodies < body_buf.len) {
+ body_buf[nbodies] = bodyPixels(part, layout);
+ nbodies += 1;
+ };
+ const bodies = body_buf[0..nbodies];
+ const ticks: []const pardes.RailTick = if (closing) &.{} else surface.rail_ticks[0..surface.nrail_ticks];
+ try paneDecor(g, gpa, placed, ticks, groups, index, chrome, layout, surface.cols, surface.rows, win_w, win_h, track);
+ // G9, while nothing moves: a halo round the body's selection.
+ if (index == 0 and groups.tracks == 0 and chrome.fx & 1 != 0) try glowBlocks(g, gpa, surface, .selection, layout, win_w, win_h);
+ // G11: a glow under the word a look-hover would open.
+ if (index == 0 and groups.tracks == 0 and chrome.fx & 2 != 0) try glowBlocks(g, gpa, surface, .hover, layout, win_w, win_h);
+ // G14: what changed glows, while nothing moves.
+ // G12: the bodies' edges shaded, a pane's in its own group.
+ if (chrome.fx & 4 != 0) try occlusion(g, gpa, placed, groups, index, surface, ceilings, layout, win_w, win_h, track);
+ // A single spine runs down each column, through every tag and body.
+ if (index == 0) for (regions) |column| {
+ if (column.kind != .column) continue;
+ const x = @as(f32, @floatFromInt(column.rect.x)) * layout.w;
+ const y0 = @as(f32, @floatFromInt(column.rect.y)) * layout.h;
+ const grid_y1 = @as(f32, @floatFromInt(surface.rows)) * layout.h;
+ const y1 = if (win_h - grid_y1 < layout.h) @max(grid_y1, win_h) else grid_y1;
+ // None at the window's edge: nothing to rule apart there.
+ if (column.rect.x == 0) continue;
+ if (y1 > y0) try addDecor(g, gpa, x, y0, x + rulePx(chrome), y1, chrome.border, 1, null, win_w, win_h);
+ };
+ // Cast last in the group, over its cells, images and chrome: a
+ // lifted pane's shadow darkens its neighbours' rails and rules
+ // as it darkens their text, and never the pane itself.
+ for (placed) |grip| {
+ if (grip.kind != .grip or grip.lift <= 0.001 or groupOf(groups, grip.serial) != index) continue;
+ var box: [4]f32 = .{ @as(f32, @floatFromInt(grip.rect.x)) * layout.w, @as(f32, @floatFromInt(grip.rect.y)) * layout.h, 0, @as(f32, @floatFromInt(grip.rect.y + grip.rect.h)) * layout.h };
+ box[2] = box[0];
+ for (placed) |part| {
+ if (part.owner != grip.owner or (part.kind != .tag and part.kind != .rail and part.kind != .body)) continue;
+ box[1] = @min(box[1], @as(f32, @floatFromInt(part.rect.y)) * layout.h);
+ box[2] = @max(box[2], @as(f32, @floatFromInt(part.rect.x + part.rect.w)) * layout.w);
+ box[3] = @max(box[3], @as(f32, @floatFromInt(part.rect.y + part.rect.h)) * layout.h);
+ }
+ // The top edge of its tag rows, for a rim: x0, x1, y.
+ const rim_edge: ?[3]f32 = for (placed) |part| {
+ if (part.owner == grip.owner and part.kind == .tag) break .{ @as(f32, @floatFromInt(grip.rect.x)) * layout.w, @as(f32, @floatFromInt(part.rect.x + part.rect.w)) * layout.w, @as(f32, @floatFromInt(part.rect.y)) * layout.h };
+ } else null;
+ try addLift(g, gpa, lift_style, ceilings, box, rim_edge, bodies, grip.lift, track, win_w, win_h);
+ }
+ // G7: a pane on the move stands off the page, rising as it sets
+ // out and settling as it lands, its shadow on the other panes'
+ // bodies only (never a tag, a grip or its own text), moving
+ // with it.
+ if (track) |active| if (active.phase != .closing and (active.effect == .slide or active.effect == .zoom or active.effect == .vertical)) {
+ const steps: f32 = @floatFromInt(@max(1, active.frames() -| 1));
+ const u = std.math.clamp(@as(f32, @floatFromInt(active.frame)) / steps, 0, 1);
+ const lift = @sin(std.math.pi * u);
+ var box: [4]f32 = .{ std.math.inf(f32), std.math.inf(f32), -std.math.inf(f32), -std.math.inf(f32) };
+ var others: [pardes.MAX_PANES][4]f32 = undefined;
+ var nothers: usize = 0;
+ for (placed) |part| {
+ if (part.kind != .tag and part.kind != .rail and part.kind != .body and part.kind != .grip) continue;
+ const r = bodyPixels(part, layout);
+ if (part.owner == active.pane) {
+ box = .{ @min(box[0], r[0]), @min(box[1], r[1]), @max(box[2], r[2]), @max(box[3], r[3]) };
+ } else if ((part.kind == .body or part.kind == .rail) and nothers < others.len) {
+ others[nothers] = r;
+ nothers += 1;
+ }
+ }
+ if (box[2] > box[0] and lift > 0.01) {
+ const h: f32 = @floatFromInt(g.cell_h);
+ const first = g.decor.items.len;
+ try addSoft(g, gpa, box, Shadow.sigma * h * lift, Shadow.side * h * lift, Shadow.drop * h * lift, @min(Shadow.strength * lift, ceilings.shadow), .{ 0, 0, 0 }, track, win_w, win_h);
+ try clipToBodies(g, gpa, first, others[0..nothers]);
+ }
+ };
+ }
+ // A notice chip is tagline hung over the body's top rows, so it is
+ // ruled off from the text beneath it the way a tag is: the same
+ // colour and thickness along its bottom, running to the window's
+ // edge when it does, fading up and dissolving with its band.
+ // A notice floats: its shadow first, then every rule.
+ for (surface.tagLayers()) |*layer| {
+ if (layer.rows == 0 or layer.kind != .notice or noticeGroup(groups, layer) != index) continue;
+ const x = @as(f32, @floatFromInt(layer.viewport.x)) * layout.w;
+ const top = (@as(f32, @floatFromInt(layer.viewport.y)) + layer.slide) * layout.h;
+ const track = groups.items[groupAt(groups, layer.viewport.x, layer.viewport.y)].track;
+ try addLift(g, gpa, lift_style, ceilings, .{ x, top, x + @as(f32, @floatFromInt(layer.viewport.w)) * layout.w, top + layout.h }, null, current_bodies, notice_lift * layer.fade, track, win_w, win_h);
+ }
+ for (surface.tagLayers()) |*layer| {
+ if (layer.rows == 0 or layer.kind != .notice or noticeGroup(groups, layer) != index) continue;
+ const x0 = @as(f32, @floatFromInt(layer.viewport.x)) * layout.w;
+ const x1 = x0 + @as(f32, @floatFromInt(layer.viewport.w)) * layout.w;
+ const rule_x1 = if (win_w - x1 < layout.w) @max(x1, win_w) else x1;
+ const top = @as(f32, @floatFromInt(layer.viewport.y)) * layout.h;
+ // A band still falling into place is cut at its row's top; its
+ // rule comes with it, and shows only once it is below that cut.
+ const rule_y = top + (1 + layer.slide) * layout.h;
+ if (rule_y - dp(1) < top) continue;
+ const track = groups.items[groupAt(groups, layer.viewport.x, layer.viewport.y)].track;
+ try addDecor(g, gpa, x0, rule_y - dp(1), rule_x1, rule_y, chrome.border, layer.fade, track, win_w, win_h);
+ }
+ if (index == groups.ink and cursors_shown) try cursorDecor(g, gpa, surface, layout, win_w, win_h);
+ }
+}
+
+/// Each pane's rule between its tag and body, and its scroll rail: a page
+/// coloured gutter with a thin track and its thumb, running down through the
+/// pixels past the last whole row. Only the panes of group `index`.
+fn paneDecor(g: *Gui, gpa: std.mem.Allocator, regions: []const pardes.Region, ticks: []const pardes.RailTick, groups: *const Groups, index: usize, chrome: *const pardes.Chrome, layout: CellLayout, cols: u16, rows: u16, win_w: f32, win_h: f32, track: ?pardes.animation.Track) !void {
+ const page = chrome.page orelse bg_default;
+ for (regions) |rail| {
+ if (rail.kind != .rail or rail.rect.h == 0 or groupOf(groups, rail.serial) != index) continue;
+ const tag = for (regions) |region| {
+ if (region.kind == .tag and region.owner == rail.owner) break region;
+ } else continue;
+ if (@as(u32, tag.rect.x) + tag.rect.w > cols or @as(u32, tag.rect.y) + tag.rect.h > rows or
+ @as(u32, rail.rect.y) + rail.rect.h > rows) continue;
+ const x0 = @as(f32, @floatFromInt(rail.rect.x)) * layout.w;
+ const x1 = @as(f32, @floatFromInt(tag.rect.x + tag.rect.w)) * layout.w;
+ // Like the band above it, the rule of a pane at the right edge runs
+ // on through the pixels past the last whole cell. Under a tag on
+ // top, over one below its body.
+ const rule_x1 = if (win_w - x1 < layout.w) @max(x1, win_w) else x1;
+ const tag_bottom = tag.rect.y > rail.rect.y;
+ const rule_y = @as(f32, @floatFromInt(if (tag_bottom) tag.rect.y else tag.rect.y + tag.rect.h)) * layout.h;
+ try addDecor(g, gpa, x0, if (tag_bottom) rule_y else rule_y - dp(1), rule_x1, if (tag_bottom) rule_y + dp(1) else rule_y, chrome.tag_rule orelse mixRgb(chrome.tag_bg, page), 1, track, win_w, win_h);
+ // Stacked panes are ruled apart as columns are, where one pane's
+ // body meets the next one's tag (acme's Border).
+ {
+ const pane_top = @min(tag.rect.y, rail.rect.y);
+ const stacked = for (regions) |other| {
+ if ((other.kind == .body or other.kind == .tag) and other.owner != rail.owner and other.rect.y + other.rect.h == pane_top and
+ other.rect.x < tag.rect.x + tag.rect.w and tag.rect.x < other.rect.x + other.rect.w) break true;
+ } else false;
+ // Inside the tag band's slack, never over its glyphs: the top
+ // slack of a tag on top, the bottom slack of the one above when
+ // tags are at the bottom; a pixel at least.
+ const y = @as(f32, @floatFromInt(pane_top)) * layout.h;
+ const spare = g.cell_h -| g.tagline_height;
+ if (stacked and !tag_bottom) {
+ const room = taglineBandOffset(pane_top, win_h, g.cell_h, g.tagline_height);
+ try addDecor(g, gpa, x0, y, rule_x1, y + @max(1, @min(rulePx(chrome), @as(f32, @floatFromInt(room)))), chrome.border, 1, track, win_w, win_h);
+ } else if (stacked and pane_top > 0) {
+ const room = spare - taglineBandOffset(pane_top - 1, win_h, g.cell_h, g.tagline_height);
+ try addDecor(g, gpa, x0, y - @max(1, @min(rulePx(chrome), @as(f32, @floatFromInt(room)))), rule_x1, y, chrome.border, 1, track, win_w, win_h);
+ }
+ }
+
+ const y0 = @as(f32, @floatFromInt(rail.rect.y)) * layout.h;
+ const body_end = rail.rect.y + rail.rect.h;
+ const body_y1 = @as(f32, @floatFromInt(body_end)) * layout.h;
+ const y1 = if (body_end == rows and win_h - body_y1 < layout.h) @max(body_y1, win_h) else body_y1;
+ // A theme's own track fills its width, the thumb one pixel short
+ // of it so the track edges it (acme's scrollbar); else a thin rail.
+ // acme's scrollbar: the track fills the scroll column, under the
+ // grip's button; the thumb is a pixel short of its right edge, so
+ // the track edges it.
+ const column = scrollColumn(g, chrome, rail.rect.x, layout);
+ try addDecor(g, gpa, x0, y0, x0 + layout.w, y1, page, 1, track, win_w, win_h);
+ if (chrome.decor_checker) |gold|
+ try addChecker(g, gpa, column[0], y0, column[1], y1, chrome.scroll_track, gold, dp(@floatFromInt(@max(1, chrome.decor_checker_px))), track, win_w, win_h)
+ else
+ try addDecor(g, gpa, column[0], y0, column[1], y1, chrome.scroll_track, 1, track, win_w, win_h);
+ if (rail.thumb_h != 0 and rail.thumb_span > 0) {
+ // In pixels, not rows, and with the picture while it glides
+ // or lags behind the core's rows (both in rows of the body).
+ const lag: f32 = if (g.glide.follow.offset != 0 and g.glide.pane == rail.owner)
+ g.glide.lagLines()
+ else if (g.scroll_pane != null and g.scroll_pane.? == rail.owner) g.scroll_lag else 0;
+ const track_px = body_y1 - y0;
+ const size = @min(track_px, @max(layout.h, rail.thumb_span * track_px));
+ const at = rail.thumb_at + lag * rail.thumb_span / @as(f32, @floatFromInt(rail.rect.h));
+ const thumb_y0 = y0 + std.math.clamp(at * track_px, 0, track_px - size);
+ const thumb_y1 = if (thumb_y0 + size >= body_y1 - 0.5) y1 else thumb_y0 + size;
+ try addDecor(g, gpa, column[0], thumb_y0, column[1] - dp(1), thumb_y1, chrome.scroll_thumb, 1, track, win_w, win_h);
+ } else if (rail.thumb_h != 0) {
+ const thumb_y0 = @as(f32, @floatFromInt(rail.rect.y + rail.thumb_y)) * layout.h;
+ const thumb_y1 = if (rail.thumb_y + rail.thumb_h == rail.rect.h) y1 else @as(f32, @floatFromInt(rail.rect.y + rail.thumb_y + rail.thumb_h)) * layout.h;
+ try addDecor(g, gpa, column[0], thumb_y0, column[1] - dp(1), thumb_y1, chrome.scroll_thumb, 1, track, win_w, win_h);
+ }
+ // A query's places' ticks over the track and thumb, where its matches
+ // are in the file (Places.addTicks); the current one last, on top.
+ const track_px = body_y1 - y0;
+ for (0..2) |pass| for (ticks) |tick| {
+ if (tick.owner != rail.owner or tick.current != (pass == 1)) continue;
+ const at = @as(f32, @floatFromInt(tick.at)) / @as(f32, @floatFromInt(pardes.panes.Places.tick_scale));
+ const h = if (tick.current) dp(3) else dp(2);
+ const ty = y0 + std.math.clamp(at * track_px, 0, track_px - h);
+ try addDecor(g, gpa, column[0], ty, column[1], ty + h, if (tick.current) chrome.match_current else chrome.match_tick, 1, track, win_w, win_h);
+ };
+ }
+}
+
+/// Halfway between two colours.
+const mixRgb = pardes.colors.mix;
+
+/// A rule's width: the theme's own, or one pixel.
+fn rulePx(chrome: *const pardes.Chrome) f32 {
+ return dp(@floatFromInt(@max(1, chrome.rule_px)));
+}
+
+/// The display's density (SDL's window display scale: 2 on a 2x screen),
+/// by which every size given in logical pixels is drawn, as acme scales its
+/// Border, ButtonBorder and Scrollgap (scalesize). Cells, glyphs and what is
+/// measured in them are already the display's pixels and are not scaled.
+/// ponytail: one window per process, so one global; per window if ever two.
+var display_scale: f32 = 1;
+
+/// The window's display scale, or PARDES_TEST_SCALE (a harness forcing 2x);
+/// a test window is 1x unless forced, whatever display it lands on, so its
+/// captures are the same on any machine.
+fn updateDisplayScale(window: *c.SDL_Window) void {
+ if (std.c.getenv("PARDES_TEST_SCALE")) |forced| {
+ display_scale = std.fmt.parseFloat(f32, std.mem.span(forced)) catch 1;
+ } else if (std.c.getenv("PARDES_TEST") != null) {
+ display_scale = 1;
+ } else {
+ const scale = c.SDL_GetWindowDisplayScale(window);
+ display_scale = if (scale > 0 and std.math.isFinite(scale)) scale else 1;
+ }
+ display_scale = std.math.clamp(display_scale, 1, 4);
+}
+
+/// A theme's ornament as the cell shader draws it (Chrome.decor_*), for the
+/// frame being built: renderFrame sets it, writing a cell marks the cells
+/// it falls on, and pushLayerOpacity hands the shader its colours and
+/// sizes. ponytail: one window per process, as display_scale.
+var cell_decor: CellDecor = .{};
+/// The cells this frame lets a plaque show through, by instance, for
+/// renderFrame to drop the ones with no ink. Past its length the frame's
+/// cells are blended instead.
+var plaque_through: [16384]u32 = undefined;
+var plaque_through_len: usize = 0;
+
+fn plaqueThrough(instances: [*]CellInstance, at: u32) void {
+ instances[at].effect |= clear_bg_bit;
+ if (plaque_through_len < plaque_through.len) plaque_through[plaque_through_len] = at;
+ plaque_through_len += 1;
+}
+const CellDecor = struct {
+ /// The page's ground, when the theme dots it.
+ dots: ?[3]u8 = null,
+ /// A file name's inks in a tag, when the theme shadows it.
+ title: ?[2][3]u8 = null,
+ /// UiUniforms after background_opacity (ui.frag.glsl): the dots' colour
+ /// and strength, their period and radii, the shadow's colour and offset.
+ uniforms: [12]f32 = @splat(0),
+ /// The tag plaques' bands (window pixels) and the tag grounds: a blank
+ /// tag cell there lets its plaque show through (tagPlaques).
+ plaques: [pardes.MAX_TAG_LAYERS][4]f32 = undefined,
+ nplaques: usize = 0,
+ grounds: [2][3]u8 = .{ .{ 0, 0, 0 }, .{ 0, 0, 0 } },
+ plaques_off: bool = false,
+ /// A see-through cell over the plaques has ink of its own, so this
+ /// frame's cells are blended (renderFrame).
+ inked_clear: bool = false,
+
+ /// G13: each body's rectangle and how far its dots have moved.
+ bodies: [pardes.MAX_PANES][4]f32 = undefined,
+ shifts: [pardes.MAX_PANES]f32 = undefined,
+ nbodies: usize = 0,
+
+ fn parallaxAt(decor: *const CellDecor, x: f32, y: f32) f32 {
+ for (decor.bodies[0..decor.nbodies], decor.shifts[0..decor.nbodies]) |band, shift|
+ if (x >= band[0] and x < band[2] and y >= band[1] and y < band[3]) return shift;
+ return 0;
+ }
+
+ fn inPlaque(decor: *const CellDecor, x: f32, y: f32) bool {
+ for (decor.plaques[0..decor.nplaques]) |band|
+ if (x >= band[0] and x < band[2] and y >= band[1] and y < band[3]) return true;
+ return false;
+ }
+
+ fn of(chrome: *const pardes.Chrome) CellDecor {
+ var out: CellDecor = .{};
+ if (chrome.decor_dots) |rgb| if (chrome.page) |page| {
+ out.dots = page;
+ out.uniforms[0..4].* = .{ unit(rgb[0]), unit(rgb[1]), unit(rgb[2]), unit(chrome.decor_dot_alpha) };
+ out.uniforms[4..8].* = .{ dp(@floatFromInt(@max(2, chrome.decor_dot_px))), 0.75 * display_scale, 1.25 * display_scale, 0 };
+ };
+ if (chrome.decor_title) |rgb| {
+ out.title = .{ chrome.name_ink, chrome.active_name_ink };
+ out.uniforms[8..12].* = .{ unit(rgb[0]), unit(rgb[1]), unit(rgb[2]), dp(@floatFromInt(@max(1, chrome.decor_title_px))) };
+ }
+ return out;
+ }
+
+ fn unit(v: u8) f32 {
+ return @as(f32, @floatFromInt(v)) / 255;
+ }
+};
+
+/// A logical pixel size in the display's pixels: rounded, at least one.
+fn dp(logical: f32) f32 {
+ return @max(1, @round(logical * display_scale));
+}
+
+/// G9's state: the selection's blocks last drawn and when each appeared.
+const SelGlow = struct {
+ const Block = struct { box: [4]u16, start_ns: u64 };
+ blocks: [32]Block = undefined,
+ len: usize = 0,
+ now_ns: u64 = 0,
+ /// A block is still fading in: the core keeps frames coming.
+ fading: bool = false,
+};
+
+/// How long a glow takes to come up (§8.1's micro-feedback: 80 to 120 ms).
+const sel_glow_ns: u64 = 100 * std.time.ns_per_ms;
+
+/// A glow's kind: G9's halo round the selection, G11's under a hovered word.
+const GlowKind = enum { selection, hover };
+
+/// G9: a soft halo of the selection's own colour round each block of it in
+/// a pane body (rows of selected cells that touch), fading in over 100 ms
+/// with an ease-out. The selection itself is the halo's caster, never
+/// touched; so is a cursor beside it; the halo stays on bodies (never a
+/// tag or a grip) and at most 22%, less where the text round it would drop
+/// below min(its contrast, 4.5).
+/// G11: under the word a look-hover would open (its cells in the
+/// affordance's tint), a soft line of the theme's accent along its foot,
+/// fading in over 80 ms, as strong at most, never under a cursor.
+fn glowBlocks(g: *Gui, gpa: std.mem.Allocator, surface: *const pardes.Surface, kind: GlowKind, layout: CellLayout, win_w: f32, win_h: f32) !void {
+ const chrome = &surface.chrome;
+ const page = chrome.page orelse bg_default;
+ const fg = chrome.fg orelse fg_default;
+ // The selection's halo is its own colour; a hovered word's underline is
+ // the theme's accent (its focused grip), like a link's.
+ const glow = if (kind == .selection) chrome.sel_bg else chrome.accent;
+ // The cells a block is made of: the selection's, or the hover
+ // affordance's tint (draw.zig: halfway to a quarter of the selection).
+ const sel = if (kind == .selection) chrome.sel_bg else mixRgb(page, mixRgb(page, chrome.sel_bg));
+ const tracker = if (kind == .selection) &g.sel_glow else &g.hover_glow;
+ const rise_ns: u64 = if (kind == .selection) sel_glow_ns else 80 * std.time.ns_per_ms;
+ const cap = @min(0.22, lightenCeiling(fg, page, glow));
+ var blocks: [32][4]u16 = undefined;
+ var nblocks: usize = 0;
+ var bodies: [pardes.MAX_PANES][4]f32 = undefined;
+ var nbodies: usize = 0;
+ for (surface.regionList()) |body| {
+ if (body.kind != .body or body.rect.w == 0) continue;
+ if (nbodies < bodies.len) {
+ bodies[nbodies] = bodyPixels(body, layout);
+ nbodies += 1;
+ }
+ var open: ?[4]u16 = null; // x0, y0, x1, y1 of the block being grown
+ var row = body.rect.y;
+ while (row < body.rect.y + body.rect.h and row < surface.rows) : (row += 1) {
+ var x0: ?u16 = null;
+ var x1: u16 = 0;
+ var col = body.rect.x;
+ while (col < body.rect.x + body.rect.w and col < surface.cols) : (col += 1) {
+ const cell = &surface.cells[@as(usize, row) * surface.cols + col];
+ const selected = !cell.default and switch (cell.style.bg) {
+ .rgb => |rgb| std.mem.eql(u8, &rgb, &sel),
+ else => false,
+ };
+ if (!selected) continue;
+ if (x0 == null) x0 = col;
+ x1 = col + 1;
+ }
+ if (x0) |start| {
+ if (open) |*block| {
+ block.* = .{ @min(block[0], start), block[1], @max(block[2], x1), row + 1 };
+ } else open = .{ start, row, x1, row + 1 };
+ } else if (open) |block| {
+ if (nblocks < blocks.len) blocks[nblocks] = block;
+ nblocks += 1;
+ open = null;
+ }
+ }
+ if (open) |block| if (nblocks < blocks.len) {
+ blocks[nblocks] = block;
+ nblocks += 1;
+ };
+ }
+ nblocks = @min(nblocks, blocks.len);
+ // Each block keeps the start of the one it overlaps from the last frame.
+ var next: SelGlow = .{ .now_ns = tracker.now_ns };
+ for (blocks[0..nblocks]) |block| {
+ const start = for (tracker.blocks[0..tracker.len]) |old| {
+ if (old.box[0] < block[2] and block[0] < old.box[2] and old.box[1] < block[3] and block[1] < old.box[3]) break old.start_ns;
+ } else tracker.now_ns;
+ next.blocks[next.len] = .{ .box = block, .start_ns = start };
+ next.len += 1;
+ const t = @as(f32, @floatFromInt(tracker.now_ns -| start)) / @as(f32, @floatFromInt(rise_ns));
+ if (t < 1) next.fading = true;
+ const u = std.math.clamp(t, 0, 1);
+ const fade = 1 - (1 - u) * (1 - u) * (1 - u);
+ var caster: [4]f32 = .{ @as(f32, @floatFromInt(block[0])) * layout.w, @as(f32, @floatFromInt(block[1])) * layout.h, @as(f32, @floatFromInt(block[2])) * layout.w, @as(f32, @floatFromInt(block[3])) * layout.h };
+ const cursor_box: ?[4]f32 = if (surface.cursor) |cu| .{ @as(f32, @floatFromInt(cu.x)) * layout.w, @as(f32, @floatFromInt(cu.y)) * layout.h, @as(f32, @floatFromInt(cu.x + 1)) * layout.w, @as(f32, @floatFromInt(cu.y + 1)) * layout.h } else null;
+ const first = g.decor.items.len;
+ switch (kind) {
+ .selection => {
+ // A cursor beside the selection is not glowed over: it
+ // joins the caster.
+ if (surface.cursor) |cu| if (cu.x + 1 >= block[0] and cu.x <= block[2] and cu.y + 1 >= block[1] and cu.y <= block[3]) {
+ const cb = cursor_box.?;
+ caster = .{ @min(caster[0], cb[0]), @min(caster[1], cb[1]), @max(caster[2], cb[2]), @max(caster[3], cb[3]) };
+ };
+ try addSoft(g, gpa, caster, 0.3 * layout.h, 0, 0, cap * fade, glow, null, win_w, win_h);
+ try clipToBodies(g, gpa, first, bodies[0..nbodies]);
+ },
+ .hover => {
+ // A strip three logical pixels tall along the word's foot,
+ // its edges blurred by one: an underline of light. It is
+ // cast from a row away (addSoft leaves its caster's own
+ // rectangle out), so all of it shows.
+ const foot = caster[3] - dp(1);
+ const away = layout.h;
+ try addSoft(g, gpa, .{ caster[0] + dp(1), foot - dp(3) - away, caster[2] - dp(1), foot - away }, dp(1), 0, away, cap * fade, glow, null, win_w, win_h);
+ // Kept to the bodies, and off a cursor: the parts either
+ // side of it.
+ var parts: [4 * pardes.MAX_PANES][4]f32 = undefined;
+ var nparts: usize = 0;
+ for (bodies[0..nbodies]) |b| {
+ const cb = cursor_box orelse {
+ parts[nparts] = b;
+ nparts += 1;
+ continue;
+ };
+ if (cb[0] >= b[2] or cb[2] <= b[0] or cb[1] >= b[3] or cb[3] <= b[1]) {
+ parts[nparts] = b;
+ nparts += 1;
+ continue;
+ }
+ // Left and right of it, and above and below it.
+ parts[nparts] = .{ b[0], b[1], cb[0], b[3] };
+ parts[nparts + 1] = .{ cb[2], b[1], b[2], b[3] };
+ parts[nparts + 2] = .{ cb[0], b[1], cb[2], cb[1] };
+ parts[nparts + 3] = .{ cb[0], cb[3], cb[2], b[3] };
+ nparts += 4;
+ }
+ try clipToBodies(g, gpa, first, parts[0..nparts]);
+ },
+ }
+ }
+ tracker.* = next;
+}
+
+/// G12: ambient occlusion, a pane body darkening faintly toward its edges
+/// (§9.1: an inner shadow of 1 to 2%): four soft strips cast from just
+/// outside the body inward, clipped to it and round a cursor, black in
+/// linear light, under the same contrast ceiling as a lift.
+fn occlusion(g: *Gui, gpa: std.mem.Allocator, regions: []const pardes.Region, groups: *const Groups, index: usize, surface: *const pardes.Surface, ceilings: LiftCeilings, layout: CellLayout, win_w: f32, win_h: f32, track: ?pardes.animation.Track) !void {
+ const strength = @min(0.02, ceilings.shadow);
+ if (strength <= 0.002) return;
+ const reach = 0.5 * layout.h;
+ for (regions) |body| {
+ if (body.kind != .body or body.rect.w == 0 or body.rect.h == 0 or groupOf(groups, body.serial) != index) continue;
+ const b = bodyPixels(body, layout);
+ // The body, less a cursor's cell in it: left, right, above, below.
+ var parts: [4][4]f32 = undefined;
+ var nparts: usize = 0;
+ const cursor: ?[4]f32 = if (surface.cursor) |cu| .{ @as(f32, @floatFromInt(cu.x)) * layout.w, @as(f32, @floatFromInt(cu.y)) * layout.h, @as(f32, @floatFromInt(cu.x + 1)) * layout.w, @as(f32, @floatFromInt(cu.y + 1)) * layout.h } else null;
+ if (cursor) |cb| if (!(cb[0] >= b[2] or cb[2] <= b[0] or cb[1] >= b[3] or cb[3] <= b[1])) {
+ parts = .{ .{ b[0], b[1], cb[0], b[3] }, .{ cb[2], b[1], b[2], b[3] }, .{ cb[0], b[1], cb[2], cb[1] }, .{ cb[0], cb[3], cb[2], b[3] } };
+ nparts = 4;
+ };
+ if (nparts == 0) {
+ parts[0] = b;
+ nparts = 1;
+ }
+ const t = reach / 3;
+ const strips = [_][4]f32{
+ .{ b[0], b[1] - t, b[2], b[1] },
+ .{ b[0], b[3], b[2], b[3] + t },
+ .{ b[0] - t, b[1], b[0], b[3] },
+ .{ b[2], b[1], b[2] + t, b[3] },
+ };
+ for (strips) |strip| {
+ const first = g.decor.items.len;
+ try addSoft(g, gpa, strip, reach / 3, 0, 0, strength, .{ 0, 0, 0 }, track, win_w, win_h);
+ try clipToBodies(g, gpa, first, parts[0..nparts]);
+ }
+ }
+}
+
+/// A theme's tag plaques (Chrome.decor_box_*), drawn under the cells of
+/// group `index`: each pane tag, and with the still panes the column and
+/// workspace tags, becomes a framed box inside its own band with a hard
+/// shadow down and right that stays inside the band too, so it never falls
+/// on a body, a grip or the next pane. The focused pane's box is striped,
+/// its words on plates of the tag's ground (their cells stay opaque; the
+/// spaces between let the stripes through, emitInstance); a column or the
+/// workspace takes a quieter box, a one-pixel frame and a two-pixel shadow.
+fn tagPlaques(g: *Gui, gpa: std.mem.Allocator, regions: []const pardes.Region, groups: *const Groups, index: usize, chrome: *const pardes.Chrome, layout: CellLayout, win_w: f32, win_h: f32, track: ?pardes.animation.Track) !void {
+ const border_rgb = chrome.decor_box_border orelse return;
+ if (cell_decor.plaques_off) return;
+ const page = chrome.page orelse bg_default;
+ // The workspace and column plaques first: a pane's plaque right under
+ // them shares their bottom edge (plaqueBox) and draws its frame last.
+ for ([_]bool{ false, true }) |panes| for (regions) |tag| {
+ const pane = tag.kind == .tag;
+ if (pane != panes) continue;
+ if (!pane and tag.kind != .column_tag and tag.kind != .workspace_tag) continue;
+ if (tag.rect.w == 0 or tag.rect.h == 0) continue;
+ if (pane and groupOf(groups, tag.serial) != index) continue;
+ if (!pane and index != 0) continue;
+ const plaque = plaqueBox(g, chrome, regions, tag, layout, win_w, win_h) orelse continue;
+ const b = plaque.border;
+ const sh = plaque.shadow;
+ const fill = if (tag.active) chrome.tag_focus_bg else chrome.tag_bg;
+ // The band's own ground, then the shadow, the frame and the fill,
+ // each only where the ones over it leave it showing: all four are
+ // opaque, so that is the same picture drawn once, not four times.
+ const shadow: [4]f32 = .{ plaque.box[0] + sh[0], plaque.box[1] + sh[1], plaque.box[2] + sh[0], plaque.box[3] + sh[1] };
+ const inner: [4]f32 = .{ plaque.box[0] + b, plaque.box[1] + b, plaque.box[2] - b, plaque.box[3] - b };
+ try addDecorExcept(g, gpa, plaque.band, &.{ plaque.box, shadow }, page, track, win_w, win_h);
+ const shadow_rgb = chrome.decor_box_shadow orelse border_rgb;
+ try addDecorExcept(g, gpa, shadow, &.{plaque.box}, if (pane) shadow_rgb else mixRgb(shadow_rgb, page), track, win_w, win_h);
+ try addDecorExcept(g, gpa, plaque.box, &.{inner}, border_rgb, track, win_w, win_h);
+ if (pane and tag.active and chrome.decor_box_stripe != null)
+ try addPattern(g, gpa, inner[0], inner[1], inner[2], inner[3], chrome.decor_box_stripe.?, fill, dp(@floatFromInt(@max(1, chrome.decor_box_stripe_px))), true, track, win_w, win_h)
+ else
+ try addDecor(g, gpa, inner[0], inner[1], inner[2], inner[3], fill, 1, track, win_w, win_h);
+ };
+}
+
+/// Flat decor over `rect` (window pixels) less each of `holes`: up to four
+/// strips round the first hole's part of it, each less the rest.
+fn addDecorExcept(g: *Gui, gpa: std.mem.Allocator, rect: [4]f32, holes: []const [4]f32, rgb: [3]u8, track: ?pardes.animation.Track, win_w: f32, win_h: f32) std.mem.Allocator.Error!void {
+ if (rect[0] >= rect[2] or rect[1] >= rect[3]) return;
+ if (holes.len == 0) return addDecor(g, gpa, rect[0], rect[1], rect[2], rect[3], rgb, 1, track, win_w, win_h);
+ const hole = holes[0];
+ const x0 = @max(rect[0], hole[0]);
+ const y0 = @max(rect[1], hole[1]);
+ const x1 = @min(rect[2], hole[2]);
+ const y1 = @min(rect[3], hole[3]);
+ if (x0 >= x1 or y0 >= y1) return addDecorExcept(g, gpa, rect, holes[1..], rgb, track, win_w, win_h);
+ for ([_][4]f32{
+ .{ rect[0], rect[1], rect[2], y0 },
+ .{ rect[0], y1, rect[2], rect[3] },
+ .{ rect[0], y0, x0, y1 },
+ .{ x1, y0, rect[2], y1 },
+ }) |strip| try addDecorExcept(g, gpa, strip, holes[1..], rgb, track, win_w, win_h);
+}
+
+test "decor less its holes covers each pixel of the rest once and none of the holes" {
+ const gpa = std.testing.allocator;
+ var g: Gui = undefined;
+ g.cell_w = 1;
+ g.cell_h = 1;
+ g.decor = .empty;
+ g.glide = .{};
+ g.scroll_pane = null;
+ g.scroll_lag = 0;
+ defer g.decor.deinit(gpa);
+ const holes = [_][4]f32{ .{ 3, 2, 9, 6 }, .{ 5, 4, 12, 8 }, .{ 30, 30, 40, 40 } };
+ try addDecorExcept(&g, gpa, .{ 1, 1, 11, 10 }, &holes, .{ 1, 2, 3 }, null, 16, 12);
+ for (0..12) |y| for (0..16) |x| {
+ const px: f32 = @as(f32, @floatFromInt(x)) + 0.5;
+ const py: f32 = @as(f32, @floatFromInt(y)) + 0.5;
+ var hits: usize = 0;
+ for (g.decor.items) |item| {
+ const r: [4]f32 = .{ (item.x0 + 1) / 2 * 16, (1 - item.y0) / 2 * 12, (item.x1 + 1) / 2 * 16, (1 - item.y1) / 2 * 12 };
+ hits += @intFromBool(px > r[0] and px < r[2] and py > r[1] and py < r[3]);
+ }
+ const in_rect = px > 1 and px < 11 and py > 1 and py < 10;
+ const in_hole = for (holes) |h| {
+ if (px > h[0] and px < h[2] and py > h[1] and py < h[3]) break true;
+ } else false;
+ try std.testing.expectEqual(@as(usize, @intFromBool(in_rect and !in_hole)), hits);
+ };
+}
+
+const Plaque = struct { band: [4]f32, box: [4]f32, border: f32, shadow: [2]f32 };
+
+/// A tag's plaque in window pixels: its band (the rows, from after the
+/// grip to the end), the framed box round the tagline's text, and the
+/// frame's and the shadow's widths, the shadow cut to what the band's slack
+/// below the text and its right end leave. Null where there is no room.
+/// Tags stacked on each other (the workspace's over the columns', a
+/// column's over its first pane's) share one edge, the ruled one between
+/// their bands: the upper box runs down to it and casts no shadow down, the
+/// lower one's frame lies over it. Every box in a column spans the same
+/// pixels across, right of the grips, its shadow short of the next column.
+fn plaqueBox(g: *const Gui, chrome: *const pardes.Chrome, regions: []const pardes.Region, tag: pardes.Region, layout: CellLayout, win_w: f32, win_h: f32) ?Plaque {
+ const pane = tag.kind == .tag;
+ const first = tag.rect.y;
+ const last = tag.rect.y + tag.rect.h - 1;
+ // Flush against its grip's button, so the two read as one piece: the
+ // gap between button and text (the scroll gap) is the plaque's, and so
+ // is the cell before its text, so its frame is never under the first
+ // letter. A column's plaque starts where the pane's under it does.
+ const grip_kind: pardes.Region.Kind = if (tag.kind == .column_tag) .column_grip else .grip;
+ const x0 = for (regions) |grip| {
+ if (tag.kind != .workspace_tag and grip.kind == grip_kind and grip.owner == tag.owner)
+ break scrollColumn(g, chrome, grip.rect.x, layout)[1];
+ } else @as(f32, @floatFromInt(tag.rect.x)) * layout.w;
+ const x1_cells = @as(f32, @floatFromInt(tag.rect.x + tag.rect.w)) * layout.w;
+ const window_edge = win_w - x1_cells < layout.w;
+ const x1 = if (window_edge) @max(x1_cells, win_w) else x1_cells;
+ const stacked_on = tagBandAt(regions, tag, .above);
+ const stacked_under = tagBandAt(regions, tag, .below);
+ const row_top = @as(f32, @floatFromInt(first)) * layout.h;
+ const row_bottom = @as(f32, @floatFromInt(last + 1)) * layout.h;
+ const text_top = row_top + @as(f32, @floatFromInt(taglineBandOffset(first, win_h, g.cell_h, g.tagline_height)));
+ const text_bottom = @as(f32, @floatFromInt(last)) * layout.h + @as(f32, @floatFromInt(taglineBandOffset(last, win_h, g.cell_h, g.tagline_height) + g.tagline_height));
+ const border = @min(if (pane) dp(@floatFromInt(@max(1, chrome.decor_box_border_px))) else dp(1), @floor(text_top - row_top));
+ if (border < 1) return null;
+ // The shadow's full offset to the right; down, what the slack under the
+ // text leaves (a pixel or three at a tagline under the body's size).
+ const want: f32 = if (pane) dp(@floatFromInt(chrome.decor_box_shadow_px)) else dp(2);
+ const drop = if (stacked_under) 0 else std.math.clamp(@floor(row_bottom - text_bottom - border), 0, want);
+ // Every box ends where a pane's does, short of the next column's rule
+ // by a pane frame's width past its shadow, so no shadow meets the rule
+ // and a column's box lines up with its panes'; the window's edge needs
+ // no gap.
+ const pane_shadow = dp(@floatFromInt(chrome.decor_box_shadow_px));
+ const gap = @max(0, pane_shadow - want) + if (window_edge) 0 else dp(@floatFromInt(@max(1, chrome.decor_box_border_px)));
+ if (x1 - x0 < 4 * border + want + gap) return null;
+ return .{
+ .band = .{ x0, row_top, x1, row_bottom },
+ .box = .{
+ x0,
+ if (stacked_on) row_top - border else text_top - border,
+ x1 - want - gap,
+ if (stacked_under) row_bottom else text_bottom + border,
},
- );
+ .border = border,
+ .shadow = .{ want, drop },
+ };
}
-fn buildOverlay(
- g: *Gui,
- core: ?*const pardes.Pardes,
- surface: *const pardes.Surface,
- layout: CellLayout,
- sw: u32,
- sh: u32,
- topbar_pane_border_rgb: [3]u8,
- tagline_rgb: [3]u8,
- transient_on: bool,
- debug_on: bool,
-) u32 {
- if (g.overlay_vertices.len == 0 or sw == 0 or sh == 0) return 0;
- const win_w: f32 = @floatFromInt(sw);
- const win_h: f32 = @floatFromInt(sh);
- var builder = OverlayBuilder{ .vertices = g.overlay_vertices, .win_w = win_w, .win_h = win_h };
- appendWorkspacePet(g, core, surface, &builder);
- if (topbarPaneBorderHeight(surface, g.cell_h, g.tagline_height)) |height| {
- const y0: f32 = @floatFromInt(g.cell_h - height / 2);
- const rgb = topbar_pane_border_rgb;
- builder.addRect(0, y0, win_w, y0 + @as(f32, @floatFromInt(height)), .{
- .r = @as(f32, @floatFromInt(rgb[0])) / 255.0,
- .g = @as(f32, @floatFromInt(rgb[1])) / 255.0,
- .b = @as(f32, @floatFromInt(rgb[2])) / 255.0,
- .a = 1.0,
- });
+/// Whether another tag's band (the workspace's, a column's, a pane's) meets
+/// `tag`'s right above or below it, across some of its width.
+fn tagBandAt(regions: []const pardes.Region, tag: pardes.Region, side: enum { above, below }) bool {
+ for (regions) |other| {
+ if (other.kind != .tag and other.kind != .column_tag and other.kind != .workspace_tag) continue;
+ if (other.rect.h == 0 or std.meta.eql(other.rect, tag.rect)) continue;
+ const meets = switch (side) {
+ .above => other.rect.y + other.rect.h == tag.rect.y,
+ .below => tag.rect.y + tag.rect.h == other.rect.y,
+ };
+ if (meets and other.rect.x < tag.rect.x + tag.rect.w and tag.rect.x < other.rect.x + other.rect.w) return true;
+ }
+ return false;
+}
+
+/// The two short bars on each row of a grip with no mode glyph there,
+/// centered in its anchor. Only the panes of group `index`.
+fn gripDecor(g: *Gui, gpa: std.mem.Allocator, regions: []const pardes.Region, cells: []const pardes.Cell, groups: *const Groups, index: usize, chrome: *const pardes.Chrome, layout: CellLayout, cols: u16, rows: u16, win_w: f32, win_h: f32, track: ?pardes.animation.Track) !void {
+ if (g.tagline_height < 6 or g.tagline_width < 3) return;
+ for (regions) |grip| {
+ if ((grip.kind != .grip and grip.kind != .column_grip) or groupOf(groups, grip.serial) != index) continue;
+ if (grip.rect.h == 0 or grip.rect.y >= rows) continue;
+ const button = gripButton(g, chrome, grip.rect.x, grip.rect.y, layout, win_h);
+ // Round the button, its first row is the tag's band: nothing of the
+ // cells under it shows there.
+ const band = if (grip.active) chrome.tag_focus_bg else chrome.tag_bg;
+ const left = @as(f32, @floatFromInt(grip.rect.x)) * layout.w;
+ const right = @as(f32, @floatFromInt(grip.rect.x + grip.rect.w)) * layout.w;
+ try addDecor(g, gpa, left, button[1], button[0], button[3], band, 1, track, win_w, win_h);
+ // Right of it, a theme's plaque starts flush against it (plaqueBox).
+ const plaqued = chrome.decor_box_border != null and !cell_decor.plaques_off;
+ if (!plaqued) try addDecor(g, gpa, button[2], button[1], right, button[3], band, 1, track, win_w, win_h);
+ // Its cells over the plaque's reach are let through (emitInstance):
+ // under the button's row, the band goes on as far as the plaque.
+ if (plaqued and grip.rect.h > 1)
+ try addDecor(g, gpa, left, button[3], button[2], @as(f32, @floatFromInt(grip.rect.y + grip.rect.h)) * layout.h, band, 1, track, win_w, win_h);
+ if (grip.kind != .grip) continue;
+ // acme's button ring, two pixels (ButtonBorder) inside the button:
+ // the focused one's in its own fill. An unfocused dirty one keeps a
+ // pixel of band inside its ring, so the four states differ in shape
+ // whatever a theme's colours (a focused dirty one is acme's
+ // modbutton, filled up to its ring).
+ {
+ // The rules drawn over the row (paneDecor, after this) cut into
+ // it: the ring runs inside them, from rule to rule.
+ const tag = for (regions) |part| {
+ if (part.kind == .tag and part.owner == grip.owner) break part;
+ } else grip;
+ const tag_bottom = for (regions) |part| {
+ if (part.kind == .rail and part.owner == grip.owner) break part.rect.y < tag.rect.y;
+ } else false;
+ const stacked = !tag_bottom and for (regions) |other| {
+ if ((other.kind == .body or other.kind == .tag) and other.owner != grip.owner and other.rect.y + other.rect.h == grip.rect.y and
+ other.rect.x < tag.rect.x + tag.rect.w and tag.rect.x < other.rect.x + other.rect.w) break true;
+ } else false;
+ const top_rule: f32 = if (tag_bottom) dp(1) else if (stacked) @max(1, @min(rulePx(chrome), @as(f32, @floatFromInt(taglineBandOffset(grip.rect.y, win_h, g.cell_h, g.tagline_height))))) else 0;
+ const bottom_rule: f32 = if (!tag_bottom and grip.rect.h == 1) dp(1) else 0;
+ const x0 = button[0];
+ const x1 = button[2];
+ const y0 = button[1] + top_rule;
+ const y1 = button[3] - bottom_rule;
+ const ring = if (grip.active) chrome.grip_focus_ring else chrome.grip_border;
+ // acme's ButtonBorder: two logical pixels.
+ const b = dp(2);
+ try addDecor(g, gpa, x0, y0, x1, y0 + b, ring, 1, track, win_w, win_h);
+ try addDecor(g, gpa, x0, y1 - b, x1, y1, ring, 1, track, win_w, win_h);
+ try addDecor(g, gpa, x0, y0 + b, x0 + b, y1 - b, ring, 1, track, win_w, win_h);
+ try addDecor(g, gpa, x1 - b, y0 + b, x1, y1 - b, ring, 1, track, win_w, win_h);
+ if (grip.dirty and !grip.active) {
+ const gap = b + dp(1);
+ try addDecor(g, gpa, x0 + b, y0 + b, x1 - b, y0 + gap, band, 1, track, win_w, win_h);
+ try addDecor(g, gpa, x0 + b, y1 - gap, x1 - b, y1 - b, band, 1, track, win_w, win_h);
+ try addDecor(g, gpa, x0 + b, y0 + gap, x0 + gap, y1 - gap, band, 1, track, win_w, win_h);
+ try addDecor(g, gpa, x1 - gap, y0 + gap, x1 - b, y1 - gap, band, 1, track, win_w, win_h);
+ }
+ }
+ const x = grip.rect.x;
+ for (0..grip.rect.h) |line| {
+ const y = grip.rect.y + @as(u16, @intCast(line));
+ if (x >= cols or y >= rows) continue;
+ const cell = &cells[@as(usize, y) * cols + x];
+ if (cell.default or cell.printableAscii() != ' ') continue;
+ // The marks are in the button's ink, from the region's state.
+ const rgb = inkOn(gripFill(chrome, grip.active, grip.dirty));
+ // The marks are the first row's alone, centered in the button.
+ if (line != 0) continue;
+ const center_x = @floor((button[0] + button[2]) / 2);
+ const center_y = @as(f32, @floatFromInt(y)) * layout.h + @as(f32, @floatFromInt(taglineBandOffset(y, win_h, g.cell_h, g.tagline_height))) + @as(f32, @floatFromInt(g.tagline_height)) / 2;
+ const half_w = @max(dp(1), @min(dp(3), @floor((button[2] - button[0] - 2 * dp(3)) / 2)));
+ // The mode's two bars: a logical pixel thick, a pixel either
+ // side of the middle.
+ const bar = dp(1);
+ try addDecor(g, gpa, @floor(center_x - half_w), @floor(center_y - bar - dp(1)), @floor(center_x + half_w), @floor(center_y - dp(1)), rgb, 1, track, win_w, win_h);
+ try addDecor(g, gpa, @floor(center_x - half_w), @floor(center_y + dp(1)), @floor(center_x + half_w), @floor(center_y + dp(1) + bar), rgb, 1, track, win_w, win_h);
+ }
}
- if (core) |p| if (p.columnBarHeight() > 0) {
- const y = @as(f32, @floatFromInt(pardes.TOPBAR_H + p.columnBarHeight())) * layout.h;
- builder.addRect(0, y - 1, win_w, y, overlayRgb(p.chromeTheme().border));
+}
+
+test "a theme's own rules and scrollbar are drawn at its widths: acme's 2px black rules and 12px track" {
+ const gpa = std.testing.allocator;
+ const core = try pardes.Pardes.init(gpa, .{ .cols = 80, .rows = 24 });
+ defer core.deinit();
+ _ = try core.newShell(1, "");
+ try std.testing.expect(pardes.layout.splitColumn(core, 0, 1, false));
+ try std.testing.expect(core.executeBuiltinLine(0, "Theme acme"));
+ for (0..40) |_| core.update(.tick);
+ core.sync();
+ const s = try core.render(core.scratch.allocator());
+ try std.testing.expectEqual(@as(u8, 2), s.chrome.rule_px);
+ // acme's 12px, at GripWidth's 150% default.
+ try std.testing.expectEqual(@as(u8, 18), s.chrome.rail_px);
+ var g: Gui = undefined;
+ g.decor = .empty;
+ g.glide = .{};
+ g.scroll_pane = null;
+ g.scroll_lag = 0;
+ defer g.decor.deinit(gpa);
+ g.cell_w = 16;
+ g.cell_h = 20;
+ g.tagline_width = 10;
+ g.tagline_height = 12;
+ var groups = makeGroups(&.{}, false);
+ try buildDecor(&g, gpa, s, &groups, fixedCellLayout(&g), 1280, 480, true);
+ const px = struct {
+ fn w(item: CellInstance) f32 {
+ return (item.x1 - item.x0) / 2 * 1280;
+ }
};
- const grid_bottom = @as(f32, @floatFromInt(surface.rows)) * layout.h;
- if (grid_bottom < win_h and bottomTaglinePresent(surface)) {
- const rgb = tagline_rgb;
- builder.addRect(0, grid_bottom, win_w, win_h, .{
- .r = @as(f32, @floatFromInt(rgb[0])) / 255.0,
- .g = @as(f32, @floatFromInt(rgb[1])) / 255.0,
- .b = @as(f32, @floatFromInt(rgb[2])) / 255.0,
- .a = 1.0,
- });
+ var spines: usize = 0;
+ var tracks: usize = 0;
+ for (g.decor.items) |item| {
+ const black = item.br == 0 and item.bg == 0 and item.bb == 0;
+ // No rule at the window's left edge; one 2px spine where columns meet.
+ if (black and @abs(px.w(item) - 2) < 0.01 and item.y1 < -0.9) {
+ try std.testing.expect(item.x0 > -1);
+ spines += 1;
+ }
+ const column = scrollColumn(&g, &s.chrome, 40, fixedCellLayout(&g));
+ if (@abs(item.br - @as(f32, 0x99) / 255) < 1e-3 and @abs(item.bb - @as(f32, 0x4c) / 255) < 1e-3 and @abs(px.w(item) - (column[1] - column[0])) < 0.01) tracks += 1;
}
- if (transient_on) {
- if (core) |p| appendPaneChrome(p, surface, layout, &builder);
- appendTagGrips(g, surface, layout, &builder);
- if (surface.cursor) |cursor| {
- if (cursor.x < surface.cols and cursor.y < surface.rows and bodyLayerAt(surface, cursor.x, cursor.y) == null and tagLayerIn(surface.tagLayers(), cursor.x, cursor.y) == null) {
- const cell = surface.cells[@as(usize, cursor.y) * surface.cols + cursor.x];
- const role = cellFontRole(&cell);
- const visual_height: f32 = if (role == .tagline)
- @floatFromInt(g.tagline_height)
- else
- layout.h;
- const cursor_layout = if (role == .tagline)
- taglineLayoutForCell(g, cursor.x)
- else
- layout;
- addCursorBar(&builder, cursor.x, cursor.y, cursor.bar, visual_height, cursor_layout, cursorColor(core, &cell, role));
+ try std.testing.expectEqual(@as(usize, 1), spines);
+ try std.testing.expect(tracks >= 2);
+}
+
+test "the scrollbar thumb moves by the pixel and follows a glide" {
+ const gpa = std.testing.allocator;
+ const core = try pardes.Pardes.init(gpa, .{ .cols = 80, .rows = 24 });
+ defer core.deinit();
+ const pane = try core.setTestFile(std.mem.asBytes(&@as([1000][5]u8, @splat("line\n".*))));
+ var g: Gui = undefined;
+ g.decor = .empty;
+ defer g.decor.deinit(gpa);
+ g.glide = .{};
+ g.scroll_pane = null;
+ g.scroll_lag = 0;
+ g.cell_w = 10;
+ g.cell_h = 20;
+ g.tagline_width = 6;
+ g.tagline_height = 12;
+ const thumb = struct {
+ // The thumb's top, in window pixels.
+ fn top(gui: *Gui, p: *pardes.Pardes) !f32 {
+ gui.decor.clearRetainingCapacity();
+ p.sync();
+ const s = try p.render(p.scratch.allocator());
+ var groups = makeGroups(&.{}, false);
+ try buildDecor(gui, std.testing.allocator, s, &groups, fixedCellLayout(gui), 800, 480, true);
+ const ink = s.chrome.scroll_thumb;
+ for (gui.decor.items) |item| if (@abs(item.br - @as(f32, @floatFromInt(ink[0])) / 255) < 1e-3 and
+ @abs(item.bg - @as(f32, @floatFromInt(ink[1])) / 255) < 1e-3 and
+ @abs(item.bb - @as(f32, @floatFromInt(ink[2])) / 255) < 1e-3) return (1 - item.y0) / 2 * 480;
+ return error.TestExpectedThumb;
+ }
+ };
+ pane.file.?.scroll = 10;
+ const at10 = try thumb.top(&g, core);
+ pane.file.?.scroll = 11;
+ const at11 = try thumb.top(&g, core);
+ // A line of a thousand moves it a fraction of a row, not 0 or 20 px.
+ try std.testing.expect(at11 > at10 and at11 - at10 < 1);
+ g.glide.pane = core.active;
+ g.glide.follow.offset = -1;
+ try std.testing.expectApproxEqAbs(at10, try thumb.top(&g, core), 1e-3);
+ // A wrapped line: the picture moved two rows for the one line, and the
+ // thumb lags the line, not two.
+ g.glide.lines_moved = 1;
+ g.glide.rows_moved = 2;
+ g.glide.follow.offset = -2;
+ try std.testing.expectApproxEqAbs(at10, try thumb.top(&g, core), 1e-3);
+}
+
+test "the rule between stacked panes stays in the tag band's slack, at any tagline size" {
+ const gpa = std.testing.allocator;
+ const core = try pardes.Pardes.init(gpa, .{ .cols = 80, .rows = 24 });
+ defer core.deinit();
+ _ = try core.newShell(1, "");
+ core.newScratchBelow(0);
+ core.sync();
+ const s = try core.render(core.scratch.allocator());
+ const lower = for (s.regionList()) |region| {
+ if (region.kind == .tag and region.rect.y > 2) break region;
+ } else return error.TestExpectedStackedTag;
+ for ([_]u32{ 12, 20 }) |tagline_h| {
+ var g: Gui = undefined;
+ g.decor = .empty;
+ g.glide = .{};
+ g.scroll_pane = null;
+ g.scroll_lag = 0;
+ defer g.decor.deinit(gpa);
+ g.cell_w = 10;
+ g.cell_h = 20;
+ g.tagline_width = 6;
+ g.tagline_height = tagline_h;
+ var groups = makeGroups(&.{}, false);
+ try buildDecor(&g, gpa, s, &groups, fixedCellLayout(&g), 800, 480, true);
+ const top = @as(f32, @floatFromInt(lower.rect.y)) * 20;
+ const slack: f32 = @floatFromInt(@max(1, pardes.taglineBandOffset(lower.rect.y, 480, 20, tagline_h)));
+ var found = false;
+ for (g.decor.items) |item| {
+ const y0 = (1 - item.y0) / 2 * 480;
+ const y1 = (1 - item.y1) / 2 * 480;
+ if (@abs(y0 - top) > 0.01 or @abs(item.br - @as(f32, @floatFromInt(s.chrome.border[0])) / 255) > 1e-3) continue;
+ found = true;
+ try std.testing.expect(y1 - y0 <= slack + 0.01);
+ }
+ try std.testing.expect(found);
+ }
+}
+
+test "an empty column is ruled on both sides, as between two filled ones" {
+ const gpa = std.testing.allocator;
+ const core = try pardes.Pardes.init(gpa, .{ .cols = 80, .rows = 24 });
+ defer core.deinit();
+ _ = try core.newShell(1, "");
+ try std.testing.expect(pardes.layout.splitColumn(core, 0, 1, false));
+ // Newcol from the left pane: an empty column between the two filled ones.
+ core.newColumn(0);
+ core.sync();
+ try std.testing.expectEqual(@as(usize, 3), core.ncol);
+ try std.testing.expectEqual(@as(usize, 0), core.col_n[1]);
+ const s = try core.render(core.scratch.allocator());
+ var g: Gui = undefined;
+ g.decor = .empty;
+ g.glide = .{};
+ g.scroll_pane = null;
+ g.scroll_lag = 0;
+ defer g.decor.deinit(gpa);
+ g.cell_w = 10;
+ g.cell_h = 20;
+ g.tagline_width = 6;
+ g.tagline_height = 12;
+ const layout = fixedCellLayout(&g);
+ var groups = makeGroups(&.{}, false);
+ try buildDecor(&g, gpa, s, &groups, layout, 800, 480, true);
+ const border = [3]f32{ @as(f32, @floatFromInt(s.chrome.border[0])) / 255, @as(f32, @floatFromInt(s.chrome.border[1])) / 255, @as(f32, @floatFromInt(s.chrome.border[2])) / 255 };
+ // Its left edge and its right edge (the next column's left): each a
+ // rule `rule_px` wide in the border colour, down to the window's foot.
+ for ([_]usize{ 1, 2 }) |column| {
+ const px: f32 = @floatFromInt(@as(u32, core.col_x[column]) * 10);
+ const rule = for (g.decor.items) |item| {
+ if (@abs(item.x0 - (px / 800 * 2 - 1)) < 1e-4 and @abs(item.x1 - ((px + @as(f32, @floatFromInt(s.chrome.rule_px))) / 800 * 2 - 1)) < 1e-4 and
+ std.mem.eql(f32, &.{ item.br, item.bg, item.bb }, &border)) break item;
+ } else return error.TestExpectedColumnRule;
+ try std.testing.expectEqual(@as(f32, -1), rule.y1);
+ }
+}
+
+test "at a 2x display every logical pixel is two: rules, the tag rule, the grip's ring, the rail's edge" {
+ const gpa = std.testing.allocator;
+ const core = try pardes.Pardes.init(gpa, .{ .cols = 80, .rows = 24 });
+ defer core.deinit();
+ _ = try core.newShell(1, "");
+ try std.testing.expect(pardes.layout.splitColumn(core, 0, 1, false));
+ try std.testing.expect(core.executeBuiltinLine(0, "Theme acme"));
+ for (0..40) |_| core.update(.tick);
+ core.sync();
+ const s = try core.render(core.scratch.allocator());
+ for ([_]f32{ 1, 2 }) |scale| {
+ display_scale = scale;
+ defer display_scale = 1;
+ var g: Gui = undefined;
+ g.decor = .empty;
+ g.glide = .{};
+ g.scroll_pane = null;
+ g.scroll_lag = 0;
+ defer g.decor.deinit(gpa);
+ g.cell_w = 16;
+ g.cell_h = 32;
+ g.tagline_width = 12;
+ g.tagline_height = 24;
+ var groups = makeGroups(&.{}, false);
+ try buildDecor(&g, gpa, s, &groups, fixedCellLayout(&g), 1280, 768, true);
+ const w = struct {
+ fn of(item: CellInstance) f32 {
+ return (item.x1 - item.x0) / 2 * 1280;
}
+ fn h(item: CellInstance) f32 {
+ return (item.y0 - item.y1) / 2 * 768;
+ }
+ };
+ var spine: ?f32 = null;
+ var tag_rule: ?f32 = null;
+ var ring: ?f32 = null;
+ for (g.decor.items) |item| {
+ const rgb: [3]u8 = .{ @intFromFloat(@round(item.br * 255)), @intFromFloat(@round(item.bg * 255)), @intFromFloat(@round(item.bb * 255)) };
+ // The spine between the columns: black, tall.
+ if (std.mem.eql(u8, &rgb, &.{ 0, 0, 0 }) and w.h(item) > 300) spine = @round(w.of(item));
+ // The tag rule: #8888cc, wide and thin.
+ if (std.mem.eql(u8, &rgb, &.{ 0x88, 0x88, 0xcc }) and w.of(item) > 200) tag_rule = @round(w.h(item));
+ // The ring's left side: #8888cc, a tag row tall.
+ if (std.mem.eql(u8, &rgb, &.{ 0x88, 0x88, 0xcc }) and w.h(item) > 10 and w.of(item) < 8) ring = @round(w.of(item));
}
+ try std.testing.expectEqual(@as(?f32, 2 * scale), spine);
+ try std.testing.expectEqual(@as(?f32, 1 * scale), tag_rule);
+ try std.testing.expectEqual(@as(?f32, 2 * scale), ring);
+ // The rail starts after the rule, a logical 2 in, and keeps a
+ // logical 3 clear of the text when the cell is narrow.
+ const column = scrollColumn(&g, &s.chrome, 40, fixedCellLayout(&g));
+ try std.testing.expectEqual(40 * 16 + 2 * scale, column[0]);
+ g.cell_w = 12;
+ defer g.cell_w = 16;
+ const narrow = scrollColumn(&g, &s.chrome, 40, fixedCellLayout(&g));
+ try std.testing.expectEqual(@as(f32, 40 * 12 + 2 * scale), narrow[0]);
+ try std.testing.expectEqual(@as(f32, 40 * 12) + 12 * @as(f32, @floatFromInt(config.GUTTER)) - 3 * scale, narrow[1]);
+ g.cell_w = 8;
+ // A bar cursor is an eighth of its cell, never under a logical pixel
+ // (an 8 px cell: one pixel, two at 2x).
+ const saved = s.cursor;
+ defer s.cursor = saved;
+ s.cursor = .{ .x = 60, .y = 10, .bar = true };
+ var boxes: [max_cursors]CursorBox = undefined;
+ const n = cursorBoxes(&g, s, fixedCellLayout(&g), 768, &boxes);
+ const bar = for (boxes[0..n]) |box| {
+ if (box.bar and box.x0 == 60 * 8) break box;
+ } else return error.NoBarCursor;
+ try std.testing.expectEqual(scale, bar.x1 - bar.x0);
}
- if (transient_on) for (surface.bodyLayers()) |*layer| {
+}
+
+test "decor is read from the regions, each pane's in its own group" {
+ const gpa = std.testing.allocator;
+ const core = try pardes.Pardes.init(gpa, .{ .cols = 80, .rows = 24 });
+ defer core.deinit();
+ _ = try core.newShell(1, "");
+ try std.testing.expect(pardes.layout.splitColumn(core, 0, 1, false));
+ core.sync();
+ const s = try core.render(core.scratch.allocator());
+ var g: Gui = undefined;
+ g.decor = .empty;
+ g.glide = .{};
+ g.scroll_pane = null;
+ g.scroll_lag = 0;
+ defer g.decor.deinit(gpa);
+ g.cell_w = 10;
+ g.cell_h = 20;
+ g.tagline_width = 6;
+ g.tagline_height = 12;
+ const layout = fixedCellLayout(&g);
+ const ndc = struct {
+ fn x(px: f32) f32 {
+ return px / 800 * 2 - 1;
+ }
+ };
+ var groups = makeGroups(&.{}, false);
+ try buildDecor(&g, gpa, s, &groups, layout, 800, 480, true);
+ // A spine one pixel wide at each column's left edge, down from under the
+ // workspace tag; a rail two pixels wide at each pane's.
+ for (core.col_x[0..core.ncol]) |x| {
+ const left = ndc.x(@as(f32, @floatFromInt(x)) * 10);
+ // Two pixels (rule_px), and none at the window's own edge.
+ const spine = for (g.decor.items) |item| {
+ if (item.x0 == left and @abs(item.x1 - ndc.x(@as(f32, @floatFromInt(x)) * 10 + 2)) < 0.0001 and
+ @abs(item.y0 - (1 - 20.0 / 480.0 * 2)) < 0.0001 and std.mem.eql(f32, &.{ item.br, item.bg, item.bb }, &.{ @as(f32, @floatFromInt(s.chrome.border[0])) / 255, @as(f32, @floatFromInt(s.chrome.border[1])) / 255, @as(f32, @floatFromInt(s.chrome.border[2])) / 255 })) break item;
+ } else null;
+ try std.testing.expectEqual(x == 0, spine == null);
+ if (spine) |rule| {
+ try std.testing.expectApproxEqAbs(@as(f32, 1 - 20.0 / 480.0 * 2), rule.y0, 0.0001);
+ try std.testing.expectEqual(@as(f32, -1), rule.y1);
+ }
+ // The scrollbar fills the scroll column right of the rule.
+ const column = scrollColumn(&g, &s.chrome, x, layout);
+ const rail = for (g.decor.items) |item| {
+ if (@abs(item.x0 - ndc.x(column[0])) < 0.0001 and @abs(item.x1 - ndc.x(column[1])) < 0.0001 and
+ @abs(item.br - @as(f32, @floatFromInt(s.chrome.scroll_track[0])) / 255) < 0.0001) break item;
+ } else return error.TestExpectedRail;
+ _ = rail;
+ }
+ try std.testing.expectEqual(@as(u32, 0), groups.items[groups.notices].decor_count);
+ const still = groups.items[0].decor_count;
+
+ // Pane 1 moving: its rule and rail leave tier 0 for its track's group,
+ // which moves them with it.
+ const serial = core.panes[1].?.serial;
+ const moving: pardes.animation.Track = .{ .pane = 1, .serial = serial, .phase = .moving, .effect = .slide, .from = .{ .x = 0, .y = 1, .w = 40, .h = 23 }, .to = .{ .x = 40, .y = 1, .w = 40, .h = 23 } };
+ groups = makeGroups(&.{moving}, true);
+ try buildDecor(&g, gpa, s, &groups, layout, 800, 480, groups.tracks == 0);
+ const tracked = groups.items[1];
+ try std.testing.expect(tracked.decor_count >= 4);
+ try std.testing.expectEqual(still, groups.items[0].decor_count + tracked.decor_count);
+ for (g.decor.items[tracked.decor_start..][0..tracked.decor_count]) |item|
+ try std.testing.expectEqual(@as(u32, @backingInt(pardes.animation.Transition.slide)), item.effect);
+ // Cursors stand still while panes move.
+ try std.testing.expectEqual(@as(u32, 0), groups.items[groups.ink].decor_count);
+}
+
+test "a pane on the move casts a shadow on the other panes' bodies alone, most at mid-way" {
+ const gpa = std.testing.allocator;
+ const core = try pardes.Pardes.init(gpa, .{ .cols = 80, .rows = 24 });
+ defer core.deinit();
+ _ = try core.newShell(1, "");
+ try std.testing.expect(pardes.layout.splitColumn(core, 0, 1, false));
+ try std.testing.expect(core.executeBuiltinLine(0, "Theme acme"));
+ for (0..40) |_| core.update(.tick);
+ core.sync();
+ const s = try core.render(core.scratch.allocator());
+ var g: Gui = undefined;
+ g.decor = .empty;
+ g.glide = .{};
+ g.scroll_pane = null;
+ g.scroll_lag = 0;
+ defer g.decor.deinit(gpa);
+ g.cell_w = 10;
+ g.cell_h = 20;
+ g.tagline_width = 6;
+ g.tagline_height = 12;
+ const layout = fixedCellLayout(&g);
+ const serial = core.panes[1].?.serial;
+ var strengths: [3]f32 = @splat(0);
+ for ([_]u16{ 0, 6, 12 }, 0..) |frame, i| {
+ g.decor.clearRetainingCapacity();
+ const moving: pardes.animation.Track = .{ .pane = 1, .serial = serial, .phase = .moving, .effect = .slide, .frame = frame, .frame_count = 13, .from = .{ .x = 0, .y = 1, .w = 40, .h = 23 }, .to = .{ .x = 40, .y = 1, .w = 40, .h = 23 } };
+ var groups = makeGroups(&.{moving}, true);
+ if (!moving.active()) groups = makeGroups(&.{}, true);
+ try buildDecor(&g, gpa, s, &groups, layout, 800, 480, false);
+ for (g.decor.items) |item| {
+ if (item.effect & soft_shadow_bit == 0) continue;
+ strengths[i] = @max(strengths[i], item.fr);
+ // Clipped to pane 0's body or rail, never pane 1's, never a tag.
+ try std.testing.expect(item.clip_x1 >= item.clip_x0);
+ for (s.regionList()) |region| {
+ if (region.kind != .tag and region.kind != .grip and !(region.owner == 1 and (region.kind == .body or region.kind == .rail))) continue;
+ const r = bodyPixels(region, layout);
+ try std.testing.expect(item.clip_x1 <= r[0] or item.clip_x0 >= r[2] or item.clip_y1 <= r[1] or item.clip_y0 >= r[3]);
+ }
+ }
+ }
+ // Rising as it sets out, gone as it lands.
+ try std.testing.expectEqual(@as(f32, 0), strengths[0]);
+ try std.testing.expect(strengths[1] > 0.05);
+ try std.testing.expectEqual(@as(f32, 0), strengths[2]);
+}
+
+test "the selection glows round its block, on the body only, fading in over 100 ms" {
+ const gpa = std.testing.allocator;
+ const core = try pardes.Pardes.init(gpa, .{ .cols = 80, .rows = 24 });
+ defer core.deinit();
+ _ = try core.setTestFile(std.mem.asBytes(&@as([30][20]u8, @splat("some text on a line\n".*))));
+ core.settings.selection_glow = true;
+ core.sync();
+ const s = try core.render(core.scratch.allocator());
+ try std.testing.expectEqual(@as(u8, 1), s.chrome.fx);
+ // Two rows of a selection in the body, as the core paints one.
+ const body = for (s.regionList()) |region| {
+ if (region.kind == .body) break region;
+ } else return error.NoBody;
+ for (0..2) |dy| for (5..12) |x| {
+ const cell = &s.cells[(@as(usize, body.rect.y) + 3 + dy) * s.cols + body.rect.x + x];
+ cell.default = false;
+ cell.style.bg = .{ .rgb = s.chrome.sel_bg };
+ };
+ s.cursor = null;
+ var g: Gui = undefined;
+ g.decor = .empty;
+ g.glide = .{};
+ g.scroll_pane = null;
+ g.scroll_lag = 0;
+ defer g.decor.deinit(gpa);
+ g.cell_w = 10;
+ g.cell_h = 20;
+ g.tagline_width = 6;
+ g.tagline_height = 12;
+ g.sel_glow = .{ .now_ns = std.time.ns_per_s };
+ var strengths: [2]f32 = .{ 0, 0 };
+ for ([_]u64{ 0, 150 * std.time.ns_per_ms }, 0..) |later, i| {
+ g.decor.clearRetainingCapacity();
+ g.sel_glow.now_ns = std.time.ns_per_s + later;
+ var groups = makeGroups(&.{}, false);
+ try buildDecor(&g, gpa, s, &groups, fixedCellLayout(&g), 800, 480, true);
+ for (g.decor.items) |item| {
+ if (item.effect & soft_shadow_bit == 0) continue;
+ const rgb: [3]u8 = .{ @intFromFloat(@round(item.br * 255)), @intFromFloat(@round(item.bg * 255)), @intFromFloat(@round(item.bb * 255)) };
+ if (!std.mem.eql(u8, &rgb, &s.chrome.sel_bg)) continue;
+ strengths[i] = @max(strengths[i], item.fr);
+ // On the body alone.
+ const r = bodyPixels(body, fixedCellLayout(&g));
+ try std.testing.expect(item.clip_x0 >= r[0] - 0.01 and item.clip_x1 <= r[2] + 0.01 and item.clip_y0 >= r[1] - 0.01 and item.clip_y1 <= r[3] + 0.01);
+ }
+ try std.testing.expectEqual(@as(usize, 1), g.sel_glow.len);
+ }
+ // Just appeared: nothing yet, and still fading; later, up to its cap.
+ try std.testing.expectEqual(@as(f32, 0), strengths[0]);
+ try std.testing.expect(strengths[1] > 0.05 and strengths[1] <= 0.22 + 1e-4);
+ try std.testing.expect(!g.sel_glow.fading);
+}
+
+test "a hovered word glows along its foot, never over the cursor, fading in over 80 ms" {
+ const gpa = std.testing.allocator;
+ const core = try pardes.Pardes.init(gpa, .{ .cols = 80, .rows = 24 });
+ defer core.deinit();
+ _ = try core.setTestFile(std.mem.asBytes(&@as([30][20]u8, @splat("some text on a line\n".*))));
+ core.settings.hover_glow = true;
+ core.sync();
+ const s = try core.render(core.scratch.allocator());
+ try std.testing.expectEqual(@as(u8, 2), s.chrome.fx);
+ const body = for (s.regionList()) |region| {
+ if (region.kind == .body) break region;
+ } else return error.NoBody;
+ const page = s.chrome.page orelse bg_default;
+ const tint = mixRgb(page, mixRgb(page, s.chrome.sel_bg));
+ const row = body.rect.y + 4;
+ for (5..12) |x| {
+ const cell = &s.cells[@as(usize, row) * s.cols + body.rect.x + x];
+ cell.default = false;
+ cell.style.bg = .{ .rgb = tint };
+ }
+ s.cursor = .{ .x = body.rect.x + 8, .y = row };
+ var g: Gui = undefined;
+ g.decor = .empty;
+ g.glide = .{};
+ g.scroll_pane = null;
+ g.scroll_lag = 0;
+ defer g.decor.deinit(gpa);
+ g.cell_w = 10;
+ g.cell_h = 20;
+ g.tagline_width = 6;
+ g.tagline_height = 12;
+ g.sel_glow = .{};
+ g.hover_glow = .{ .now_ns = std.time.ns_per_s };
+ var strongest: f32 = 0;
+ for ([_]u64{ 0, 90 * std.time.ns_per_ms }) |later| {
+ g.decor.clearRetainingCapacity();
+ g.hover_glow.now_ns = std.time.ns_per_s + later;
+ var groups = makeGroups(&.{}, false);
+ try buildDecor(&g, gpa, s, &groups, fixedCellLayout(&g), 800, 480, true);
+ for (g.decor.items) |item| {
+ if (item.effect & soft_shadow_bit == 0) continue;
+ if (later == 0) try std.testing.expect(false);
+ strongest = @max(strongest, item.fr);
+ // Never over the cursor's cell.
+ const cx0: f32 = @floatFromInt(@as(u32, s.cursor.?.x) * 10);
+ const cy0: f32 = @floatFromInt(@as(u32, s.cursor.?.y) * 20);
+ try std.testing.expect(item.clip_x1 <= cx0 + 0.01 or item.clip_x0 >= cx0 + 10 - 0.01 or item.clip_y1 <= cy0 + 0.01 or item.clip_y0 >= cy0 + 20 - 0.01);
+ }
+ }
+ try std.testing.expect(strongest > 0.05);
+ try std.testing.expect(!g.hover_glow.fading);
+}
+
+test "occlusion shades each body's edges, inside it, never a tag, a grip or the cursor" {
+ const gpa = std.testing.allocator;
+ const core = try pardes.Pardes.init(gpa, .{ .cols = 80, .rows = 24 });
+ defer core.deinit();
+ _ = try core.setTestFile(std.mem.asBytes(&@as([30][20]u8, @splat("some text on a line\n".*))));
+ core.settings.occlusion = true;
+ core.sync();
+ const s = try core.render(core.scratch.allocator());
+ try std.testing.expectEqual(@as(u8, 4), s.chrome.fx);
+ const body = for (s.regionList()) |region| {
+ if (region.kind == .body) break region;
+ } else return error.NoBody;
+ // The cursor on the body's top-left cell, where the shade is.
+ s.cursor = .{ .x = body.rect.x, .y = body.rect.y };
+ var g: Gui = undefined;
+ g.decor = .empty;
+ g.glide = .{};
+ g.scroll_pane = null;
+ g.scroll_lag = 0;
+ defer g.decor.deinit(gpa);
+ g.cell_w = 10;
+ g.cell_h = 20;
+ g.tagline_width = 6;
+ g.tagline_height = 12;
+ g.sel_glow = .{};
+ g.hover_glow = .{};
+ var groups = makeGroups(&.{}, false);
+ try buildDecor(&g, gpa, s, &groups, fixedCellLayout(&g), 800, 480, true);
+ const r = bodyPixels(body, fixedCellLayout(&g));
+ var shades: usize = 0;
+ for (g.decor.items) |item| {
+ if (item.effect & soft_shadow_bit == 0) continue;
+ shades += 1;
+ try std.testing.expect(item.fr <= 0.02 + 1e-6);
+ try std.testing.expect(item.clip_x0 >= r[0] - 0.01 and item.clip_x1 <= r[2] + 0.01 and item.clip_y0 >= r[1] - 0.01 and item.clip_y1 <= r[3] + 0.01);
+ const cx: f32 = @floatFromInt(@as(u32, s.cursor.?.x) * 10);
+ const cy: f32 = @floatFromInt(@as(u32, s.cursor.?.y) * 20);
+ try std.testing.expect(item.clip_x1 <= cx + 0.01 or item.clip_x0 >= cx + 10 - 0.01 or item.clip_y1 <= cy + 0.01 or item.clip_y0 >= cy + 20 - 0.01);
+ }
+ try std.testing.expect(shades >= 4);
+}
+
+test "a body tells its first line, and lapis's dots under it move a quarter as far" {
+ const gpa = std.testing.allocator;
+ const core = try pardes.Pardes.init(gpa, .{ .cols = 80, .rows = 24 });
+ defer core.deinit();
+ const pane = try core.setTestFile(std.mem.asBytes(&@as([80][5]u8, @splat("line\n".*))));
+ pane.scrollBy(8);
+ try std.testing.expect(core.executeBuiltinLine(0, "Theme lapis"));
+ core.settings.parallax = true;
+ for (0..40) |_| core.update(.tick);
+ core.sync();
+ const s = try core.render(core.scratch.allocator());
+ const body = for (s.regionList()) |region| {
+ if (region.kind == .body) break region;
+ } else return error.NoBody;
+ try std.testing.expectEqual(@as(i32, 8), body.line);
+ try std.testing.expect(s.chrome.fx & 8 != 0);
+ // The shift the cell shader is handed: a quarter of 8 rows of 20 px,
+ // upward, within the dots' period.
+ var decor = CellDecor.of(&s.chrome);
+ const period = decor.uniforms[4];
+ decor.bodies[0] = .{ 0, 0, 800, 480 };
+ decor.shifts[0] = @mod(-8.0 * 20.0 * 0.25, period);
+ decor.nbodies = 1;
+ try std.testing.expectApproxEqAbs(@mod(-40.0, period), decor.parallaxAt(10, 10), 1e-4);
+ try std.testing.expectEqual(@as(f32, 0), decor.parallaxAt(900, 10));
+}
+
+/// What a bundled post pass leaves alone (Post.Frame.spare), in window
+/// pixels: every tag with its grip, the column and workspace tags, and the
+/// notices, the chrome the focus indicators live in. A grip, the gap after
+/// it and the tag beside it are one rectangle; past the list's end the last
+/// grows to cover the rest.
+fn postSpare(surface: *const pardes.Surface, layout: CellLayout, out: *[Post.max_spare][4]f32) usize {
+ var n: usize = 0;
+ for (surface.regionList()) |region| {
+ switch (region.kind) {
+ .grip, .tag, .notice, .column_grip, .column_tag, .workspace_tag => {},
+ else => continue,
+ }
+ if (region.rect.w == 0 or region.rect.h == 0) continue;
+ const rect: [4]f32 = .{
+ @as(f32, @floatFromInt(region.rect.x)) * layout.w,
+ @as(f32, @floatFromInt(region.rect.y)) * layout.h,
+ @as(f32, @floatFromInt(region.rect.x + region.rect.w)) * layout.w,
+ @as(f32, @floatFromInt(region.rect.y + region.rect.h)) * layout.h,
+ };
+ const joined = for (out[0..n]) |*other| {
+ // The same rows, a gap cell or two apart (a grip, the gap after
+ // it, its tag): one band.
+ const gap = 2 * layout.w + 0.5;
+ if (other[1] == rect[1] and other[3] == rect[3] and rect[0] <= other[2] + gap and other[0] <= rect[2] + gap) {
+ other.* = .{ @min(other[0], rect[0]), rect[1], @max(other[2], rect[2]), rect[3] };
+ break true;
+ }
+ } else false;
+ if (joined) continue;
+ if (n == out.len) {
+ const last = &out[n - 1];
+ last.* = .{ @min(last[0], rect[0]), @min(last[1], rect[1]), @max(last[2], rect[2]), @max(last[3], rect[3]) };
+ continue;
+ }
+ out[n] = rect;
+ n += 1;
+ }
+ return n;
+}
+
+const CursorBox = Post.Frame.Cursor;
+const max_cursors = 1 + pardes.MAX_PANES + pardes.MAX_TAG_LAYERS;
+
+/// Where the frame draws the focused caret, its top in grid rows: from its
+/// own springs (the quad's, while it moves or while a glide moves the text)
+/// or its cell; carried by the text's glide when its line rode it. The probe
+/// records it and the glide tests hold its invariants.
+fn caretRow(g: *const Gui, surface: *const pardes.Surface) ?f32 {
+ const chrome = &surface.chrome;
+ const cursor = surface.cursor orelse return null;
+ const quad = chrome.cursor_glide & 2 != 0 and (chrome.cursor_glide & 1 != 0 or g.glide.follow.offset != 0);
+ return if (quad) chrome.cursor_quad[1] - caretRide(g, surface) else @floatFromInt(cursor.y);
+}
+
+/// The rows a caret whose line rode the wheel's glide is drawn above its
+/// cell: the text's own offset, so it moves with its line as a glyph does
+/// (its springs landed on the cell, draw.glideCursor).
+fn caretRide(g: *const Gui, surface: *const pardes.Surface) f32 {
+ const glide = &g.glide;
+ if (!glide.caret_rides or glide.follow.offset == 0) return 0;
+ const cu = surface.cursor orelse return 0;
+ const x0 = glide.rect.x + config.GUTTER;
+ if (cu.x < x0 or cu.x >= x0 + glide.bw() or cu.y < glide.body_y or cu.y >= glide.body_y + glide.body_h) return 0;
+ return glide.follow.offset;
+}
+
+/// Every cursor on the frame where it is drawn, in window pixels: the grid's
+/// where no layer has its cell, and each layer's at that layer's pitch. A bar
+/// is an eighth of its cell wide, a block the whole cell.
+fn cursorBoxes(g: *const Gui, surface: *const pardes.Surface, layout: CellLayout, win_h: f32, out: *[max_cursors]CursorBox) usize {
+ const chrome = &surface.chrome;
+ const page = chrome.page orelse bg_default;
+ var n: usize = 0;
+ if (surface.cursor) |cursor| {
+ if (cursor.x < surface.cols and cursor.y < surface.rows and bodyLayerAt(surface, cursor.x, cursor.y) == null and tagLayerIn(surface.tagLayers(), cursor.x, cursor.y) == null) {
+ const cell = &surface.cells[@as(usize, cursor.y) * surface.cols + cursor.x];
+ const role = cellFontRole(cell);
+ const width: f32 = if (role == .tagline) @floatFromInt(g.tagline_width) else layout.w;
+ const height = std.math.clamp(if (role == .tagline) @as(f32, @floatFromInt(g.tagline_height)) else layout.h, 1.0, layout.h);
+ const x0 = @as(f32, @floatFromInt(cursor.x)) * layout.w;
+ const y0 = @as(f32, @floatFromInt(cursor.y)) * layout.h + @as(f32, @floatFromInt(taglineBandOffset(cursor.y, win_h, @intFromFloat(layout.h), @intFromFloat(height))));
+ out[n] = .{ .x0 = x0, .y0 = y0, .x1 = x0 + if (cursor.bar) @max(dp(1), width / 8.0) else width, .y1 = y0 + height, .rgb = cursorColor(chrome, cell, role), .text = page, .bar = cursor.bar };
+ n += 1;
+ }
+ }
+ for (surface.bodyLayers()) |*layer| {
if (layer.rows == 0) continue;
+ const cursor = layer.cursor orelse continue;
+ if (cursor.y >= layer.rows or cursor.x >= layer.cols) continue;
const left = @as(f32, @floatFromInt(layer.viewport.x)) * layout.w;
const bottom = @as(f32, @floatFromInt(layer.viewport.y + layer.viewport.h)) * layout.h;
- if (layer.cursor) |cursor| {
- if (!cursor.bar or cursor.y >= layer.rows or cursor.x >= layer.cols) continue;
- const top = layer.rowTop(cursor.y, layout.h, @floatFromInt(g.tagline_height));
- if (top >= bottom) continue;
- const height = layer.rowHeight(cursor.y, layout.h, @floatFromInt(g.tagline_height));
- const role: pardes.FontRole = if (cursor.y < layer.context_rows) .tagline else .body;
- const width: f32 = if (role == .tagline) @floatFromInt(g.tagline_width) else layout.w;
- const x = left + @as(f32, @floatFromInt(cursor.x)) * width;
- const cell = &layer.cells[@as(usize, cursor.y) * layer.cols + cursor.x];
- builder.addRect(x, top, x + @max(1, width / 8), @min(bottom, top + height), overlayRgb(cursorColor(core, cell, role)));
- }
- };
- if (transient_on) for (surface.tagLayers()) |*layer| {
- if (layer.cols == 0) continue;
+ const top = layer.rowTop(cursor.y, layout.h, @floatFromInt(g.tagline_height));
+ if (top >= bottom) continue;
+ const height = layer.rowHeight(cursor.y, layout.h, @floatFromInt(g.tagline_height));
+ const role: pardes.FontRole = if (cursor.y < layer.context_rows) .tagline else .body;
+ const width: f32 = if (role == .tagline) @floatFromInt(g.tagline_width) else layout.w;
+ const x = left + @as(f32, @floatFromInt(cursor.x)) * width;
+ const cell = &layer.cells[@as(usize, cursor.y) * layer.cols + cursor.x];
+ out[n] = .{ .x0 = x, .y0 = top, .x1 = x + if (cursor.bar) @max(dp(1), width / 8) else width, .y1 = @min(bottom, top + height), .rgb = cursorColor(chrome, cell, role), .text = page, .bar = cursor.bar };
+ n += 1;
+ }
+ for (surface.tagLayers()) |*layer| {
+ if (layer.rows == 0) continue;
const cursor = layer.cursor orelse continue;
- if (!cursor.bar or cursor.col >= layer.cols) continue;
+ if (cursor.x >= layer.cols or cursor.y >= layer.rows) continue;
const width: f32 = @floatFromInt(g.tagline_width);
const left = @as(f32, @floatFromInt(layer.viewport.x)) * layout.w;
const right = left + @as(f32, @floatFromInt(layer.viewport.w)) * layout.w;
- const x = left + @as(f32, @floatFromInt(cursor.col)) * width;
- if (x >= right) continue;
- const top = @as(f32, @floatFromInt(layer.viewport.y)) * layout.h + @as(f32, @floatFromInt(taglineBandOffset(layer.viewport.y, builder.win_h, g.cell_h, g.tagline_height, true)));
- builder.addRect(x, top, @min(right, x + @max(1, width / 8)), top + @as(f32, @floatFromInt(g.tagline_height)), overlayRgb(cursorColor(core, &layer.cells[cursor.col], .tagline)));
- };
- if (transient_on) appendTouchOverlay(g, &builder, debug_on);
+ // Past a full row's end the caret sits at the tag's right edge, as
+ // the grid's does (and the core's cursor box, draw.focusedCursorBox).
+ const x = @min(left + @as(f32, @floatFromInt(cursor.x)) * width, right - if (cursor.bar) @max(dp(1), width / 8) else width);
+ const y = layer.viewport.y + cursor.y;
+ const top = @as(f32, @floatFromInt(y)) * layout.h + @as(f32, @floatFromInt(taglineBandOffset(y, win_h, g.cell_h, g.tagline_height)));
+ out[n] = .{ .x0 = x, .y0 = top, .x1 = @min(right, x + if (cursor.bar) @max(dp(1), width / 8) else width), .y1 = top + @as(f32, @floatFromInt(g.tagline_height)), .rgb = cursorColor(chrome, &layer.cells[@as(usize, cursor.y) * layer.cols + cursor.x], .tagline), .text = page, .bar = cursor.bar };
+ n += 1;
+ }
+ return n;
+}
+
+/// The bar cursors as decor; a block cursor is its cell's own colours.
+fn cursorDecor(g: *Gui, gpa: std.mem.Allocator, surface: *const pardes.Surface, layout: CellLayout, win_w: f32, win_h: f32) !void {
+ var boxes: [max_cursors]CursorBox = undefined;
+ for (boxes[0..cursorBoxes(g, surface, layout, win_h, &boxes)]) |box|
+ if (box.bar) try addDecor(g, gpa, box.x0, box.y0, box.x1, box.y1, box.rgb, 1, null, win_w, win_h);
+}
+
+/// The triangle overlay: the workspace pet and the touch debug view, over
+/// everything.
+fn buildOverlay(
+ g: *Gui,
+ core: ?*const pardes.Pardes,
+ surface: *const pardes.Surface,
+ sw: u32,
+ sh: u32,
+ debug_on: bool,
+) u32 {
+ if (g.overlay_vertices.len == 0 or sw == 0 or sh == 0) return 0;
+ var builder = OverlayBuilder{ .vertices = g.overlay_vertices, .win_w = @floatFromInt(sw), .win_h = @floatFromInt(sh) };
+ appendWorkspacePet(g, core, surface, &builder);
+ appendCursorGlide(g, surface, &builder);
+ appendTouchOverlay(g, &builder, debug_on);
return @intCast(builder.len);
}
+/// G3: the focused cursor while it glides or blinks, its quad from the core
+/// (Chrome.cursor_quad, grid cells) in its cursor colour; a little less than
+/// solid, so the glyphs it passes over stay legible.
+fn appendCursorGlide(g: *Gui, surface: *const pardes.Surface, builder: *OverlayBuilder) void {
+ const chrome = &surface.chrome;
+ if (g.cursor_quad_alpha <= 0.001) return;
+ const layout = fixedCellLayout(g);
+ const ride = caretRide(g, surface);
+ if (ride != 0) {
+ // Carried past the body's edge with its line: clipped as the text is.
+ const mid = chrome.cursor_quad[1] - ride + 0.5;
+ const top: f32 = @floatFromInt(g.glide.body_y);
+ if (mid < top or mid > top + @as(f32, @floatFromInt(g.glide.body_h))) return;
+ }
+ var px: [4][2]f32 = undefined;
+ var centre: [2]f32 = .{ 0, 0 };
+ for (&px, 0..) |*point, i| {
+ point.* = .{ chrome.cursor_quad[i * 2] * layout.w, (chrome.cursor_quad[i * 2 + 1] - ride) * layout.h };
+ centre[0] += point[0] / 4;
+ centre[1] += point[1] / 4;
+ }
+ // Its colour: the cursor the cells would draw nearest the quad.
+ var boxes: [max_cursors]CursorBox = undefined;
+ var rgb: [3]u8 = chrome.fg orelse fg_default;
+ var nearest: f32 = std.math.inf(f32);
+ for (boxes[0..cursorBoxes(g, surface, layout, builder.win_h, &boxes)]) |box| {
+ const dx = (box.x0 + box.x1) / 2 - centre[0];
+ const dy = (box.y0 + box.y1) / 2 - centre[1];
+ if (dx * dx + dy * dy < nearest) {
+ nearest = dx * dx + dy * dy;
+ rgb = box.rgb;
+ }
+ }
+ const color: OverlayColor = .{ .r = @as(f32, @floatFromInt(rgb[0])) / 255, .g = @as(f32, @floatFromInt(rgb[1])) / 255, .b = @as(f32, @floatFromInt(rgb[2])) / 255, .a = g.cursor_quad_alpha };
+ builder.addTri(px[0][0], px[0][1], px[1][0], px[1][1], px[2][0], px[2][1], color);
+ builder.addTri(px[0][0], px[0][1], px[2][0], px[2][1], px[3][0], px[3][1], color);
+}
+
fn appendWorkspacePet(g: *Gui, core: ?*const pardes.Pardes, surface: *const pardes.Surface, builder: *OverlayBuilder) void {
const p = core orelse return;
- const kind: pet.Kind = @enumFromInt(@intFromEnum(p.settings.pet));
+ const kind: pet.Kind = @fromBackingInt(@intCast(@backingInt(p.settings.pet)));
if (kind == .off or surface.rows == 0 or surface.cols == 0) {
g.pet_state = .{};
return;
}
// Read only the rendered global row. No pane/column tags, status text or
- // mouse targets are changed, and editing the workspace parks the pet.
+ // mouse targets are changed; editing the workspace tag leaves it be.
var occupied: usize = 0;
for (surface.cells[0..surface.cols], 0..) |*cell, i| {
if (cellCodepoint(cell) != ' ') occupied = i + 1;
}
- const editing = p.topbar_col != null and p.header_column == null;
- const band_top: f32 = @floatFromInt(taglineBandOffset(0, builder.win_h, g.cell_h, g.tagline_height, true));
+ const band_top: f32 = @floatFromInt(taglineBandOffset(0, builder.win_h, g.cell_h, g.tagline_height));
const region = if (occupied >= surface.cols) null else pet.lane(
occupied,
@floatFromInt(g.tagline_width),
builder.win_w,
band_top,
@floatFromInt(g.tagline_height),
- editing,
);
// SDL's regular pump already wakes at least every 16 ms. Quantization in
// sample keeps this independent of input, render rate and scene effects,
@@ -6586,16 +10657,24 @@ fn appendWorkspacePet(g: *Gui, core: ?*const pardes.Pardes, surface: *const pard
const pose = g.pet_state.sample(kind, c.SDL_GetTicks(), region) orelse return;
const ink = overlayRgb(p.chromeTheme().tag_fg);
const eye = overlayRgb(p.chromeTheme().tag_bg);
+ // Behind the cursor: the overlay is over the cells, so the pixels a
+ // cursor covers are left out.
+ var boxes: [max_cursors]CursorBox = undefined;
+ const cursors = boxes[0..cursorBoxes(g, surface, fixedCellLayout(g), builder.win_h, &boxes)];
for (0..pet.height) |y| for (0..pet.width) |x| {
const color = pet.pixel(kind, pose, x, y);
if (color == 0) continue;
const x0 = pose.x + @as(f32, @floatFromInt(x)) * pose.scale;
const y0 = pose.y + @as(f32, @floatFromInt(y)) * pose.scale;
+ const covered = for (cursors) |box| {
+ if (x0 < box.x1 and x0 + pose.scale > box.x0 and y0 < box.y1 and y0 + pose.scale > box.y0) break true;
+ } else false;
+ if (covered) continue;
builder.addRect(x0, y0, x0 + pose.scale, y0 + pose.scale, if (color == 2) eye else ink);
};
}
-test "pet overlay stays beyond workspace text and vanishes while its tag is edited" {
+test "pet overlay stays beyond workspace text and keeps going while its tag is edited" {
std.testing.refAllDecls(pet);
const core = try pardes.Pardes.init(std.testing.allocator, .{ .cols = 80, .rows = 24 });
defer core.deinit();
@@ -6622,40 +10701,20 @@ test "pet overlay stays beyond workspace text and vanishes while its tag is edit
try std.testing.expect(x >= 20 * 8 - 0.01);
try std.testing.expect(y >= 0 and y < 20);
}
- core.topbar_col = 0;
- core.header_column = null;
+ const before = g.pet_state;
+ pardes.tagline.enterHeader(core, null);
builder.len = 0;
appendWorkspacePet(&g, core, &surface, &builder);
- try std.testing.expectEqual(@as(usize, 0), builder.len);
+ try std.testing.expect(builder.len > 0);
+ try std.testing.expectEqual(before.tick, g.pet_state.tick);
+ try std.testing.expectEqual(before.x, g.pet_state.x);
}
-fn cursorColor(core: ?*const pardes.Pardes, cell: *const pardes.Cell, role: pardes.FontRole) [3]u8 {
- if (core) |p| return if (role == .tagline) switch (cell.style.fg) {
- .rgb => |rgb| rgb,
- else => p.chromeTheme().tag_fg,
- } else p.theme().fg orelse fg_default;
- return switch (cell.style.fg) {
+fn cursorColor(chrome: *const pardes.Chrome, cell: *const pardes.Cell, role: pardes.FontRole) [3]u8 {
+ return if (role == .tagline) switch (cell.style.fg) {
.rgb => |rgb| rgb,
- .index => |index| palColor(index),
- // Detached frames carry explicit page backgrounds but blank cells need
- // not carry foreground ink. Keep their insertion caret visible too.
- .default => switch (cell.style.bg) {
- .rgb => |rgb| if ((@as(u16, rgb[0]) * 3 + @as(u16, rgb[1]) * 6 + rgb[2]) / 10 > 140)
- .{ 32, 32, 32 }
- else
- fg_default,
- else => fg_default,
- },
- };
-}
-
-test "detached insertion caret contrasts with blank light and dark pages" {
- var cell: pardes.Cell = .{ .default = false, .style = .{ .bg = .{ .rgb = .{ 248, 246, 237 } } } };
- try std.testing.expectEqual([3]u8{ 32, 32, 32 }, cursorColor(null, &cell, .body));
- cell.style.bg = .{ .rgb = .{ 24, 28, 32 } };
- try std.testing.expectEqual(fg_default, cursorColor(null, &cell, .body));
- cell.style.fg = .{ .rgb = .{ 122, 188, 160 } };
- try std.testing.expectEqual([3]u8{ 122, 188, 160 }, cursorColor(null, &cell, .body));
+ else => chrome.tag_fg,
+ } else chrome.fg orelse fg_default;
}
fn overlayRgb(rgb: [3]u8) OverlayColor {
@@ -6667,154 +10726,6 @@ fn overlayRgb(rgb: [3]u8) OverlayColor {
};
}
-fn cellBackgroundIs(cell: *const pardes.Cell, rgb: [3]u8) bool {
- return !cell.default and switch (cell.style.bg) {
- .rgb => |bg| std.mem.eql(u8, &bg, &rgb),
- else => false,
- };
-}
-
-// The canonical surface still owns scrollbar positions and hit targets. Only
-// their pixel ink is inset here; no layout, selection or mouse coordinates move.
-fn appendPaneChrome(
- core: *const pardes.Pardes,
- surface: *const pardes.Surface,
- layout: CellLayout,
- builder: *OverlayBuilder,
-) void {
- const chrome = core.chromeTheme();
- const page = overlayRgb(core.theme().bg orelse bg_default);
- for (core.panes, core.rects) |slot, r| {
- if (slot == null or r.w <= config.GUTTER or r.h <= pardes.BOX_H) continue;
- if (@as(u32, r.x) + r.w > surface.cols or @as(u32, r.y) + r.h > surface.rows) continue;
- const tag_y = if (core.settings.tag_bottom) r.y + r.h - pardes.BOX_H else r.y;
- const body_y = if (core.settings.tag_bottom) r.y else r.y + pardes.BOX_H;
- const body_end = body_y + r.h - pardes.BOX_H;
- const x0 = @as(f32, @floatFromInt(r.x)) * layout.w;
- const x1 = x0 + @as(f32, @floatFromInt(r.w)) * layout.w;
- const tag_cells = surface.cells[@as(usize, tag_y) * surface.cols + r.x + pardes.TAG_TEXT_INSET ..][0 .. r.w - pardes.TAG_TEXT_INSET];
- const tag_visible = for (tag_cells) |*cell| {
- if (cellFontRole(cell) != .tagline) break false;
- } else true;
- if (tag_visible) {
- const rule_y = @as(f32, @floatFromInt(tag_y + @as(u16, if (core.settings.tag_bottom) 0 else 1))) * layout.h;
- builder.addRect(x0, rule_y - @as(f32, if (core.settings.tag_bottom) 0 else 1), x1, rule_y + @as(f32, if (core.settings.tag_bottom) 1 else 0), overlayRgb(chrome.border));
- }
-
- // Do not paint over resize previews or debug text occupying the rail.
- var thumb_start: ?u16 = null;
- var thumb_end: u16 = body_y;
- var row = body_y;
- while (row < body_end) : (row += 1) {
- const cell = &surface.cells[@as(usize, row) * surface.cols + r.x];
- if (cell.printableAscii() != ' ') break;
- if (cellBackgroundIs(cell, chrome.scroll_thumb)) {
- if (thumb_start == null) thumb_start = row;
- thumb_end = row + 1;
- } else if (!cellBackgroundIs(cell, chrome.scroll_track)) break;
- }
- if (row != body_end) continue;
- const y0 = @as(f32, @floatFromInt(body_y)) * layout.h;
- const y1 = @as(f32, @floatFromInt(body_end)) * layout.h;
- builder.addRect(x0, y0, x0 + layout.w, y1, page);
- appendSquareRail(builder, x0, y0, y1, layout.w, false, overlayRgb(chrome.scroll_track));
- if (thumb_start) |first| {
- const thumb_y0 = @as(f32, @floatFromInt(first)) * layout.h;
- const thumb_y1 = @as(f32, @floatFromInt(thumb_end)) * layout.h;
- appendSquareRail(builder, x0, thumb_y0, thumb_y1, layout.w, true, overlayRgb(chrome.scroll_thumb));
- }
- }
- appendColumnSpines(core, surface.rows, layout, builder);
-}
-
-// Tag handles use the canonical physical cells, including detached frames.
-// Their tag text begins at the layer viewport and may use a narrower font.
-fn appendTagGrips(g: *const Gui, surface: *const pardes.Surface, layout: CellLayout, builder: *OverlayBuilder) void {
- if (g.tagline_height < 6 or g.tagline_width < 3) return;
- for (surface.tagLayers()) |layer| {
- if (layer.cols == 0 or layer.kind != .pane or layer.viewport.x < pardes.TAG_TEXT_INSET) continue;
- const x = layer.viewport.x - pardes.TAG_TEXT_INSET;
- const y = layer.viewport.y;
- if (x >= surface.cols or y >= surface.rows) continue;
- const cell = &surface.cells[@as(usize, y) * surface.cols + x];
- if (cell.default or cell.printableAscii() != ' ') continue;
- const rgb = switch (cell.style.fg) {
- .rgb => |rgb| rgb,
- else => continue,
- };
- const center_x = (@as(f32, @floatFromInt(x)) + @as(f32, @floatFromInt(config.GUTTER)) / 2) * layout.w;
- const center_y = @as(f32, @floatFromInt(y)) * layout.h + @as(f32, @floatFromInt(taglineBandOffset(y, builder.win_h, g.cell_h, g.tagline_height, true))) + @as(f32, @floatFromInt(g.tagline_height)) / 2;
- const half_w = @max(1, @min(3, layout.w - 2));
- builder.addRect(@floor(center_x - half_w), @floor(center_y - 2), @floor(center_x + half_w), @floor(center_y - 1), overlayRgb(rgb));
- builder.addRect(@floor(center_x - half_w), @floor(center_y + 1), @floor(center_x + half_w), @floor(center_y + 2), overlayRgb(rgb));
- }
-}
-
-test "column grips stay unmarked while pane marks retain physical centering" {
- var g: Gui = undefined;
- g.tagline_height = 12;
- g.tagline_width = 6;
- g.cell_h = 20;
- var cells: [80]pardes.Cell = @splat(.{ .default = false, .style = .{ .fg = .{ .rgb = .{ 100, 120, 140 } } } });
- var surface: pardes.Surface = .{ .cols = 20, .rows = 4, .cells = &cells };
- surface.tag_layers[0] = .{ .kind = .column, .viewport = .{ .x = 8, .y = 1, .w = 13, .h = 1 }, .cols = 20 };
- surface.tag_layers[1] = .{ .kind = .pane, .viewport = .{ .x = 8, .y = 3, .w = 13, .h = 1 }, .cols = 20 };
- var vertices: [24]OverlayVertex = undefined;
- var builder: OverlayBuilder = .{ .vertices = &vertices, .win_w = 200, .win_h = 80 };
- appendTagGrips(&g, &surface, .{ .w = 10, .h = 20, .x_off = 0, .y_off = 0 }, &builder);
- try std.testing.expectEqual(@as(usize, 12), builder.len);
- try std.testing.expectApproxEqAbs(@as(f32, 57.0 / 200.0 * 2.0 - 1.0), vertices[0].x, 0.0001);
-}
-
-fn appendSquareRail(builder: *OverlayBuilder, x: f32, y0: f32, y1: f32, cell_w: f32, thumb: bool, color: OverlayColor) void {
- const width = @min(cell_w, if (thumb) @max(2, @floor(cell_w * 0.5)) else 2);
- builder.addRect(x, y0, x + width, y1, color);
-}
-
-fn appendColumnSpines(core: *const pardes.Pardes, rows: u16, layout: CellLayout, builder: *OverlayBuilder) void {
- const y0 = @as(f32, @floatFromInt(pardes.TOPBAR_H)) * layout.h;
- const y1 = @as(f32, @floatFromInt(rows)) * layout.h;
- if (y1 <= y0) return;
- // A single boundary spans all panes, including their tags. Its left edge
- // agrees with the square scroll markers and existing move-box hit area.
- for (core.col_x[0..core.ncol], core.col_w[0..core.ncol]) |col, width| {
- if (width == 0) continue;
- const x = @as(f32, @floatFromInt(col)) * layout.w;
- builder.addRect(x, y0, x + 1, y1, overlayRgb(core.chromeTheme().border));
- }
-}
-
-test "square scroll markers share the column edge and have no rounded end inset" {
- var vertices: [12]OverlayVertex = undefined;
- var builder: OverlayBuilder = .{ .vertices = &vertices, .win_w = 800, .win_h = 480 };
- appendSquareRail(&builder, 400, 40, 480, 10, false, overlayRgb(.{ 40, 40, 40 }));
- appendSquareRail(&builder, 400, 80, 160, 10, true, overlayRgb(.{ 100, 100, 100 }));
- try std.testing.expectEqual(@as(usize, 12), builder.len);
- try std.testing.expectEqual(vertices[0].x, vertices[6].x);
- try std.testing.expectApproxEqAbs(@as(f32, 1 - 80.0 / 480.0 * 2), vertices[6].y, 0.0001);
- try std.testing.expectApproxEqAbs(@as(f32, 1 - 160.0 / 480.0 * 2), vertices[8].y, 0.0001);
- try std.testing.expectApproxEqAbs(@as(f32, 5.0 / 800.0 * 2), vertices[7].x - vertices[6].x, 0.0001);
-}
-
-test "column spines remain continuous across every pane tag and body" {
- const core = try pardes.Pardes.init(std.testing.allocator, .{ .cols = 80, .rows = 24 });
- defer core.deinit();
- _ = try core.newShell(1, "");
- try std.testing.expect(pardes.layout.splitColumn(core, 0, 1, false));
- pardes.test_api.sync(core);
- var vertices: [12]OverlayVertex = undefined;
- var builder: OverlayBuilder = .{ .vertices = &vertices, .win_w = 800, .win_h = 480 };
- appendColumnSpines(core, 24, .{ .w = 10, .h = 20, .x_off = 0, .y_off = 0 }, &builder);
- try std.testing.expectEqual(@as(usize, 12), builder.len);
- for (0..2) |col| {
- const first = vertices[col * 6];
- const bottom = vertices[col * 6 + 2];
- try std.testing.expectApproxEqAbs(@as(f32, 1 - 20.0 / 480.0 * 2), first.y, 0.0001);
- try std.testing.expectEqual(@as(f32, -1), bottom.y);
- try std.testing.expectApproxEqAbs(@as(f32, @floatFromInt(core.col_x[col])) * 10.0 / 800.0 * 2 - 1, first.x, 0.0001);
- }
-}
-
fn appendTouchOverlay(g: *Gui, builder: *OverlayBuilder, debug_on: bool) void {
if (!debug_on) {
g.touch.click_flash_frames = 0;
@@ -6882,7 +10793,8 @@ fn uploadOverlayGpu(g: *Gui, cmd: *c.SDL_GPUCommandBuffer, vertex_count: u32) bo
}
fn pushLayerOpacity(cmd: *c.SDL_GPUCommandBuffer, pass: ?*c.SDL_GPURenderPass, opacity: f32) void {
- const uniforms = [4]f32{ opacity, 0, 0, 0 };
+ var uniforms = [4]f32{ opacity, 0, 0, 0 } ++ @as([12]f32, @splat(0));
+ uniforms[4..].* = cell_decor.uniforms;
c.SDL_PushGPUFragmentUniformData(cmd, 0, &uniforms, @sizeOf(@TypeOf(uniforms)));
// The source alpha is geometric/image coverage, not window opacity. Its
// alpha contribution is multiplied by this constant separately, so a
@@ -7087,32 +10999,6 @@ fn miniGlyph(ch: u8) [5]u8 {
};
}
-fn effCp(key: vaxis.Key) u21 {
- if (key.text) |t| {
- const view = std.unicode.Utf8View.init(t) catch return key.codepoint;
- var it = view.iterator();
- if (it.nextCodepoint()) |cp| {
- if (it.nextCodepoint() == null) return cp;
- }
- }
- return key.shifted_codepoint orelse key.codepoint;
-}
-
-fn mapKey(cp: u21) u21 {
- return switch (cp) {
- vaxis.Key.up => pardes.Key.up,
- vaxis.Key.down => pardes.Key.down,
- vaxis.Key.left => pardes.Key.left,
- vaxis.Key.right => pardes.Key.right,
- vaxis.Key.home => pardes.Key.home,
- vaxis.Key.end => pardes.Key.end,
- vaxis.Key.page_up => pardes.Key.page_up,
- vaxis.Key.page_down => pardes.Key.page_down,
- vaxis.Key.delete => pardes.Key.delete,
- else => cp,
- };
-}
-
fn envU16(env: *std.process.Environ.Map, name: []const u8) ?u16 {
const raw = env.get(name) orelse return null;
return std.fmt.parseInt(u16, raw, 10) catch null;
@@ -7120,13 +11006,14 @@ fn envU16(env: *std.process.Environ.Map, name: []const u8) ?u16 {
test "compact body layer rendering fills recovered rows and clips the final glyph" {
var g: Gui = undefined;
+ g.words = .{};
g.cell_w = 10;
g.cell_h = 20;
g.tagline_width = 6;
g.tagline_height = 12;
g.space_slot = .{ .u = 0, .v = 0 };
var cells: [24]pardes.Cell = @splat(.{});
- var layer: pardes.BodyLayer = .{
+ var layer: pardes.Layer = .{
.viewport = .{ .x = 3, .y = 2, .w = 2, .h = 5 },
.cols = 2,
.rows = 12,
@@ -7159,13 +11046,14 @@ test "compact body layer rendering fills recovered rows and clips the final glyp
test "compact tag layers fill available width and clip at their physical edge" {
var g: Gui = undefined;
+ g.words = .{};
g.cell_w = 10;
g.cell_h = 20;
g.tagline_width = 6;
g.tagline_height = 12;
g.space_slot = .{ .u = 0, .v = 0 };
var cells: [6]pardes.Cell = @splat(.{});
- const layer: pardes.TagLayer = .{ .kind = .pane, .id = 0, .serial = 7, .viewport = .{ .x = 2, .y = 3, .w = 3, .h = 1 }, .cols = 6, .cells = &cells, .bg = .{ 20, 30, 40 } };
+ const layer: pardes.Layer = .{ .kind = .pane, .id = 0, .serial = 7, .viewport = .{ .x = 2, .y = 3, .w = 3, .h = 1 }, .cols = 6, .rows = 1, .cells = &cells, .bg = .{ 20, 30, 40 } };
var instances: [8]CellInstance = undefined;
var next: u32 = 0;
emitTagLayer(&g, &instances, &next, &layer, 100, 100, null, Ground.opaqueRgb(bg_default), false, false);
diff --git a/src/gui/pet.zig b/src/gui/pet.zig
index 2b031f0e..7a13ca91 100644
--- a/src/gui/pet.zig
+++ b/src/gui/pet.zig
@@ -8,11 +8,13 @@ pub const height = 9;
pub const max_vertices = width * height * 6;
pub const Lane = struct { left: f32, right: f32, top: f32, scale: f32 };
pub const Pose = struct { x: f32, y: f32, scale: f32, left: bool, walking: bool, frame: u8 };
+/// The frog's hop: sits two ticks, takes off, peaks for two, comes down, lands.
+const hop_ticks = 8;
/// Only the trailing blank part of the global tag is eligible. The caller
/// supplies its last occupied cell, including any wide-grapheme continuation.
-pub fn lane(occupied: usize, cell_w: f32, screen_w: f32, top: f32, band_h: f32, editing: bool) ?Lane {
- if (editing or cell_w <= 0 or band_h < height + 2) return null;
+pub fn lane(occupied: usize, cell_w: f32, screen_w: f32, top: f32, band_h: f32) ?Lane {
+ if (cell_w <= 0 or band_h < height + 2) return null;
const scale = @min(3, @floor((band_h - 2) / height));
const left = @as(f32, @floatFromInt(occupied + 2)) * cell_w;
const right = screen_w - 2 * cell_w - width * scale;
@@ -24,24 +26,26 @@ pub const State = struct {
kind: Kind = .off,
tick: ?u64 = null,
x: f32 = 0,
+ target: f32 = 0,
left: bool = false,
idle: u8 = 12,
frame: u8 = 0,
+ rng: std.Random.DefaultPrng = undefined,
+ /// No lane (the tag's text has filled it) hides the pet but keeps
+ /// where it was and what it was doing.
pub fn sample(s: *State, kind: Kind, now_ms: u64, area: ?Lane) ?Pose {
- const region = area orelse {
- s.* = .{};
- return null;
- };
+ const region = area orelse return null;
if (kind == .off) {
s.* = .{};
return null;
}
const tick = now_ms / 100;
if (s.kind != kind or s.tick == null) {
- s.* = .{ .kind = kind, .tick = tick, .x = region.left };
+ s.* = .{ .kind = kind, .tick = tick, .x = region.left, .target = region.left, .rng = .init(now_ms) };
}
s.x = std.math.clamp(s.x, region.left, region.right);
+ s.target = std.math.clamp(s.target, region.left, region.right);
// Coming back from suspension never launches the pet across the tag.
const steps = @min(tick -| s.tick.?, 2);
s.tick = tick;
@@ -49,15 +53,25 @@ pub const State = struct {
s.frame +%= 1;
if (s.idle > 0) {
s.idle -= 1;
+ if (s.idle == 0) {
+ // Wander to a random spot of the lane; one too close
+ // would be a shuffle in place, so take the far end.
+ s.target = region.left + s.rng.random().float(f32) * (region.right - region.left);
+ if (@abs(s.target - s.x) < 8 * region.scale)
+ s.target = if (s.x - region.left > region.right - s.x) region.left else region.right;
+ s.left = s.target < s.x;
+ s.frame = 255; // the walk starts at frame 0
+ }
continue;
}
- const speed: f32 = if (kind == .cat) 1.8 else 1.3;
- s.x += (if (s.left) -speed else speed) * region.scale;
- if (s.x >= region.right or s.x <= region.left) {
- s.x = std.math.clamp(s.x, region.left, region.right);
- s.left = !s.left;
- s.idle = if (kind == .cat) 18 else 24;
+ // The cat walks steadily; the frog travels only while airborne.
+ const phase = s.frame % hop_ticks;
+ if (kind == .cat or (phase >= 2 and phase < 6)) {
+ const step = (if (kind == .cat) @as(f32, 1.8) else 2.6) * region.scale;
+ s.x = if (s.left) @max(s.target, s.x - step) else @min(s.target, s.x + step);
}
+ if (s.x == s.target and (kind == .cat or phase == hop_ticks - 1))
+ s.idle = s.rng.random().intRangeAtMost(u8, 20, 60);
}
return .{ .x = @floor(s.x), .y = region.top, .scale = region.scale, .left = s.left, .walking = s.idle == 0, .frame = s.frame };
}
@@ -76,14 +90,25 @@ const cat = [_][]const u8{
};
const frog = [_][]const u8{
" ",
- " ## ## ",
- " #o####o# ",
- " ######## ",
- " ###### ",
- " ######## ",
- " ########## ",
- " ## ## ",
- "### ###",
+ " ",
+ " ",
+ " ## ",
+ " #o## ",
+ " #########",
+ " ######### ",
+ " ##### ## ",
+ "###### ### ",
+};
+const frog_leap = [_][]const u8{
+ " ## ",
+ " #o## ",
+ " #######",
+ " ######## ",
+ " ####### ",
+ " ### ## ",
+ "## # ",
+ "# ",
+ " ",
};
/// 0 transparent, 1 theme ink, 2 eye cutout. Walk legs and idle blinks are
@@ -99,13 +124,16 @@ pub fn pixel(kind: Kind, pose: Pose, x_in: usize, y: usize) u2 {
if (!pose.walking and breathing) {
if (kind == .cat and y == 3 and x <= 1)
return @intFromBool(x == 0);
- if (kind == .frog and y == 4 and (x == 2 or x == 9)) return 1;
+ if (kind == .frog and ((y == 6 and x == 11) or (y == 7 and x == 10))) return 1;
}
- if (pose.walking and alternate and y >= 7) {
- if (kind == .cat) return @intFromBool((y == 7 and (x == 3 or x == 7)) or (y == 8 and (x == 2 or x == 8)));
- return @intFromBool((y == 7 and (x == 2 or x == 9)) or (y == 8 and (x <= 2 or x >= 9)));
- }
- const ch = (if (kind == .cat) cat else frog)[y][x];
+ if (kind == .cat and pose.walking and alternate and y >= 7)
+ return @intFromBool((y == 7 and (x == 3 or x == 7)) or (y == 8 and (x == 2 or x == 8)));
+ // A hopping frog leaps two rows low at take-off and one on the way down.
+ const phase = pose.frame % hop_ticks;
+ const leaping = kind == .frog and pose.walking and phase >= 2 and phase < 6;
+ const sink: usize = if (!leaping) 0 else if (phase == 2) 2 else if (phase == 5) 1 else 0;
+ if (y < sink) return 0;
+ const ch = (if (kind == .cat) cat else if (leaping) frog_leap else frog)[y - sink][x];
return switch (ch) {
'#' => 1,
'o' => if (!pose.walking and pose.frame % 30 >= 27) 1 else 2,
@@ -113,11 +141,10 @@ pub fn pixel(kind: Kind, pose: Pose, x_in: usize, y: usize) u2 {
};
}
-test "pet stays in trailing workspace blanks and disappears during editing" {
- try std.testing.expect(lane(20, 8, 200, 0, 16, false) == null);
- try std.testing.expect(lane(3, 8, 200, 0, 16, true) == null);
- try std.testing.expect(lane(3, 8, 200, 0, 10, false) == null);
- const region = lane(3, 8, 200, 2, 20, false).?;
+test "pet stays in trailing workspace blanks, and a lost lane hides it without a reset" {
+ try std.testing.expect(lane(20, 8, 200, 0, 16) == null);
+ try std.testing.expect(lane(3, 8, 200, 0, 10) == null);
+ const region = lane(3, 8, 200, 2, 20).?;
try std.testing.expect(region.left >= 5 * 8);
var state: State = .{};
var moved = false;
@@ -130,12 +157,15 @@ test "pet stays in trailing workspace blanks and disappears during editing" {
reversed = reversed or pose.left;
}
try std.testing.expect(moved and reversed);
+ const kept = state;
try std.testing.expect(state.sample(.cat, 300000, null) == null);
+ try std.testing.expectEqual(kept.x, state.x);
+ try std.testing.expectEqual(kept.tick, state.tick);
try std.testing.expect(state.sample(.off, 300100, region) == null);
}
test "pet clock is fixed rate and sprites bounded in both directions" {
- const region = lane(1, 8, 400, 0, 16, false).?;
+ const region = lane(1, 8, 400, 0, 16).?;
var state: State = .{};
const start = state.sample(.frog, 1000, region).?;
try std.testing.expectEqualDeep(start, state.sample(.frog, 1099, region).?);
@@ -150,8 +180,23 @@ test "pet clock is fixed rate and sprites bounded in both directions" {
};
}
+test "pet rests at random spots and the frog travels only in the air" {
+ const region = lane(1, 8, 800, 0, 16).?;
+ var state: State = .{};
+ var last = state.sample(.frog, 0, region).?;
+ var rested_midway = false;
+ for (1..3000) |i| {
+ const pose = state.sample(.frog, i * 100, region).?;
+ const phase = pose.frame % hop_ticks;
+ if (pose.x != last.x) try std.testing.expect(pose.walking and phase >= 2 and phase < 6);
+ rested_midway = rested_midway or (last.walking and !pose.walking and pose.x > region.left and pose.x < @floor(region.right));
+ last = pose;
+ }
+ try std.testing.expect(rested_midway);
+}
+
test "pet initial idle visibly animates without walking or leaving its tile" {
- const region = lane(1, 8, 400, 0, 16, false).?;
+ const region = lane(1, 8, 400, 0, 16).?;
for ([_]Kind{ .cat, .frog }) |kind| {
var state: State = .{};
const initial = state.sample(kind, 0, region).?;