summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
authorGabriel Schneider <[email protected]>2026-11-05 13:56:13 -0300
committerGabriel Schneider <[email protected]>2026-11-05 15:26:36 -0300
commit3488111273764c17a42870484fabc36abb0634a1 (patch)
treefa5440938b0feb1b0b38c3bca92326501a622413 /src
parentc2885d899c95b9c4a72786940289afd0b3ddbde8 (diff)
downloadpardes-3488111273764c17a42870484fabc36abb0634a1.tar.gz
pardes-3488111273764c17a42870484fabc36abb0634a1.zip
effects out, the core's motion: the view's glide is the frontends' alone, and the core keeps no motion and no clock but its deadlines; glide.zig is a frontend's picture of a scroll, measured on the frame it is about to draw against the last it drew (a body's first line and the text it shows in its region, Region.doc new; the last frame's cells kept by the glide itself), on the frontend's own clock, the tty drawing it at whole rows and the window at the pixel; each frontend draws its own motions' frames from the last frame (the tty's poll presents it again, the window's loop renders it again, as its blink did) and paces its own waits, so the core's continuous path goes (Pardes.continuous and shell_continuous, the pump's one-millisecond wait, the view's drawn fields, the tape's watch of it); the Motion word and its five flavours go (the glide and the caret move at the default's pace, and no switch for reduced motion is left), and animation.zig with them (Motion and Spring gone, Follow now glide.zig's with its test, CursorGlide gone with the core's caret, Blink the window's with its test, Box and layout.panelBox gone, the frame's length now Pardes.frame_ns); a PDF strip no longer glides, its scroll landing at once (its follow, stripAt's motion and Pdf.moving go); the window's glide tests are fed frame by frame as the window feeds them; the window monkey runs by seed, not by flavour, and the 9P monkey loses Motion; the tty wakes a frame at a time while its glide or trail moves, as the core's continuous path woke it; all 109 snapshot goldens and the 16 GUI goldens unchanged; tests gone: a carried spring keeps its speed; a spring settles without overshoot; each flavour is its own motion; a cursor eases a cell at a time (animation.zig's); a PDF strip glides a notch and a page to their marks; a PDF glide renders the pages it crosses
Co-Authored-By: Claude Opus 5.5 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNAtZenFv4weoMD3cge
Diffstat (limited to 'src')
-rw-r--r--src/FrameStats.zig4
-rw-r--r--src/Messages.zig5
-rw-r--r--src/animation.zig656
-rw-r--r--src/builtins.zig2
-rw-r--r--src/config.zig17
-rw-r--r--src/draw.zig7
-rw-r--r--src/glide.zig383
-rw-r--r--src/gui/gui.zig164
-rw-r--r--src/layout.zig11
-rw-r--r--src/pardes.zig48
-rw-r--r--src/pdf_view.zig137
-rw-r--r--src/surface.zig4
-rw-r--r--src/tape.zig2
-rw-r--r--src/tui/tui.zig67
-rw-r--r--src/views.zig14
15 files changed, 461 insertions, 1060 deletions
diff --git a/src/FrameStats.zig b/src/FrameStats.zig
index 623acd24..34a629dd 100644
--- a/src/FrameStats.zig
+++ b/src/FrameStats.zig
@@ -24,7 +24,7 @@
//! on a real display.
const std = @import("std");
const pardes = @import("pardes.zig");
-const animation = @import("animation.zig");
+const frame_ns = @import("pardes.zig").frame_ns;
const FrameStats = @This();
@@ -85,7 +85,7 @@ long: ?*[long_capacity]Frame = null,
/// Frames recorded since the start; the ring holds the last of them.
count: u64 = 0,
/// The display's refresh period, as the shell knows it.
-period_ns: u64 = animation.frame_ns,
+period_ns: u64 = frame_ns,
/// The end of the last drawn frame's present, and whether anything was
/// still moving then (the next frame was owed at once).
last_end_ns: u64 = 0,
diff --git a/src/Messages.zig b/src/Messages.zig
index 0ab10dab..e18815e3 100644
--- a/src/Messages.zig
+++ b/src/Messages.zig
@@ -5,7 +5,6 @@ const pardes = @import("pardes.zig");
const memory = @import("memory.zig");
const std = @import("std");
const layout = @import("layout.zig");
-const animation = @import("animation.zig");
const ctlfs = @import("ninep/tree.zig");
const panes = @import("panes.zig");
const CellStyle = @import("surface.zig").CellStyle;
@@ -307,7 +306,7 @@ pub fn messageWake(p: *const Pardes, pane: *const Pane) ?u64 {
/// Animation frames a message timing lasts; at least one.
pub fn messageFrames(ms: u16) u16 {
- return @intCast(@max(1, (@as(u32, ms) + animation.frame_ms - 1) / animation.frame_ms));
+ return @intCast(@max(1, (@as(u32, ms) + pardes.frame_ms - 1) / pardes.frame_ms));
}
/// What notice band `i` says. The grid pass and the band layers both
@@ -874,7 +873,7 @@ test "an idle core wants no wake and a lingering message sleeps to its linger's
const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 80, .rows = 24 });
defer p.deinit();
while (p.nextEffect()) |_| {}
- const frame = animation.frame_ns;
+ const frame = pardes.frame_ns;
p.advance(1_000_000);
try std.testing.expectEqual(@as(?u64, null), p.nextWake());
const pane = p.panes[p.active].?;
diff --git a/src/animation.zig b/src/animation.zig
deleted file mode 100644
index 25abf421..00000000
--- a/src/animation.zig
+++ /dev/null
@@ -1,656 +0,0 @@
-//! The springs that settle a view and the cursor, and the Motion flavours
-//! they move by (colors.zig fades the chrome).
-const std = @import("std");
-
-/// The curves a theme change's chrome fades on (colors.ChromeAnimation).
-pub const Easing = enum(u8) { smooth, out_cubic };
-
-pub fn sample(easing: Easing, raw: f32) f32 {
- const t = std.math.clamp(raw, 0.0, 1.0);
- return switch (easing) {
- .smooth => t * t * (3.0 - 2.0 * t),
- .out_cubic => 1.0 - (1.0 - t) * (1.0 - t) * (1.0 - t),
- };
-}
-
-/// A fractional box in grid cells: the cursor's quad aims at one.
-pub const Box = extern struct {
- x: f32 = 0,
- y: f32 = 0,
- w: f32 = 0,
- h: f32 = 0,
-};
-
-pub const frame_ms: u32 = 16;
-pub const frame_ns: u64 = frame_ms * std.time.ns_per_ms;
-pub const transition_steps: u16 = 10;
-
-/// How the fx track moves (`Motion <flavour>`, docs/effects.md): one set of
-/// parameters a flavour picks, read by every animation that follows the
-/// classic principles, so a flavour is data and no effect branches on it.
-pub const Motion = struct {
- pub const Flavour = enum(u8) { off, crisp, smooth, bouncy, playful };
-
- /// Nothing moves: every change lands at once (reduced motion).
- instant: bool = false,
- /// Timing: the spring's natural frequency, rad/s; slow in / slow out
- /// come from the spring itself.
- omega: f32 = 36,
- /// Follow-through: 1 is critically damped (no overshoot); below 1 it
- /// settles past its target and back.
- zeta: f32 = 1,
- /// Anticipation: a move from rest first winds up the other way, by
- /// this fraction of the distance.
- anticipate: f32 = 0,
- /// Squash and stretch: how much a moving thing lengthens along its
- /// velocity and squashes as it lands (G3's cursor, G7's panes).
- stretch: f32 = 0,
- /// Secondary action: how far behind a follower trails its leader (the
- /// shadow behind a pane, a notice's text behind its chip), as the
- /// follower's frequency over the leader's; 1 is in step.
- follow: f32 = 1,
- /// Arcs: how far a two-dimensional path bows, as a fraction of its
- /// length (the cursor's glide).
- arc: f32 = 0,
- /// Exaggeration: how far a small motion goes, as a multiple of its
- /// plain distance (a lift of 1 rises `gain`), so a flavour's character
- /// shows on a motion only a few pixels big.
- gain: f32 = 1,
- /// Timing: a move from rest leaves at this fraction of full speed (1:
- /// out of the gate at once and easing in, 0: slow in and slow out).
- launch: f32 = 0,
- /// For a motion of fixed length (a pane's move, a notice's drop): its
- /// length as a multiple of the effect's own, and the spring's frequency
- /// over that length (`ease`).
- span: f32 = 1,
- norm: f32 = 10,
-
- pub fn of(flavour: Flavour) Motion {
- return switch (flavour) {
- .off => .{ .instant = true },
- // Productivity: quick and exact, nothing past its mark.
- .crisp => .{ .omega = 60, .launch = 1, .span = 0.6, .norm = 10 },
- // Longer and softer, easing in and out, still without a bounce.
- // The default: within §8.1's 220 ms for an arrival.
- .smooth => .{ .omega = 34, .follow = 0.85, .arc = 0.04, .span = 1.1, .norm = 6 },
- // Clearly past its mark and back, once or twice, stretching
- // with its speed.
- .bouncy => .{ .omega = 24, .zeta = 0.35, .stretch = 0.15, .follow = 0.8, .arc = 0.08, .gain = 1.25, .span = 1.4, .norm = 13 },
- // A cartoon's: winds up, flies past, squashes as it lands,
- // its followers trailing.
- .playful => .{ .omega = 18, .zeta = 0.28, .anticipate = 0.15, .stretch = 0.35, .follow = 0.55, .arc = 0.15, .gain = 1.4, .span = 1.7, .norm = 18 },
- };
- }
-
- /// A move of fixed length from 0 to 1, `u` of the way through it: the
- /// flavour's spring (wind-up, overshoot and all), landing exactly on 1
- /// at its end. `instant` is there at once.
- pub fn ease(motion: Motion, u: f32) f32 {
- return motion.easeFrom(u, 0);
- }
-
- /// `ease` for a move that starts already moving at `launch` lengths
- /// per unit of `u` (a retarget): no wind-up then, the speed carried on.
- pub fn easeFrom(motion: Motion, u: f32, launch: f32) f32 {
- if (motion.instant or u >= 1) return 1;
- if (u <= 0) return 0;
- const kick = if (launch != 0) launch else (motion.launch - 2 * motion.anticipate) * motion.norm;
- const spring: Spring = .{ .omega = motion.norm, .zeta = motion.zeta, .target = 1, .from = 0, .velocity = kick, .settled = false };
- return spring.value(@intFromFloat(u * std.time.ns_per_s));
- }
-
- /// The same move's speed at `u`, in lengths per unit of `u`, set off at
- /// `launch` as `easeFrom` is.
- pub fn speedFrom(motion: Motion, u: f32, launch: f32) f32 {
- const h: f32 = 1.0 / 256.0;
- return (motion.easeFrom(@min(1, u + h), launch) - motion.easeFrom(@max(0, u - h), launch)) / (@min(1, u + h) - @max(0, u - h));
- }
-};
-
-/// A value that follows its target on a damped spring, in closed form
-/// (docs/render-pipeline.md §7.2), critically damped or under: a new target
-/// taken partway keeps the value AND its velocity, so a quick run of changes
-/// never snaps or starts over. A move from rest can wind up first
-/// (Motion.anticipate). Settled, it is exactly its target and asks for no
-/// frames.
-pub const Spring = struct {
- omega: f32 = 36,
- zeta: f32 = 1,
- target: f32 = 0,
- /// The value and velocity (per second) at `from_ns`.
- from: f32 = 0,
- velocity: f32 = 0,
- from_ns: u64 = 0,
- settled: bool = true,
-
- const State = struct { value: f32, velocity: f32 };
-
- fn at(spring: *const Spring, now_ns: u64) State {
- if (spring.settled) return .{ .value = spring.target, .velocity = 0 };
- const t: f32 = @floatCast(@as(f64, @floatFromInt(now_ns -| spring.from_ns)) / std.time.ns_per_s);
- const w = spring.omega;
- const x0 = spring.from - spring.target;
- const v0 = spring.velocity;
- if (spring.zeta >= 1) {
- const c = v0 + w * x0;
- const decay = @exp(-w * t);
- return .{ .value = spring.target + (x0 + c * t) * decay, .velocity = (v0 - w * t * c) * decay };
- }
- // Underdamped: it rings about its target as it decays.
- const z = spring.zeta;
- const wd = w * @sqrt(1 - z * z);
- const b = (v0 + z * w * x0) / wd;
- const decay = @exp(-z * w * t);
- const cos = @cos(wd * t);
- const sin = @sin(wd * t);
- return .{
- .value = spring.target + decay * (x0 * cos + b * sin),
- .velocity = decay * ((b * wd - z * w * x0) * cos - (x0 * wd + z * w * b) * sin),
- };
- }
-
- pub fn value(spring: *const Spring, now_ns: u64) f32 {
- return spring.at(now_ns).value;
- }
-
- /// Moves what it shows by `by` at `now_ns`, its speed kept, toward the
- /// same target (a scroll's picture falling behind the text it follows),
- /// at `motion`'s pace, never past its mark.
- pub fn carry(spring: *Spring, by: f32, now_ns: u64, motion: Motion) void {
- const state = spring.at(now_ns);
- spring.* = .{ .omega = motion.omega, .zeta = 1, .target = spring.target, .from = state.value + by, .velocity = state.velocity, .from_ns = now_ns, .settled = false };
- }
-
- /// Heads for `target` from wherever it is at `now_ns`, moving as it was,
- /// at the pace and damping `motion` gives: at once when it is `off`.
- pub fn retarget(spring: *Spring, target: f32, now_ns: u64, motion: Motion) void {
- if (target == spring.target) return;
- if (motion.instant) {
- spring.* = .{ .omega = motion.omega, .zeta = motion.zeta, .target = target, .from = target };
- return;
- }
- const state = spring.at(now_ns);
- // From rest, a launch, or a wind-up: set off the other way, a little.
- const kick: f32 = if (spring.settled) (motion.launch - 2 * motion.anticipate) * (target - state.value) * motion.omega else 0;
- spring.* = .{ .omega = motion.omega, .zeta = motion.zeta, .target = target, .from = state.value, .velocity = state.velocity + kick, .from_ns = now_ns, .settled = false };
- }
-
- /// Settles once it is within half a percent of its target and barely
- /// moving (no pixel of a shadow tells the rest): it is its target from
- /// then on. True while it still moves.
- pub fn step(spring: *Spring, now_ns: u64) bool {
- if (spring.settled) return false;
- const state = spring.at(now_ns);
- if (@abs(state.value - spring.target) < 5e-3 and @abs(state.velocity) < 5e-2) spring.settled = true;
- return !spring.settled;
- }
-};
-
-test "a carried spring keeps its speed, heads back to its mark and never passes it" {
- const ms = std.time.ns_per_ms;
- var spring: Spring = .{};
- const smooth = Motion.of(.smooth);
- spring.carry(-3, 0, smooth);
- try std.testing.expectEqual(@as(f32, -3), spring.value(0));
- const mid = spring.at(40 * ms);
- try std.testing.expect(mid.value > -3 and mid.value < 0 and mid.velocity > 0);
- // Another notch mid-way: one more row behind, still moving back.
- spring.carry(-1, 40 * ms, smooth);
- const after = spring.at(40 * ms);
- try std.testing.expectApproxEqAbs(mid.value - 1, after.value, 1e-5);
- try std.testing.expectApproxEqAbs(mid.velocity, after.velocity, 1e-4);
- var t: u64 = 40 * ms;
- while (spring.step(t)) : (t += frame_ns) try std.testing.expect(spring.value(t) <= 1e-4);
- try std.testing.expect(t < 400 * ms);
-}
-
-test "a spring settles without overshoot and keeps its velocity when retargeted" {
- var spring: Spring = .{};
- const ms = std.time.ns_per_ms;
- const crisp = Motion.of(.crisp);
- spring.retarget(1, 0, crisp);
- var last: f32 = 0;
- var t: u64 = 0;
- while (spring.step(t)) : (t += frame_ns) {
- const v = spring.value(t);
- try std.testing.expect(v >= last and v <= 1);
- last = v;
- }
- try std.testing.expect(t >= 80 * ms and t <= 200 * ms);
- try std.testing.expectEqual(@as(f32, 1), spring.value(t + 5 * ms));
- // Back the other way partway up: it carries on up for a moment, then
- // turns, never jumping.
- spring = .{};
- spring.retarget(1, 0, crisp);
- const before = spring.at(60 * ms);
- spring.retarget(0, 60 * ms, crisp);
- const after = spring.at(60 * ms);
- try std.testing.expectApproxEqAbs(before.value, after.value, 1e-6);
- try std.testing.expectApproxEqAbs(before.velocity, after.velocity, 1e-4);
- try std.testing.expect(spring.value(60 * ms + 500_000) > before.value);
-}
-
-test "each flavour is its own motion: off lands at once, bouncy overshoots, playful winds up first" {
- const ms = std.time.ns_per_ms;
- var spring: Spring = .{};
- spring.retarget(1, 0, Motion.of(.off));
- try std.testing.expect(spring.settled);
- try std.testing.expectEqual(@as(f32, 1), spring.value(0));
- var settle: [5]u64 = @splat(0);
- for ([_]Motion.Flavour{ .crisp, .smooth, .bouncy, .playful }) |flavour| {
- spring = .{};
- spring.retarget(1, 0, Motion.of(flavour));
- var peak: f32 = 0;
- var low: f32 = 0;
- var t: u64 = 0;
- var last = spring.at(0);
- while (spring.step(t)) : (t += ms) {
- const now = spring.at(t);
- peak = @max(peak, now.value);
- low = @min(low, now.value);
- // Continuous, a millisecond at a time: no jump anywhere.
- try std.testing.expect(@abs(now.value - last.value) < 0.07);
- last = now;
- }
- try std.testing.expect(t < 1600 * ms);
- settle[@backingInt(flavour)] = t;
- switch (flavour) {
- .crisp, .smooth => try std.testing.expect(peak <= 1.0005 and low >= 0),
- // Clearly past the mark, not a hint of it.
- .bouncy => try std.testing.expect(peak > 1.25 and low >= 0),
- .playful => try std.testing.expect(peak > 1.35 and low < -0.03),
- .off => unreachable,
- }
- }
- // Smooth takes twice crisp's time and more: a character, not a tuning.
- // Yet as the default a pane's arrival (a slide's 12 frames, scaled) is
- // inside §8.1's 220 ms, and a lift is still before 300 ms.
- try std.testing.expect(settle[@backingInt(Motion.Flavour.smooth)] > 2 * settle[@backingInt(Motion.Flavour.crisp)]);
- try std.testing.expect(settle[@backingInt(Motion.Flavour.smooth)] <= 300 * ms);
- try std.testing.expect(@round(@as(f32, 12) * Motion.of(.smooth).span) * frame_ms <= 220);
- // A fixed-length move lands exactly on its mark, whatever the flavour.
- for (std.enums.values(Motion.Flavour)) |flavour| try std.testing.expectEqual(@as(f32, 1), Motion.of(flavour).ease(1));
-}
-
-/// A view that follows its input (anim 9, 11): the picture's offset from
-/// the core's position now (in the view's own unit: rows of text, pixels of
-/// a PDF strip; negative, the picture still shows what is above), its speed
-/// (units a second), when it was last integrated, and what has been feeding
-/// it. The text body (the GUI's Glide) and a PDF strip are each one.
-pub const Follow = struct {
- offset: f32 = 0,
- speed: f32 = 0,
- at_ns: u64 = 0,
- /// The last inputs (down positive), their spacing, the last's time, and
- /// how many came as one stream.
- feed: struct { amount: f32 = 0, gap_ns: u64 = 0, last_ns: u64 = 0, count: u16 = 0 } = .{},
-
- /// How far the picture may lag, in bodies (a flick past that jumps);
- /// how fast it may move, in bodies a second, so moving text stays
- /// readable.
- pub const reach = 2;
- pub const bodies_per_s: f32 = 15;
- /// Inputs this close, each the way the last went, are one stream.
- pub const stream_ns = 150 * std.time.ns_per_ms;
-
- /// What a view's size and the flavour make of the rules: the spring at
- /// 1.5x the flavour's pace, the speed cap, the lag cap, and the offset
- /// under which it is at rest (a tenth of a pixel, in its unit).
- pub const Pace = struct { omega: f32, cap: f32, limit: f32, rest: f32 };
-
- pub fn pace(motion: Motion, body: f32, rest: f32) Pace {
- return .{ .omega = motion.omega * 1.5, .cap = body * bodies_per_s, .limit = body * reach, .rest = rest };
- }
-
- pub fn moving(follow: *const Follow) bool {
- return follow.offset != 0 or follow.speed != 0;
- }
-
- /// An input: the core moved `amount` (down positive). The picture now
- /// lags by as much more, its speed as it was.
- pub fn kick(follow: *Follow, amount: f32, now_ns: u64, p: Pace) void {
- follow.advance(now_ns, p);
- follow.offset = std.math.clamp(follow.offset - amount, -p.limit, p.limit);
- const f = &follow.feed;
- const like = f.count > 0 and (amount > 0) == (f.amount > 0) and now_ns -| f.last_ns < stream_ns;
- if (like) {
- const gap = now_ns -| f.last_ns;
- f.gap_ns = if (f.count == 1) gap else (f.gap_ns + gap) / 2;
- f.amount = (f.amount + amount) / 2;
- f.count +|= 1;
- } else f.* = .{ .amount = amount, .count = 1 };
- f.last_ns = now_ns;
- }
-
- /// The system moved on to `now_ns`. Fed by a stream, at the stream's
- /// rate (an input's amount over their spacing), held a lag `lead`
- /// behind so a late input never finds it stopped and the stream's end
- /// never runs it past its mark; else on the spring, critically damped,
- /// from the speed it has. Never faster than `p.cap`.
- pub fn advance(follow: *Follow, now_ns: u64, p: Pace) void {
- const dt: f32 = @floatCast(@as(f64, @floatFromInt(@min(now_ns -| follow.at_ns, 2 * frame_ns))) / std.time.ns_per_s);
- follow.at_ns = now_ns;
- if (follow.offset == 0 and follow.speed == 0) return;
- const omega = p.omega;
- const toward: f32 = if (follow.offset < 0) 1 else -1;
- const f = follow.feed;
- if (f.count >= 2 and f.gap_ns > 0 and now_ns -| f.last_ns < f.gap_ns * 3 / 2) {
- const gap: f32 = @floatCast(@as(f64, @floatFromInt(f.gap_ns)) / std.time.ns_per_s);
- const rate = @abs(f.amount) / gap;
- const lead = @max(@abs(f.amount), rate / omega);
- // ponytail: a gentle pull to the lead (a tenth an input), so the
- // per-frame step varies by a tenth; a stream's own jitter beyond
- // that shows. An estimate of the input clock if it ever matters.
- // A slow stream's lag runs out before its next input: never
- // faster than the spring's own pace from there (omega a unit of
- // lag a second), so it eases onto the mark, not into it at speed.
- const v = std.math.clamp(rate + 0.1 / gap * (@abs(follow.offset) - lead), 0, @min(p.cap, omega * @abs(follow.offset)));
- const step = @min(v * dt, @abs(follow.offset));
- follow.offset += toward * step;
- follow.speed = if (follow.offset == 0) 0 else toward * v;
- return;
- }
- const x = follow.offset;
- // Coming to rest from a stream: never faster than the spring's own
- // pace from here (omega a unit of lag a second), so it eases in and
- // does not pass its mark.
- if (follow.speed * x < 0 and @abs(follow.speed) > omega * @abs(x)) follow.speed = std.math.sign(follow.speed) * omega * @abs(x);
- const lead_v = follow.speed + omega * x;
- const decay = @exp(-omega * dt);
- var next = (x + lead_v * dt) * decay;
- var speed = (follow.speed - omega * dt * lead_v) * decay;
- if (@abs(next - x) > p.cap * dt) {
- next = x + std.math.sign(next - x) * p.cap * dt;
- speed = std.math.sign(next - x) * p.cap;
- }
- follow.offset = next;
- follow.speed = speed;
- if (@abs(next) < p.rest and @abs(speed) < 10 * p.rest) follow.* = .{ .at_ns = now_ns };
- }
-};
-
-test "a follow comes to rest without a snap: past its fastest frame each step is shorter, the last under a tenth of a pixel" {
- // A flick's spin (a stream of notches, then nothing), one page, and
- // notches slow enough that each lag runs out before the next (its
- // stream must ease onto each mark, never pass it).
- const p = Follow.pace(.{}, 600, 0.1);
- for ([_]struct { n: u16, gap_ms: u64 }{ .{ .n = 12, .gap_ms = 16 }, .{ .n = 1, .gap_ms = 16 }, .{ .n = 6, .gap_ms = 144 } }) |run| {
- var f: Follow = .{};
- var now: u64 = std.time.ns_per_s;
- for (0..run.n) |_| {
- f.kick(if (run.n == 1) 600 else 25, now, p);
- var waited: u64 = 0;
- while (waited < run.gap_ms) : (waited += 8) {
- now += 8 * std.time.ns_per_ms;
- const was = f.offset;
- f.advance(now, p);
- // Toward its mark only, and onto it from under a pixel.
- try std.testing.expect(f.offset <= 0 and f.offset >= was);
- if (f.offset == 0) try std.testing.expect(-was <= 3 * p.rest);
- }
- }
- var last: f32 = std.math.inf(f32);
- var before = f.offset;
- var frames: usize = 0;
- var fastest: f32 = 0;
- while (f.moving()) : (frames += 1) {
- now += frame_ns;
- f.advance(now, p);
- const step = @abs(f.offset - before);
- try std.testing.expect(@abs(f.offset) <= @abs(before));
- if (f.offset == 0) try std.testing.expect(step <= 3 * p.rest);
- fastest = @max(fastest, step);
- if (step < fastest) try std.testing.expect(step <= last);
- last = step;
- before = f.offset;
- try std.testing.expect(frames < 120);
- }
- try std.testing.expect(last <= 0.1);
- }
-}
-
-/// The focused cursor's quad (docs/render-pipeline.md §5.4), in grid cells:
-/// four corners, each on its own springs, so a jump smears along its path
-/// (the leading corners stiffer than the trailing ones, Motion.follow) and
-/// collapses at rest; a long jump bows (Motion.arc). A step of a cell or
-/// less (a key held, typing) eases there whole, its corners together, on a
-/// spring `step_pace` times stiffer still: in ~60 ms on the default, so at
-/// a keyboard's repeat it trails by half a cell and never smears a caret.
-/// Any move the caller calls a snap, and every move under Motion off,
-/// lands at once.
-pub const CursorGlide = struct {
- /// Top left, top right, bottom right, bottom left; x then y.
- corners: [4][2]Spring = @splat(@splat(.{})),
- target: Box = .{},
- from_centre: [2]f32 = .{ 0, 0 },
- placed: bool = false,
- /// When the last step (a move of a cell or less) came.
- step_ns: u64 = 0,
-
- /// How much faster than the flavour's own pace a cursor moves: it
- /// follows input (§8.1: settles in 90-150 ms on the default).
- pub const pace: f32 = 2.4;
- /// A jump longer than this, in cells, bows.
- pub const arc_from: f32 = 8;
- /// How much stiffer a step's spring is than a jump's.
- pub const step_pace: f32 = 1.5;
- /// Steps this close are a stream (a held key, typing): each lands, the
- /// caret at the keys' own rate, as an eased step a key would bounce.
- pub const stream_ns: u64 = 150 * std.time.ns_per_ms;
-
- fn cornersOf(box: Box) [4][2]f32 {
- return .{ .{ box.x, box.y }, .{ box.x + box.w, box.y }, .{ box.x + box.w, box.y + box.h }, .{ box.x, box.y + box.h } };
- }
-
- fn centre(box: Box) [2]f32 {
- return .{ box.x + box.w / 2, box.y + box.h / 2 };
- }
-
- /// Heads for `box` at `now_ns`.
- /// How a new mark is gone to: eased (a step, or a jump's smear and
- /// bow), or landed at once (a scroll: the text moved under it, not the
- /// caret; a shell carries it with the text's own glide).
- pub const How = enum { ease, land };
-
- pub fn aim(glide: *CursorGlide, box: Box, now_ns: u64, motion: Motion, how: How) void {
- // The same mark: nothing to do, unless a snap lands a glide under way.
- if (glide.placed and std.meta.eql(box, glide.target) and !(how == .land and glide.moving())) return;
- const to = cornersOf(box);
- const from_c = if (glide.placed) glide.centreAt(now_ns) else centre(box);
- const to_c = centre(box);
- const dx = to_c[0] - from_c[0];
- const dy = to_c[1] - from_c[1];
- const jump = @abs(dx) > 1.01 or @abs(dy) > 1.01;
- // A step is measured mark to mark, not from where an ease under way
- // has got to (a held key's steps read as jumps from there).
- const last = centre(glide.target);
- const one_step = glide.placed and @abs(to_c[0] - last[0]) <= 1.01 and @abs(to_c[1] - last[1]) <= 1.01;
- const streaming = one_step and glide.step_ns != 0 and now_ns -| glide.step_ns < stream_ns;
- if (one_step) glide.step_ns = now_ns;
- const land = !glide.placed or how == .land or motion.instant or streaming;
- glide.from_centre = from_c;
- glide.target = box;
- glide.placed = true;
- for (&glide.corners, to) |*corner, point| {
- // Leading: the corner ahead of the move, on the side it goes.
- const ahead = (point[0] - to_c[0]) * dx + (point[1] - to_c[1]) * dy;
- var own = motion;
- own.omega *= if (jump) pace * (if (ahead > 0) 1 else motion.follow) else pace * step_pace;
- // A step neither winds up nor overshoots: it is a caret moving.
- if (!jump) {
- own.zeta = 1;
- own.anticipate = 0;
- }
- if (land) {
- for (corner, point) |*axis, value| axis.* = .{ .omega = own.omega, .zeta = own.zeta, .target = value, .from = value };
- continue;
- }
- for (corner, point) |*axis, value| axis.retarget(value, now_ns, own);
- }
- }
-
- pub fn centreAt(glide: *const CursorGlide, now_ns: u64) [2]f32 {
- var c: [2]f32 = .{ 0, 0 };
- for (glide.corners) |corner| for (&c, corner) |*sum, axis| {
- sum.* += axis.value(now_ns) / 4;
- };
- return c;
- }
-
- /// Text under the cursor moved by (dx, dy) cells (a scroll): the quad
- /// moves with it, rather than gliding against text that jumped.
- pub fn shift(glide: *CursorGlide, dx: f32, dy: f32) void {
- for (&glide.corners) |*corner| for (corner, [2]f32{ dx, dy }) |*axis, d| {
- axis.from += d;
- axis.target += d;
- };
- glide.from_centre = .{ glide.from_centre[0] + dx, glide.from_centre[1] + dy };
- glide.target.x += dx;
- glide.target.y += dy;
- }
-
- /// The quad at `now_ns`, bowed on a long jump by the flavour's arc.
- pub fn sample(glide: *const CursorGlide, now_ns: u64, motion: Motion) [4][2]f32 {
- var out: [4][2]f32 = undefined;
- for (&out, glide.corners) |*point, corner| for (point, corner) |*value, axis| {
- value.* = axis.value(now_ns);
- };
- const to_c = centre(glide.target);
- const dx = to_c[0] - glide.from_centre[0];
- const dy = to_c[1] - glide.from_centre[1];
- const length = @sqrt(dx * dx + dy * dy);
- if (motion.arc == 0 or length < arc_from) return out;
- const now_c = glide.centreAt(now_ns);
- const left = @sqrt((to_c[0] - now_c[0]) * (to_c[0] - now_c[0]) + (to_c[1] - now_c[1]) * (to_c[1] - now_c[1]));
- const travelled = std.math.clamp(1 - left / length, 0, 1);
- const bow = motion.arc * length * 4 * travelled * (1 - travelled);
- // Perpendicular to the path, to its left.
- for (&out) |*point| {
- point[0] += -dy / length * bow;
- point[1] += dx / length * bow;
- }
- return out;
- }
-
- /// Steps the springs to `now_ns`; true while the quad still moves.
- pub fn step(glide: *CursorGlide, now_ns: u64) bool {
- var any = false;
- for (&glide.corners) |*corner| for (corner) |*axis| {
- if (axis.step(now_ns)) any = true;
- };
- return any;
- }
-
- /// How far, in cells, the furthest corner still is from its mark.
- pub fn remaining(glide: *const CursorGlide, now_ns: u64) f32 {
- var most: f32 = 0;
- for (glide.corners) |corner| for (corner) |axis| {
- most = @max(most, @abs(axis.value(now_ns) - axis.target));
- };
- return most;
- }
-
- pub fn moving(glide: *const CursorGlide) bool {
- for (glide.corners) |corner| for (corner) |axis| {
- if (!axis.settled) return true;
- };
- return false;
- }
-};
-
-/// The cursor's opacity under blink (§5.4): solid while typing and for
-/// `hold_ns` after, then on and off with an eased edge, solid again after
-/// `idle_ns` of no input. `edge` says whether it is mid-edge (a frame is
-/// owed), `next_ns` when the next edge starts (a wake).
-pub const Blink = struct {
- pub const hold_ns: u64 = 500 * std.time.ns_per_ms;
- pub const idle_ns: u64 = 10 * std.time.ns_per_s;
- pub const half_ns: u64 = 530 * std.time.ns_per_ms;
- pub const edge_ns: u64 = 80 * std.time.ns_per_ms;
-
- alpha: f32,
- edge: bool,
- next_ns: ?u64,
-
- pub fn at(now_ns: u64, input_ns: u64) Blink {
- const since = now_ns -| input_ns;
- if (since < hold_ns) return .{ .alpha = 1, .edge = false, .next_ns = input_ns + hold_ns + half_ns - edge_ns };
- if (since >= hold_ns + idle_ns) return .{ .alpha = 1, .edge = false, .next_ns = null };
- const t = (since - hold_ns) % (2 * half_ns);
- const cycle_start = now_ns - t;
- // On for a half, easing out over its last `edge_ns`; off for a half,
- // easing back in over its last.
- if (t < half_ns - edge_ns) return .{ .alpha = 1, .edge = false, .next_ns = cycle_start + half_ns - edge_ns };
- if (t < half_ns) return .{ .alpha = 1 - smooth(@as(f32, @floatFromInt(t - (half_ns - edge_ns))) / @as(f32, @floatFromInt(edge_ns))), .edge = true, .next_ns = null };
- if (t < 2 * half_ns - edge_ns) return .{ .alpha = 0, .edge = false, .next_ns = cycle_start + 2 * half_ns - edge_ns };
- return .{ .alpha = smooth(@as(f32, @floatFromInt(t - (2 * half_ns - edge_ns))) / @as(f32, @floatFromInt(edge_ns))), .edge = true, .next_ns = null };
- }
-
- fn smooth(x: f32) f32 {
- const u = std.math.clamp(x, 0, 1);
- return u * u * (3 - 2 * u);
- }
-};
-
-test "a cursor eases a cell at a time, keeps up with typing, and glides a jump, smearing, bowing and landing exactly" {
- const ms = std.time.ns_per_ms;
- const smooth_motion = Motion.of(.smooth);
- var glide: CursorGlide = .{};
- const cell: Box = .{ .x = 3, .y = 4, .w = 1, .h = 1 };
- glide.aim(cell, 0, smooth_motion, .ease);
- try std.testing.expect(!glide.moving());
- // One cell over: eases there whole, no wider than a cell, in ~60 ms.
- glide.aim(.{ .x = 4, .y = 4, .w = 1, .h = 1 }, ms, smooth_motion, .ease);
- try std.testing.expect(glide.moving());
- var step_t: u64 = ms;
- while (glide.step(step_t)) : (step_t += ms) {
- const q = glide.sample(step_t, smooth_motion);
- try std.testing.expect(q[1][0] - q[0][0] <= 1.0 + 1e-3 and q[0][0] >= 3 - 1e-3 and q[0][0] <= 4 + 1e-3);
- }
- try std.testing.expect(step_t - ms >= 30 * ms and step_t - ms <= 90 * ms);
- // At a keyboard's repeat the steps are a stream: each lands.
- var typed: f32 = 4;
- var key_t: u64 = step_t;
- for (0..20) |_| {
- typed += 1;
- glide.aim(.{ .x = typed, .y = 4, .w = 1, .h = 1 }, key_t, smooth_motion, .ease);
- key_t += 33 * ms;
- try std.testing.expect(typed - glide.sample(key_t, smooth_motion)[0][0] <= 0.6);
- }
- while (glide.step(key_t)) key_t += ms;
- // A jump of 30 cells: glides, the leading edge ahead of the trailing one.
- glide.aim(cell, key_t, smooth_motion, .land);
- const j0 = key_t;
- const far: Box = .{ .x = 34, .y = 4, .w = 1, .h = 1 };
- glide.aim(far, j0 + 2 * ms, smooth_motion, .ease);
- try std.testing.expect(glide.moving());
- const mid = glide.sample(j0 + 40 * ms, smooth_motion);
- const width = mid[1][0] - mid[0][0];
- try std.testing.expect(width > 1.5);
- // Bowed off the straight line on a long jump.
- try std.testing.expect(@abs(mid[0][1] - 4) > 0.05);
- var t: u64 = j0 + 2 * ms;
- while (glide.step(t)) t += ms;
- // Arrives within §8.1's 90-150 ms on the default, within a twentieth of
- // a cell (under a pixel); settles to rest just after, landing exactly.
- const arrived = glide.sample(j0 + 152 * ms, smooth_motion);
- try std.testing.expect(@abs(arrived[3][0] - 34) < 0.05 and @abs(arrived[1][0] - 35) < 0.05);
- try std.testing.expect(t - j0 <= 220 * ms);
- const rest = glide.sample(t, smooth_motion);
- try std.testing.expectEqual([2]f32{ 34, 4 }, rest[0]);
- try std.testing.expectEqual([2]f32{ 35, 5 }, rest[2]);
- // A scroll carries it with the text.
- glide.shift(0, -3);
- try std.testing.expectEqual([2]f32{ 34, 1 }, glide.sample(t, smooth_motion)[0]);
-}
-
-test "a blink holds while typing, eases at its edges and stops when idle" {
- const ms = std.time.ns_per_ms;
- try std.testing.expectEqual(@as(f32, 1), Blink.at(100 * ms, 0).alpha);
- const out = Blink.at(Blink.hold_ns + Blink.half_ns + 100 * ms, 0);
- try std.testing.expectEqual(@as(f32, 0), out.alpha);
- const edge = Blink.at(Blink.hold_ns + Blink.half_ns - Blink.edge_ns / 2, 0);
- try std.testing.expect(edge.edge and edge.alpha > 0.2 and edge.alpha < 0.8);
- try std.testing.expectEqual(@as(?u64, null), Blink.at(Blink.hold_ns + Blink.idle_ns + ms, 0).next_ns);
- try std.testing.expectEqual(@as(f32, 1), Blink.at(Blink.hold_ns + Blink.idle_ns + ms, 0).alpha);
-}
diff --git a/src/builtins.zig b/src/builtins.zig
index cbde62da..c1d7c50b 100644
--- a/src/builtins.zig
+++ b/src/builtins.zig
@@ -243,7 +243,7 @@ pub const registry = struct {
if (@backingInt(b) == i) return switch (setting.action) {
// a switch flips bare, a choice steps, and DumpDir and Shell bare
// are the default
- .toggle, .dump_dir, .choice, .motion, .shell => false,
+ .toggle, .dump_dir, .choice, .shell => false,
.theme, .font, .tagline_size, .window_opacity, .window_blur, .message_linger, .inactive_dim, .grip_width => true,
// bare, it says the current value (exec.applySettingBuiltin)
.tab, .callstack_depth, .search_rows => false,
diff --git a/src/config.zig b/src/config.zig
index 9a7e6848..50748b60 100644
--- a/src/config.zig
+++ b/src/config.zig
@@ -1,7 +1,6 @@
const std = @import("std");
const builtin = @import("builtin");
const layout = @import("layout.zig");
-const animation = @import("animation.zig");
const limits = @import("memory.zig").limits;
const pardes = @import("pardes.zig");
const builtins = @import("builtins.zig");
@@ -166,7 +165,6 @@ pub const leader_path = paths: {
if (builtins.capabilities.lift) table.set(.CursorBlink, null);
table.set(.JumpTrail, null);
table.set(.ProgramEsc, null);
- table.set(.Motion, null);
if (builtins.capabilities.lift) table.set(.GripWidth, null);
table.set(.InactiveDim, null);
if (builtins.capabilities.lift) table.set(.Pet, null);
@@ -713,11 +711,6 @@ pub const Runtime = struct {
/// of the theme's `rail_px` (acme's 12px Scrollwid at a 17px tagline):
/// a pixel shell's (docs/typ/themes.typ).
grip_width: u16 = 150,
- /// How the fx track's animations move (animation.Motion): off for
- /// reduced motion.
- /// Smooth by default, tuned so arrivals land inside §8.1's 220 ms; the
- /// slower flavours are a choice.
- motion: animation.Motion.Flavour = .smooth,
/// Builtins announce themselves on the message row.
verbose: bool = true,
@@ -879,8 +872,6 @@ pub const Runtime = struct {
window_blur,
message_linger,
dump_dir,
- /// A motion flavour.
- motion,
/// A percentage, 0 through 100.
inactive_dim,
grip_width,
@@ -937,7 +928,6 @@ pub const Runtime = struct {
.{ .word = "CursorBlink", .action = .{ .toggle = .cursor_blink }, .doc = "The cursor blinks, solid while typing, on or off." },
.{ .word = "JumpTrail", .action = .{ .toggle = .jump_trail }, .doc = "A jump of the cursor leaves a short trail that fades, on or off." },
.{ .word = "ProgramEsc", .action = .{ .toggle = .program_esc }, .doc = "In a raw terminal, Esc goes to the program and Shift-Esc backs out, on; off (the default) swaps them." },
- .{ .word = "Motion", .action = .motion, .doc = "How animations move: off, crisp, smooth, bouncy or playful." },
.{ .word = "GripWidth", .action = .grip_width, .doc = "The grip and scrollbar width, as a percent of the theme's rail." },
.{ .word = "InactiveDim", .action = .inactive_dim, .doc = "Fade the unfocused panes' text by a percentage, 0 through 100, 0 off." },
.{ .word = "Pet", .action = .{ .choice = .pet }, .doc = "The window's companion in the workspace tag's blank space: off, cat or frog." },
@@ -1035,7 +1025,6 @@ pub const Runtime = struct {
now.* = stepped(@TypeOf(now.*), now.*, argument) orelse return false;
},
},
- .motion => state.motion = stepped(animation.Motion.Flavour, state.motion, argument) orelse return false,
.inactive_dim => state.inactive_dim = number(u8, argument, " \t\r\n%", 0, 100) orelse return false,
.grip_width => state.grip_width = number(u16, argument, " \t\r\n%", 50, 300) orelse return false,
.callstack_depth => state.callstack_depth = number(u8, argument, " \t\r\n", 1, @import("lsp/lsp.zig").callstack_max_depth) orelse return false,
@@ -1062,7 +1051,6 @@ pub const Runtime = struct {
.choice => |which| switch (which) {
inline else => |field| comptime words.of(@FieldType(Runtime, @tagName(field))),
},
- .motion => comptime words.of(animation.Motion.Flavour),
else => null,
};
}
@@ -1194,7 +1182,6 @@ pub const Runtime = struct {
.choice => |which| switch (which) {
inline else => |field| try out.print("{s} {s}\n", .{ setting.word, @tagName(@field(state, @tagName(field))) }),
},
- .motion => try out.print("{s} {s}\n", .{ setting.word, @tagName(state.motion) }),
};
if (context.locations.len > 0) try out.print("LocationsConfig {s}\n", .{context.locations});
}
@@ -1370,8 +1357,8 @@ pub const Runtime = struct {
.{ "TaglineSize", "73" }, .{ "WindowOpacity", "85" }, .{ "WindowBlur", "40" },
.{ "MessageLinger", "1500" }, .{ "DumpDir", "~/dumps" }, .{ "TermImages", "petscii" },
.{ "JumpScope", "all" }, .{ "SearchPlace", "column" }, .{ "SearchPane", "new" },
- .{ "Motion", "playful" }, .{ "GripWidth", "200" }, .{ "InactiveDim", "35" },
- .{ "CallstackDepth", "16" }, .{ "Tab", "8" }, .{ "SearchRows", "12" },
+ .{ "GripWidth", "200" }, .{ "InactiveDim", "35" }, .{ "CallstackDepth", "16" },
+ .{ "Tab", "8" }, .{ "SearchRows", "12" },
};
for (values) |v| try std.testing.expect(apply(&state, find(v[0]).?, v[1]));
try std.testing.expect(state.font.requested_name.set("Wanted Mono"));
diff --git a/src/draw.zig b/src/draw.zig
index fe4921ff..75d6378b 100644
--- a/src/draw.zig
+++ b/src/draw.zig
@@ -7,7 +7,6 @@ const std = @import("std");
const vaxis = @import("vaxis");
const pardes = @import("pardes.zig");
const layout = @import("layout.zig");
-const animation = @import("animation.zig");
const config = @import("config.zig");
const panes = @import("panes.zig");
const modal = @import("modal.zig");
@@ -61,7 +60,11 @@ pub fn place(p: *Pardes, s: *Surface) void {
if (pane.collapsed) continue;
const body_h = r.h -| pane.tag_rows;
const line: i32 = if (pane.file) |f| @intCast(@min(f.scroll, std.math.maxInt(i32))) else if (pane.isTerminal()) panes.terminal.gridOffset(pane) else 0;
- s.addRegion(.{ .kind = .body, .owner = owner, .serial = pane.serial, .active = active, .line = line, .rect = .{ .x = r.x + config.GUTTER, .y = body_y, .w = r.w - config.GUTTER, .h = body_h } });
+ // The text it shows, for a frontend's glide to tell apart: a file's
+ // path, a generated text's revision with it (rows rewritten as its
+ // view moved are another text's); none for a terminal or a picture.
+ const doc: u64 = if (pane.file) |f| std.hash.Wyhash.hash(if (f.output != null) f.revision else 0, f.path) else 0;
+ s.addRegion(.{ .kind = .body, .owner = owner, .serial = pane.serial, .active = active, .line = line, .doc = doc, .rect = .{ .x = r.x + config.GUTTER, .y = body_y, .w = r.w - config.GUTTER, .h = body_h } });
var rail: Region = .{ .kind = .rail, .owner = owner, .serial = pane.serial, .active = active, .rect = .{ .x = r.x, .y = body_y, .w = config.GUTTER, .h = body_h } };
// An image's rail has no thumb; a native PDF's is measured as its
// pages are placed (Pdf.draw); every other pane's is here.
diff --git a/src/glide.zig b/src/glide.zig
index ced0ca85..723beba9 100644
--- a/src/glide.zig
+++ b/src/glide.zig
@@ -1,45 +1,41 @@
-//! The view's glide (G6, anim 3, 9, 12): the text's picture following
-//! its core's rows, one system on every shell. The GUI draws it at the
-//! pixel; the tty at whole rows (panel_compositor.glideRows).
+//! The view's glide (G6, anim 3, 9, 12): a frontend's own picture of a
+//! scroll, on its own clock, from the frames it draws alone. Whatever
+//! scrolls a text (a wheel's lines, Ctrl-d, a page, G, n, a Look) scrolls
+//! the core at once, so every key and click acts on where the text is; the
+//! frontend sees a body's first line move between two frames (Region.line)
+//! and its picture follows there, critically damped (text never passes its
+//! mark), every distance on the same law. The GUI draws it at the pixel;
+//! the tty at whole rows (tui.zig's glideRows). Nothing here reaches back
+//! into the core.
const std = @import("std");
const pardes = @import("pardes.zig");
const config = @import("config.zig");
-/// G6 (docs/render-pipeline.md §9.1): whatever scrolls a text (a wheel's
-/// lines, Ctrl-d, a page, G, n, a Look) scrolls the core at once, so every
-/// key and click acts on where the text is, and the picture glides there
-/// on the Motion flavour's spring (critically damped: text never passes its
-/// mark), every distance on the same law. How far the rows moved is
-/// measured on the next frame against the last, a line wrapped over several
-/// rows or a terminal's output included, and the rows that left are kept to
-/// draw in the gap. A move past what the two frames share (a page and more,
-/// G) has no rows between them to show: the picture comes from the last
-/// frame's body as if it lay just past the new one, one body away, so a
-/// jump of any length reads as one body's slide.
+/// How far the rows moved is measured on the frame against the last drawn,
+/// a line wrapped over several rows or a terminal's output included, and
+/// the rows that left are kept to draw in the gap. A move past what the two
+/// frames share (a page and more, G) has no rows between them to show: the
+/// picture comes from the last frame's body as if it lay just past the new
+/// one, one body away, so a jump of any length reads as one body's slide.
///
/// The picture's motion is one system with its own state, integrated in
-/// one place every frame (`advance`), and every scroll, whatever made it,
-/// is an input into it (`kick`): it moves the target by the rows the core
-/// moved and leaves the motion as it is. What the system was doing decides
-/// how it is absorbed: inputs coming as a stream (each like the last, at a
-/// steady spacing: a held key, a spun wheel) feed it, and it moves at the
-/// stream's own rate, a lag of an input or so behind, never easing toward
-/// each target (that was a bounce a line); an input into a resting view,
-/// or against the way it moves, starts the spring from the speed it has
-/// (an ease, a turn through zero); a jump mid-glide adds its rows with the
-/// speed kept. The spring's settle only comes once the inputs stop.
+/// one place every frame (`Follow.advance`), and every scroll, whatever
+/// made it, is an input into it (`Follow.kick`): it moves the target by the
+/// rows the core moved and leaves the motion as it is. Inputs coming as a
+/// stream (each like the last, at a steady spacing: a held key, a spun
+/// wheel) feed it at the stream's own rate; an input into a resting view,
+/// or against the way it moves, starts the spring from the speed it has; a
+/// jump mid-glide adds its rows with the speed kept.
pub const Glide = struct {
/// The picture's lag behind the core's rows and its motion (rows).
- follow: pardes.animation.Follow = .{},
+ follow: Follow = .{},
now_ns: u64 = 0,
pane: usize = 0,
rect: pardes.Rect = .{ .x = 0, .y = 0, .w = 0, .h = 0 },
body_y: u16 = 0,
body_h: u16 = 0,
- /// A scroll made and not yet measured: its direction, and the body's
- /// rows before it.
- pending: bool = false,
+ /// The way the last scroll went, and the body's rows before it.
dir: i8 = 0,
before: []pardes.Cell = &.{},
/// The rows past the body's top (`above`) and bottom (`below`), nearest
@@ -59,24 +55,25 @@ pub const Glide = struct {
/// (a page, a held key's): the tty draws a carried caret with the rows.
caret_row: ?u16 = null,
caret_rides: bool = false,
- /// The Motion flavour the last loop step read.
- motion: pardes.animation.Motion = .{},
- /// Each pane's view as the last loop step saw it (stepGlide): its
- /// serial, first line and file, so a view that moved since is found
+ /// Each body as the last frame showed it, by its pane: its serial,
+ /// first line, text and place, so a view that moved since is found
/// whatever moved it.
- seen: [pardes.MAX_PANES]struct { serial: u32 = 0, line: i64 = 0, file: u64 = 0, revision: u32 = 0 } = @splat(.{}),
+ seen: [pardes.MAX_PANES]struct { serial: u32 = 0, line: i32 = 0, doc: u64 = 0, rect: pardes.Rect = .{ .x = 0, .y = 0, .w = 0, .h = 0 } } = @splat(.{}),
+ /// The last frame's cells, which a move is measured against.
+ last: []pardes.Cell = &.{},
+ last_cols: u16 = 0,
+ last_rows: u16 = 0,
/// The rows kept past each edge, in bodies, so a jump made while one
/// glides carries on from where it is: as far as the picture may lag.
- pub const reach = pardes.animation.Follow.reach;
+ pub const reach = Follow.reach;
pub fn moving(glide: *const Glide) bool {
- return glide.follow.moving() or glide.pending;
+ return glide.follow.moving();
}
pub fn stop(glide: *Glide) void {
glide.follow = .{ .at_ns = glide.follow.at_ns };
- glide.pending = false;
glide.nabove = 0;
glide.nbelow = 0;
glide.pending_lines = 0;
@@ -95,6 +92,7 @@ pub const Glide = struct {
gpa.free(glide.before);
gpa.free(glide.above);
gpa.free(glide.below);
+ gpa.free(glide.last);
}
pub fn bw(glide: *const Glide) u16 {
@@ -102,18 +100,94 @@ pub const Glide = struct {
}
/// The rules at this body's size: a tenth of a pixel is 5e-3 rows.
- pub fn pace(glide: *const Glide, motion: pardes.animation.Motion) pardes.animation.Follow.Pace {
- return pardes.animation.Follow.pace(motion, @floatFromInt(glide.body_h), 5e-3);
+ pub fn pace(glide: *const Glide) Follow.Pace {
+ return Follow.pace(@floatFromInt(glide.body_h), 5e-3);
}
- pub fn advance(glide: *Glide, now_ns: u64, motion: pardes.animation.Motion) void {
- glide.follow.advance(now_ns, glide.pace(motion));
+ /// The frame about to be drawn, at `now_ns` on the frontend's clock:
+ /// the glide moves on to now, and a body whose first line moved since
+ /// the last frame (the same text in the same place) is measured against
+ /// that frame and kicks it. A terminal's view glides only under the
+ /// wheel (`wheeled`: its output scrolls it at every line, and that is no
+ /// glide); not one the frontend moves by the pixel (`direct`). One glide
+ /// at a time: the focused body's, else the one that moved most.
+ pub fn frame(glide: *Glide, gpa: std.mem.Allocator, surface: *const pardes.Surface, now_ns: u64, wheeled: ?usize, direct: ?usize) void {
+ glide.now_ns = now_ns;
+ defer glide.remember(gpa, surface);
+ if (glide.follow.moving()) {
+ glide.follow.advance(now_ns, glide.pace());
+ if (glide.follow.offset == 0) {
+ glide.nabove = 0;
+ glide.nbelow = 0;
+ glide.lines_moved = 0;
+ glide.rows_moved = 0;
+ }
+ }
+ var pick: ?pardes.Region = null;
+ var delta: i64 = 0;
+ var shown: [pardes.MAX_PANES]bool = @splat(false);
+ for (surface.regionList()) |region| {
+ if (region.kind != .body or region.owner >= glide.seen.len) continue;
+ const id: usize = region.owner;
+ shown[id] = true;
+ const was = glide.seen[id];
+ glide.seen[id] = .{ .serial = region.serial, .line = region.line, .doc = region.doc, .rect = region.rect };
+ if (was.serial != region.serial or was.doc != region.doc or was.line == region.line) continue;
+ // The last frame drew this body where it is now: a pane that
+ // moved or was resized in the same step has no picture to glide
+ // from.
+ if (!std.meta.eql(was.rect, region.rect)) continue;
+ if (region.doc == 0 and wheeled != id) continue;
+ if (direct == id) continue;
+ const moved = @as(i64, region.line) - was.line;
+ if (pick) |best| if (best.active or (!region.active and @abs(moved) <= @abs(delta))) continue;
+ pick = region;
+ delta = moved;
+ }
+ for (&glide.seen, shown) |*seen, here| if (!here) {
+ seen.* = .{};
+ };
+ const body = pick orelse return;
+ const r = body.rect;
+ const rect: pardes.Rect = .{ .x = r.x -| config.GUTTER, .y = r.y, .w = r.w + config.GUTTER, .h = r.h };
+ // A new pane or place: what was kept belongs to another picture.
+ if (glide.pane != body.owner or !std.meta.eql(glide.rect, rect)) glide.stop();
+ glide.pane = body.owner;
+ glide.rect = rect;
+ glide.body_y = r.y;
+ glide.body_h = r.h;
+ const w = r.w;
+ if (w == 0 or r.h == 0 or glide.last_cols != surface.cols or glide.last_rows != surface.rows or
+ r.x + w > surface.cols or r.y + r.h > surface.rows) return glide.stop();
+ // The body as the last frame drew it, which the move is measured from.
+ const n = @as(usize, w) * r.h;
+ if (glide.before.len < n) glide.before = gpa.realloc(glide.before, n) catch &.{};
+ if (glide.before.len < n) return glide.stop();
+ for (0..r.h) |row| @memcpy(glide.before[row * w ..][0..w], glide.last[(@as(usize, r.y) + row) * glide.last_cols + r.x ..][0..w]);
+ glide.dir = @intCast(std.math.sign(delta));
+ glide.pending_lines += @floatFromInt(@abs(delta));
+ glide.measure(gpa, surface);
+ }
+
+ /// This frame's cells and caret, for the next frame's measure.
+ fn remember(glide: *Glide, gpa: std.mem.Allocator, surface: *const pardes.Surface) void {
+ if (glide.last.len != surface.cells.len) {
+ gpa.free(glide.last);
+ glide.last = gpa.alloc(pardes.Cell, surface.cells.len) catch &.{};
+ }
+ if (glide.last.len != surface.cells.len) {
+ glide.last_cols = 0;
+ return;
+ }
+ @memcpy(glide.last, surface.cells);
+ glide.last_cols = surface.cols;
+ glide.last_rows = surface.rows;
+ glide.caret_row = if (surface.cursor) |c| c.y else null;
}
/// Finds how far the pane's body rows moved, `dir` rows at a time, by
/// the rows of `surface` against `before`; keeps the rows that left.
- pub fn measure(glide: *Glide, gpa: std.mem.Allocator, surface: *const pardes.Surface) void {
- glide.pending = false;
+ fn measure(glide: *Glide, gpa: std.mem.Allocator, surface: *const pardes.Surface) void {
const w = glide.bw();
const h = glide.body_h;
const x0 = glide.rect.x + config.GUTTER;
@@ -187,89 +261,7 @@ pub const Glide = struct {
std.mem.copyForwards(pardes.Cell, other.*[0 .. @as(usize, other_n.* - dropped) * w], other.*[@as(usize, dropped) * w ..][0 .. @as(usize, other_n.* - dropped) * w]);
other_n.* -= dropped;
// An input: the core's rows moved by as many (down positive).
- glide.follow.kick(@as(f32, @floatFromInt(shift)) * @as(f32, @floatFromInt(glide.dir)), glide.now_ns, glide.pace(glide.motion));
- }
-
- /// Finds the text whose view moved since the last loop step, however
- /// it moved (the wheel, a key, a Look), and snapshots its body as the
- /// last frame drew it (`core.surface`), so the frame about to be drawn
- /// can measure the move (`measure`); moves the glide on to now. A
- /// terminal's view glides only under the wheel (`wheeled`: its output
- /// scrolls it at every line, and that is no glide); not one the shell
- /// moves by the pixel (`direct`).
- pub fn step(glide: *Glide, core: *pardes.Pardes, gpa: std.mem.Allocator, wheeled: ?usize, direct: ?usize) void {
- glide.now_ns = core.now_ns;
- glide.motion = pardes.animation.Motion.of(core.settings.motion);
- if (glide.follow.moving()) {
- glide.advance(core.now_ns, glide.motion);
- core.needs_frame = true;
- if (glide.follow.offset == 0) {
- glide.nabove = 0;
- glide.nbelow = 0;
- glide.lines_moved = 0;
- glide.rows_moved = 0;
- }
- }
- // ponytail: one glide at a time, the focused pane's, else the one that
- // moved most; a second pane scrolled in the same step lands. A glide a
- // pane (and a scissor each) if two ever need to move together.
- // The view that moved: the focused pane's, else the one that moved
- // most; not one showing another file now.
- const s = &core.surface;
- var pick: ?usize = null;
- var delta: i64 = 0;
- for (core.panes, 0..) |slot, id| {
- const pane = slot orelse {
- glide.seen[id] = .{};
- continue;
- };
- const line: i64 = if (pane.file) |f| @intCast(f.scroll) else if (pane.isTerminal()) pardes.panes.terminal.gridOffset(pane) else 0;
- const file: u64 = if (pane.file) |f| std.hash.Wyhash.hash(0, f.path) else 0;
- const revision: u32 = if (pane.file) |f| f.revision else 0;
- const was = glide.seen[id];
- glide.seen[id] = .{ .serial = pane.serial, .line = line, .file = file, .revision = revision };
- if (was.serial != pane.serial or was.file != file or was.line == line or pane.collapsed or pane.hasPdf()) continue;
- // Generated text rewritten as its view moved (a query pane's live
- // rows, a +Search refilled, Callstack): the rows are another
- // text's, not this one's moved; it lands.
- if (pane.file) |f| if (f.output != null and revision != was.revision) continue;
- if (pane.file == null and wheeled != id) continue;
- if (direct == id) continue;
- const moved = line - was.line;
- if (pick) |best| if (best == core.active or (id != core.active and @abs(moved) <= @abs(delta))) continue;
- pick = id;
- delta = moved;
- }
- const id = pick orelse return;
- const pane = core.panes[id].?;
- const r = core.rects[id];
- if (r.h <= pane.tag_rows or r.w <= config.GUTTER) return;
- const body_y = core.bodyTop(pane, r);
- const body_h = r.h -| pane.tag_rows;
- const w = r.w - config.GUTTER;
- const x0 = r.x + config.GUTTER;
- // The last frame drew this body where it is now: a pane that moved or
- // was resized in the same step has no picture to glide from.
- const drawn = for (s.regionList()) |region| {
- if (region.kind == .body and region.owner == id and region.serial == pane.serial) break std.meta.eql(region.rect, pardes.Rect{ .x = x0, .y = body_y, .w = w, .h = body_h });
- } else false;
- // A new pane or place: what was kept belongs to another picture.
- if (glide.pane != id or !std.meta.eql(glide.rect, r) or glide.body_y != body_y or glide.body_h != body_h or glide.pending) glide.stop();
- glide.pane = id;
- glide.rect = r;
- glide.body_y = body_y;
- glide.body_h = body_h;
- if (glide.motion.instant or !drawn or x0 + w > s.cols or body_y + body_h > s.rows or s.cells.len == 0) return glide.stop();
- // The body as the last frame drew it, which the move is measured from.
- const n = @as(usize, w) * body_h;
- if (glide.before.len < n) glide.before = gpa.realloc(glide.before, n) catch &.{};
- if (glide.before.len < n) return glide.stop();
- for (0..body_h) |row| @memcpy(glide.before[row * w ..][0..w], s.cells[(@as(usize, body_y) + row) * s.cols + x0 ..][0..w]);
- glide.pending = true;
- glide.caret_row = if (s.cursor) |c| c.y else null;
- glide.dir = @intCast(std.math.sign(delta));
- glide.pending_lines += @floatFromInt(@abs(delta));
- core.needs_frame = true;
+ glide.follow.kick(@as(f32, @floatFromInt(shift)) * @as(f32, @floatFromInt(glide.dir)), glide.now_ns, glide.pace());
}
pub fn ensure(glide: *Glide, gpa: std.mem.Allocator) bool {
@@ -290,3 +282,144 @@ pub fn sameRow(a: []const pardes.Cell, b: []const pardes.Cell) bool {
}
return true;
}
+
+/// A frame's length at 60 Hz, what a tick of the follow is clamped to.
+const frame_ns: u64 = 16 * std.time.ns_per_ms;
+
+/// A view that follows its input (anim 9, 11): the picture's offset from
+/// the core's position now (rows of text; negative, the picture still
+/// shows what is above), its speed (rows a second), when it was last
+/// integrated, and what has been feeding it.
+pub const Follow = struct {
+ offset: f32 = 0,
+ speed: f32 = 0,
+ at_ns: u64 = 0,
+ /// The last inputs (down positive), their spacing, the last's time, and
+ /// how many came as one stream.
+ feed: struct { amount: f32 = 0, gap_ns: u64 = 0, last_ns: u64 = 0, count: u16 = 0 } = .{},
+
+ /// How far the picture may lag, in bodies (a flick past that jumps);
+ /// how fast it may move, in bodies a second, so moving text stays
+ /// readable.
+ pub const reach = 2;
+ pub const bodies_per_s: f32 = 15;
+ /// Inputs this close, each the way the last went, are one stream.
+ pub const stream_ns = 150 * std.time.ns_per_ms;
+ /// The spring's natural frequency, rad/s: arrivals land inside §8.1's
+ /// 220 ms.
+ pub const omega: f32 = 51;
+
+ /// What a view's size makes of the rules: the speed cap, the lag cap,
+ /// and the offset under which it is at rest (a tenth of a pixel, in
+ /// rows).
+ pub const Pace = struct { cap: f32, limit: f32, rest: f32 };
+
+ pub fn pace(body: f32, rest: f32) Pace {
+ return .{ .cap = body * bodies_per_s, .limit = body * reach, .rest = rest };
+ }
+
+ pub fn moving(follow: *const Follow) bool {
+ return follow.offset != 0 or follow.speed != 0;
+ }
+
+ /// An input: the core moved `amount` (down positive). The picture now
+ /// lags by as much more, its speed as it was.
+ pub fn kick(follow: *Follow, amount: f32, now_ns: u64, p: Pace) void {
+ follow.advance(now_ns, p);
+ follow.offset = std.math.clamp(follow.offset - amount, -p.limit, p.limit);
+ const f = &follow.feed;
+ const like = f.count > 0 and (amount > 0) == (f.amount > 0) and now_ns -| f.last_ns < stream_ns;
+ if (like) {
+ const gap = now_ns -| f.last_ns;
+ f.gap_ns = if (f.count == 1) gap else (f.gap_ns + gap) / 2;
+ f.amount = (f.amount + amount) / 2;
+ f.count +|= 1;
+ } else f.* = .{ .amount = amount, .count = 1 };
+ f.last_ns = now_ns;
+ }
+
+ /// The system moved on to `now_ns`. Fed by a stream, at the stream's
+ /// rate (an input's amount over their spacing), held a lag `lead`
+ /// behind so a late input never finds it stopped and the stream's end
+ /// never runs it past its mark; else on the spring, critically damped,
+ /// from the speed it has. Never faster than `p.cap`.
+ pub fn advance(follow: *Follow, now_ns: u64, p: Pace) void {
+ const dt: f32 = @floatCast(@as(f64, @floatFromInt(@min(now_ns -| follow.at_ns, 2 * frame_ns))) / std.time.ns_per_s);
+ follow.at_ns = now_ns;
+ if (follow.offset == 0 and follow.speed == 0) return;
+ const toward: f32 = if (follow.offset < 0) 1 else -1;
+ const f = follow.feed;
+ if (f.count >= 2 and f.gap_ns > 0 and now_ns -| f.last_ns < f.gap_ns * 3 / 2) {
+ const gap: f32 = @floatCast(@as(f64, @floatFromInt(f.gap_ns)) / std.time.ns_per_s);
+ const rate = @abs(f.amount) / gap;
+ const lead = @max(@abs(f.amount), rate / omega);
+ // ponytail: a gentle pull to the lead (a tenth an input), so the
+ // per-frame step varies by a tenth; a stream's own jitter beyond
+ // that shows. An estimate of the input clock if it ever matters.
+ // A slow stream's lag runs out before its next input: never
+ // faster than the spring's own pace from there (omega a unit of
+ // lag a second), so it eases onto the mark, not into it at speed.
+ const v = std.math.clamp(rate + 0.1 / gap * (@abs(follow.offset) - lead), 0, @min(p.cap, omega * @abs(follow.offset)));
+ const step = @min(v * dt, @abs(follow.offset));
+ follow.offset += toward * step;
+ follow.speed = if (follow.offset == 0) 0 else toward * v;
+ return;
+ }
+ const x = follow.offset;
+ // Coming to rest from a stream: never faster than the spring's own
+ // pace from here (omega a unit of lag a second), so it eases in and
+ // does not pass its mark.
+ if (follow.speed * x < 0 and @abs(follow.speed) > omega * @abs(x)) follow.speed = std.math.sign(follow.speed) * omega * @abs(x);
+ const lead_v = follow.speed + omega * x;
+ const decay = @exp(-omega * dt);
+ var next = (x + lead_v * dt) * decay;
+ var speed = (follow.speed - omega * dt * lead_v) * decay;
+ if (@abs(next - x) > p.cap * dt) {
+ next = x + std.math.sign(next - x) * p.cap * dt;
+ speed = std.math.sign(next - x) * p.cap;
+ }
+ follow.offset = next;
+ follow.speed = speed;
+ if (@abs(next) < p.rest and @abs(speed) < 10 * p.rest) follow.* = .{ .at_ns = now_ns };
+ }
+};
+
+test "a follow comes to rest without a snap: past its fastest frame each step is shorter, the last under a tenth of a pixel" {
+ // A flick's spin (a stream of notches, then nothing), one page, and
+ // notches slow enough that each lag runs out before the next (its
+ // stream must ease onto each mark, never pass it).
+ const p = Follow.pace(600, 0.1);
+ for ([_]struct { n: u16, gap_ms: u64 }{ .{ .n = 12, .gap_ms = 16 }, .{ .n = 1, .gap_ms = 16 }, .{ .n = 6, .gap_ms = 144 } }) |run| {
+ var f: Follow = .{};
+ var now: u64 = std.time.ns_per_s;
+ for (0..run.n) |_| {
+ f.kick(if (run.n == 1) 600 else 25, now, p);
+ var waited: u64 = 0;
+ while (waited < run.gap_ms) : (waited += 8) {
+ now += 8 * std.time.ns_per_ms;
+ const was = f.offset;
+ f.advance(now, p);
+ // Toward its mark only, and onto it from under a pixel.
+ try std.testing.expect(f.offset <= 0 and f.offset >= was);
+ if (f.offset == 0) try std.testing.expect(-was <= 3 * p.rest);
+ }
+ }
+ var last: f32 = std.math.inf(f32);
+ var before = f.offset;
+ var frames: usize = 0;
+ var fastest: f32 = 0;
+ while (f.moving()) : (frames += 1) {
+ now += frame_ns;
+ f.advance(now, p);
+ const step = @abs(f.offset - before);
+ try std.testing.expect(@abs(f.offset) <= @abs(before));
+ if (f.offset == 0) try std.testing.expect(step <= 3 * p.rest);
+ fastest = @max(fastest, step);
+ if (step < fastest) try std.testing.expect(step <= last);
+ last = step;
+ before = f.offset;
+ try std.testing.expect(frames < 120);
+ }
+ try std.testing.expect(last <= 0.1);
+ }
+}
diff --git a/src/gui/gui.zig b/src/gui/gui.zig
index 343ad991..8d69ed80 100644
--- a/src/gui/gui.zig
+++ b/src/gui/gui.zig
@@ -999,6 +999,12 @@ const Gui = struct {
trail: JumpTrail = .{},
/// The caret's ease, on the window's own clock (Caret).
caret: Caret = .{},
+ /// The window's clock for the frame being drawn (Shell.ownNow), and
+ /// what moved the glide's view since the last (stepGlide): the pane a
+ /// wheel scrolled, one a touchpad moves by the pixel.
+ now_ns: u64 = 0,
+ glide_wheeled: ?usize = null,
+ glide_direct: ?usize = null,
/// The last key, click or wheel, which the blink holds for.
input_ns: u64 = 0,
live_ctrl: bool = false,
@@ -2214,7 +2220,7 @@ fn remoteSession(init: std.process.Init, g: *Gui, opts_in: pardes.Options, test_
}
}
-const frame_ms: c_int = @intCast(pardes.animation.frame_ns / std.time.ns_per_ms);
+const frame_ms: c_int = @intCast(pardes.frame_ns / std.time.ns_per_ms);
const StdinFeed = struct {
parser: vaxis.Parser = .{},
@@ -3253,6 +3259,12 @@ const Shell = struct {
s.closeTheWindow();
}
+ /// The window's own clock: the test's virtual one, the paced tick, else
+ /// SDL's.
+ fn ownNow(s: *const Shell) u64 {
+ return s.test_clock orelse s.paced_ns orelse c.SDL_GetTicksNS();
+ }
+
/// The Gui holds the window of the core's live view.
fn follow(s: *Shell) void {
const g = s.gui orelse return;
@@ -3646,7 +3658,7 @@ fn waitInput(ctx: ?*anyopaque, timeout_ms: u32) void {
// 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 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;
+ const polls = g.scroll_lag != 0 or g.scroll_delta != 0 or g.scroll_notch != 0 or frontendMoving(g) or g.gamepad != null or s.test_mode or core.needs_frame;
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.
@@ -3674,7 +3686,7 @@ fn waitInput(ctx: ?*anyopaque, timeout_ms: u32) void {
// 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();
+ const paced = s.test_clock == null and latency_fd < 0 and !s.test_mode and !minimized and frontendMoving(g);
var tick: u64 = 0;
if (paced) {
const period = refreshNs(g);
@@ -3704,7 +3716,7 @@ fn waitInput(ctx: ?*anyopaque, timeout_ms: u32) void {
// 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()) {
+ if (frontendMoving(g)) {
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)) {
@@ -3868,9 +3880,11 @@ fn pollFrame(ctx: ?*anyopaque) void {
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);
if (s.test_mode) writeTestStatus(g, core, s.presented);
- // 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| {
+ // A blink edge, or the window's own motion (its glide, its caret, a
+ // jump's trail): the last frame again, moved on, no core render.
+ if ((g.blink_due or frontendMoving(g)) and !core.needs_frame and s.presented) if (s.surface) |frame| {
g.blink_due = false;
+ g.now_ns = s.ownNow();
s.presented = renderFrame(g, s.gpa, core, frame) catch false;
};
}
@@ -3975,20 +3989,65 @@ fn runDemo(g: *Gui, in: *Input, core: *pardes.Pardes) void {
/// 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, on: bool) ?pardes.animation.Blink {
+/// The cursor's opacity under blink (§5.4): solid while typing and for
+/// `hold_ns` after, then on and off with an eased edge, solid again after
+/// `idle_ns` of no input. `edge` says whether it is mid-edge (a frame is
+/// owed), `next_ns` when the next edge starts (a wake).
+pub const Blink = struct {
+ pub const hold_ns: u64 = 500 * std.time.ns_per_ms;
+ pub const idle_ns: u64 = 10 * std.time.ns_per_s;
+ pub const half_ns: u64 = 530 * std.time.ns_per_ms;
+ pub const edge_ns: u64 = 80 * std.time.ns_per_ms;
+
+ alpha: f32,
+ edge: bool,
+ next_ns: ?u64,
+
+ pub fn at(now_ns: u64, input_ns: u64) Blink {
+ const since = now_ns -| input_ns;
+ if (since < hold_ns) return .{ .alpha = 1, .edge = false, .next_ns = input_ns + hold_ns + half_ns - edge_ns };
+ if (since >= hold_ns + idle_ns) return .{ .alpha = 1, .edge = false, .next_ns = null };
+ const t = (since - hold_ns) % (2 * half_ns);
+ const cycle_start = now_ns - t;
+ // On for a half, easing out over its last `edge_ns`; off for a half,
+ // easing back in over its last.
+ if (t < half_ns - edge_ns) return .{ .alpha = 1, .edge = false, .next_ns = cycle_start + half_ns - edge_ns };
+ if (t < half_ns) return .{ .alpha = 1 - smooth(@as(f32, @floatFromInt(t - (half_ns - edge_ns))) / @as(f32, @floatFromInt(edge_ns))), .edge = true, .next_ns = null };
+ if (t < 2 * half_ns - edge_ns) return .{ .alpha = 0, .edge = false, .next_ns = cycle_start + 2 * half_ns - edge_ns };
+ return .{ .alpha = smooth(@as(f32, @floatFromInt(t - (2 * half_ns - edge_ns))) / @as(f32, @floatFromInt(edge_ns))), .edge = true, .next_ns = null };
+ }
+
+ fn smooth(x: f32) f32 {
+ const u = std.math.clamp(x, 0, 1);
+ return u * u * (3 - 2 * u);
+ }
+};
+
+test "a blink holds while typing, eases at its edges and stops when idle" {
+ const ms = std.time.ns_per_ms;
+ try std.testing.expectEqual(@as(f32, 1), Blink.at(100 * ms, 0).alpha);
+ const out = Blink.at(Blink.hold_ns + Blink.half_ns + 100 * ms, 0);
+ try std.testing.expectEqual(@as(f32, 0), out.alpha);
+ const edge = Blink.at(Blink.hold_ns + Blink.half_ns - Blink.edge_ns / 2, 0);
+ try std.testing.expect(edge.edge and edge.alpha > 0.2 and edge.alpha < 0.8);
+ try std.testing.expectEqual(@as(?u64, null), Blink.at(Blink.hold_ns + Blink.idle_ns + ms, 0).next_ns);
+ try std.testing.expectEqual(@as(f32, 1), Blink.at(Blink.hold_ns + Blink.idle_ns + ms, 0).alpha);
+}
+
+fn blinkNow(g: *const Gui, on: bool) ?Blink {
if (g.no_blink or !on or !g.caret.placed) return null;
if (c.SDL_GetWindowFlags(g.window) & c.SDL_WINDOW_INPUT_FOCUS == 0) return null;
const since = monoNs() -| g.input_ns;
// Relative to now: `next_ns` is how long until the next edge.
- const b = pardes.animation.Blink.at(since, 0);
+ const b = 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;
+ const mode = c.SDL_GetCurrentDisplayMode(c.SDL_GetDisplayForWindow(g.window)) orelse return pardes.frame_ns;
+ if (!(mode.*.refresh_rate > 1)) return pardes.frame_ns;
return @intFromFloat(@as(f64, std.time.ns_per_s) / mode.*.refresh_rate);
}
@@ -4045,6 +4104,7 @@ fn present(ctx: ?*anyopaque, surface: *const pardes.Surface) void {
const frame = surface;
s.surface = frame;
g.frame_arrival_ns = monoNs();
+ g.now_ns = s.ownNow();
s.presented = renderFrame(g, s.gpa, core, frame) catch |err| blk: {
log.err("render: {t}", .{err});
break :blk false;
@@ -4559,13 +4619,10 @@ test "a wheel over codex in a terminal reaches its pty as the mouse reports it a
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.
+/// Feeds a wheel's notches to the core, and keeps what moved the view for
+/// the frame's glide (Glide.frame).
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.trail.active or g.caret.moving();
+ _ = gpa;
const notch = g.scroll_notch;
g.scroll_notch = 0;
var wheeled: ?usize = null;
@@ -4592,9 +4649,22 @@ fn stepGlide(g: *Gui, core: *pardes.Pardes, gpa: std.mem.Allocator) void {
}
if (wheeled != null) core.needs_frame = true;
}
+ if (wheeled != null) g.glide_wheeled = wheeled;
// 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);
+ g.glide_direct = if (g.scroll_lag != 0 or g.scroll_delta != 0) g.scroll_pane else null;
+}
+
+/// The window's own motions under way (its glide, its caret, a jump's
+/// trail): it draws their frames itself, on its own clock.
+fn frontendMoving(g: *const Gui) bool {
+ return g.glide.moving() or g.caret.moving() or g.trail.active;
+}
+
+/// The frame's glide (Glide.frame) on the window's clock, with what moved
+/// its view since the last.
+fn glideFrame(g: *Gui, gpa: std.mem.Allocator, surface: *const pardes.Surface) void {
+ g.glide.frame(gpa, surface, g.now_ns, g.glide_wheeled, g.glide_direct);
+ g.glide_wheeled = null;
}
test "a notch scrolls the core at once and the picture glides after it, a wrapped line's rows at a time" {
@@ -4610,7 +4680,6 @@ test "a notch scrolls the core at once and the picture glides after it, a wrappe
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;
@@ -4626,19 +4695,19 @@ test "a notch scrolls the core at once and the picture glides after it, a wrappe
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);
+ // The window has drawn the view once (Glide.frame finds a view that moved).
+ g.now_ns = now;
+ glideFrame(&g, gpa, s);
// 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);
+ glideFrame(&g, gpa, s);
+ // The window's own motion: it draws its frames while it moves.
+ try std.testing.expect(frontendMoving(&g));
// 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);
@@ -4650,17 +4719,14 @@ test "a notch scrolls the core at once and the picture glides after it, a wrappe
now += 7 * ms;
core.advance(now);
stepGlide(&g, core, gpa);
+ g.now_ns = now;
+ glideFrame(&g, gpa, s);
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());
+ try std.testing.expect(!frontendMoving(&g));
}
test "a wheel's caret rides with its line, the text's own glide, never a spring of its own" {
@@ -4672,7 +4738,6 @@ test "a wheel's caret rides with its line, the text's own glide, never a spring
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();
@@ -4691,6 +4756,9 @@ test "a wheel's caret rides with its line, the text's own glide, never a spring
g.scroll_col = r.x + 10;
g.scroll_row = r.y + r.h - 2;
stepGlide(&g, core, gpa);
+ // The window has drawn the view once (Glide.frame finds a view that moved).
+ g.now_ns = now;
+ glideFrame(&g, gpa, s);
const before: f32 = @floatFromInt(s.cursor.?.y);
g.scroll_notch = 1;
stepGlide(&g, core, gpa);
@@ -4700,7 +4768,8 @@ test "a wheel's caret rides with its line, the text's own glide, never a spring
core.advance(now);
_ = arena.reset(.retain_capacity);
s = try core.render(arena.allocator());
- if (g.glide.pending) g.glide.measure(gpa, s);
+ g.now_ns = now;
+ glideFrame(&g, gpa, s);
seeCaret(&g, s, fixedCellLayout(&g), 480, now);
if (frames == 0) {
try std.testing.expect(g.glide.caret_rides);
@@ -4738,8 +4807,8 @@ const GlideRun = struct {
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);
+ g.now_ns = now;
+ glideFrame(g, gpa, s);
seeCaret(g, s, fixedCellLayout(g), @floatFromInt(@as(u32, s.rows) * g.cell_h), now);
seq.offsets[frame] = g.glide.follow.offset;
seq.lines[frame] = @intCast(core.panes[core.active].?.file.?.scroll);
@@ -4772,7 +4841,7 @@ const GlideRun = struct {
}
};
-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" {
+test "every scroll glides on one law: a half page, a page, the far jumps, a run of them retargeting" {
const gpa = std.testing.allocator;
const core = try pardes.Pardes.init(gpa, .{ .cols = 100, .rows = 40 });
defer core.deinit();
@@ -4781,7 +4850,6 @@ test "every scroll glides on one law: a half page, a page, the far jumps, a run
// 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);
@@ -4837,12 +4905,6 @@ test "every scroll glides on one law: a half page, a page, the far jumps, a run
// 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" {
@@ -4853,7 +4915,6 @@ test "a held key moves the view at the stream's own rate, never a bounce a line,
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);
@@ -5418,10 +5479,9 @@ fn renderFrame(
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);
- if (g.glide.moving()) g.glide.advance(g.glide.now_ns, g.glide.motion);
+ glideFrame(g, gpa, surface);
var groups: Groups = .{};
- const now = monoNs();
+ const now = g.now_ns;
seeCaret(g, surface, layout, win_h, now);
// While the cursor glides or blinks the cells' cursors are not drawn;
// the focused one is the overlay's quad. One or the other every frame
@@ -5435,17 +5495,13 @@ fn renderFrame(
// stay legible; solid again as it lands.
const caret_alpha: f32 = if (gliding) 0.85 + 0.15 * std.math.clamp(1 - g.caret.remaining(now) / 0.5, 0, 1) else 1;
g.cursor_quad_alpha = if (quad_mode) caret_alpha * blink_alpha else 0;
- // A gliding caret asks for the frames it glides through.
- if (gliding) core.shell_continuous = true;
// The probe's view of this frame's motion (FrameStats.Frame).
// A focused PDF's strip is the core's (pdf_view.draw).
const pdf_focus = if (core.panes[core.active]) |pane| pane.hasPdf() else false;
if (!pdf_focus) core.frames.scroll = g.glide.follow.offset;
core.frames.caret = caretRow(g, surface, now) orelse 0;
const cursors_shown = !quad_mode;
- var overlay_count = buildOverlay(g, core.settings.pet, core.settings.jump_trail and core.settings.motion != .off, surface, now, sw, sh);
- // A trail fading asks for the frames it fades through.
- if (g.trail.active) core.shell_continuous = true;
+ var overlay_count = buildOverlay(g, core.settings.pet, core.settings.jump_trail, surface, now, sw, sh);
if (overlay_count != 0 and !uploadOverlayGpu(g, cmd, overlay_count))
overlay_count = 0;
if (!prepareNativeImages(g, gpa, cmd, surface, &groups, sw, sh)) {
@@ -7361,11 +7417,11 @@ 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
+ const idle = presented and !core.needs_frame and !frontendMoving(g) 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;
+ 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(frontendMoving(g)), @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;
diff --git a/src/layout.zig b/src/layout.zig
index 46db6439..9c600cd7 100644
--- a/src/layout.zig
+++ b/src/layout.zig
@@ -4,8 +4,6 @@ const tagline = @import("tagline.zig");
const dump = @import("dump.zig");
const config = @import("config.zig");
const panes = @import("panes.zig");
-const animation = @import("animation.zig");
-const Box = animation.Box;
const Pardes = pardes.Pardes;
const Pane = pardes.Pane;
pub const Rect = struct { x: u16 = 0, y: u16 = 0, w: u16 = 0, h: u16 = 0 };
@@ -1167,15 +1165,6 @@ fn collapseGroup(p: *Pardes, c: usize, start: usize, end: usize) void {
compute(p);
}
-pub fn panelBox(rect: Rect) Box {
- return .{
- .x = @floatFromInt(rect.x),
- .y = @floatFromInt(rect.y),
- .w = @floatFromInt(rect.w),
- .h = @floatFromInt(rect.h),
- };
-}
-
pub fn columnBoundary(width: u16, prefix: u128, total: u128) u16 {
if (total == 0) return 0;
const pixels = (@as(u128, width) * prefix + total / 2) / total;
diff --git a/src/pardes.zig b/src/pardes.zig
index fb5b7f43..ec684b78 100644
--- a/src/pardes.zig
+++ b/src/pardes.zig
@@ -1,6 +1,9 @@
const std = @import("std");
pub const layout = @import("layout.zig");
-pub const animation = @import("animation.zig");
+/// The core's step: `advance` runs a `.tick` a frame of this, and
+/// `nextWake` answers in whole frames of it.
+pub const frame_ms: u32 = 16;
+pub const frame_ns: u64 = frame_ms * std.time.ns_per_ms;
pub const glide = @import("glide.zig");
pub const FrameStats = @import("FrameStats.zig");
pub const modal = @import("modal.zig");
@@ -446,7 +449,6 @@ test {
_ = @import("upgrade.zig");
_ = @import("recent.zig");
_ = @import("Store.zig");
- _ = @import("animation.zig");
_ = @import("pager.zig");
_ = @import("Places.zig");
_ = @import("FrameStats.zig");
@@ -3369,10 +3371,6 @@ pub const Pardes = struct {
chrome: colors.ChromeTheme = colors.initial_chrome,
/// Every drawn frame's timings (FrameStats: the Debug box, PARDES_FRAMES).
frames: FrameStats = .{},
- /// A pixel shell's own render-time motion is under way (its smooth
- /// scroll, G6): the core then keeps the continuous path running, so the
- /// shell draws every loop and a virtual clock moves on, as for a lift.
- shell_continuous: bool = false,
native_images: bool = false,
/// The shell can take a changed image a few rows at a time (a texture row
/// upload, a shared-memory hand-off), so a PDF selection is repainted as
@@ -3499,7 +3497,7 @@ pub const Pardes = struct {
present_skipped: bool = false,
/// Core time. `now_ns` is the shell's monotonic clock as `advance` was
/// last given it; `stepped_ns` is how far animation has been stepped
- /// along it, in whole frames of `animation.frame_ns`. Idle, the two are
+ /// along it, in whole frames of `frame_ns`. Idle, the two are
/// the same instant.
now_ns: u64 = 0,
stepped_ns: u64 = 0,
@@ -3591,7 +3589,7 @@ pub const Pardes = struct {
// A frame, and the animations and timings that make it.
"surface", "frames", "chrome",
"frame_arena", "scratch",
- "needs_frame", "present_skipped", "shell_continuous", "native_image_patches",
+ "needs_frame", "present_skipped", "native_image_patches",
"echo",
// Drained by every pump before its digest; a replica's queues
// are its own.
@@ -5016,7 +5014,7 @@ pub const Pardes = struct {
// waits on is its own (a picture decoding wakes only a frame
// that draws it), and the tape has the same calls either way.
const now = if (v.now) |clock| clock(h.ctx) else p.now_ns;
- const timeout: u32 = if (p.continuous()) 1 else if (p.nextWake()) |due| wake: {
+ const timeout: u32 = if (p.nextWake()) |due| wake: {
const ms = ((due -| now) + std.time.ns_per_ms - 1) / std.time.ns_per_ms;
break :wake @intCast(std.math.clamp(ms, 1, std.math.maxInt(u32)));
} else 0;
@@ -5038,7 +5036,7 @@ pub const Pardes = struct {
// rendering and nothing else.
// A shell with a clock draws what `advance` stepped; one without
// steps its own `.tick`s and draws while anything animates.
- if (!p.needs_frame and !p.continuous() and (v.now != null or !p.animationActive())) return p.frames.idle();
+ if (!p.needs_frame and (v.now != null or !p.animationActive())) return p.frames.idle();
// No one to see it: the frame stays owed (needs_frame), not drawn.
// A pty streaming into an unwatched session spent most of its time
// drawing what nobody looked at.
@@ -5063,8 +5061,8 @@ pub const Pardes = struct {
p.present_skipped = false;
if (v.post_present) |f| f(h.ctx);
// Still moving: the next frame is owed a period from now.
- const owed = if (p.nextWake()) |due| due <= p.stepped_ns + animation.frame_ns else false;
- p.frames.record(FrameStats.nowNs(), owed or p.continuous(), skipped);
+ const owed = if (p.nextWake()) |due| due <= p.stepped_ns + frame_ns else false;
+ p.frames.record(FrameStats.nowNs(), owed, skipped);
}
/// What a pump does between its wait and its frame: the queued inputs
@@ -6809,7 +6807,7 @@ pub const Pardes = struct {
/// the core owns is in this one list, which is what lets every shell
/// sleep exactly as long as nothing changes.
pub fn nextWake(p: *const Pardes) ?u64 {
- const next = p.stepped_ns + animation.frame_ns;
+ const next = p.stepped_ns + frame_ns;
// Held 9P writes go in when they pause: wake for it, never before
// the next frame (writes served before the shell's clock was first
// seen are stamped 0, which `advance` would count back from).
@@ -6827,7 +6825,7 @@ pub const Pardes = struct {
const streaming = p.stream.wake(next);
if (streaming) |due| if (due <= next) return next;
var frames: ?u64 = null;
- if (streaming) |due| frames = @max(1, (due -| p.stepped_ns + animation.frame_ns - 1) / animation.frame_ns);
+ if (streaming) |due| frames = @max(1, (due -| p.stepped_ns + frame_ns - 1) / frame_ns);
if (p.look_hover_wait) |waiting| {
const delay = config.look_preview_delay_frames;
frames = @max(1, delay -| waiting.frames);
@@ -6839,13 +6837,13 @@ pub const Pardes = struct {
// Del's question goes up at the end of its delay: a frame then, and
// none after (stepped time has reached it).
for (p.panes) |slot| if (slot) |pane| if (pane.prompt == .del_side and pane.question_due_ns > p.stepped_ns) {
- const wait = @max(1, (pane.question_due_ns - p.stepped_ns + animation.frame_ns - 1) / animation.frame_ns);
+ const wait = @max(1, (pane.question_due_ns - p.stepped_ns + frame_ns - 1) / frame_ns);
frames = if (frames) |soonest| @min(soonest, wait) else wait;
};
// A paste's Enter waiting on its REPL goes at the end of its wait,
// a time on the clock: the frames from `stepped_ns` that reach it.
for (p.panes) |slot| if (slot) |pane| if (pane.repl_enter > 0) {
- const wait = @max(1, (pane.repl_enter_due_ns -| p.stepped_ns + animation.frame_ns - 1) / animation.frame_ns);
+ const wait = @max(1, (pane.repl_enter_due_ns -| p.stepped_ns + frame_ns - 1) / frame_ns);
frames = if (frames) |soonest| @min(soonest, wait) else wait;
};
// A terminal's kitty animation, at its next frame. Only a time still
@@ -6854,25 +6852,17 @@ pub const Pardes = struct {
for (p.panes) |slot| if (slot) |pane| if (panes.terminal.animationDueMs(pane)) |due_ms| {
const due = due_ms *| std.time.ns_per_ms;
if (due > p.stepped_ns) {
- const wait = @max(1, (due - p.stepped_ns + animation.frame_ns - 1) / animation.frame_ns);
+ const wait = @max(1, (due - p.stepped_ns + frame_ns - 1) / frame_ns);
frames = if (frames) |soonest| @min(soonest, wait) else wait;
}
};
- return if (frames) |n| p.stepped_ns + n * animation.frame_ns else null;
- }
-
- /// A render-time animation is moving (a pane's lift): it is sampled at
- /// each frame's own `now`, so while it moves the shell draws every loop
- /// and its present (vsync) paces it, at the display's rate. `nextWake`
- /// is for the stepped animations, which count frames of `frame_ns`.
- pub fn continuous(p: *const Pardes) bool {
- return p.shell_continuous or panes.Pdf.moving(p);
+ return if (frames) |n| p.stepped_ns + n * frame_ns else null;
}
/// For shells that only need a yes or no: macOS, which keeps its own
/// frame bank.
pub fn animationActive(p: *const Pardes) bool {
- return p.nextWake() != null or p.continuous();
+ return p.nextWake() != null;
}
/// Bring core animation up to `now_ns`, the shell's monotonic clock: one
@@ -6889,7 +6879,7 @@ pub const Pardes = struct {
p.clock_started = true;
p.now_ns = now_ns;
if (!started) p.stepped_ns = now_ns;
- const frame = animation.frame_ns;
+ const frame = frame_ns;
var moving: u32 = 0;
// The session's ticks are the recording session's: a picture still
// decoding or a fade still moving asks for frames the way a message
@@ -7503,7 +7493,7 @@ test "the Del question shows only once its delay is up: a quick SPC d j never se
for (pane.notices.kinds[0..pane.notices.len]) |kind| try std.testing.expect(kind != .prompt);
// The loop wakes for it, at the end of the delay and not before.
const wake = p.nextWake().?;
- try std.testing.expect(wake >= pane.question_due_ns and wake < pane.question_due_ns + animation.frame_ns);
+ try std.testing.expect(wake >= pane.question_due_ns and wake < pane.question_due_ns + frame_ns);
p.now_ns = pane.question_due_ns - 1;
_ = try p.render(frame.allocator());
for (pane.notices.kinds[0..pane.notices.len]) |kind| try std.testing.expect(kind != .prompt);
diff --git a/src/pdf_view.zig b/src/pdf_view.zig
index 5a371720..e615521d 100644
--- a/src/pdf_view.zig
+++ b/src/pdf_view.zig
@@ -193,81 +193,6 @@ test "PDF selections retain their owning page across page focus" {
try std.testing.expectEqual(@as(usize, 0), state.selection_text.len);
}
-test "a PDF strip glides a notch and a page to their marks, eased and never past them, and follows a touchpad's fraction at once" {
- if (comptime !enabled) return;
- const gpa = std.testing.allocator;
- var state = try State.open(gpa, "docs/design.pdf", 1);
- defer state.deinit(gpa);
- const view: Viewport = .{ .pixel_w = 800, .pixel_h = 600 };
- const motion = pardes.animation.Motion.of(.smooth);
- ensureLayout(&state, view);
- var now: u64 = std.time.ns_per_s;
- try std.testing.expectEqual(state.document_scroll_y, stripAt(&state, view, motion, now));
- for ([_]f64{ 20, 600 }) |step| {
- const from = state.document_scroll_y;
- _ = scrollDocument(&state, view, step);
- const mark = state.document_scroll_y;
- // The input's frame still shows where it was; then it eases in.
- var shown = stripAt(&state, view, motion, now);
- try std.testing.expectEqual(from, shown);
- var last_step: f64 = 0;
- var peaked = false;
- for (0..60) |_| {
- now += pardes.animation.frame_ns;
- const next = stripAt(&state, view, motion, now);
- const moved = next - shown;
- try std.testing.expect(moved >= 0 and next <= mark);
- // Past its fastest, each frame's step is no longer than the last.
- if (moved < last_step) peaked = true;
- if (peaked) try std.testing.expect(moved <= last_step + 1e-9);
- last_step = moved;
- shown = next;
- }
- try std.testing.expectEqual(mark, shown);
- try std.testing.expect(!state.follow.moving());
- try std.testing.expect(last_step <= 1);
- }
- // A touchpad's fraction: drawn where the core is, the same frame.
- const from = state.document_scroll_y;
- _ = scrollDocument(&state, view, 0.25);
- state.direct_y += state.document_scroll_y - from;
- try std.testing.expectEqual(from + 0.25, stripAt(&state, view, motion, now));
-}
-
-test "a PDF glide renders the pages it crosses in its input's frame, but a far jump's only where it comes to rest" {
- if (comptime !enabled) return;
- const gpa = std.testing.allocator;
- var state = try State.open(gpa, "docs/design.pdf", 1);
- defer state.deinit(gpa);
- var arena: std.heap.ArenaAllocator = .init(gpa);
- defer arena.deinit();
- const view: Viewport = .{ .pixel_w = 400, .pixel_h = 300 };
- const motion = pardes.animation.Motion.of(.smooth);
- const key: TintKey = .{ .mode = .disabled, .colors = undefined };
- const none: HighlightInput = .{ .hover_color = .{ 0, 0, 0 }, .selection_color = .{ 0, 0, 0 } };
- ensureLayout(&state, view);
- const frame = struct {
- fn f(st: *State, a: *std.heap.ArenaAllocator, m: pardes.animation.Motion, k: TintKey, h: HighlightInput) void {
- const v: Viewport = .{ .pixel_w = 400, .pixel_h = 300 };
- const shown = stripAt(st, v, m, std.time.ns_per_s);
- st.document_scroll_y = shown;
- _ = renderFrame(st, std.testing.allocator, a.allocator(), v, pardes.pdf_raster_policy, k, h, st.drawn_y - shown, st.far);
- st.document_scroll_y = st.drawn_y;
- }
- }.f;
- frame(&state, &arena, motion, key, none);
- // A body down, onto page one's lower part: what it crosses is drawn.
- _ = scrollDocument(&state, view, 300);
- frame(&state, &arena, motion, key, none);
- try std.testing.expect(!state.far and rasterForPage(&state, 0) != null);
- // Far, to page three: only it; the slide comes in over page two's place.
- state.document_scroll_y = @floatFromInt(state.page_starts[3]);
- frame(&state, &arena, motion, key, none);
- try std.testing.expect(state.far);
- try std.testing.expect(rasterForPage(&state, 3) != null);
- try std.testing.expect(rasterForPage(&state, 2) == null);
-}
-
test "off the loop: pages land from lanes, a stale request's raster never lands, and a job nobody waits for is aborted" {
if (comptime !enabled) return;
const gpa = std.testing.allocator;
@@ -631,11 +556,8 @@ pub const State = if (enabled) struct {
layout_fit: FitMode = .width,
layout_valid: bool = false,
document_scroll_y: f64 = 0,
- /// The strip as drawn lags `document_scroll_y` by `follow` (anim 11,
- /// the text's motion system, in pixels): `drawn_y` is where the core
- /// stood at the last frame, `direct_y` what moved it since that the
- /// picture takes as it comes (a touchpad, a relayout).
- follow: pardes.animation.Follow = .{},
+ /// Where the core stood at the last frame (`drawn_y`), and what moved
+ /// it since by the pixel (`direct_y`: a touchpad, a relayout).
drawn_y: f64 = 0,
direct_y: f64 = 0,
/// The last kick was a jump past a body (renderFrame's `far`).
@@ -2540,7 +2462,6 @@ pub fn ensureLayout(state: *State, viewport: Viewport) void {
state.drawn_y += state.document_scroll_y - before;
state.relayout_keeps_motion = false;
} else if (relaid) {
- state.follow = .{};
state.drawn_y = state.document_scroll_y;
state.direct_y = 0;
}
@@ -2973,10 +2894,9 @@ pub fn placeY(pane: *const pardes.Pane, at: Place) ?f64 {
@as(f64, @floatFromInt(at.at)) / place_scale * @as(f64, @floatFromInt(state.page_heights[page]));
}
-/// A jump to `at` (Back, Forward): the core is there at once and the strip
-/// follows through the motion system, a far one as one body's slide, the
-/// page rendered where it comes to rest. Not laid out yet (a pane just
-/// reopened), it is anchored there for the first layout.
+/// A jump to `at` (Back, Forward): the strip is there at once. Not laid
+/// out yet (a pane just reopened), it is anchored there for the first
+/// layout.
pub fn landAt(core: *pardes.Pardes, pane: *pardes.Pane, at: Place) void {
if (comptime !enabled) return;
const state = pane.pdf orelse return;
@@ -3330,8 +3250,8 @@ pub fn highlightInput(
};
}
-/// `glide`: a notch, which the strip glides; else a touchpad's fraction,
-/// which it follows as it comes.
+/// `glide`: a notch; else a touchpad's fraction, counted as moved by the
+/// pixel (`direct_y`).
pub fn scrollPane(core: *pardes.Pardes, pane: *pardes.Pane, delta_pixels: f64, glide: bool) bool {
if (comptime !enabled) return false;
const tz = tracy.zone(@src(), "pdf.scroll_notch");
@@ -3345,33 +3265,16 @@ pub fn scrollPane(core: *pardes.Pardes, pane: *pardes.Pane, delta_pixels: f64, g
return true;
}
-/// Where the strip is drawn this frame (anim 11): what moved the core's
-/// position since the last frame kicks its follow, as a scroll kicks the
-/// text's, all but what moved it directly; the follow then moves on to now.
-fn stripAt(state: *State, view: Viewport, motion: pardes.animation.Motion, now_ns: u64) f64 {
- const pace = pardes.animation.Follow.pace(motion, @floatFromInt(view.pixel_h), 0.1);
- const moved = state.document_scroll_y - state.drawn_y - state.direct_y;
+/// Where the strip is drawn this frame: where the core stands, a scroll
+/// landing at once; which way it went, for the page rendered ahead.
+fn stripAt(state: *State, view: Viewport) f64 {
+ const moved = state.document_scroll_y - state.drawn_y;
+ if (moved != 0) state.ahead = if (moved > 0) 1 else -1;
state.drawn_y = state.document_scroll_y;
state.direct_y = 0;
- if (motion.instant) {
- state.follow = .{};
- } else if (moved != 0) {
- // A move past a body slides one, as a text's far jump does (G6):
- // the pages between are rendered for the slide, not crossed.
- const body: f64 = @floatFromInt(view.pixel_h);
- state.far = @abs(moved) > body;
- state.ahead = if (moved > 0) 1 else -1;
- state.follow.kick(@floatCast(std.math.clamp(moved, -body, body)), now_ns, pace);
- } else state.follow.advance(now_ns, pace);
+ state.far = false;
const max_scroll = @as(f64, @floatFromInt(state.document_height -| view.pixel_h));
- return std.math.clamp(state.drawn_y + state.follow.offset, 0, max_scroll);
-}
-
-/// A PDF strip is still on its way to where the core stands.
-pub fn moving(core: *const pardes.Pardes) bool {
- if (comptime !enabled) return false;
- for (core.panes) |slot| if (slot) |pane| if (pane.pdf) |state| if (state.follow.moving()) return true;
- return false;
+ return std.math.clamp(state.drawn_y, 0, max_scroll);
}
pub fn verticalWheel(core: *pardes.Pardes, pane: *pardes.Pane, direction: i8) void {
@@ -3413,10 +3316,9 @@ pub fn draw(
const key = TintKey{ .mode = state.tint, .colors = tintColors(core) };
applySizes(state, core.pdf_gpa);
ensureLayout(state, view);
- // Drawn where the strip's follow is; the core's position comes back
- // after (`drawn_y`), unless a search's reveal moved it as it drew,
- // which is then drawn there at once.
- const shown = stripAt(state, view, pardes.animation.Motion.of(core.settings.motion), core.now_ns);
+ // Drawn where the core stands (`drawn_y`), unless a search's reveal
+ // moved it as it drew, which is then drawn there.
+ const shown = stripAt(state, view);
state.document_scroll_y = shown;
defer state.document_scroll_y = state.drawn_y;
if (pane_id == core.active) core.frames.scroll = @floatCast(shown);
@@ -3435,10 +3337,7 @@ pub fn draw(
state.drawn_y - shown,
state.far,
);
- if (state.document_scroll_y != shown) {
- state.follow = .{};
- state.drawn_y = state.document_scroll_y;
- }
+ if (state.document_scroll_y != shown) state.drawn_y = state.document_scroll_y;
var placed_any = false;
var page = visible.first;
const visible_end = visible.first + visible.len;
diff --git a/src/surface.zig b/src/surface.zig
index ec4d73b1..3716df4f 100644
--- a/src/surface.zig
+++ b/src/surface.zig
@@ -246,8 +246,10 @@ pub const Region = struct {
/// A notice's index in its pane's `notices`.
notice: u8 = 0,
/// A body's view: the first line it shows (a file's scroll, a
- /// terminal's grid offset).
+ /// terminal's grid offset), and the text it shows (`draw.place`'s doc:
+ /// 0 for a terminal or a picture), which a frontend's glide follows.
line: i32 = 0,
+ doc: u64 = 0,
/// Cells the column-move rail takes off the right edge while it runs
/// there: layers and pixel shells stop short of them, the grid does not.
clip: u16 = 0,
diff --git a/src/tape.zig b/src/tape.zig
index ad5a1c04..c76fd445 100644
--- a/src/tape.zig
+++ b/src/tape.zig
@@ -170,7 +170,7 @@ pub const shape = blk: {
};
/// Fields a host writes straight into the core between its calls.
-const watched = .{ "native_images", "native_image_patches", "present_skipped", "shell_continuous", "needs_frame", "quit", "windowed", "active", "unattended" };
+const watched = .{ "native_images", "native_image_patches", "present_skipped", "needs_frame", "quit", "windowed", "active", "unattended" };
const Kind = enum(u8) { input, done, host, ret, set, digest };
/// A digest record's kind byte (replica.zig reads a unit's last).
diff --git a/src/tui/tui.zig b/src/tui/tui.zig
index 319e6c1b..05d29272 100644
--- a/src/tui/tui.zig
+++ b/src/tui/tui.zig
@@ -1335,7 +1335,7 @@ pub fn remote(init: std.process.Init, opts: pardes.Options, path: []const u8, se
}
if (link.owed or r.echo.changed) link.dirty = true;
// Predictions out: judged a frame at a time while they are.
- if (r.echo.n > 0 or r.echo.cursor != null or r.echo.nd > 0) requestWake(io, @intCast(pardes.animation.frame_ns / std.time.ns_per_ms));
+ if (r.echo.n > 0 or r.echo.cursor != null or r.echo.nd > 0) requestWake(io, @intCast(pardes.frame_ns / std.time.ns_per_ms));
if (link.quietCheck()) |ms| requestWake(io, ms);
if (r.diverged != null) link.quit = true;
}
@@ -1910,7 +1910,7 @@ const Shell = struct {
.now = clockNow,
.present = present,
.post_present = postPresent,
- .poll_frame = stepGlide,
+ .poll_frame = ownFrame,
};
const vtable: host_io.Host.VTable = .{
@@ -2215,12 +2215,16 @@ const Shell = struct {
const s = of(ctx);
// The wait is the 9P connections' turn with the core. A timeout (the
// core's next wake) arrives through the same queue (`wakeWatch`).
- // While anything moves, a frame a tick (animation.frame_ns) on a grid
+ // While anything moves, a frame a tick (pardes.frame_ns) on a grid
// of them, as the GUI paces to its display: the loop ran as fast as
// the terminal answered, a frame every 2 ms, each a write. An input
// ends the wait at once and its frame is drawn then; the ticks after
// it run from it.
var wait = timeout_ms;
+ // The tty's own motions (its glide, a jump's trail) wake it a frame at
+ // a time while they move: on a virtual clock a millisecond's wait
+ // moves it a frame (waitOnce), on the real one the pace below sets it.
+ if (s.moving()) wait = 1;
// Detached, nobody's key dismisses a message: they go on the clock
// (the pump's, after this wait), which wakes it.
if (!s.attached()) {
@@ -2229,10 +2233,10 @@ const Shell = struct {
break;
};
}
- const paced = s.test_clock == null and s.core.continuous();
+ const paced = s.test_clock == null and s.moving();
var tick: u64 = 0;
if (paced) {
- const period = pardes.animation.frame_ns;
+ const period = pardes.frame_ns;
const now: u64 = @intCast(std.Io.Clock.awake.now(s.io).nanoseconds);
tick = if (s.pace_ns != 0 and now -| s.pace_ns < 2 * period) s.pace_ns + period else now;
if (tick < now) tick += (now - tick) / period * period;
@@ -2266,7 +2270,7 @@ const Shell = struct {
while (!paced and s.output_seen and !s.input_seen and !s.core.quit and s.test_clock == null) {
if (s.input_ns > s.drawn_ns) break;
if (s.focused_ns > s.drawn_ns and s.focused_ns -| s.input_ns < std.time.ns_per_s) break;
- const due = s.drawn_ns + pardes.animation.frame_ns;
+ const due = s.drawn_ns + pardes.frame_ns;
const now: u64 = @intCast(std.Io.Clock.awake.now(s.io).nanoseconds);
if (now + std.time.ns_per_ms > due) break;
s.waitOnce(@intCast((due - now) / std.time.ns_per_ms));
@@ -2280,9 +2284,9 @@ const Shell = struct {
break :held held;
} else next: {
if (wait != 0) {
- // A virtual clock moves a frame a wake while anything moves
- // continuously (the glide), as the real one would.
- s.wake_to = s.core.nextWake() orelse if (s.core.continuous()) s.core.now_ns + pardes.animation.frame_ns else 0;
+ // A virtual clock moves a frame a wake while the tty's own
+ // motions move (the glide), as the real one would.
+ s.wake_to = s.core.nextWake() orelse if (s.moving()) s.core.now_ns + pardes.frame_ns else 0;
requestWake(s.io, wait);
}
pardes.turn.rest();
@@ -2567,17 +2571,22 @@ const Shell = struct {
s.loop.postEvent(.files_changed) catch {};
}
- /// ponytail: a terminal's scrollback under the wheel lands here (the
- /// wheel reaches the core as a mouse event, not counted as the GUI's
- /// notches are); `wheeled` from the mouse event if it should glide.
- fn stepGlide(ctx: ?*anyopaque) void {
+ /// The tty's own motions (its glide, a jump's trail) are under way.
+ fn moving(s: *const Shell) bool {
+ const sc = s.term() orelse return false;
+ return sc.glide.moving() or sc.trail.active;
+ }
+
+ /// The tty's own motions draw their frames themselves: the last frame
+ /// again, moved on, when the core has none to draw.
+ fn ownFrame(ctx: ?*anyopaque) void {
const s = of(ctx);
- if (s.term()) |sc| sc.glide.step(s.core, s.gpa, null, null);
+ if (s.moving() and !s.core.needs_frame and s.core.surface.cells.len != 0) present(ctx, &s.core.surface);
}
fn pollFrame(ctx: ?*anyopaque) void {
const s = of(ctx);
- stepGlide(ctx);
+ defer ownFrame(ctx);
if (s.fs) |f| if (f.tick().pending) {
_ = s.loop.tryPostEvent(.fs_ready) catch {};
};
@@ -2611,15 +2620,14 @@ const Shell = struct {
_ = s.frame.reset(.retain_capacity);
const tz_cells = tracy.zone(@src(), "surface->vaxis");
const win = vx.window();
- if (sc.glide.pending) sc.glide.measure(s.gpa, canonical);
- if (sc.glide.moving()) sc.glide.advance(s.core.now_ns, sc.glide.motion);
+ // The tty's own motions, on its own clock, from the frame alone.
+ const now: u64 = s.test_clock orelse @intCast(std.Io.Clock.awake.now(s.io).nanoseconds);
+ sc.glide.frame(s.gpa, canonical, now, null, null);
s.core.frames.scroll = @round(sc.glide.follow.offset);
const glided = glideRows(s.frame.allocator(), canonical, &sc.glide) catch canonical;
const truecolor = vx.caps.rgb or colortermTruecolor();
- const trail_on = s.core.settings.jump_trail and truecolor and s.core.settings.motion != .off;
- const shown = trailCells(s.frame.allocator(), glided, &sc.trail, trail_on, s.test_clock orelse @intCast(std.Io.Clock.awake.now(s.io).nanoseconds)) catch glided;
- // Each of the shell's own motions asks for frames while it runs.
- s.core.shell_continuous = sc.glide.moving() or sc.trail.active;
+ const trail_on = s.core.settings.jump_trail and truecolor;
+ const shown = trailCells(s.frame.allocator(), glided, &sc.trail, trail_on, now) catch glided;
paintCells(win, shown.cells, shown.cols, shown.rows);
if (s.remote) |c| if (c.link.notice_len > 0) noticeLine(win, c.link.notice(), shown.cols, shown.rows);
tz_cells.end();
@@ -3519,21 +3527,18 @@ test "the tty draws a glide at whole rows: once a flick or a spin slows, its ste
defer text.deinit(gpa);
for (0..3000) |i| try text.print(gpa, "{d:0>5} line\n", .{i});
_ = try core.setTestFile(text.items);
- core.settings.motion = .smooth;
var arena: std.heap.ArenaAllocator = .init(gpa);
defer arena.deinit();
var glide: pardes.glide.Glide = .{};
defer glide.deinit(gpa);
var now: u64 = std.time.ns_per_s;
- // One tick of the tty: its loop step, the frame, the picture.
+ // One tick of the tty: the frame, the picture.
const tick = struct {
fn f(c: *pardes.Pardes, g: *pardes.glide.Glide, a: *std.heap.ArenaAllocator, t: u64) !i32 {
c.advance(t);
- g.step(c, std.testing.allocator, null, null);
_ = a.reset(.retain_capacity);
const s = try c.render(a.allocator());
- if (g.pending) g.measure(std.testing.allocator, s);
- if (g.moving()) g.advance(t, g.motion);
+ g.frame(std.testing.allocator, s, t, null, null);
_ = try glideRows(a.allocator(), s, g);
return @intFromFloat(@round(g.follow.offset));
}
@@ -3543,19 +3548,19 @@ test "the tty draws a glide at whole rows: once a flick or a spin slows, its ste
for (0..notches) |i| {
core.update(.{ .mouse = .{ .button = .wheel_down, .kind = .press, .col = 20, .row = 10 } });
if (i % 2 == 1) {
- now += pardes.animation.frame_ns;
+ now += pardes.frame_ns;
_ = try tick(core, &glide, &arena, now);
}
}
- var drawn = try tick(core, &glide, &arena, now + pardes.animation.frame_ns);
- now += pardes.animation.frame_ns;
+ var drawn = try tick(core, &glide, &arena, now + pardes.frame_ns);
+ now += pardes.frame_ns;
var last_step: i32 = std.math.maxInt(i32);
var last_gap: usize = 0;
var since: usize = 0;
var ticks: usize = 0;
while (glide.moving()) : (ticks += 1) {
try std.testing.expect(ticks < 200);
- now += pardes.animation.frame_ns;
+ now += pardes.frame_ns;
const k = try tick(core, &glide, &arena, now);
const step = k - drawn;
drawn = k;
@@ -3584,7 +3589,7 @@ test "the tty draws a glide at whole rows: once a flick or a spin slows, its ste
const row = (core.surface.cursor orelse return error.NoCursor).y;
for (0..20) |i| {
if (i % 2 == 0) keys.j(core);
- now += pardes.animation.frame_ns;
+ now += pardes.frame_ns;
_ = try tick(core, &glide, &arena, now);
const shown = try glideRows(arena.allocator(), &core.surface, &glide);
try std.testing.expectEqual(row, (shown.cursor orelse return error.NoCursor).y);
diff --git a/src/views.zig b/src/views.zig
index 59910f5b..7e087523 100644
--- a/src/views.zig
+++ b/src/views.zig
@@ -37,7 +37,7 @@ pub const fields = [_][:0]const u8{
"col_tags", "col_serial", "finder", "rects",
"col_x", "col_w", "active",
"jumps", "njumps", "jcur", "jump_force",
- "active_column", "shell_continuous",
+ "active_column",
"native_images", "native_image_patches", "windowed",
"drag", "mouse_grab", "window_focused", "focus_told",
"hover_col", "hover_row", "pointer_raw_col", "pointer_raw_row",
@@ -534,16 +534,11 @@ pub fn deinit(p: *Pardes) void {
}
}
-/// What drawing a view keeps of its own (its animations, its panels as
-/// presented), kept from a frame drawn while it was out.
-const drawn_fields = [_][:0]const u8{"shell_continuous"};
-
/// Each view but the live one drawn and presented, the live one put back
/// after exactly as it was: no digested field moves, so a replica that
-/// draws nothing (and skips this) stays the same. A view drawn keeps only
-/// what its drawing made (`drawn_fields`); whatever its unpark brought
-/// inside a changed text is not kept, and is done again when it is next
-/// live. Before the live one's frame: the surface after the pump is its.
+/// draws nothing (and skips this) stays the same. A view drawn keeps
+/// nothing of its drawing: whatever its unpark brought inside a changed
+/// text is not kept, and is done again when it is next live. Before the live one's frame: the surface after the pump is its.
pub fn drawOthers(p: *Pardes, h: pardes.Host) !void {
const live = p.view;
const v = h.vtable;
@@ -581,7 +576,6 @@ pub const Present = struct { ctx: ?*anyopaque, f: ?*const fn (?*anyopaque, *cons
/// and a replica that draws nothing would keep them).
fn drawParked(p: *Pardes, k: u8, present: Present) !void {
try unparked(p, k, present, drawLive);
- copy(&drawn_fields, &p.parked[k].?.view, p);
}
fn drawLive(present: Present, p: *Pardes) anyerror!void {