diff options
Diffstat (limited to 'anim/src/cursor.zig')
| -rw-r--r-- | anim/src/cursor.zig | 153 |
1 files changed, 117 insertions, 36 deletions
diff --git a/anim/src/cursor.zig b/anim/src/cursor.zig index 2811488..f0f90ff 100644 --- a/anim/src/cursor.zig +++ b/anim/src/cursor.zig @@ -84,6 +84,10 @@ pub const Plan = struct { /// The line fires (not on a step that goes on from the last one's /// mark: a crossing stepped over, from its call row). fires: bool = true, + /// Seconds of the step before's cool still to run at this one's start + /// (a step that went on from it without its rest: a crossing from its + /// call row): what it struck goes on cooling, never cut in a frame. + cooling: f32 = 0, /// Once the pattern is known: the levels a stagger apart from the /// first frame, the mark after them, in `seconds`. @@ -91,8 +95,9 @@ pub const Plan = struct { return .{ .gait = .run, .at = .{ 0, time.stagger, 2 * time.stagger }, .advance = time.run_ease, .travel = time.run_ease, .total = seconds }; } + /// The mark, seen only where a phrase ends, moves over the step there: never in a frame. pub fn sprinting(seconds: f32) Plan { - return .{ .gait = .sprint, .at = @splat(0), .advance = 0, .travel = 0, .total = seconds }; + return .{ .gait = .sprint, .at = @splat(0), .advance = 0, .travel = seconds, .total = seconds }; } }; @@ -115,7 +120,7 @@ pub const Cursor = struct { /// 0 to 1 through the step it is taking; 1 at rest. phase: anim.Value, /// The step's `Plan`, a value a field. - plan: [9]anim.Value, + plan: [10]anim.Value, /// The moment the current mark was on, and the one it is on (or going to). marks: [2]anim.Value, /// 1 while steps are hurried (the head counts them), and while what @@ -147,7 +152,7 @@ pub const Cursor = struct { .stops = undefined, .gaits = undefined, .phase = s.value(1), - .plan = .{ s.value(0), s.value(plan.at[0]), s.value(plan.at[1]), s.value(plan.at[2]), s.value(plan.advance), s.value(plan.travel), s.value(plan.total), s.value(0), s.value(1) }, + .plan = .{ s.value(0), s.value(plan.at[0]), s.value(plan.at[1]), s.value(plan.at[2]), s.value(plan.advance), s.value(plan.travel), s.value(plan.total), s.value(0), s.value(1), s.value(0) }, .marks = .{ s.value(here), s.value(here) }, .hurried = s.value(0), .veil = s.value(0), @@ -176,7 +181,7 @@ pub const Cursor = struct { stops: [history]anim.Value, gaits: [history]anim.Value, phase: anim.Value, - plan: [9]anim.Value, + plan: [10]anim.Value, marks: [2]anim.Value, hurried: anim.Value, veil: anim.Value, @@ -253,24 +258,24 @@ pub const Cursor = struct { const Step = struct { stops: [history]f32, gaits: [history]f32, - plan: [9]f32, + plan: [10]f32, marks: [2]f32, count: f32, seconds: f32, fn run(st: @This(), sf: *anim.Frame, v: Cursor) void { - var set: [2 * history + 13]anim.Animation = undefined; + var set: [2 * history + 14]anim.Animation = undefined; for (v.stops, st.stops, 0..) |value, is, i| set[i] = value.to(is); - for (v.gaits, st.gaits, 0..) |value, is, i| set[history + 13 + i] = value.to(is); + for (v.gaits, st.gaits, 0..) |value, is, i| set[history + 14 + i] = value.to(is); for (v.plan, st.plan, history..) |value, is, n| set[n] = value.to(is); - set[history + 9] = v.marks[0].to(st.marks[0]); - set[history + 10] = v.marks[1].to(st.marks[1]); - set[history + 11] = v.phase.to(0); - set[history + 12] = v.count.to(st.count); + set[history + 10] = v.marks[0].to(st.marks[0]); + set[history + 11] = v.marks[1].to(st.marks[1]); + set[history + 12] = v.phase.to(0); + set[history + 13] = v.count.to(st.count); sf.play(set, .{ .seconds = 0 }); sf.play(.{v.phase.to(1)}, .{ .seconds = st.seconds, .ease = anim.ease.linear }); } }; - var st: Step = .{ .stops = undefined, .gaits = undefined, .plan = .{ @floatFromInt(@intFromEnum(plan.gait)), plan.at[0], plan.at[1], plan.at[2], plan.advance, plan.travel, plan.total, @floatFromInt(@intFromBool(plan.wave)), @floatFromInt(@intFromBool(plan.fires)) }, .marks = undefined, .count = settled(s, c.count) + 1, .seconds = seconds }; + var st: Step = .{ .stops = undefined, .gaits = undefined, .plan = .{ @floatFromInt(@intFromEnum(plan.gait)), plan.at[0], plan.at[1], plan.at[2], plan.advance, plan.travel, plan.total, @floatFromInt(@intFromBool(plan.wave)), @floatFromInt(@intFromBool(plan.fires)), plan.cooling }, .marks = undefined, .count = settled(s, c.count) + 1, .seconds = seconds }; st.stops[0] = @floatFromInt(to); for (1..history) |i| st.stops[i] = settled(s, c.stops[i - 1]); st.gaits[0] = @floatFromInt(@intFromEnum(plan.gait)); @@ -329,10 +334,15 @@ pub const Cursor = struct { const regs: f32 = @floatFromInt(@popCount(rec.registersChanged(from, to) & ~quiet)); // Memory gives up its slot when nothing it touched is drawn. var wrote_n: usize = 0; - for (rec.written(from, to)) |span| wrote_n += @intFromBool(rec.drawn(span, from, to)); + var strikes_n: usize = 0; + for (rec.written(from, to)) |span| { + wrote_n += @intFromBool(rec.drawn(span, from, to)); + strikes_n += @intFromBool(takesPlace(rec, span, from, to)); + } var read_n: usize = 0; for (rec.read(from, to)) |span| read_n += @intFromBool(rec.drawn(span, from, to)); - const wrote: f32 = @floatFromInt(wrote_n); + // As many strikes as writes take a place (`takesPlace`): the last is 6 f a write after the first. + const wrote: f32 = @floatFromInt(if (wrote_n > 0) @max(strikes_n, 1) else 0); const touched = wrote_n > 0 or read_n > 0; const deeper = rec.depths[to] > rec.depths[from]; const back = rec.depths[to] < rec.depths[from]; @@ -485,6 +495,7 @@ pub const Cursor = struct { .total = placed.value(c.plan[6]), .wave = placed.value(c.plan[7]) >= 0.5, .fires = placed.value(c.plan[8]) >= 0.5, + .cooling = placed.value(c.plan[9]), }, .marks = .{ whole(rec, placed.value(c.marks[0])), whole(rec, placed.value(c.marks[1])) }, .hurried = placed.value(c.hurried), @@ -510,6 +521,13 @@ pub const Cursor = struct { } }; +/// Whether a write of the step from `from` to `to` takes a place among +/// its strikes: not on a stack frame the step has already left (a callee's +/// words, under rsp, that no window shows: `Recording.drawn`). +fn takesPlace(rec: *const Recording, span: Recording.Span, from: u64, to: u64) bool { + return rec.drawn(span, from, to) or zt.telescope.region(rec.moment(to), span.addr) catch .none != .stack; +} + fn whole(rec: *const Recording, value: f32) u64 { return @min(@as(u64, @intFromFloat(@max(value, 0))), rec.end()); } @@ -671,7 +689,9 @@ pub const Now = struct { n.rec.moment(n.stops[age]).read(addr, is[0..l], known_is[0..l]) catch return null; var out: ?[2]u8 = null; for (0..l) |i| if (known_was[i] and known_is[i] and was[i] != is[i]) { - out = .{ if (out) |o| o[0] else @intCast(i), @intCast(i) }; + // Its first apart: assigned in one expression, `out` would be read as it is written. + const first: u8 = if (out) |o| o[0] else @intCast(i); + out = .{ first, @intCast(i) }; }; return out; } @@ -718,6 +738,8 @@ pub const Now = struct { if (a == 0 or a > s.ember_steps) return .none; // A run changes values unmarked: it shows them settled. if (n.gaits[a] == .run) return .none; + // The step before went on into this one before its cool was done: it cools on. + if (a == 1 and n.plan.cooling > 0 and n.gaits[1] == .walk and !n.resting() and n.time < n.plan.cooling) return cooled(1 - (n.plan.cooling - n.time) / s.cool, .nothing, 0); if (a < s.ember_steps) return .ember; // Linear: a fade, as the mark leaves: secondary action does not // start on the fire's frame, where the step's primary one does. @@ -753,17 +775,23 @@ pub const Now = struct { if (since_strike >= -s.arm) armed.arm = std.math.clamp((since_strike + s.arm) / time.stagger, 0, 1); return armed; } - const cooled = (n.time - n.plan.advance) / s.cool; const in = std.math.clamp(since_strike / s.in, 0, 1); + var h = cooled((n.time - n.plan.advance) / s.cool, if (was.level >= 1) .ember else .nothing, if (was.level >= 1) 1 - in else 0); + h.in = in; + h.out = if (since_strike < s.pulse) theme.pulse(since_strike / s.pulse) else 0; + return h; + } + + /// A struck thing `cooled` of the way through its cool (0 to 1): the + /// paper going on `glide`; the turned corner coming in over the cool's + /// last 6 f (and the old one, `corner_was`, going as a strike comes in over it). + fn cooled(p: f32, from: @FieldType(ui.Heat, "from"), corner_was: f32) ui.Heat { + const s = time.strike; return .{ .level = 1, - .solid = 1 - glide(std.math.clamp(cooled, 0, 1)), - .in = in, - .from = if (was.level >= 1) .ember else .nothing, - .out = if (since_strike < s.pulse) theme.pulse(since_strike / s.pulse) else 0, - // The turned corner: the old one goes as the paper comes in over - // it; the new one comes in over the cool's last 6 f. - .corner = @max(std.math.clamp((cooled - 1) * s.cool / s.corner + 1, 0, 1), if (was.level >= 1) 1 - in else 0), + .solid = 1 - glide(std.math.clamp(p, 0, 1)), + .from = from, + .corner = @max(std.math.clamp((p - 1) * s.cool / s.corner + 1, 0, 1), corner_was), }; } @@ -771,13 +799,33 @@ pub const Now = struct { /// `level`, `delay` seconds after its first, and 6 f after the write of /// this step before theirs. pub fn written(n: Now, addr: u64, size: u64, level: Level, delay: f32) ui.Heat { + var h = n.heat(n.writeAge(addr, size), n.writeAgeFrom(addr, size, 1), n.sinceStrike(addr, size, level, delay)); // What the kernel fills in a crossing lands as its work does it, unpulsed. - if (level == .memory) if (syscalls.filledAt(n, addr)) |at| { - var h = n.heat(n.writeAge(addr, size), n.writeAgeFrom(addr, size, 1), n.time - at); - h.out = 0; - return h; + if (level == .memory and syscalls.filledAt(n, addr) != null) h.out = 0; + return h; + } + + /// Seconds since the strike of `addr .. addr + size` with `level`, + /// `delay` after its first and 6 f after the write of this step before + /// theirs; what the kernel fills in a crossing, as its work lands it. + fn sinceStrike(n: Now, addr: u64, size: u64, level: Level, delay: f32) f32 { + if (level == .memory) if (syscalls.filledAt(n, addr)) |at| return n.time - at; + return n.since(level, delay + n.writeDelay(addr, size)); + } + + /// Seconds since this step's write of `addr .. addr + size` struck in + /// memory, at a walk; null where the step did not write it, or at + /// another pace. Until `in / 2` after it (s+3) the old value stands, + /// through the arm (`shownAt`, a dump's runs, a chain's hops). + pub fn struckAgo(n: Now, addr: u64, size: u64) ?f32 { + if (!n.walking() or n.writeAge(addr, size) != 0) return null; + // What the kernel fills, a byte every 2 f: the value is there once its last byte is. + var last: ?f32 = null; + for (0..size) |i| if (syscalls.filledAt(n, addr + i)) |at| { + last = @max(last orelse at, at); }; - return n.heat(n.writeAge(addr, size), n.writeAgeFrom(addr, size, 1), n.since(level, delay + n.writeDelay(addr, size))); + if (last) |at| return n.time - at; + return n.sinceStrike(addr, size, .memory, 0); } /// `written`, struck `since` seconds ago (a loupe's own times: it strikes once it has opened). @@ -785,11 +833,44 @@ pub const Now = struct { return n.heat(n.writeAge(addr, size), n.writeAgeFrom(addr, size, 1), struck); } - /// The state to draw the memory at `addr` from: `shown(.memory)`, but - /// what the kernel fills in a crossing from when its byte lands. - pub fn shownAt(n: Now, addr: u64) Recording.Moment { - if (syscalls.filledAt(n, addr)) |at| return if (n.time - at >= time.strike.in / 2.0) n.moment() else n.before(); - return n.shown(.memory); + /// The state to draw the memory at `addr .. addr + size` from: + /// `shown(.memory)`, but a write of this step from its own strike + /// (s+3), never before its arm; what the kernel fills in a crossing + /// from when its byte lands. + pub fn shownAt(n: Now, addr: u64, size: u64) Recording.Moment { + return if (n.landedAt(addr, size)) n.moment() else n.before(); + } + + /// Whether memory at `addr .. addr + size` shows the step's state (`shownAt`). + pub fn landedAt(n: Now, addr: u64, size: u64) bool { + if (n.struckAgo(addr, size)) |ago| return ago >= time.strike.in / 2.0; + return n.landed(.memory, 0); + } + + /// The memory a chain from `value` (a register's, struck or not) reads + /// as the panels show it (`shownAt`: the word it points at, from its + /// strike), and, where the step changes what the chain says, seconds + /// since its hops are followed again (`extend`): 4 f after the bytes + /// land, never before. Null where the chain did not change. + /// Before the bytes land, from their strike, the hops it shows fade out + /// (the third: how much they show), so that none goes in a frame. + pub fn following(n: Now, value: u64) struct { Recording.Moment, ?f32, f32 } { + const memory = n.shownAt(value, 8); + if (!n.walking()) return .{ memory, null, 1 }; + const struck = n.struckAgo(value, 8) orelse n.since(.memory, 0); + const land = time.strike.in / 2.0; + // Followed again only while that shows (its hops 4 f apart, 6 f each). + if (struck < 0 or struck > land + 0.5) return .{ memory, null, 1 }; + var bufs: [2][6]zt.telescope.Link = undefined; + var texts: [2][48]u8 = undefined; + const was = zt.telescope.chase(n.before(), value, &bufs[0], &texts[0]) catch return .{ memory, null, 1 }; + const is = zt.telescope.chase(n.moment(), value, &bufs[1], &texts[1]) catch return .{ memory, null, 1 }; + const same = was.len == is.len and for (was, is) |a, b| { + if (a.value != b.value or !std.mem.eql(u8, a.text, b.text)) break false; + } else true; + if (same) return .{ memory, null, 1 }; + if (!n.landedAt(value, 8)) return .{ memory, null, 1 - std.math.clamp(struck / land, 0, 1) }; + return .{ memory, struck - 4.0 / 60.0, 1 }; } /// `written`, on a thing the viewer has watched only through the steps @@ -805,9 +886,9 @@ pub const Now = struct { var order: f32 = 0; var last: ?u64 = null; for (n.rec.written(n.stops[1], n.stops[0])) |span| { - if (span.addr < addr + size and span.addr + span.len > addr) return @min(order, 3) * write_apart; - // The kernel's own writes have their own times (`filledAt`). - if (syscalls.filledAt(n, span.addr) != null) continue; + if (span.addr < addr +| size and span.addr + span.len > addr) return @min(order, 3) * write_apart; + // The kernel's own writes have their own times (`filledAt`); a frame the step has left takes no place. + if (syscalls.filledAt(n, span.addr) != null or !takesPlace(n.rec, span, n.stops[1], n.stops[0])) continue; // Bytes of one write (one store, in pieces) are one strike. if (last == null or span.addr != last.?) order += 1; last = span.addr + span.len; |
