diff options
| author | Gabriel Schneider <[email protected]> | 2026-11-11 14:43:13 -0300 |
|---|---|---|
| committer | Gabriel Schneider <[email protected]> | 2026-11-11 16:17:33 -0300 |
| commit | 3093eb55ac4a7054f51f06ea2786b5f9c9ec73f6 (patch) | |
| tree | f1bc91879a447f178dfaba39d0df107d01e557bd /anim/src/map.zig | |
| parent | a72831d5c322078260314c305ddd940e4967947d (diff) | |
| download | computeranim-3093eb55ac4a7054f51f06ea2786b5f9c9ec73f6.tar.gz computeranim-3093eb55ac4a7054f51f06ea2786b5f9c9ec73f6.zip | |
canim: a minimap in each pane; source wherever it can be had, libc's included
From the user. Each pane with more than it shows carries a strip of its
whole column at its right edge, the pane's window outlined and what
happens off it marked there; the corner minimap is gone and the dive
folds each column of the map into its pane's strip. The source panel
follows the pc into any file the build has: glibc's own, from the
distro's debuginfod by an optional step that caches them by build id
(zig build sources; nothing else touches the network), and musl's, from
Zig's lib directory. The syscalls scene shows open64.c on the way down,
and a new scene follows the same call through a Zig-built musl. A
graph's counts and inks are as of the moment shown.
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.zig | 882 |
1 files changed, 636 insertions, 246 deletions
diff --git a/anim/src/map.zig b/anim/src/map.zig index 108bafd..ee1d2a1 100644 --- a/anim/src/map.zig +++ b/anim/src/map.zig @@ -1,11 +1,12 @@ -//! The `map` and the `minimap` (design/README.md, "The map and the +//! The `map` and the panes' minimaps (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. +//! a stage of 3840 by 2160 at the context's type size; and each pane's +//! column of it, small, in a `strip` inside the pane's frame at its right. +//! 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, +//! and a strip frames it. const std = @import("std"); const sk = @import("sketch"); const anim = @import("anim"); @@ -18,17 +19,25 @@ const Split = theme.layout.Split; pub const Panel = enum { band, view, source, disasm, registers, stack, backtrace }; +/// The panes with a strip, in the order of their places in the strips' images. +pub const stripped = [_]Panel{ .source, .disasm, .stack, .view }; + +fn slotOf(panel: Panel) ?usize { + return std.mem.indexOfScalar(Panel, &stripped, panel); +} + /// `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. +/// `travel`), each pane's column squeezing into its strip with it; the +/// rest of the map gone by `gone`; the strips and the tags in from `lift`; +/// then `still` from `land`. `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. + /// A panel's way, and its column's. pub const travel = 60; - pub const fall = 72; + pub const gone = 72; pub const lift = 84; /// The last of seven panels in place: 24 + 6 * 6 + 60. pub const land = 120; @@ -41,14 +50,6 @@ pub fn looking(f: *sk.Frame) bool { return f.host.env("CANIM_MAP") != null; } -/// The dive's frames over which the falling map crossfades into the minimap's drawing. -pub const minimap_lands = [2]f32{ 90, 96 }; - -/// How much of the minimap shows at dive frame `t`: none while the map falls, crossfading in as it lands. -pub fn minimapShows(t: f32) f32 { - return std.math.clamp((t - minimap_lands[0]) / (minimap_lands[1] - minimap_lands[0]), 0, 1); -} - /// Where each working window is on the map this frame, in canvas pixels. var window_px: [7]?[4]f32 = @splat(null); @@ -72,8 +73,8 @@ pub fn measure(panel: Panel, n: usize) void { } /// A working panel shows the rows of keys `now` (first and last), going -/// there from `was`, `p` of the way (eased): its outline on the minimap -/// glides with its scroll, and never jumps. +/// there from `was`, `p` of the way (eased): its outline on the map and +/// its window on its strip glide with its scroll, and never jump. pub fn window(panel: Panel, now: [2]u64, was: [2]u64, p: f32) void { if (!ui.mapping) windows[@intFromEnum(panel)] = .{ .now = now, .was = was, .p = p }; } @@ -89,6 +90,28 @@ pub fn row(panel: Panel, key: u64, u: ui.Ui, r: Rect) void { counts[i] += 1; } +/// How much of a pane's strip shows as the pane fades through to another +/// column (another file, another function) over the advance's `travel` +/// seconds: out and in as the pane does, as late as the strip's own +/// drawing is (`time.minimap_lag` and half its fade), so that the column it +/// changes to comes in while the strip is out. +pub fn through(now: @import("cursor.zig").Now, travel: f32) f32 { + if (now.resting() or travel <= 0) return 1; + const lag = theme.time.minimap_lag + @as(f32, theme.time.minimap_fade) / 2.0 / 60.0; + return @abs(2 * std.math.clamp((now.time - now.plan.advance - lag) / travel, 0, 1) - 1); +} + +/// Whether `panel`'s column on its strip has the rows of keys `keys[0]` to `keys[1]`. +pub fn inColumn(panel: Panel, keys: [2]u64) bool { + const col = &atlas.columns[slotOf(panel) orelse return false]; + return col.span(.{ keys[0], keys[0] }) != null and col.span(.{ keys[1], keys[1] }) != null; +} + +/// The width a pane's rows have: its box's, less its strip's in the working frame. +pub fn content(w: f32) f32 { + return if (ui.mapping) w else w - theme.strip.cost; +} + /// The map's boxes for a recording, packed by content: each panel as long /// as its rows (`measure`), the next under it 12 apart (design/README.md, /// "The map and the minimap"). The drawing and the source in the first @@ -113,7 +136,7 @@ pub fn split(rec: *const Recording, lens: bool, way: [2]u64, graph: bool) Split const source_y = if (lens) band.y + band.h + gap else st.y; // The backtrace as long as the call chain gets over the scene's way: packed once, never repacked under the eye. const bt_rows = @max(want(.backtrace, 0), deepest(rec, way)); - const source_rows: f32 = @floatFromInt(@min(rec.line_count, theme.layout.rowsIn(foot - source_y - gap - panelH(bt_rows)))); + const source_rows: f32 = @floatFromInt(@min(rec.most_lines, theme.layout.rowsIn(foot - source_y - gap - panelH(bt_rows)))); const source: Rect = .{ .x = c[0], .y = source_y, .w = w, .h = panelH(source_rows) }; const bt_y = source.y + source.h + gap; // The view as long as what draws there has wanted: none where nothing does (a lens drawn alone). @@ -125,7 +148,7 @@ pub fn split(rec: *const Recording, lens: bool, way: [2]u64, graph: bool) Split const disasm: Rect = .{ .x = c[1], .y = st.y, .w = w, .h = panelH(@min(want(.disasm, theme.map.disasm_rows), theme.map.disasm_rows)) }; // The source longer than its column (69 lines round the current line, or the file whole if shorter) // goes on at the top of the next column's free space, under its tag, `continued`. - const lines_left: f32 = @as(f32, @floatFromInt(@min(rec.line_count, theme.map.disasm_rows))) - source_rows; + const lines_left: f32 = @as(f32, @floatFromInt(@min(rec.most_lines, theme.map.disasm_rows))) - source_rows; const under_disasm = disasm.y + disasm.h + gap; const more_rows = @min(lines_left, @as(f32, @floatFromInt(theme.layout.rowsIn(foot - under_disasm)))); const source_more: Rect = .{ .x = c[1], .y = under_disasm, .w = w, .h = if (more_rows >= 3) panelH(more_rows) else 0 }; @@ -141,7 +164,7 @@ pub fn split(rec: *const Recording, lens: bool, way: [2]u64, graph: bool) Split if (graph) { const regs: Rect = .{ .x = c[3], .y = st.y, .w = w, .h = panelH(17) }; const nothing: Rect = .{ .x = c[3], .y = st.y, .w = w, .h = 0 }; - const src: Rect = .{ .x = c[0], .y = st.y, .w = w, .h = panelH(@floatFromInt(@min(rec.line_count, theme.layout.rowsIn(foot - st.y - gap - panelH(bt_rows))))) }; + const src: Rect = .{ .x = c[0], .y = st.y, .w = w, .h = panelH(@floatFromInt(@min(rec.most_lines, theme.layout.rowsIn(foot - st.y - gap - panelH(bt_rows))))) }; const bt: Rect = .{ .x = c[0], .y = src.y + src.h + gap, .w = w, .h = @min(panelH(bt_rows), foot - (src.y + src.h + gap)) }; return .{ .band = .{ .x = c[0], .y = st.y, .w = w, .h = 0 }, @@ -326,18 +349,16 @@ pub const Spare = struct { /// frame's component bound to that stage. pub const Map = struct { stage: *Stage, - parts: [12]Part = undefined, + parts: [14]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). + /// on: the working frame, each pane's column in its strip). t: anim.Value, /// The map as an object of the scene, under the panels: it shows from `show`. obj: anim.Obj = undefined, - /// Where the program is: for the thread across the gutter, and the minimap's flashes. + /// Where the program is: for the thread across the gutter, and the strips' flashes. cursor: ?@import("cursor.zig").Cursor = null, /// The scene's loupes: open, each is a panel of its own on the map (`Spare`). loupes: [2]?*const @import("loupe.zig").Loupe = .{ null, null }, @@ -345,18 +366,31 @@ pub const Map = struct { /// no line crosses the lanes; the band's window is the whole graph; the /// disassembly's, the rows it shows. graph: bool = false, + /// With `graph`: the stage of the linear disassembly the strip is a + /// column of (the map draws the graph, which is its own whole). + linear: ?*Stage = null, - const Part = struct { ctx: *const anyopaque, draw: *const fn (*const anyopaque, *sk.Frame, anim.Placed) void }; + /// Which drawings a part is in: the map's, the strips' (what they are + /// drawn from: a pane's column, as the linear disassembly the map draws + /// as a graph or a descent), or both. + pub const In = enum { both, map, strips }; + /// `panel`: the box it draws in (null: a lens's, its drawing and its view), for a column squeezing in a dive. + const Part = struct { ctx: *const anyopaque, draw: *const fn (*const anyopaque, *sk.Frame, anim.Placed) void, in: In, panel: ?Panel }; - /// Puts `component` (bound to `m.stage`) on the map, drawn in the order added. + /// Puts `component` (bound to `m.stage`; a lens, unless `addIn` says + /// which panel it is) on the map, drawn in the order added. pub fn add(m: *Map, s: *anim.Frame, component: anytype) void { + m.addIn(s, component, .both, null); + } + + pub fn addIn(m: *Map, s: *anim.Frame, component: anytype, in: In, panel: ?Panel) 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 }; + }.draw, .in = in, .panel = panel }; m.n += 1; } @@ -367,7 +401,7 @@ pub const Map = struct { m.add(s, component); } - /// Whether the working frame is in place (the minimap is the map). + /// Whether the working frame is in place. pub fn settled(m: *const Map, at: anim.Placed) bool { return at.value(m.t) >= diving.land; } @@ -385,8 +419,8 @@ pub const Map = struct { /// `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. + /// each pane's column squeezing into its strip with it; the rest of + /// the map fades where it is; 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 }); } @@ -400,22 +434,34 @@ pub const Map = struct { 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`). + /// The map while it is shown or a dive plays (the scene's first + /// object): filling the frame at half its size, the rest of it fading + /// where it is as each pane's column squeezes into its strip. 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); context.thread_shows = std.math.clamp((t - diving.land) / 12, 0, 1); if (t >= diving.land) return; + // The columns' rows, where the strips have them. + m.strips(f, placed); const fixed = @import("words.zig").fixed(f, placed, 0); - const at = m.falling(f, placed, t); - // Large, it is under the panels diving out of it; small (`falling`), over them, into the corner. - if (at.scale >= small * fixed.at.scale) m.copy(f, at, fixed, t) else fixed.fill(.{ .x = 0, .y = 0, .w = theme.canvas.width, .h = theme.canvas.height }, theme.color.page); + fixed.fill(.{ .x = 0, .y = 0, .w = theme.canvas.width, .h = theme.canvas.height }, theme.color.page); + const at = half(fixed.at); + // The rest of the map veiled from 6 to 24 f, then gone where it is by 72. + var rest = at; + rest.pose.opacity *= 1 - std.math.clamp((t - diving.move) / (diving.gone - diving.move), 0, 1); + m.drawParts(f, rest); + const veil = std.math.clamp((t - diving.bright) / (diving.move - diving.bright), 0, 1); + (ui.Ui{ .f = f, .at = rest }).veil(theme.map.stage, veil); + // The windows bright from 0 to 6 f, over the veil: a pane's with a strip rides on its column. + const bright = std.math.clamp(t / diving.bright, 0, 1); + m.outline(f, rest, bright, true); // 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); + var ways: [7]f32 = @splat(0); // In the frame's reading order, except that a panel drawn over another // sets off first: a panel in its place is never crossed by one still // on its way (the disassembly over the source's foot, the stack over @@ -433,22 +479,117 @@ pub const Map = struct { const lead = (if (whole) 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)); + ways[i] = p; 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. + // The tags, rules and lanes, and the strips, come in as the map lands. const chrome = std.math.clamp((t - diving.lift) / 12, 0, 1); // Out of a graph the rows and the lens are another form of what the map shows there: they come in on their way. const other = m.graph and (i == @intFromEnum(Panel.disasm) or i == @intFromEnum(Panel.band)); context.zoomed[i] = .{ .box = box, .to = .{ .x = x, .y = y, .w = box.w * scale, .h = box.h * scale }, .chrome = chrome, .shows = if (other) p else 1 }; }; } + // Each pane's column squeezing into its strip: their places on the map give way first, then they go. + for ([_]bool{ true, false }) |masking| for (stripped) |panel| { + const box = switch (panel) { + inline else => |tag| @field(working, @tagName(tag)), + }; + const gone = 1 - stripShows(panel, t); + // The graph's linear column is not on the map: its strip comes in with the tags. + if (box.h > 0 and gone > 0 and windows[@intFromEnum(panel)] != null and !(m.graph and panel == .disasm)) m.squeeze(f, fixed, at, panel, box, ways[@intFromEnum(panel)], .{ .masking = masking, .shows = gone, .veil = veil, .bright = bright }); + }; + } + + /// How much of a pane's strip shows at dive frame `t`: it comes in as + /// its pane lands (12 f), its column going into it. + fn stripShows(panel: Panel, t: f32) f32 { + // The panels' order setting off (`draw`). + const order: f32 = switch (panel) { + .band => 0, + .view => 1, + .disasm => 2, + .stack => 3, + .source => 4, + .registers => 5, + .backtrace => 6, + }; + const lands = diving.move + order * diving.apart + diving.travel; + return std.math.clamp((t - lands + 12) / 12, 0, 1); } - /// Frames into the dive now; 0 (the map filling the frame, as a scene - /// that opens on it shows it) with `CANIM_MAP` in the environment. - fn diveAt(m: *const Map, f: *sk.Frame, placed: anim.Placed) f32 { - return if (looking(f)) 0 else placed.value(m.t); + /// The map filling the frame: half its units. + fn half(at: anim.Placed) anim.Placed { + var out = at; + out.xf = at.xf.mul(.scale(0.5, 0.5)); + out.scale = at.scale * 0.5; + return out; + } + + const Squeeze = struct { masking: bool, shows: f32, veil: f32, bright: f32 }; + + /// A pane's column in a dive, `p` of its way (eased) from its place on + /// the map (`at`: filling the frame) into the pane's strip: the rows the + /// strip shows, its width and its height each on its logarithm (to 36 + /// of 880; to 4 of 24 a row), the text thinning as it lands, the + /// window's outline riding on it. With `masking`, only its place on the + /// map given up (the page over it: the column goes from there). + fn squeeze(m: *const Map, f: *sk.Frame, fixed: ui.Ui, at: anim.Placed, panel: Panel, box: Rect, p: f32, how: Squeeze) void { + const col = &atlas.columns[slotOf(panel).?]; + if (col.n == 0) return; + const st = theme.strip; + const cm = theme.metric.context; + const r = stripRect(box); + const cap = (r.h - st.top - st.foot) / st.pitch; + const win = windowOn(panel, col) orelse return; + const first = firstShown(col, win, cap); + const k = [2]f32{ std.math.pow(f32, 0.5, 1 - p) * std.math.pow(f32, st.across, p), std.math.pow(f32, 0.5, 1 - p) * std.math.pow(f32, @as(f32, st.pitch) / cm.row, p) }; + var offset: f32 = 0; + for (m.column(at, panel)) |b| { + if (b.h <= 0) continue; + const n: f32 = @floatFromInt(theme.layout.rowsIn(b.h)); + defer offset += n; + const lo = @max(first, offset); + const hi = @min(first + cap, @min(offset + n, col.rows)); + if (hi <= lo) continue; + const body = b.y + cm.tag + cm.pad; + const rows_rect: Rect = .{ .x = b.x, .y = body + (lo - offset) * cm.row, .w = b.w, .h = (hi - lo) * cm.row }; + if (how.masking) { + (ui.Ui{ .f = f, .at = at }).fill(.{ .x = rows_rect.x, .y = rows_rect.y - cm.pad, .w = rows_rect.w, .h = rows_rect.h + 2 * cm.pad }, theme.color.page); + continue; + } + // Its first row: where it is on the map, and where it goes in the strip. + const from = [2]f32{ rows_rect.x / 2, rows_rect.y / 2 }; + const to = [2]f32{ r.x + st.left, r.y + st.top + (lo - first) * st.pitch }; + var moved = fixed.at; + moved.xf = fixed.at.xf.mul(.translate(std.math.lerp(from[0], to[0], p), std.math.lerp(from[1], to[1], p))).mul(.scale(k[0], k[1])).mul(.translate(-rows_rect.x, -rows_rect.y)); + moved.scale = fixed.at.scale * k[1]; + moved.pose.opacity *= how.shows; + const u: ui.Ui = .{ .f = f, .at = moved }; + // Its parts clip to their boxes inside it. + u.clip(rows_rect); + const a0 = moved.xf.apply(.{ rows_rect.x, rows_rect.y }); + const a1 = moved.xf.apply(.{ rows_rect.x + rows_rect.w, rows_rect.y + rows_rect.h }); + ui.bound = .{ .x = @round(a0[0]), .y = @round(a0[1]), .w = @round(a1[0]) - @round(a0[0]), .h = @round(a1[1]) - @round(a0[1]) }; + m.drawPanel(f, moved, panel); + // Veiled with the map until it leaves. + u.veil(rows_rect, how.veil * (1 - p)); + ui.bound = null; + u.unclip(); + // The window's outline, where its rows are in this box: from the map's (dim, 2 and 4 out) to the strip's (primary, 2). + const w0 = @max(win[0], lo); + const w1 = @min(win[1] + 1, hi); + if (w1 > w0) { + const a = moved.xf.apply(.{ rows_rect.x, body + (w0 - offset) * cm.row }); + const c = moved.xf.apply(.{ rows_rect.x + rows_rect.w, body + (w1 - offset) * cm.row }); + const line = std.math.lerp(theme.map.outline / 2.0, st.window, p) * fixed.at.scale; + const out = std.math.lerp(theme.map.outline_out / 2.0, 0, p) * fixed.at.scale; + const ink = ui.mix(ui.mix(theme.color.text.dim, theme.color.text.bright, how.bright), theme.color.text.primary, p); + var raw: ui.Ui = .{ .f = f, .at = moved }; + raw.at.xf = .identity; + raw.frame(.{ .x = a[0] - out - line, .y = a[1] - out - line, .w = c[0] - a[0] + 2 * (out + line), .h = c[1] - a[1] + 2 * (out + line) }, ink, line); + } + } } /// With `CANIM_MAP` in the environment every frame is the map filling @@ -457,130 +598,44 @@ pub const Map = struct { /// any scene's map at 1:1 in a 4K export. pub fn wholeMap(m: *const Map, f: *sk.Frame, placed: anim.Placed) void { const fixed = @import("words.zig").fixed(f, placed, 0); - m.copy(f, m.falling(f, placed, 0), fixed, 0); - } - - /// Below this scale (of the frame's) the falling map is drawn over the - /// panels, on its way into the corner, and not under them. - const small = 0.12; - - /// Where the map is at dive frame `t`: from filling the frame (half - /// its units) to the minimap's rect (a twentieth), its scale on the - /// logarithm, its corner going toward the minimap's as the scale does, - /// so that it falls into the corner. - fn falling(m: *const Map, f: *sk.Frame, placed: anim.Placed, t: f32) anim.Placed { - _ = m; - const fixed = @import("words.zig").fixed(f, placed, 0); - 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 toward = (0.5 - k) / (0.5 - theme.minimap.scale); - var at = fixed.at; - at.xf = at.xf.mul(.translate(toward * mini.x, toward * mini.y)).mul(.scale(k, k)); - at.scale = fixed.at.scale * k; - return at; - } - - /// The falling map, veiled, its windows outlined, and its edge as the - /// minimap's; it crossfades into the minimap's own drawing as it lands. - fn copy(m: *const Map, f: *sk.Frame, at: anim.Placed, fixed: ui.Ui, t: f32) void { - const shows = 1 - minimapShows(t); - if (shows <= 0) return; - const mini = at.scale < small * fixed.at.scale; - if (!mini) fixed.fill(.{ .x = 0, .y = 0, .w = theme.canvas.width, .h = theme.canvas.height }, theme.color.page); - var faded = at; - faded.pose.opacity *= shows; - m.drawAt(f, faded, mini); - // 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) / (minimap_lands[1] - diving.lift), 0, 1)); - (ui.Ui{ .f = f, .at = faded }).veil(theme.map.stage, veil); - // The windows bright from 0 to 6 f, over the veil. - m.outline(f, faded, mini, std.math.clamp(t / diving.bright, 0, 1)); - var edge: ui.Ui = .{ .f = f, .at = faded }; - edge.at.xf = .identity; - const a = at.xf.apply(.{ 0, 0 }); - const b = at.xf.apply(.{ 2 * theme.canvas.width, 2 * theme.canvas.height }); - const q = std.math.clamp((0.5 * fixed.at.scale - at.scale) / ((0.5 - theme.minimap.scale) * fixed.at.scale), 0, 1); - edge.faded(q).frame(.{ .x = a[0] - 1, .y = a[1] - 1, .w = b[0] - a[0] + 2, .h = b[1] - a[1] + 2 }, theme.color.rule, @max(1, fixed.at.scale)); + fixed.fill(.{ .x = 0, .y = 0, .w = theme.canvas.width, .h = theme.canvas.height }, theme.color.page); + m.drawAt(f, half(fixed.at)); } - /// Small, the falling map over the working panels (the minimap's drawer calls it). - pub fn fallingOver(m: *const Map, f: *sk.Frame, placed: anim.Placed) void { - const t = placed.value(m.t); - if (t >= minimap_lands[1]) return; - const fixed = @import("words.zig").fixed(f, placed, 0); - const at = m.falling(f, placed, t); - if (at.scale >= small * fixed.at.scale) return; - // Its ground, so that it reads over what it passes. - var ground: ui.Ui = .{ .f = f, .at = at }; - ground.at.pose.opacity *= 1 - minimapShows(t); - ground.fill(.{ .x = 0, .y = 0, .w = 2 * theme.canvas.width, .h = 2 * theme.canvas.height }, theme.color.page); - m.copy(f, at, fixed, t); + /// 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. + pub fn drawAt(m: *const Map, f: *sk.Frame, at: anim.Placed) void { + m.drawParts(f, at); + m.outline(f, at, 0, false); } - /// 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); + /// The parts that draw `panel` (a dump: the lens's), as the map draws them. + fn drawPanel(m: *const Map, f: *sk.Frame, at: anim.Placed, panel: Panel) void { + ui.mapping = true; + defer ui.mapping = false; + for (m.parts[0..m.n]) |p| if (p.in != .strips and (p.panel == panel or (p.panel == null and panel == .view))) p.draw(p.ctx, f, at); } - fn drawParts(m: *const Map, f: *sk.Frame, at: anim.Placed, mini: bool) void { + fn drawParts(m: *const Map, f: *sk.Frame, at: anim.Placed) void { ui.mapping = true; - ui.strokes = mini; counts = @splat(0); - for (m.parts[0..m.n]) |p| p.draw(p.ctx, f, at); - if (m.cursor) |c| if (!m.graph) m.thread(f, at, c.now(at), mini); + for (m.parts[0..m.n]) |p| if (p.in != .strips) p.draw(p.ctx, f, at); + if (m.cursor) |c| if (!m.graph) m.thread(f, at, c.now(at)); ui.mapping = false; - ui.strokes = false; } /// The thread on the map: the current line and the pc's row, joined - /// across the gutter between source and disassembly (x 1008), gold; on - /// the minimap a stroke a pixel wide. And there, a mark no working - /// window shows `flash`es: a ring 8 across drawing out to 14 and gone - /// (12 f), with the strike (the minimap's own time, 6 f behind). - fn thread(m: *const Map, f: *sk.Frame, at: anim.Placed, now: @import("cursor.zig").Now, mini: bool) void { + /// across the gutter between source and disassembly (x 1008), gold. + fn thread(m: *const Map, f: *sk.Frame, at: anim.Placed, now: @import("cursor.zig").Now) void { _ = m; const rec = now.rec; - const k = at.scale; var raw: ui.Ui = .{ .f = f, .at = at }; raw.at.xf = .identity; const marked = now.marked(); - const line = rows_of(.source, rec.own[marked]); - const pc = rows_of(.disasm, rec.register(marked, "rip")); - if (line != null and pc != null) { - const a = line.?; - const b = pc.?; - const lane = at.xf.apply(.{ 1008, 0 })[0]; - const w = if (mini) @max(1, k / theme.minimap.scale) else theme.stroke.line * k; - const gold = theme.mark(.current).solid; - raw.route(&.{ .{ a[2], (a[1] + a[3]) / 2 }, .{ lane, (a[1] + a[3]) / 2 }, .{ lane, (b[1] + b[3]) / 2 }, .{ b[0], (b[1] + b[3]) / 2 } }, gold, .{ .width = w, .head = null, .radius = 0 }); - } - if (!mini or !now.walking()) return; - // A mark no working window shows: a word struck or read, on the - // stack (its own column or continued) or in memory the map draws - // (the view's dump, the dumps round the pointers), flashes where the - // map has it, in the mark's colour. - const since = now.since(.memory, 0); - const p = since / (12.0 / 60.0); - if (p < 0 or p > 1) return; - const marks = [2]struct { spans: []const Recording.Span, ink: u24 }{ - .{ .spans = rec.written(now.stops[1], now.stops[0]), .ink = theme.color.struck }, - .{ .spans = rec.read(now.stops[1], now.stops[0]), .ink = theme.mark(.read).solid }, - }; - for (marks) |mark| for (mark.spans) |span| { - // Where the map has it: the stack's word, or the 16 bytes of a dump's row. - const word = span.addr & ~@as(u64, 7); - const sixteen = span.addr & ~@as(u64, 15); - const panel: Panel, const key: u64 = if (rows_of(.stack, word) != null) .{ .stack, word } else .{ .view, sixteen }; - const box = rows_of(panel, key) orelse continue; - if (windows[@intFromEnum(panel)]) |win| if (key >= win.now[0] and key <= win.now[1]) continue; - const c = ui.Vec{ (box[0] + box[2]) / 2, (box[1] + box[3]) / 2 }; - const r = std.math.lerp(@as(f32, 4), 7, p) * k / theme.minimap.scale; - raw.faded(1 - p).disc(c, r, null, ui.rgb(mark.ink), @max(1, k / theme.minimap.scale)); - }; + const line = rows_of(.source, rec.shown[marked].line) orelse return; + const pc = rows_of(.disasm, rec.register(marked, "rip")) orelse return; + const lane = at.xf.apply(.{ 1008, 0 })[0]; + raw.route(&.{ .{ line[2], (line[1] + line[3]) / 2 }, .{ lane, (line[1] + line[3]) / 2 }, .{ lane, (pc[1] + pc[3]) / 2 }, .{ pc[0], (pc[1] + pc[3]) / 2 } }, theme.mark(.current).solid, .{ .width = theme.stroke.line * at.scale, .head = null, .radius = 0 }); } /// The top and bottom of the map's rows of panel `i` with keys from `keys[0]` to `keys[1]`, in canvas pixels. @@ -606,8 +661,9 @@ pub const Map = struct { } /// 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 { + /// from `dim` to bright; where they are is kept (`window_px`). With + /// `riding`, a pane's with a strip is not drawn: it rides on its column (`squeeze`). + fn outline(m: *const Map, f: *sk.Frame, at: anim.Placed, bright: f32, riding: bool) void { var raw: ui.Ui = .{ .f = f, .at = at }; raw.at.xf = .identity; const k = at.scale; @@ -628,116 +684,439 @@ pub const Map = struct { const was = spanOf(i, win.was) orelse is; if (is orelse was) |to| { const from = was orelse to; - // On the minimap each end on whole pixels: crisp at rest, between them only while it glides. - const snap = struct { - fn of(v: f32, on: bool) f32 { - return if (on) @round(v) else v; - } - }.of; - r[1] = std.math.lerp(snap(from[0], mini), snap(to[0], mini), win.p); - r[3] = std.math.lerp(snap(from[1], mini), snap(to[1], mini), win.p); + r[1] = std.math.lerp(from[0], to[0], win.p); + r[3] = std.math.lerp(from[1], to[1], win.p); shown = true; // In a graph the rows a window shows are in blocks: round them, not the panel's width. if (m.graph and panel == .disasm) if (boxOf(i, win.now)) |round| { const was_box = boxOf(i, win.was) orelse round; - r[0] = std.math.lerp(snap(was_box[0], mini), snap(round[0], mini), win.p); - r[2] = std.math.lerp(snap(was_box[2], mini), snap(round[2], mini), win.p); + r[0] = std.math.lerp(was_box[0], round[0], win.p); + r[2] = std.math.lerp(was_box[2], round[2], win.p); }; } } - // On the minimap on whole pixels (a window's ends already are, at rest). - if (mini) { - r[0] = @round(r[0]); - r[2] = @round(r[2]); - if (windows[i] == null) { - r[1] = @round(r[1]); - r[3] = @round(r[3]); - } - } 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; + const rides = riding and slotOf(panel) != null and !(m.graph and panel == .disasm); + if (shown and !rides) { + const w = theme.map.outline * k; + const out = theme.map.outline_out * k; const ring: Rect = .{ .x = r[0] - out, .y = r[1] - out, .w = r[2] - r[0] + 2 * out, .h = r[3] - r[1] + 2 * out }; - const ink = ui.mix(if (mini) theme.color.text.primary else theme.color.text.dim, theme.color.text.bright, bright); - // On the minimap not snapped to pixels: a window that glides moves a pixel over many frames, not in one. - if (mini) { - const pen = raw.at.pen(.{ .fill = ink }); - for ([4]sk.math.Rect{ .{ .x = ring.x, .y = ring.y, .w = ring.w, .h = w }, .{ .x = ring.x, .y = ring.y + ring.h - w, .w = ring.w, .h = w }, .{ .x = ring.x, .y = ring.y + w, .w = w, .h = ring.h - 2 * w }, .{ .x = ring.x + ring.w - w, .y = ring.y + w, .w = w, .h = ring.h - 2 * w } }) |edge| sk.draw.rect(f, edge, pen); - } else raw.frame(ring, ink, if (bright > 0) w * 1.5 else w); + raw.frame(ring, ui.mix(theme.color.text.dim, theme.color.text.bright, bright), if (bright > 0) w * 1.5 else w); } } } } -}; -/// The minimap's drawings, a frame apart, and what they are averaged into: -/// the host's images, made once for a size. -/// shortcut: a process-wide cache of host images, for one player at a time; two at once want it in their Session. -var fades: struct { w: u32 = 0, h: u32 = 0, images: [theme.time.minimap_fade + 1]sk.Image = undefined } = .{}; + /// The boxes on the map of `panel`'s column, in order: the second where + /// it goes on (`continued`), or none. + fn column(m: *const Map, at: anim.Placed, panel: Panel) [2]Rect { + const sp = m.stage.now(at); + const none: Rect = .{ .x = 0, .y = 0, .w = 0, .h = 0 }; + return switch (panel) { + .source => .{ sp.source, sp.source_more }, + .disasm => .{ if (m.linear) |l| l.now(at).disasm else sp.disasm, none }, + .stack => .{ sp.stack, sp.more }, + .view => .{ sp.view, none }, + else => .{ none, none }, + }; + } + + /// The strips, drawn once a frame: the map drawn for them (`collect`) + /// six times, each from the cursor's mirror a frame later (6 to 11 f + /// behind: `Cursor.lagInto`) and with the panes' windows as they were + /// as long ago (`past`), each into an image of every strip as it shows + /// (its rows round its window, the window framed), and those averaged: + /// every change on a strip, a window gliding or its column scrolling + /// too, fades in over 6 f from 6 f after its onset, and nothing on it + /// moves a pixel in a frame. + fn strips(m: *const Map, f: *sk.Frame, at: anim.Placed) void { + if (atlas.frame == f.in.frame and atlas.map == m) return; + atlas.frame = f.in.frame; + atlas.map = m; + f.clip(null); + const st = theme.strip; + const k = @import("words.zig").fixed(f, at, 0).at.scale; + const w: u32 = @intFromFloat(@ceil(@as(f32, stripped.len * st.w) * k)); + const h: u32 = @intFromFloat(@ceil(theme.canvas.stage.h * k)); + if (atlas.w != w or atlas.h != h) { + if (atlas.w != 0) for (atlas.images) |img| f.host.freeImage(img); + for (&atlas.images) |*img| img.* = f.host.newImage(w, h); + atlas.w = w; + atlas.h = h; + } + if (atlas.scrap == null) atlas.scrap = f.host.newImage(4, 4); + atlas.k = k; + // After a seek the windows kept are of another time. + if (f.in.jumped) past = @splat(.{}); + past[f.in.frame % past.len] = .{ .frame = f.in.frame, .windows = windows }; + // Each pane's strip as high as its box has it now (a relayout moves them). + const working = m.frame.now(at); + var heights: [stripped.len]f32 = undefined; + for (stripped, &heights) |panel, *sh| sh.* = switch (panel) { + inline else => |tag| stripRect(@field(working, @tagName(tag))).h, + }; + const values = f.scratch.dupe(f32, at.values) catch return; + var placed = at; + placed.values = values; + placed.xf = .identity; + placed.scale = 1; + placed.pose.opacity = 1; + const n = theme.time.minimap_fade; + var weights: [n]f32 = @splat(0); + var made: usize = 0; + const chrome = ui.chrome; + defer ui.chrome = chrome; + var cols: [stripped.len]Column = undefined; + for (0..n) |lag| { + const then = pastWindows(f.in.frame, @as(u64, @intFromFloat(theme.time.minimap_lag * 60)) + lag); + // A mirror the same as the one before draws the same (its windows too): its drawing counts twice. + const moved = lag > 0 and !std.meta.eql(then, pastWindows(f.in.frame, @as(u64, @intFromFloat(theme.time.minimap_lag * 60)) + lag - 1)); + const differs = (if (m.cursor) |c| c.lagInto(values, lag) else lag == 0) or moved; + if (differs) { + m.collect(f, placed); + m.columns(placed, &cols); + if (made == 0) atlas.columns = cols; + f.target(atlas.images[made]); + f.clear(ui.rgb(theme.color.well)); + m.render(f, placed, k, &cols, then, heights); + made += 1; + } + weights[made - 1] += 1; + } + // Averaged: each drawing over those before it at its share of the drawings so far. + const whole: sk.Rect = .{ .x = 0, .y = 0, .w = @floatFromInt(w), .h = @floatFromInt(h) }; + f.target(atlas.images[n]); + var so_far: f32 = 0; + for (atlas.images[0..made], weights[0..made]) |img, weight| { + so_far += weight; + f.image(img, whole, .{ .tint = sk.Color.white.alphaFloat(weight / so_far) }); + } + f.target(.none); + } + + /// The map drawn for the strips, into nothing that shows: its parts + /// publish their rows and the text, marks and arcs they draw are + /// collected (`ui.collected`), with the flashes of the moment. + fn collect(m: *const Map, f: *sk.Frame, placed: anim.Placed) void { + f.target(atlas.scrap.?); + ui.mapping = true; + ui.strokes = true; + counts = @splat(0); + ui.collected.reset(); + for (m.parts[0..m.n]) |p| if (p.in != .map) p.draw(p.ctx, f, placed); + f.clip(null); + n_flashes = 0; + if (m.cursor) |c| flash(c.now(placed)); + ui.mapping = false; + ui.strokes = false; + } -/// 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`. -/// Every change on it fades in over `time.minimap_fade` frames from -/// `time.minimap_lag` after its onset: it is the average of that many -/// drawings, each from the cursor's mirror a frame later (`Cursor.lagInto`), -/// so a stroke that changes, a mark that comes and the gold that moves on -/// all fade, and a window's glide is smoothed, never stepped. -pub fn minimap(m: *const Map, f: *sk.Frame, at: anim.Placed) void { - var shown = at; - shown.pose.opacity *= minimapShows(m.diveAt(f, at)); - if (shown.pose.opacity <= 0) return; - const fixed = @import("words.zig").fixed(f, shown, 0); - const box = theme.minimap.box; - const a = fixed.at.xf.apply(.{ box.x, box.y }); - const b = fixed.at.xf.apply(.{ box.x + box.w, box.y + box.h }); - const px: sk.Rect = .{ .x = @round(a[0]), .y = @round(a[1]), .w = @round(b[0]) - @round(a[0]), .h = @round(b[1]) - @round(a[1]) }; - const w: u32 = @intFromFloat(@max(px.w, 1)); - const h: u32 = @intFromFloat(@max(px.h, 1)); - if (fades.w != w or fades.h != h) { - if (fades.w != 0) for (fades.images) |img| f.host.freeImage(img); - for (&fades.images) |*img| img.* = f.host.newImage(w, h); - fades.w = w; - fades.h = h; + /// Each strip's column, from the map just collected: its rows' keys and places. + fn columns(m: *const Map, at: anim.Placed, out: *[stripped.len]Column) void { + for (stripped, out) |panel, *c| { + c.* = .{}; + const boxes = m.column(at, panel); + const i = @intFromEnum(panel); + for (rows[i][0..counts[i]]) |rw| { + if (c.n == c.keys.len) break; + const place = spotIn(boxes, rw.box[0] + 1, rw.box[1], false) orelse continue; + c.keys[c.n] = rw.key; + c.at[c.n] = place.r; + c.n += 1; + c.rows = @max(c.rows, @round(place.r) + 1); + } + } } - // Each drawing in an image of its own, the page under it, in the image's pixels. - var placed = fixed.at; - placed.pose.opacity = 1; - placed.xf = sk.math.Affine.translate(-px.x, -px.y).mul(fixed.at.xf).mul(.translate(box.x, box.y)).mul(.scale(theme.minimap.scale, theme.minimap.scale)); - placed.scale = fixed.at.scale * theme.minimap.scale; - const values = f.scratch.dupe(f32, at.values) catch return; - placed.values = values; - // Its drawings outline the windows in their images' pixels: where the - // falling map has them (a dive's panels set off from there) is kept. - const falling_px = window_px; - defer window_px = falling_px; - const n = theme.time.minimap_fade; - var weights: [n]f32 = @splat(0); - var made: usize = 0; - for (0..n) |k| { - // A mirror the same as the one before draws the same: its drawing counts twice. - const differs = if (m.cursor) |c| c.lagInto(values, k) else k == 0; - if (differs) { - f.target(fades.images[made]); - f.clear(ui.rgb(theme.color.page)); - m.drawAt(f, placed, true); - made += 1; + + /// Every strip, as it shows, into the image in hand, a strip's width + /// each (`heights`: as high as each is): its column's rows round its + /// window (`then`: the panes' windows as long ago as the drawing is), + /// each run of text a stroke from where it starts, as long as it is, in + /// its ink 65% of the way from the page; at a row's left its marks (the + /// current row gold, a strike vermilion, a read in read's colour, held + /// a vermilion 2 by 2); an arc with an end off its pane's window a + /// 2-unit line in its ink down the left edge; a block's first row a + /// tick; a flash's ring; three faint dots at an end where the column + /// goes on; the window framed 2 in primary. + fn render(m: *const Map, f: *sk.Frame, at: anim.Placed, k: f32, cols: *const [stripped.len]Column, then: [7]?Window, heights: [stripped.len]f32) void { + const st = theme.strip; + var boxes: [stripped.len][2]Rect = undefined; + for (stripped, &boxes) |panel, *b| b.* = m.column(at, panel); + // Each strip's window and the first row it shows. + var wins: [stripped.len]?[2]f32 = undefined; + var firsts: [stripped.len]f32 = undefined; + var caps: [stripped.len]f32 = undefined; + for (stripped, cols, &wins, &firsts, &caps, heights) |panel, *col, *win, *first, *cap, sh| { + cap.* = (sh - st.top - st.foot) / st.pitch; + win.* = spanOf2(then[@intFromEnum(panel)], col); + // Whole rows at rest: its strokes on the image's pixels. + first.* = firstShown(col, win.* orelse .{ 0, 0 }, @floor(cap.*)); } - weights[made - 1] += 1; + // Where row `r` of strip `slot` is drawn, and whether it shows. + const Row = struct { + fn y(fs: [stripped.len]f32, slot: usize, r: f32) f32 { + return st.top + (r - fs[slot]) * st.pitch; + } + fn shows(fs: [stripped.len]f32, cs: [stripped.len]f32, slot: usize, r: f32) bool { + return r > fs[slot] - 0.75 and r < fs[slot] + cs[slot] - 0.25; + } + }; + const c = &ui.collected; + const page = ui.rgb(theme.color.page); + for (c.runs[0..c.n_runs]) |run| for (boxes, 0..) |pair, slot| { + const spot = spotIn(pair, run.x0, run.y, true) orelse continue; + if (Row.shows(firsts, caps, slot, spot.r)) { + const ink = ui.mix(page, run.ink.alphaFloat(1), st.ink).alphaFloat(@as(f32, @floatFromInt(run.ink.a)) / 255); + pixels(f, k, slot, st.left + spot.x * st.across, Row.y(firsts, slot, spot.r), (run.x1 - run.x0) * st.across, st.stroke, ink); + } + break; + }; + // The marks of each row: the most of each kind it has, side by side in the catalogue's order. + var shows: [stripped.len][atlas_rows][4]f32 = @splat(@splat(@splat(0))); + var place: [stripped.len][atlas_rows]f32 = undefined; + for (c.marks[0..c.n_marks]) |mk| for (boxes, 0..) |pair, slot| { + const spot = spotIn(pair, mk.x, mk.y, mk.kind != .tick) orelse continue; + if (!Row.shows(firsts, caps, slot, spot.r)) break; + if (mk.kind == .tick) { + pixels(f, k, slot, 0, Row.y(firsts, slot, spot.r) - 1, st.left + st.mark, 2, ui.rgb(theme.color.rule).alphaFloat(mk.shows)); + break; + } + const near = @round(spot.r); + if (near < 0 or near >= atlas_rows) break; + const i: usize = @intFromFloat(near); + shows[slot][i][@intFromEnum(mk.kind)] = @max(shows[slot][i][@intFromEnum(mk.kind)], @min(mk.shows, 1)); + place[slot][i] = spot.r; + break; + }; + for (shows, place, 0..) |of_slot, places, slot| for (of_slot, places) |kinds, r| { + var x: f32 = st.left; + const y = Row.y(firsts, slot, r); + const write = ui.rgb(theme.mark(.write).solid); + if (kinds[0] > 0) { + pixels(f, k, slot, x, y, st.mark, st.mark, ui.rgb(theme.mark(.current).solid).alphaFloat(kinds[0])); + x += st.mark_apart; + } + if (kinds[1] > 0) { + pixels(f, k, slot, x, y, st.mark, st.mark, write.alphaFloat(kinds[1])); + x += st.mark_apart; + } else if (kinds[3] > 0) { + pixels(f, k, slot, x + 1, y + 1, st.held, st.held, write.alphaFloat(kinds[3])); + x += st.mark_apart; + } + if (kinds[2] > 0) pixels(f, k, slot, x, y, st.mark, st.mark, ui.rgb(theme.mark(.read).solid).alphaFloat(kinds[2])); + }; + for (c.arcs[0..c.n_arcs]) |arc| for (boxes, 0..) |pair, slot| { + const a = spotIn(pair, arc.x, arc.from, true) orelse continue; + const b = spotIn(pair, arc.x, arc.to, true) orelse break; + // An arc with both ends in its pane's window is there: only one with an end off it is here. + const win = wins[slot] orelse break; + const in = struct { + fn of(r: f32, w: [2]f32) bool { + return r > w[0] - 0.5 and r < w[1] + 0.5; + } + }.of; + if (in(a.r, win) and in(b.r, win)) break; + const y0 = @max(Row.y(firsts, slot, @min(a.r, b.r)) + 1, st.top); + const y1 = @min(Row.y(firsts, slot, @max(a.r, b.r)) + 2, st.top + caps[slot] * st.pitch); + if (y1 > y0) pixels(f, k, slot, 0, y0, 2, y1 - y0, arc.ink); + break; + }; + // A flash: a ring 8 across drawing out to 14, and gone. + var scaled = at; + scaled.xf = sk.math.Affine.scale(k, k); + scaled.scale = k; + const u: ui.Ui = .{ .f = f, .at = scaled }; + for (flashes[0..n_flashes]) |fl| { + const slot = slotOf(fl.panel).?; + const r = (cols[slot].span(.{ fl.key, fl.key }) orelse continue)[0]; + if (!Row.shows(firsts, caps, slot, r)) continue; + u.faded(1 - fl.p).disc(.{ @as(f32, @floatFromInt(slot)) * st.w + st.left + 7, Row.y(firsts, slot, r) + 1.5 }, std.math.lerp(@as(f32, 4), 7, fl.p), null, ui.rgb(fl.ink), 2); + } + for (cols, firsts, caps, wins, 0..) |*col, first, cap, win, slot| { + const left = @as(f32, @floatFromInt(slot)) * st.w; + // Where it goes on: three faint dots, 2 by 2, 6 apart, coming as the column's end leaves (over a row). + const shown = @min(cap, col.rows - first); + for ([2]f32{ std.math.clamp(first, 0, 1), std.math.clamp(col.rows - first - shown, 0, 1) }, [2]f32{ 0, st.top + cap * st.pitch + 1 }) |q, y| if (q > 0) { + for (0..3) |i| pixels(f, k, slot, 13 + 6 * @as(f32, @floatFromInt(i)), y, 2, 2, ui.rgb(theme.color.text.faint).alphaFloat(q)); + }; + // Its window: the brightest thing on it. + if (win) |w| { + const top = st.top + (w[0] - first) * st.pitch - st.window; + const bottom = st.top + (w[1] - first + 1) * st.pitch + 1; + u.frame(.{ .x = left, .y = top, .w = st.w, .h = bottom - top }, theme.color.text.primary, st.window); + } + } + } +}; + +/// The most rows a column has in the strips' images. +const atlas_rows = 160; + +/// A pane's column of the map as its strip draws it: each of its rows' +/// key and place (rows from the column's top, continuous where the map's +/// panel scrolls), and how many rows the column has. +const Column = struct { + n: usize = 0, + keys: [atlas_rows]u64 = undefined, + at: [atlas_rows]f32 = undefined, + rows: f32 = 0, + + /// The first and last place of its rows with keys `keys[0]` to `keys[1]`. + fn span(c: *const Column, keys: [2]u64) ?[2]f32 { + var lo = std.math.inf(f32); + var hi = -std.math.inf(f32); + for (c.keys[0..c.n], c.at[0..c.n]) |key, at| if (key >= keys[0] and key <= keys[1]) { + lo = @min(lo, at); + hi = @max(hi, at); + }; + return if (lo <= hi) .{ lo, hi } else null; } - // Averaged: each drawing over those before it at its share of the drawings so far. - const whole: sk.Rect = .{ .x = 0, .y = 0, .w = px.w, .h = px.h }; - f.target(fades.images[n]); - var so_far: f32 = 0; - for (fades.images[0..made], weights[0..made]) |img, weight| { - so_far += weight; - f.image(img, whole, .{ .tint = sk.Color.white.alphaFloat(weight / so_far) }); +}; + +/// The strips' images: one for each lagging drawing of the map +/// (`time.minimap_fade`) and their average, last; each strip a column of +/// them, its column whole from its top. +/// shortcut: a process-wide cache of host images, for one player at a time; two at once want it in their Session. +var atlas: struct { + w: u32 = 0, + h: u32 = 0, + images: [theme.time.minimap_fade + 1]sk.Image = undefined, + /// What a collecting drawing draws into: nothing of it shows. + scrap: ?sk.Image = null, + /// The frame they were made for, and of which map. + frame: u64 = std.math.maxInt(u64), + map: ?*const Map = null, + /// Pixels a unit. + k: f32 = 1, + columns: [stripped.len]Column = @splat(.{}), +} = .{}; + +/// The panes' windows in the frames before, for the strips' lagging drawings (`Map.strips`). +var past: [16]struct { frame: u64 = std.math.maxInt(u64), windows: [7]?Window = @splat(null) } = @splat(.{}); + +/// The panes' windows `back` frames before frame `now` (where they were not kept, as they are). +fn pastWindows(now: u64, back: u64) [7]?Window { + const e = past[(now -% back) % past.len]; + return if (e.frame == now -% back) e.windows else windows; +} + +/// Where a window is on a column: its first and last row, between where it +/// was and where it is, as far as its scroll had gone. +fn spanOf2(maybe: ?Window, col: *const Column) ?[2]f32 { + const win = maybe orelse return null; + const is = col.span(win.now) orelse return null; + const was = col.span(win.was) orelse is; + return .{ std.math.lerp(was[0], is[0], win.p), std.math.lerp(was[1], is[1], win.p) }; +} + +/// The map whose columns the strips are (`context` sets it). +/// shortcut: process-wide, as the drawing flags are: one scene drawn at a time. +pub var current: ?*const Map = null; + +/// A mark no working window shows, `flash`ing on its pane's strip. +const Flash = struct { panel: Panel, key: u64, ink: u24, p: f32 }; +var flashes: [16]Flash = undefined; +var n_flashes: usize = 0; + +/// The flashes of the step, in the strips' time (6 f behind): a word +/// struck or read on the stack or in the view's dump that its pane's +/// window does not show; `p` of its 12 f. +fn flash(now: @import("cursor.zig").Now) void { + if (!now.walking()) return; + const p = now.since(.memory, 0) / (12.0 / 60.0); + if (p < 0 or p > 1) return; + const rec = now.rec; + const marks = [2]struct { spans: []const Recording.Span, ink: u24 }{ + .{ .spans = rec.written(now.stops[1], now.stops[0]), .ink = theme.color.struck }, + .{ .spans = rec.read(now.stops[1], now.stops[0]), .ink = theme.mark(.read).solid }, + }; + for (marks) |mark| for (mark.spans) |span| { + // Where the map has it: the stack's word, or the 16 bytes of a dump's row. + const word = span.addr & ~@as(u64, 7); + const sixteen = span.addr & ~@as(u64, 15); + const panel: Panel, const key: u64 = if (Map.rows_of(.stack, word) != null) .{ .stack, word } else .{ .view, sixteen }; + if (Map.rows_of(panel, key) == null) continue; + if (windows[@intFromEnum(panel)]) |win| if (key >= win.now[0] and key <= win.now[1]) continue; + if (n_flashes == flashes.len) return; + flashes[n_flashes] = .{ .panel = panel, .key = key, .ink = mark.ink, .p = p }; + n_flashes += 1; + }; +} + +const Spot = struct { r: f32, x: f32 }; + +/// Where a point of the map is in a column of `boxes`: its row, counted +/// from the column's top (continuous: `middle`, a point on a row's middle, +/// else on its top), and how far across its box. +fn spotIn(boxes: [2]Rect, x: f32, y: f32, middle: bool) ?Spot { + const cm = theme.metric.context; + var offset: f32 = 0; + for (boxes) |b| { + if (b.h <= 0) continue; + const body = b.y + cm.tag + cm.pad; + const n: f32 = @floatFromInt(theme.layout.rowsIn(b.h)); + if (x >= b.x - 1 and x <= b.x + b.w + 1 and y >= body - 1 and y <= body + n * cm.row + 1) + return .{ .r = offset + (y - body - @as(f32, if (middle) cm.row / 2 else 0)) / cm.row, .x = x - b.x }; + offset += n; } - f.target(.none); - f.image(fades.images[n], px, .{ .tint = sk.Color.white.alphaFloat(shown.pose.opacity) }); - fixed.frame(.{ .x = box.x - 1, .y = box.y - 1, .w = box.w + 2, .h = box.h + 2 }, theme.color.rule, 1); + return null; +} + +/// A rect of a strip's column, in strip units from its slot's corner, in the image's pixels (one at least). +fn pixels(f: *sk.Frame, k: f32, slot: usize, x: f32, y: f32, w: f32, h: f32, color: sk.Color) void { + const left = @as(f32, @floatFromInt(slot)) * theme.strip.w; + const x0 = @round((left + x) * k); + const y0 = @round(y * k); + const x1 = @max(@round((left + x + w) * k), x0 + 1); + const y1 = @max(@round((y + h) * k), y0 + 1); + f.fill(sk.Rect{ .x = x0, .y = y0, .w = x1 - x0, .h = y1 - y0 }, color); +} + +/// Where a pane's window is on its column now: its first and last row, +/// between where it was and where it is, as far as its scroll has gone. +fn windowOn(panel: Panel, col: *const Column) ?[2]f32 { + return spanOf2(windows[@intFromEnum(panel)], col); +} + +/// The first row a strip of `cap` rows shows: the column's top, or where +/// it is longer, the window in the middle, clamped to the column's ends. +fn firstShown(col: *const Column, win: [2]f32, cap: f32) f32 { + if (col.rows <= cap) return 0; + return std.math.clamp((win[0] + win[1] + 1) / 2 - cap / 2, 0, col.rows - cap); +} + +/// A pane's strip, in the pane's units (`box` its box). +fn stripRect(box: Rect) Rect { + const st = theme.strip; + return .{ .x = box.x + box.w - st.inset - st.w, .y = box.y + theme.metric.context.tag, .w = st.w, .h = box.h - theme.metric.context.tag - st.inset }; +} + +/// A pane's minimap (design/README.md, "The map and the minimap"): its +/// column of the map in a strip inside its frame at its right; where the +/// column is longer than the strip, the rows round its window, with three +/// faint dots at an end where it goes on; its window framed in primary, +/// gliding with its scroll. `u` is the pane's `Ui` at its box's corner (a +/// pane fading through passes its faded one); drawn last, over its rows. +pub fn strip(panel: Panel, u: ui.Ui, box: Rect) void { + if (ui.mapping) return; + const m = current orelse return; + const f = u.f; + if (looking(f)) return; + const slot = slotOf(panel) orelse return; + // In a dive it comes in as its pane lands. + const v = u.faded(Map.stripShows(panel, u.at.value(m.t))); + if (v.at.pose.opacity <= 0) return; + m.strips(f, u.at); + const col = &atlas.columns[slot]; + if (col.n == 0) return; + const st = theme.strip; + const r = stripRect(.{ .x = 0, .y = 0, .w = box.w, .h = box.h }); + if (r.h <= st.top + st.foot + st.pitch) return; + // The strip as its drawings have it, its rows, dots and window in place. + const k = atlas.k; + const a = v.at.xf.apply(.{ r.x, r.y }); + const b = v.at.xf.apply(.{ r.x + r.w, r.y + r.h }); + f.image(atlas.images[theme.time.minimap_fade], sk.Rect{ .x = a[0], .y = a[1], .w = b[0] - a[0], .h = b[1] - a[1] }, .{ .src = sk.Rect{ .x = @as(f32, @floatFromInt(slot)) * st.w * k, .y = 0, .w = st.w * k, .h = r.h * k }, .tint = sk.Color.white.alphaFloat(v.at.pose.opacity) }); } test "the map's columns hold their panels" { @@ -745,3 +1124,14 @@ test "the map's columns hold their panels" { const st = theme.map.stage; try std.testing.expectEqual(@as(f32, 3840), st.x + st.w + st.x); } + +test "a point of the map is placed in its column, the second box going on from the first" { + const cm = theme.metric.context; + const boxes = [2]Rect{ .{ .x = 0, .y = 0, .w = 880, .h = theme.layout.panelH(10) }, .{ .x = 900, .y = 100, .w = 880, .h = theme.layout.panelH(5) } }; + const first = spotIn(boxes, 40, cm.tag + cm.pad + 3 * cm.row + cm.row / 2, true).?; + try std.testing.expectEqual(@as(f32, 3), first.r); + const second = spotIn(boxes, 940, 100 + cm.tag + cm.pad + cm.row, false).?; + try std.testing.expectEqual(@as(f32, 11), second.r); + try std.testing.expectEqual(@as(f32, 40), second.x); + try std.testing.expect(spotIn(boxes, 2000, 50, true) == null); +} |
