diff options
Diffstat (limited to 'anim/src/ties.zig')
| -rw-r--r-- | anim/src/ties.zig | 119 |
1 files changed, 106 insertions, 13 deletions
diff --git a/anim/src/ties.zig b/anim/src/ties.zig index d18b996..3968d23 100644 --- a/anim/src/ties.zig +++ b/anim/src/ties.zig @@ -73,6 +73,11 @@ pub const Place = union(enum) { } }; +/// The stack's window this frame: its first word, how many it shows, and +/// where its pin lane runs (canvas pixels: x, the first row's top, the +/// row's height). A link to a word outside it ends at its edge. +pub var stack_window: ?struct { first: u64, slots: usize, x: f32, top: f32, row: f32 } = null; + /// What this frame's components have said so far, in canvas pixels: left, top, right, bottom. /// shortcut: one table for the process, emptied by `Ties.draw`; a scene with two players at once wants it on the frame. var table: [512]struct { key: u64, box: [4]f32 } = undefined; @@ -128,6 +133,24 @@ pub fn pinShows(now: cursors.Now, i: usize, target: enum { slot, node }) struct }; } +/// `establish` for a lens: its element `k` (in address order), `r` +/// seconds into its elements' coming in: each fades in rising 8 units +/// over 12 f, 2 f after the one before (all begun by 12 f after the +/// first), with its row's quiet bracket beside it; no lines. How much of +/// it shows, and how far below its place it is. +pub fn rise(r: f32, k: usize, n: usize) struct { element: f32, below: f32 } { + const apart = @min(time.stagger, time.quick / @as(f32, @floatFromInt(@max(n, 2) - 1))); + const p = std.math.clamp((r - @as(f32, @floatFromInt(k)) * apart) / time.quick, 0, 1); + const eased = theme.ease(.enter, p); + return .{ .element = p, .below = (1 - eased) * time.caption_rise }; +} + +/// How long `n` elements take to come in. +pub fn riseTime(n: usize) f32 { + const apart = @min(time.stagger, time.quick / @as(f32, @floatFromInt(@max(n, 2) - 1))); + return @as(f32, @floatFromInt(n -| 1)) * apart + time.quick; +} + pub const Ties = struct { cursor: cursors.Cursor, stage: *const Stage, @@ -139,6 +162,7 @@ pub const Ties = struct { pub fn draw(g: *const Ties, f: *sk.Frame, at: anim.Placed) void { defer said = 0; + defer stack_window = null; const now = g.cursor.now(at); // In canvas pixels, `k` of them a unit: places come from panels anywhere. var raw: ui.Ui = .{ .f = f, .at = at }; @@ -182,7 +206,20 @@ pub const Ties = struct { const value = regs.named(name) orelse continue; const from = find(.{ .register = i }) orelse continue; const node = find(.{ .node_pin = value }); - const target = node orelse find(.{ .slot_pin = value }) orelse continue; + // A word of the stack outside its window: the link ends at the + // window's edge, with a stub and how many words on it is. + var beyond: ?i64 = null; + const target = node orelse find(.{ .slot_pin = value }) orelse edge: { + const w = stack_window orelse continue; + if (value % 8 != 0 or rows.regionOf(now.moment(), value) != .stack) continue; + const words = @as(i64, @bitCast(value -% w.first)) >> 3; + if (words >= 0 and words < w.slots) continue; + if (@abs(words) > 64) continue; + beyond = if (words < 0) words else words - @as(i64, @intCast(w.slots)) + 1; + // Its nearest row's pin lane. + const y = if (words < 0) w.top else w.top + @as(f32, @floatFromInt(w.slots - 1)) * w.row; + break :edge [4]f32{ w.x, y, w.x + 10 * k, y + w.row }; + }; const since = now.since(.cpu, strikeDelay(now, i)); const l = time.link; const drawn = cursors.standard(std.math.clamp((since - l.after) / linkTime(if (node != null) .node else .slot), 0, 1)); @@ -190,7 +227,9 @@ pub const Ties = struct { if (drawn <= 0 or back >= 1) return; const color = rows.ink(rows.regionOf(now.moment(), value)); const y = (from[1] + from[3]) / 2; - const lane = at.xf.apply(.{ theme.metric.tie.link_lane, 0 })[0]; + // What climbs into the band takes the gutter's left lane; what + // goes down to a slot, the right. + const lane = at.xf.apply(.{ if (node != null) theme.metric.tie.link_lane else theme.metric.tie.projection_lane, 0 })[0]; var points: [5]ui.Vec = undefined; var n: usize = 0; points[0] = .{ edge[0] + 2 * k, y }; @@ -203,6 +242,15 @@ pub const Ties = struct { points[3] = .{ cx, bottom }; points[4] = .{ cx, pin[1] }; n = 5; + } else if (beyond) |words| { + // Off the window: to its nearest row, into the pin lane, out + // to the panel's rule, where a head points on. + const mid = (target[1] + target[3]) / 2; + const rule = if (words < 0) target[1] - 6 * k else target[3] + 6 * k; + points[2] = .{ lane, mid }; + points[3] = .{ target[0] + 6 * k, mid }; + points[4] = .{ target[0] + 6 * k, rule }; + n = 5; } else { // Along the gutter to the slot's row, and into its pin lane. const mid = (target[1] + target[3]) / 2; @@ -210,7 +258,18 @@ pub const Ties = struct { points[3] = .{ target[0] - 2 * k, mid }; n = 4; } - raw.route(points[0..n], color, .{ .width = theme.stroke.tie.link * k, .head = .{ 10 * k, 10 * k }, .progress = drawn, .from = cursors.standard(back), .radius = theme.metric.tie.radius * k }); + raw.route(points[0..n], color, .{ .width = theme.stroke.tie.link * k, .head = if (beyond == null) .{ 10 * k, 10 * k } else .{ 9 * k, 12 * k }, .progress = drawn, .from = cursors.standard(back), .radius = theme.metric.tie.radius * k }); + if (beyond) |words| if (drawn >= 1) { + // How far the target is, faint, 6 past the head. + const v = raw.faded(1 - std.math.clamp((now.time - now.plan.advance) / l.out, 0, 1)); + const tip = points[4]; + v.text(.mono, theme.size.mono.context, tip[0] + 12 * k, tip[1] + (if (words < 0) @as(f32, 6) else 14) * k, v.print("{d} rows", .{@abs(words)}), theme.color.text.faint); + }; + // The pin rides the line's head: the register's name beside it. + if (drawn > 0 and drawn < 1 and beyond == null) { + const tip = along(points[0..n], drawn); + raw.text(.mono_bold, theme.size.mono.context, tip[0] + 8 * k, tip[1] - 6 * k, name, theme.color.text.primary); + } return; } } @@ -224,27 +283,49 @@ pub const Ties = struct { .{ .spans = rec.read(now.stops[1], now.stops[0]), .role = .read }, }; for (kinds) |kind| for (kind.spans) |span| { - const word = span.addr & ~@as(u64, 7); - const run = find(.{ .dump_run = word }) orelse continue; - const part = find(.{ .node_part = word }) orelse continue; - const node_addr = nodeOf(word) orelse continue; + // The run that begins where the bytes do (an element of an + // array), else the word they are in (a field of a node). + const word = if (find(.{ .dump_run = span.addr }) != null) span.addr else span.addr & ~@as(u64, 7); + // From the dump's run to the part of the drawing made of it; or + // from a word of the stack to the call it is the way back of. + const slot = find(.{ .word = span.addr }); + // (A return draws no line: its node's badge is struck with rax's digits.) + const stacked = kind.role == .write and slot != null and find(.{ .node_address = span.addr }) != null and find(.{ .dump_run = word }) == null; + const run = if (stacked) slot.? else find(.{ .dump_run = word }) orelse continue; + if (!stacked) _ = find(.{ .node_part = word }) orelse continue; + const node_addr = if (stacked) span.addr else nodeOf(word) orelse continue; const over = find(.{ .node_address = node_addr }) orelse continue; const p = time.project; const since = now.since(.memory, 0); const bracket = std.math.clamp(since / p.bracket, 0, 1); - const drawn = cursors.standard(std.math.clamp((since - p.bracket) / p.draw, 0, 1)); + const drawn = cursors.standard(std.math.clamp((since - p.bracket) / @as(f32, if (stacked) p.far else p.draw), 0, 1)); const out = 1 - std.math.clamp((now.time - now.plan.advance) / p.out, 0, 1); if (bracket <= 0 or out <= 0) return; const color = theme.mark(kind.role).solid; const v = raw.faded(out); const tie = [2]f32{ theme.metric.bracket.tie[0] * k, theme.metric.bracket.tie[1] * k }; - // The bracket takes the row: x 7 of the dump, the row's height. - const bx = run[0] - (rows.byteX(@intCast(word % 16)) - 4 - theme.metric.bytes.bracket) * k; + // The bracket takes the row: x 7 of the dump, the row's height; + // on the stack, the panel's left padding. + const bx = if (stacked) run[0] - (theme.metric.slot.chain - 5) * k else run[0] - (rows.byteX(@intCast(word % 16)) - 4 - theme.metric.bytes.bracket) * k; v.faded(bracket).bracket(bx, run[1] + 2 * k, run[3] - 2 * k, color, tie, 1, false); - const lane = at.xf.apply(.{ theme.metric.tie.projection_lane, 0 })[0]; - const top = at.xf.apply(.{ 0, split.band.y + theme.metric.context.tag + theme.metric.lens.top_lane })[1]; const cx = (over[0] + over[2]) / 2; const y = (run[1] + run[3]) / 2; + if (stacked) { + // A frame's way back to its call's node: up the gutter's + // left lane, along the drawing's bottom lane, up to a + // bracket under the node, serifs up. + const lane = at.xf.apply(.{ theme.metric.tie.link_lane, 0 })[0]; + const bottom = at.xf.apply(.{ 0, split.band.y + split.band.h - theme.metric.lens.bottom_lane })[1]; + v.route(&.{ .{ bx - 1 * k, y }, .{ lane, y }, .{ lane, bottom }, .{ cx, bottom }, .{ cx, over[3] + 5 * k } }, color, .{ .width = theme.stroke.tie.projection * k, .head = null, .progress = drawn, .radius = theme.metric.tie.projection_radius * k }); + if (drawn >= 1) { + v.fill(.{ .x = over[0], .y = over[3] + 2 * k, .w = over[2] - over[0], .h = 3 * k }, color); + v.fill(.{ .x = over[0], .y = over[3] - 3 * k, .w = 3 * k, .h = 8 * k }, color); + v.fill(.{ .x = over[2] - 3 * k, .y = over[3] - 3 * k, .w = 3 * k, .h = 8 * k }, color); + } + return; + } + const lane = at.xf.apply(.{ theme.metric.tie.projection_lane, 0 })[0]; + const top = at.xf.apply(.{ 0, split.band.y + theme.metric.context.tag + theme.metric.lens.top_lane })[1]; v.route(&.{ .{ bx - 1 * k, y }, .{ lane, y }, .{ lane, top }, .{ cx, top }, .{ cx, over[1] - 4 * k } }, color, .{ .width = theme.stroke.tie.projection * k, .head = null, .progress = drawn, .radius = theme.metric.tie.projection_radius * k }); // Over the node's address: a bracket, serifs down. if (drawn >= 1) { @@ -252,12 +333,24 @@ pub const Ties = struct { v.fill(.{ .x = over[0], .y = over[1] - 5 * k, .w = 3 * k, .h = 8 * k }, color); v.fill(.{ .x = over[2] - 3 * k, .y = over[1] - 5 * k, .w = 3 * k, .h = 8 * k }, color); } - _ = part; return; }; } }; +/// The point `p` of the way along the straight path through `points`. +fn along(points: []const ui.Vec, p: f32) ui.Vec { + var total: f32 = 0; + for (points[0 .. points.len - 1], points[1..]) |a, b| total += sk.math.distance(a, b); + var left = total * p; + for (points[0 .. points.len - 1], points[1..]) |a, b| { + const d = sk.math.distance(a, b); + if (left <= d and d > 0) return sk.math.mix(a, b, left / d); + left -= d; + } + return points[points.len - 1]; +} + /// The node a field's address belongs to: the drawn node at or below it, within a record. fn nodeOf(addr: u64) ?u64 { var best: ?u64 = null; |
