diff options
| author | Gabriel Schneider <[email protected]> | 2026-11-05 12:56:09 -0300 |
|---|---|---|
| committer | Gabriel Schneider <[email protected]> | 2026-11-05 15:18:26 -0300 |
| commit | 88ae8456407e0ce9a2dd70ced0c53d8aa5f63fda (patch) | |
| tree | c4c805e0e729f485b8fc1ae6a26c547b2fb7d356 /src/jump_trail.zig | |
| parent | e65ada6bfab3e3851281be253b5e8187b652b66b (diff) | |
| download | pardes-88ae8456407e0ce9a2dd70ced0c53d8aa5f63fda.tar.gz pardes-88ae8456407e0ce9a2dd70ced0c53d8aa5f63fda.zip | |
the jump trail back, the frontends' alone: a jump of the cursor, three cells or more between two frames, leaves three to five cells behind it that fade in 120 ms, as the terminal's did, now seen by each frontend in the cursor of the Surface it shows and timed on its own clock (src/jump_trail.zig, shared by both); the tty tints those cells' ground toward the text again (truecolor terminals, COLORTERM read again for it), and the window draws over them in its overlay, both only on the page's own ground in the cursor's body; JumpTrail is a plain setting again (config.Runtime.jump_trail, off by default, dumped and replicated, in /ctl), which the frontends read; a frontend's trail asks for frames while it fades (shell_continuous, as its glide does)
Co-Authored-By: Claude Opus 5.5 <[email protected]>
Claude-Session: https://claude.ai/code/session_016Y9MNAtZenFv4weoMD3cge
Diffstat (limited to 'src/jump_trail.zig')
| -rw-r--r-- | src/jump_trail.zig | 87 |
1 files changed, 87 insertions, 0 deletions
diff --git a/src/jump_trail.zig b/src/jump_trail.zig new file mode 100644 index 00000000..25eba636 --- /dev/null +++ b/src/jump_trail.zig @@ -0,0 +1,87 @@ +//! JumpTrail: a jump of the cursor, three cells or more between two frames, +//! leaves a trail of three to five cells behind it along its path, most +//! beside the cursor, all fading out over 120 ms. A frontend's own: it sees +//! the cursor of the Surface it shows, frame after frame, and times the fade +//! on its own clock; the tty tints those cells' ground toward the text, the +//! window draws over them. Nothing of it reaches the core, which keeps the +//! setting alone (config.Runtime.jump_trail). +const std = @import("std"); + +pub const life_ns: u64 = 120 * std.time.ns_per_ms; + +/// A cell of the trail, and how far toward the text it is drawn (0 to 1). +pub const Cell = struct { x: i32, y: i32, strength: f32 }; + +last: ?[2]u16 = null, +from: [2]u16 = .{ 0, 0 }, +to: [2]u16 = .{ 0, 0 }, +start_ns: u64 = 0, +/// Fading: a frontend draws frames until it is not. +active: bool = false, + +const JumpTrail = @This(); + +/// A frame shows the cursor at `cursor` (null: none) at `now_ns`: the +/// trail's cells in it, the one beside the cursor first, or none. +pub fn see(trail: *JumpTrail, cursor: ?[2]u16, on: bool, now_ns: u64, out: *[5]Cell) []const Cell { + const here = cursor orelse { + trail.* = .{}; + return out[0..0]; + }; + if (trail.last) |was| { + const dx = @as(i32, here[0]) - was[0]; + const dy = @as(i32, here[1]) - was[1]; + if (on and @max(@abs(dx), @abs(dy)) >= 3) trail.* = .{ .from = was, .to = here, .start_ns = now_ns, .active = true }; + } + trail.last = here; + const age = now_ns -| trail.start_ns; + if (!on or !trail.active or age >= life_ns or !std.meta.eql(trail.to, here)) { + trail.active = false; + return out[0..0]; + } + const t = @as(f32, @floatFromInt(age)) / @as(f32, @floatFromInt(life_ns)); + const fade = (1 - t) * (1 - t); + const dx: f32 = @floatFromInt(@as(i32, trail.from[0]) - trail.to[0]); + const dy: f32 = @floatFromInt(@as(i32, trail.from[1]) - trail.to[1]); + const span = @max(@abs(dx), @abs(dy)); + const n: usize = @intFromFloat(std.math.clamp(@round(span / 4), 3, 5)); + var len: usize = 0; + var k: usize = 1; + var last_cell: ?[2]i32 = null; + var step: f32 = 1; + while (k <= n and step <= span) : (step += 1) { + const x: i32 = @intFromFloat(@round(@as(f32, @floatFromInt(trail.to[0])) + dx * step / span)); + const y: i32 = @intFromFloat(@round(@as(f32, @floatFromInt(trail.to[1])) + dy * step / span)); + if (last_cell) |seen| if (seen[0] == x and seen[1] == y) continue; + last_cell = .{ x, y }; + defer k += 1; + const strength = 0.55 * fade * (1 - @as(f32, @floatFromInt(k - 1)) / @as(f32, @floatFromInt(n))); + if (strength < 0.02) continue; + out[len] = .{ .x = x, .y = y, .strength = strength }; + len += 1; + } + return out[0..len]; +} + +test "a jump leaves a few cells behind the cursor, fading in 120 ms; a step, or off, leaves none" { + const ms = std.time.ns_per_ms; + var trail: JumpTrail = .{}; + var out: [5]Cell = undefined; + try std.testing.expectEqual(@as(usize, 0), trail.see(.{ 2, 1 }, true, 1000 * ms, &out).len); + // Ten cells right: a trail back toward where it was, on its row, behind + // it, never its own cell, strongest beside it. + const lit = trail.see(.{ 12, 1 }, true, 1016 * ms, &out); + try std.testing.expect(trail.active and lit.len >= 3 and lit.len <= 5); + for (lit, 0..) |cell, i| { + try std.testing.expectEqual(@as(i32, 1), cell.y); + try std.testing.expect(cell.x > 2 and cell.x < 12); + if (i > 0) try std.testing.expect(cell.strength < lit[i - 1].strength and cell.x < lit[i - 1].x); + } + // Gone by 120 ms. + try std.testing.expectEqual(@as(usize, 0), trail.see(.{ 12, 1 }, true, 1150 * ms, &out).len); + try std.testing.expect(!trail.active); + // A step of a cell leaves none; nor does a jump with it off. + try std.testing.expectEqual(@as(usize, 0), trail.see(.{ 13, 1 }, true, 1200 * ms, &out).len); + try std.testing.expectEqual(@as(usize, 0), trail.see(.{ 2, 1 }, false, 1216 * ms, &out).len); + try std.testing.expect(!trail.active); +} |
