summaryrefslogtreecommitdiff
path: root/src/jump_trail.zig
blob: 25eba63670db44c843a3895c464957875f3551e2 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
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);
}