summaryrefslogtreecommitdiff
path: root/anim/src/map.zig
diff options
context:
space:
mode:
authorGabriel Schneider <[email protected]>2026-11-10 23:36:18 -0300
committerGabriel Schneider <[email protected]>2026-11-10 23:55:42 -0300
commit81d97a9e38c740a96af13a8a981878947a508bc0 (patch)
treebbe53f2f4c195f378a5a8cb67dfac1277ac68c82 /anim/src/map.zig
parent2a46b60e1d115ff5149a112bc0f800467c0efaee (diff)
downloadcomputeranim-81d97a9e38c740a96af13a8a981878947a508bc0.tar.gz
computeranim-81d97a9e38c740a96af13a8a981878947a508bc0.zip
canim: quieter marks, the stack's roles, the loupe, arcs, the minimap, the map and the dive
From the user's notes on the second videos. The current row is a white wash, a strike a softened vermilion, held a turned corner. A stack row has its offset from rsp and its role from the tracer (a saved register, a local by name, argc and argv). The loupe is the telescope as a floating panel: the memory round what a pointer leads to, a pointer inside it opening the next. A pointer to a row of its own panel is an arc in a lane, in dumps, loupes and the stack. Every scene has the minimap; the map is the same moment with every panel at full length on 3840 by 2160, and the list opens on it and dives to the working frame, each panel travelling to its place. Recordings hold more round each stop. Co-Authored-By: Claude Fable 5.2 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNCKgYCGiANnEwcEQxa
Diffstat (limited to 'anim/src/map.zig')
-rw-r--r--anim/src/map.zig286
1 files changed, 286 insertions, 0 deletions
diff --git a/anim/src/map.zig b/anim/src/map.zig
new file mode 100644
index 0000000..e22db9f
--- /dev/null
+++ b/anim/src/map.zig
@@ -0,0 +1,286 @@
+//! The `map` and the `minimap` (design/README.md, "The map and the
+//! minimap"): the working frame unfolded, every panel at its full length on
+//! a stage of 3840 by 2160 at the context's type size, and the same at a
+//! twentieth in the caption band's right end. Its panels are the working
+//! frame's components bound to a stage of their own (`split`), drawn with
+//! `ui.mapping` set: then they publish their rows (`row`), and in the
+//! working frame their windows (`window`); the map outlines each working
+//! window round the rows of its own that it shows.
+const std = @import("std");
+const sk = @import("sketch");
+const anim = @import("anim");
+const ui = @import("ui.zig");
+const Recording = @import("Recording.zig");
+const Stage = @import("stage.zig").Stage;
+const theme = ui.theme;
+const Rect = theme.Rect;
+const Split = theme.layout.Split;
+
+pub const Panel = enum { band, view, source, disasm, registers, stack, backtrace };
+
+/// `dive`'s frames: the windows bright by `bright`, the rest veiled by
+/// `move`, when the panels set off (each `apart` after the one before, for
+/// `travel`); the veil lifts from `lift` as the map lands at `land`; then
+/// `still`. `surface` takes `surface` back.
+pub const diving = struct {
+ pub const bright = 6;
+ pub const move = 24;
+ pub const apart = 6;
+ /// A panel's way, and the map's.
+ pub const travel = 60;
+ pub const fall = 72;
+ pub const lift = 84;
+ /// The last of seven panels in place: 24 + 6 * 6 + 60.
+ pub const land = 120;
+ pub const still = 30;
+ pub const surface = 84;
+};
+
+/// Where each working window is on the map this frame, in canvas pixels.
+var window_px: [7]?[4]f32 = @splat(null);
+
+/// The working frame's windows this frame: the first and last key of the
+/// rows each shows (a line number, an address).
+var windows: [7]?[2]u64 = @splat(null);
+/// The map's rows this frame, in canvas pixels: each one's key and box.
+var rows: [7][160]struct { key: u64, box: [4]f32 } = undefined;
+var counts: [7]usize = @splat(0);
+
+/// A working panel shows the rows of keys `first` to `last`.
+pub fn window(panel: Panel, first: u64, last: u64) void {
+ if (!ui.mapping) windows[@intFromEnum(panel)] = .{ first, last };
+}
+
+/// A map panel's row of key `key` is at `r`, in `u`'s units.
+pub fn row(panel: Panel, key: u64, u: ui.Ui, r: Rect) void {
+ if (!ui.mapping) return;
+ const i = @intFromEnum(panel);
+ if (counts[i] == rows[i].len) return;
+ const a = u.at.xf.apply(.{ r.x, r.y });
+ const b = u.at.xf.apply(.{ r.x + r.w, r.y + r.h });
+ rows[i][counts[i]] = .{ .key = key, .box = .{ a[0], a[1], b[0], b[1] } };
+ counts[i] += 1;
+}
+
+/// The map's boxes for a recording: the drawing (with a lens) and the
+/// source in the first column, the disassembly in the second, the lens's
+/// view (its region whole), the registers and the backtrace in the third,
+/// the stack in the fourth. Each as long as its content where that is
+/// shorter than the column.
+// shortcut: a panel longer than its column is a window of what fits; continuing it in the next column's free space (`continued`), and the key in a column's foot, are not built.
+pub fn split(rec: *const Recording, lens: bool) Split {
+ const st = theme.map.stage;
+ const c = theme.map.columns;
+ const w = theme.map.column;
+ const gap = theme.canvas.row_gap;
+ const panelH = theme.layout.panelH;
+ const foot = st.y + st.h;
+ const band: Rect = .{ .x = c[0], .y = st.y, .w = w, .h = if (lens) theme.layout.split.subject.band.h else 0 };
+ const source_y = if (lens) band.y + band.h + gap else st.y;
+ const source_rows: f32 = @floatFromInt(@min(rec.line_count, theme.layout.rowsIn(foot - source_y)));
+ const view: Rect = .{ .x = c[2], .y = st.y, .w = w, .h = if (lens) panelH(theme.map.memory_rows) else 0 };
+ const registers: Rect = .{ .x = c[2], .y = if (lens) view.y + view.h + gap else st.y, .w = w, .h = panelH(17) };
+ const bt_y = registers.y + registers.h + gap;
+ return .{
+ .band = band,
+ .view = view,
+ .source = .{ .x = c[0], .y = source_y, .w = w, .h = panelH(source_rows) },
+ .disasm = .{ .x = c[1], .y = st.y, .w = w, .h = panelH(theme.map.disasm_rows) },
+ .registers = registers,
+ .stack = .{ .x = c[3], .y = st.y, .w = w, .h = st.h },
+ .backtrace = .{ .x = c[2], .y = bt_y, .w = w, .h = @min(panelH(12), foot - bt_y) },
+ .dump_rows = theme.map.memory_rows,
+ };
+}
+
+/// The map: its stage, and the components drawn on it, each a working
+/// frame's component bound to that stage.
+pub const Map = struct {
+ stage: *Stage,
+ parts: [8]Part = undefined,
+ n: usize = 0,
+ /// The panel the narration is in: its window bright on the minimap.
+ focus: ?Panel = null,
+ /// The working frame, whose panels dive out of their windows.
+ frame: *const Stage,
+ /// Frames into a `dive` (0: the map fills the frame; `diving.land` and
+ /// on: the working frame, the map its minimap).
+ t: anim.Value,
+ /// The map as an object of the scene, under the panels: it shows from `show`.
+ obj: anim.Obj = undefined,
+
+ const Part = struct { ctx: *const anyopaque, draw: *const fn (*const anyopaque, *sk.Frame, anim.Placed) void };
+
+ /// Puts `component` (bound to `m.stage`) on the map, drawn in the order added.
+ pub fn add(m: *Map, s: *anim.Frame, component: anytype) void {
+ const T = @TypeOf(component);
+ const kept = s.new(component);
+ m.parts[m.n] = .{ .ctx = kept, .draw = struct {
+ fn draw(ctx: *const anyopaque, f: *sk.Frame, at: anim.Placed) void {
+ @as(*const T, @ptrCast(@alignCast(ctx))).draw(f, at);
+ }
+ }.draw };
+ m.n += 1;
+ }
+
+ /// Whether the working frame is in place (the minimap is the map).
+ pub fn settled(m: *const Map, at: anim.Placed) bool {
+ return at.value(m.t) >= diving.land;
+ }
+
+ /// The map filling the frame, before a scene's first `dive`: it fades
+ /// in (18 f) with `with` (the working panels, at their windows on it).
+ pub fn show(m: *const Map, s: *anim.Frame, with: anytype) void {
+ s.play(.{m.t.to(0)}, .{ .seconds = 0 });
+ var all: [with.len + 1]anim.Animation = undefined;
+ all[0] = m.obj.fadeIn();
+ inline for (with, 1..) |o, i| all[i] = o.fadeIn();
+ s.play(all, .{ .seconds = theme.time.cascade, .ease = anim.ease.linear });
+ }
+
+ /// `dive`: the windows go bright, the rest of the map is veiled; each
+ /// window travels to its panel's place, growing from the map's size to
+ /// the frame's on a logarithm (`glide`, 6 f apart in reading order),
+ /// as the map falls to the minimap's place; the veil lifts as it lands;
+ /// then the frame is still.
+ pub fn dive(m: *const Map, s: *anim.Frame) void {
+ s.play(.{m.t.to(diving.land + diving.still)}, .{ .seconds = @as(f32, diving.land + diving.still) / 60.0, .ease = anim.ease.linear });
+ }
+
+ /// `surface`: the dive backwards, a little quicker; then the map is
+ /// still before anything plays on it.
+ pub fn surface(m: *const Map, s: *anim.Frame) void {
+ s.play(.{m.t.to(diving.land)}, .{ .seconds = 0 });
+ s.play(.{m.t.to(0)}, .{ .seconds = @as(f32, diving.surface) / 60.0, .ease = anim.ease.linear });
+ s.wait(@as(f32, diving.still) / 60.0);
+ }
+
+ /// The map while it is shown or travelling (the scene's first object):
+ /// filling the frame at half its size, or on its way to the minimap.
+ /// It sets where each working panel is drawn on the way (`context.zoomed`).
+ pub fn draw(m: *const Map, f: *sk.Frame, placed: anim.Placed) void {
+ const context = @import("context.zig");
+ context.zoomed = @splat(null);
+ const t = placed.value(m.t);
+ if (t >= diving.land) return;
+ const fixed = @import("words.zig").fixed(f, placed, 0);
+ // The map: from filling the frame (half its units) to the minimap's rect (a twentieth).
+ const q = theme.ease(.glide, std.math.clamp((t - diving.move) / diving.fall, 0, 1));
+ const mini = theme.minimap.box;
+ const k = std.math.pow(f32, 0.5, 1 - q) * std.math.pow(f32, theme.minimap.scale, q);
+ const origin = [2]f32{ q * mini.x, q * mini.y };
+ var at = fixed.at;
+ at.xf = at.xf.mul(.translate(origin[0], origin[1])).mul(.scale(k, k));
+ at.scale = fixed.at.scale * k;
+ fixed.fill(.{ .x = 0, .y = 0, .w = theme.canvas.width, .h = theme.canvas.height }, theme.color.page);
+ m.drawAt(f, at, k < 0.12);
+ // The rest of the map veiled from 6 f to 24 f, lifting as it lands.
+ const veil = std.math.clamp((t - diving.bright) / (diving.move - diving.bright), 0, 1) * (1 - std.math.clamp((t - diving.lift) / (diving.land - diving.lift), 0, 1));
+ (ui.Ui{ .f = f, .at = at }).veil(theme.map.stage, veil);
+ // The windows bright from 0 to 6 f, over the veil.
+ m.outline(f, at, k < 0.12, std.math.clamp(t / diving.bright, 0, 1));
+ // Each working panel: from its window on the map at the start to its place, 6 f after the one before.
+ const back = at.xf.invert();
+ const working = m.frame.now(placed);
+ inline for (.{ "band", "view", "source", "registers", "disasm", "stack", "backtrace" }, 0..) |name, order| {
+ const i = @intFromEnum(@field(Panel, name));
+ const box = @field(working, name);
+ if (box.h > 0) if (window_px[i]) |w| {
+ const a = back.apply(.{ w[0], w[1] });
+ const b = back.apply(.{ w[2], w[3] });
+ // On the map as it fills the frame (half its units): the panel's rows on the window's rows, its tag above them.
+ const s0 = (b[0] - a[0]) / 2 / box.w;
+ const lead = (if (i == @intFromEnum(Panel.band)) 0 else theme.metric.context.tag + theme.metric.context.pad) * s0;
+ const from: Rect = .{ .x = a[0] / 2, .y = a[1] / 2 - lead, .w = box.w * s0, .h = box.h * s0 };
+ const p = theme.ease(.glide, std.math.clamp((t - diving.move - @as(f32, @floatFromInt(order)) * diving.apart) / diving.travel, 0, 1));
+ const scale = std.math.pow(f32, s0, 1 - p);
+ const x = std.math.lerp(from.x, box.x, p);
+ const y = std.math.lerp(from.y, box.y, p);
+ // The tags, rules and lanes come in as the map lands.
+ const chrome = std.math.clamp((t - diving.lift) / 12, 0, 1);
+ context.zoomed[i] = .{ .box = box, .to = .{ .x = x, .y = y, .w = box.w * scale, .h = box.h * scale }, .chrome = chrome };
+ };
+ }
+ }
+
+ /// The map in `at`'s transform (the map's units), and the working
+ /// frame's windows outlined on it: a 2-unit `dim` frame 4 out; on the
+ /// minimap (`mini`) a pixel of primary, the focused one 1.5.
+ pub fn drawAt(m: *const Map, f: *sk.Frame, at: anim.Placed, mini: bool) void {
+ m.drawParts(f, at, mini);
+ m.outline(f, at, mini, 0);
+ }
+
+ fn drawParts(m: *const Map, f: *sk.Frame, at: anim.Placed, mini: bool) void {
+ ui.mapping = true;
+ ui.strokes = mini;
+ counts = @splat(0);
+ for (m.parts[0..m.n]) |p| p.draw(p.ctx, f, at);
+ ui.mapping = false;
+ ui.strokes = false;
+ }
+
+ /// The working windows' outlines on the map in `at`, `bright` of the way
+ /// from `dim` to bright; where they are is kept (`window_px`).
+ fn outline(m: *const Map, f: *sk.Frame, at: anim.Placed, mini: bool, bright: f32) void {
+ var raw: ui.Ui = .{ .f = f, .at = at };
+ raw.at.xf = .identity;
+ const k = at.scale;
+ const split_ = m.stage.now(at);
+ inline for (.{ "band", "view", "source", "disasm", "registers", "stack", "backtrace" }) |name| {
+ const panel = @field(Panel, name);
+ const i = @intFromEnum(panel);
+ const box = @field(split_, name);
+ if (box.h > 0) {
+ const a = at.xf.apply(.{ box.x, box.y });
+ const b = at.xf.apply(.{ box.x + box.w, box.y + box.h });
+ var r: [4]f32 = .{ a[0], a[1], b[0], b[1] };
+ var shown = panel == .registers or panel == .band;
+ if (windows[i]) |win| {
+ var top: f32 = std.math.inf(f32);
+ var bottom: f32 = -std.math.inf(f32);
+ for (rows[i][0..counts[i]]) |rw| if (rw.key >= win[0] and rw.key <= win[1]) {
+ top = @min(top, rw.box[1]);
+ bottom = @max(bottom, rw.box[3]);
+ };
+ if (top < bottom) {
+ r[1] = top;
+ r[3] = bottom;
+ shown = true;
+ }
+ }
+ window_px[i] = if (shown) r else null;
+ if (shown) {
+ const focus = m.focus == panel;
+ // On the minimap a pixel of the frame: `k` is the canvas's pixels to a map unit.
+ const w = if (mini) @as(f32, if (focus) 1.5 else 1) * k / theme.minimap.scale else theme.map.outline * k;
+ const out = if (mini) w else theme.map.outline_out * k;
+ raw.frame(.{ .x = r[0] - out, .y = r[1] - out, .w = r[2] - r[0] + 2 * out, .h = r[3] - r[1] + 2 * out }, ui.mix(if (mini) theme.color.text.primary else theme.color.text.dim, theme.color.text.bright, bright), if (bright > 0 and !mini) w * 1.5 else w);
+ }
+ }
+ }
+ }
+};
+
+/// The minimap: `m` at a twentieth in the caption band's right end, still
+/// while the camera moves; the page under it, framed a pixel in `rule`.
+pub fn minimap(m: *const Map, f: *sk.Frame, at: anim.Placed) void {
+ const fixed = @import("words.zig").fixed(f, at, 0);
+ const box = theme.minimap.box;
+ fixed.fill(box, theme.color.page);
+ var placed = fixed.at;
+ placed.xf = placed.xf.mul(.translate(box.x, box.y)).mul(.scale(theme.minimap.scale, theme.minimap.scale));
+ placed.scale = fixed.at.scale * theme.minimap.scale;
+ const clip = fixed.at.xf.apply(.{ box.x, box.y });
+ const end = fixed.at.xf.apply(.{ box.x + box.w, box.y + box.h });
+ f.clip(sk.Rect{ .x = @round(clip[0]), .y = @round(clip[1]), .w = @round(end[0]) - @round(clip[0]), .h = @round(end[1]) - @round(clip[1]) });
+ m.drawAt(f, placed, true);
+ f.clip(null);
+ fixed.frame(.{ .x = box.x - 1, .y = box.y - 1, .w = box.w + 2, .h = box.h + 2 }, theme.color.rule, 1);
+}
+
+test "the map's columns hold their panels" {
+ try std.testing.expectEqual(@as(f32, 1688), theme.layout.panelH(theme.map.disasm_rows));
+ const st = theme.map.stage;
+ try std.testing.expectEqual(@as(f32, 3840), st.x + st.w + st.x);
+}