summaryrefslogtreecommitdiff
path: root/anim
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
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')
-rw-r--r--anim/README.md86
-rw-r--r--anim/build.zig18
-rw-r--r--anim/scenes/fib.zig1
-rw-r--r--anim/scenes/gallery.zig29
-rw-r--r--anim/scenes/list.zig31
-rw-r--r--anim/scenes/sort.zig1
-rw-r--r--anim/scenes/syscalls.zig1
-rw-r--r--anim/src/array.zig1
-rw-r--r--anim/src/context.zig90
-rw-r--r--anim/src/cursor.zig13
-rw-r--r--anim/src/disasm.zig3
-rw-r--r--anim/src/hexdump.zig81
-rw-r--r--anim/src/loupe.zig181
-rw-r--r--anim/src/map.zig286
-rw-r--r--anim/src/nodes.zig1
-rw-r--r--anim/src/objects.zig11
-rw-r--r--anim/src/root.zig30
-rw-r--r--anim/src/rows.zig174
-rw-r--r--anim/src/source.zig3
-rw-r--r--anim/src/theme.zig139
-rw-r--r--anim/src/ties.zig9
-rw-r--r--anim/src/ui.zig117
-rw-r--r--anim/src/words.zig8
-rw-r--r--anim/test/gallery.script4
-rw-r--r--anim/test/gallery/atoms.pngbin104376 -> 104371 bytes
-rw-r--r--anim/test/gallery/loupe.pngbin0 -> 242294 bytes
-rw-r--r--anim/test/gallery/none.pngbin223316 -> 231981 bytes
-rw-r--r--anim/test/gallery/rest.pngbin230773 -> 237262 bytes
-rw-r--r--anim/test/gallery/rows.pngbin113603 -> 117065 bytes
-rw-r--r--anim/test/gallery/step.pngbin230367 -> 236811 bytes
-rw-r--r--anim/test/gallery/subject.pngbin204673 -> 210793 bytes
-rw-r--r--anim/tools/chart.py6
32 files changed, 1182 insertions, 142 deletions
diff --git a/anim/README.md b/anim/README.md
index bf2100a..c59630a 100644
--- a/anim/README.md
+++ b/anim/README.md
@@ -88,7 +88,7 @@ through `Cursor.now(at)`.
| --- | --- | --- | --- |
| `title` | the series and the legend of marks | a card | |
| `fib` | recursion: each call a frame and a node | `subject`, `calls` | `steps` |
-| `list` | a list reversed: each `next` turned | `subject`, `nodes` | `list` |
+| `list` | a list reversed: each `next` turned; it opens on the map and dives into the frame; after the first load the pointer loaded opens in a loupe, and the `next` in it one deeper | `subject`, `nodes` | `list` |
| `sort` | insertion sort: compares and swaps | `subject`, `array` | `sort` |
| `syscalls` | open, read, close, write: the kernel's side | `subject`, `syscalls` | `hello` |
| `zoom` | one line of C as its instructions, the call's bytes | `none`, the camera at x2 | `steps` |
@@ -103,17 +103,20 @@ every state the code has in the `gallery` scene.
| Layer | Block | Where | Notes |
| --- | --- | --- | --- |
| 0 tokens | grid, colour, type, the splits | `src/theme.zig` | per "Token changes" (`metric.calls`, `time.pin`, `time.continue_wave`, `time.relayout_fade` there; the insn's character counts gone); JetBrains Mono NL (`.code*` faces) for all mono, Medium under 30 |
-| 1 atom | `address` (`lead`, `name`, `rwx`), `value` (and `Ui.typed`: `fd`, `bool`, `char`), `arrow` (`points`, `holds`, `more`), `mark`s, `plaque` (`chip`), `pin` (`row`, `under`), `bracket` (`quiet`, `tie`, `thread`), `tag` | `src/ui.zig` (`Ui.address`, `.value`, `.arrow`, `.written`, `.read`, `.cellWritten`, `.cellRead`, `.current`, `.trail`, `.unknown`, `.chip`, `.pinRow`, `.pinUnder`, `.bracket`, `.panel`) | marks in the context: `armed`, `struck`, `held` (a tick), `read`; in a lens's cell the same with a bar |
+| 1 atom | `address` (`lead`, `name`, `rwx`), `value` (and `Ui.typed`: `fd`, `bool`, `char`), `arrow` (`points`, `holds`, `more`), `mark`s, `plaque` (`chip`), `pin` (`row`, `under`), `bracket` (`quiet`, `tie`, `thread`), `tag` | `src/ui.zig` (`Ui.address`, `.value`, `.arrow`, `.written`, `.corner`, `.read`, `.cellWritten`, `.cellRead`, `.current`, `.trail`, `.unknown`, `.chip`, `.pinRow`, `.pinUnder`, `.bracket`, `.panel`) | marks as mock 15's column B: `current` the white wash (`color.wash`) and the gold plaque; `struck` the softened paper (`color.struck`) with bold bright digits; `held` a turned corner (9; 12 on a lens's cell), in over the cool's last 6 f (`Heat.corner`, `time.strike.corner`); `armed`, `read` |
| | `byte` | `src/rows.zig` `bytes` | `number`, `pointer`, `text` (a string's ink), `loose` (a byte of no field: the allocator's, padding, past what a dump is of), `unread`; `pad`; `bytesAt` moves the bytes right of a long (stack) address, by the dump's widest |
-| 2 row | `chain`, `reg` (and `rip` with the flags), `slot`, `line`, `bytes`, `call` (`span`, `callRow`) | `src/rows.zig` | `chain` follows `zt.telescope.chase`; cut at its far end, `more` |
+| 2 row | `chain`, `reg` (and `rip` with the flags), `slot`, `line`, `bytes`, `call` (`span`, `callRow`) | `src/rows.zig` | `chain` follows `zt.telescope.chase`; cut at its far end, `more`. `slot`: pins from 16, the offset from rsp ranged right to 172, the address at 184, the chain, its role ranged right where the room ends, from `zt.telescope.slots` (`saved rbx`, a local's name in primary, `argc`, `argv[0]`, `argv end`, `envp end`, `auxv`; nothing for a return address or `.none`). `bytes`: the bracket at 24, the address at 34, the bytes 12 after it and at 132 at least |
+| | `arc` | `src/rows.zig` (`Arcs`), `src/hexdump.zig` (`pointerArcs`) | a pointer to a row of its own panel: lanes at 4, 10, 16 in a dump or a loupe, 4 and 10 on the stack; longest outermost, a chain in one lane; standing at 60% toward the page, full in the step that writes or reads it and always in a loupe; rewritten: the old dashed with the arm, fading from 6 f after the strike as the new draws (12 f), quieting with the cool; a stub to the rule for a target in the region past the window, only in its step; a saved rbp's only in its step; a dump withholds the arcs an open loupe carries |
| | `insn` | `src/disasm.zig` | columns at 2, 31, 40, 134, 180, 264, 564; operands whole, the annotation from 564 or a character after them; then a size word goes, then the operands give way, never inside `[]`; `current`, `ran` (every instruction of the last three steps), `ahead`, `outside`; the jump lane from the jump just before the pc's moment |
| 3 panel | `registers`, `stack`, `backtrace` | `src/context.zig` | the stack's window on `[rsp, rbp+16)` keeping the touched word in view, its tag the first and last word shown (`rsp+20 to rsp+48`), rsp and rbp's pins travelling 18 f after rsp's strike (`time.pin`, keeping their place among the names they leave and join), at rest only where the register points; a window that moves farther than its own height (six or eight slots) fades out and in round memory's strike, and what it brings, and what changed before it, is plain; a frame's name longer than the spans' room shortens the chains beside it; `call` spans and the backtrace (`#n`, name, arguments at 384, file and line) from `zt.telescope.frames`, the frames two stops share sliding to their new depth; the backtrace as a lens's drawing with `Context.Options.backtrace` |
| | `source` | `src/source.zig` | the whole file in a window, its middle third; numbers as wide as the program's largest line (SQLite's six digits), the text moved right by as much; a window going farther than its own height fades out and in |
| | `disasm` | `src/disasm.zig` | 17 rows (9 as subject), fewer above near a function's start; the line column as wide as the source's; two windows that overlap scroll, others fade out and in |
| | `hexdump` | `src/hexdump.zig` | a lens's view (`hexdump.panel`): `bytes` rows and their reading, veiled at a sprint; one reading for every dump (`hexdump.reading`), a list a character apart, a typed number as its type reads (`char` quoted, `bool` by name); the address room once a dump, by its widest; `Dump`, a view of a region by the fields a scene gives it (`Field`: where, how long, read as a number, big-endian or not, a pointer, text, or left to the eye), the rows that hold a field and a `more` row for each stretch left out, and where those rows outnumber the window, a window kept round the first row a mark or the step is on, the rest folded into `more` rows; marks the scene plays, and the step's only from the stop it came in at (`since`); the bytes a syscall was given as the kernel took them (`given`), and only what the debugger read at the stop (`seen`) |
+| | `loupe` | `src/loupe.zig` (`canim.loupe`, `Loupe.open`, `.close`) | five rows round a pointer's target, lifted (`color.lift`, `lift_tag`, `shade` 12 and 16; 20 and 26 deeper), hanging from its pointer (its tag on the row's foot, 92 left of the digits, clamped to the stage), a 4-high bracket under the digits its stem, the target's fields framed bright; from a register, or from a pointer field of a loupe; `open` 36 f (read 6, stem and rise 18 with the shadow, the frame 6 f after), `close` 12 f |
| | lenses: `nodes`, `array`, `calls`, `syscalls`, `backtrace` | `src/nodes.zig`, `src/array.zig`, `src/calls.zig` (`Tree`), `src/syscalls.zig` (`Crossing`), `src/context.zig` (`Backtrace`, `lens`) | the drawing in `band` (over the program column), its view in `view` (over the state column): `nodes` and `array` a dump (`hexdump.panel`), `calls` the backtrace with arguments, `syscalls` the bytes the call is given or fills, `backtrace` (eleven rows as subject, five beside) a `Dump` the scene gives; an `under` pin's names in the order they came, the first left |
| 4 tie | `thread`, `link` (and its `pin`), `projection`, `echo` | `src/ties.zig` | panels publish places (`anchor`); `Ties`, added last, draws in the channels: a link climbs to a node by the gutter's left lane and goes down to a slot by the right, its name riding its head, a target past the stack's window a stub and a row count; a projection from the view's bytes, or from a frame's return address to its call's node |
-| 5 frame | `stage` and `relayout` | `src/stage.zig` | splits `none`, `beside`, `subject` (`theme.layout.split`): the band is `band` (the drawing) and `view`; `relayout` fades the drawing round its move; `holdStack` holds the stack's window for the camera, with `free` slots |
+| 5 frame | `map`, `minimap`, `dive`, `surface` | `src/map.zig` (`Map`, `split`, `minimap`), `Context.map` | the working frame's panels bound to a stage of 3840 by 2160 (`map.split`: the drawing and the source, the disassembly 69, the view 32, the registers and the backtrace, the stack 69 from 16 words above rsp); its rows published while `ui.mapping`; the working windows outlined (2 `dim`, 4 out); the minimap the same at a twentieth under the clock (text as 1-unit strokes at 45% toward the page, marks as blocks; `ui.strokes`), the count ranged right at 1648; `Map.show`, `.dive` (outlines bright 6 f, veil to 24, each panel from its window to its place 60 f, 6 f apart in reading order, opaque on the way, its rows on the window's rows, its tag and rules in at the end; the map falls to the minimap's rect over 72 f; 120 f and 30 f still), `.surface` (the dive back, 84 f, then 30 f still); per-panel transforms through `context.at` (`context.zoomed`) |
+| | `stage` and `relayout` | `src/stage.zig` | splits `none`, `beside`, `subject` (`theme.layout.split`): the band is `band` (the drawing) and `view`; `relayout` fades the drawing round its move; `holdStack` holds the stack's window for the camera, with `free` slots |
| | `clock`, `caption`, `veil`, `card` | `src/words.zig`, `src/root.zig` (`Narrator`, `Camera`) | the clock still while a step plays, its piece fading in once the mark lands; a caption stays its reading time; the title card is `scenes/title.zig` |
| 6 verb | `fire`, `arm`, `strike`, `cool`, `read`, `extend`, `link`, `project`, `travel` (pins), `advance`, `cascade`, `continue` (`Cursor.continue`, `Plan.wave`), `run`, `sprint`, `establish` (`Context.establish`: a drawing's elements fade in rising, no lines), `scroll`, `relayout`, `visit`, `say` | `src/cursor.zig` (the timetable), the blocks (each draws its state at the instant) | tokens in `theme.time`; a level gives up its slot when nothing it touched is drawn (`Recording.drawn`) |
@@ -126,7 +129,9 @@ and read (a debugger's `touch` reads count), each moment's `touch` and
`build.zig` records four programs of `tools/` under `ztrace record` (the
debugger: registers, the stack, what they point at, the instructions round
-the pc with their lines and callees' parameter counts, at every stop), each
+the pc with their lines and callees' parameter counts, what each stack
+word is (`zt.telescope.slots`), at every stop: `--stack 1024 --around 256
+--disasm 69`, what the map needs, except where noted), each
by a bare name in a directory of its own with an empty environment, without
address randomisation, with the tools built `ReleaseFast` (a step through
the agent's or the runtime's code is a moment, and a slow tracer stretches
@@ -136,12 +141,12 @@ and no canary stepped through that the source does not say.
| Name | Program | Stops | Moments, bytes | Also |
| --- | --- | --- | --- | --- |
-| `steps` | `fib.c`, static musl, `-O0` | every instruction | 1999, 336 KB | |
-| `hello` | `hello.c`, static musl | every line | 233, 101 KB | reads `tools/note` |
-| `sort` | `sort.c`, `ztrace cc --instr vars --only sort,a` | every instruction, `--from main` | 5076, 617 KB | `--ring`: the variables' names and types; each `__zt_var` call is stepped (4 of them) |
-| `list` | `list.c`, `ztrace cc --instr vars --only push,reverse,head` | every instruction, `--from reverse` | 3421, 528 KB | `--alloc --preload` the agent: allocator headers are read; the pushes (the agent's and the runtime's first calls) run through |
+| `steps` | `fib.c`, static musl, `-O0` | every instruction | 1999, 431 KB (336 KB before) | |
+| `hello` | `hello.c`, static musl | every line | 233, 126 KB (101 KB) | reads `tools/note` |
+| `sort` | `sort.c`, `ztrace cc --instr vars --only sort,a` | every instruction, `--from main` | 5154, 799 KB (617 KB) | `--ring`: the variables' names and types; each `__zt_var` call is stepped (4 of them); `--stack 256` (below) |
+| `list` | `list.c`, `ztrace cc --instr vars --only push,reverse,head` | every instruction, `--from reverse` | 3369, 782 KB (528 KB) | `--alloc --preload` the agent: allocator headers are read; the pushes (the agent's and the runtime's first calls) run through; `--stack 256` (below) |
| `gallery` | the old `list` by line, kept in `test/gallery/list.ztrace` | | 134, 88 KB | the gallery's pictures depend on the drawing only |
-| `sqlite` | `sqlite.c` (three rows into a table, committed) with SQLite 3.50.4's amalgamation, system clang `-O2 -g -fno-omit-frame-pointer -no-pie -fno-stack-protector -Wl,-z,now`, glibc | `--by break`: `sqlite3_step`, `sqlite3BtreeInsert`, `unixWrite`, and the instruction after its `pwrite64` (found by objdump); every syscall recorded, `-s 4096`, `--stack 512` | 181 (42 stops, 138 syscalls), 95 KB | made only with `-Dsqlite=DIR` (default `~/05-genizah/sqlite/sqlite-amalgamation-3500400`), in a new temporary directory each time; `sqlite3.c` is embedded as the source |
+| `sqlite` | `sqlite.c` (three rows into a table, committed) with SQLite 3.50.4's amalgamation, system clang `-O2 -g -fno-omit-frame-pointer -no-pie -fno-stack-protector -Wl,-z,now`, glibc | `--by break`: `sqlite3_step`, `sqlite3BtreeInsert`, `unixWrite`, and the instruction after its `pwrite64` (found by objdump); every syscall recorded, `-s 4096` | 181 (42 stops, 138 syscalls), 233 KB (139 KB) | made only with `-Dsqlite=DIR` (default `~/05-genizah/sqlite/sqlite-amalgamation-3500400`), in a new temporary directory each time; `sqlite3.c` is embedded as the source |
A recording that begins inside a call (`--from`) has that call open from
its first stop (`Recording.index`, from the frame chain). Writes are the
@@ -150,26 +155,38 @@ bytes whose value changed, to the element the instruction stored (its
counts as assigning a local (and as a name coming to a node's pin). A register's change over a step is net: a
call's rsp put back is not struck. The vDSO's `clock_gettime` is stepped
through under the runtime and the agent: its retry loop makes the counts
-vary a little from one recording to the next. An address no symbol
+vary a little from one recording to the next, and with a slower stop it
+seldom gets out: `list` with `--stack 512` took 27 000 to 42 000 moments,
+with 1024 0.3 to 1.6 million (100 MB, minutes), against 3 900 at 256
+(`--around` and `--disasm` matter little). So the two instrumented
+programs keep `--stack 256` (48 words with the 128 bytes under rsp): their
+map's stack column is shorter. The tracer should run through a call into
+the vDSO as `step` runs through code without lines. An address no symbol
holds is named from its module's first mapping (`list+2c89`).
## Motion, as measured
`tools/chart.py chart` on the 1080p exports in `out/` (the designer's five
-checks; its regions follow the two-panel band now). Encoded with `-g 600`:
-x264's keyframe at 10, 20, 30 s is a one-frame fade the instrument sees.
-"Before" is the exports this pass started from (10 November, evening);
-"after" the ones it made: the continue's wave, plain windows and dumps
-after a fade, the crossing's order, pins at rest only where their
-register points, `time.pin`, the compact reading, names by arrival.
+checks; its regions are the working frame's; the minimap, 1664 to 1856 by
+912 to 1020, is in none). Encoded with `-g 600`: x264's keyframe at 10,
+20, 30 s is a one-frame fade the instrument sees. "Before" is the last
+pass's exports; "after" this pass's: the new marks, the stack's row, arcs,
+the minimap, the list's map and dive and its loupes, the recordings remade.
| | fib | list | sort | syscalls | zoom | sqlite |
| --- | --- | --- | --- | --- | --- | --- |
| POP, before / after | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 |
-| CROWD, before / after | 2 / 2 | 7 / 7 | 5 / 5 | 1 / 1 | 4 / 4 | 1 / 0 |
-| RUSH, before / after | 0 / 0 | 2 / 2 | 0 / 0 | 2 / 1 | 0 / 0 | 1 / 1 |
-| AIR, before / after | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 1 / 1 | 4 / 5 |
-| seconds, after | 41.5 | 60.5 | 42.0 | 37.9 | 32.0 | 64.6 |
+| CROWD, before / after | 2 / 2 | 7 / 6 | 5 / 4 | 1 / 1 | 4 / 3 | 0 / 1 |
+| RUSH, before / after | 0 / 2 | 2 / 2 | 0 / 0 | 1 / 1 | 0 / 0 | 1 / 2 |
+| AIR, before / after | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 1 / 1 | 5 / 5 |
+| seconds, after | 41.5 | 70.9 | 42.0 | 37.9 | 32.0 | 64.6 |
+
+New this pass: list's CROWD at 2.52 is the dive (the windows go bright,
+then every panel sets off within 0.5 s: by design one move); fib's RUSH at
+5.78 and 7.30 is x264 noise in the caption band (30 pixels changing by 6
+to 24 levels under the still caption while the panels move), not a
+caption arriving; sqlite's new RUSH at 19.05 is not examined. The rest are
+as below.
What fires, and why it is left:
@@ -199,6 +216,33 @@ What fires, and why it is left:
## What is not done
+- The map is packed into fixed places (`map.split`): a panel longer than
+ its column is a window of what fits; continuing in the next column's
+ free space under `continued`, the key in a column's foot, `memory` in
+ a scene without a lens, and loupes as panels on the map (and as lifted
+ blocks on the minimap) are not built. The sqlite scene's lenses (the
+ backtrace, the kernel's side) and the zoom scene have no drawing on
+ their map. A disassembly of 69 rows shows what the recording decoded
+ round the pc, so a small function leaves rows empty.
+- The minimap draws no thread and no `flash`; its windows are outlined a
+ frame behind the panels that publish them after the clock (the lens's
+ view). The scene's focus is not set on it.
+- `dive`: every panel travels 60 f (the catalogue's 72 f is the map's
+ fall), so that seven of them 6 f apart land by 120 f; the drawing does
+ not crossfade between sizes (the list's are the same, subject on both);
+ panels draw in the scene's order (source, disassembly, registers, stack,
+ then the lens), not the reading order, so the stack passes over the
+ registers' lower rows, opaque, for about 0.35 s before it lands. Only
+ the list opens on the map; no scene surfaces, and no sprint or far
+ continue plays on the map.
+- A loupe keeps to the stage but does not yet move past the current marks
+ or a changed row; on the 1920 stage a deeper loupe has 20, not 120, to
+ its right (the stage's edge), and covers most of the first. The
+ catalogue's stem is 3 in its strokes and 4 in the loupe's anatomy: it is
+ 4 here.
+- An `arc`'s lane change does not glide (12 f): a lane is given each
+ frame from the arcs then present.
+
- Back pointers between nodes still run under the nodes: a page keyline
round each pin's stub and head shows them passing behind it (there is
no lane for them in `beside`).
diff --git a/anim/build.zig b/anim/build.zig
index 29a4b05..21abbce 100644
--- a/anim/build.zig
+++ b/anim/build.zig
@@ -74,6 +74,12 @@ pub fn build(b: *std.Build) void {
alloc: bool = false,
/// A file of tools/ it reads, by its bare name.
reads: ?[]const u8 = null,
+ /// Bytes of stack above rsp each stop records. An instrumented
+ /// program's runtime reads the clock through the vDSO, whose retry
+ /// loop is stepped: with 512 or more the loop seldom gets through
+ /// (`list` took 27 000 to 42 000 moments at 512, and 0.3 to 1.6
+ /// million at 1024, against 3 900 at 256), so those take 256.
+ stack: []const u8 = "1024",
};
for ([_]Recording{
.{ .name = "steps", .source = "fib.c", .by = "insn" },
@@ -83,8 +89,8 @@ pub fn build(b: *std.Build) void {
// are told by the instrumentation (each a call into its runtime,
// stepped like any other); `list` starts at `reverse`, its pushes
// (the agent's and the runtime's first calls) run through.
- .{ .name = "sort", .source = "sort.c", .by = "insn", .instr = "vars", .only = "sort,a", .from = "main" },
- .{ .name = "list", .source = "list.c", .by = "insn", .instr = "vars", .only = "push,reverse,head", .from = "reverse", .alloc = true },
+ .{ .name = "sort", .source = "sort.c", .by = "insn", .instr = "vars", .only = "sort,a", .from = "main", .stack = "256" },
+ .{ .name = "list", .source = "list.c", .by = "insn", .instr = "vars", .only = "push,reverse,head", .from = "reverse", .alloc = true, .stack = "256" },
}) |r| {
const source = b.path(b.fmt("tools/{s}", .{r.source}));
var program: std.Build.LazyPath = undefined;
@@ -115,7 +121,11 @@ pub fn build(b: *std.Build) void {
if (r.reads) |name| _ = where.addCopyFile(b.path(b.fmt("tools/{s}", .{name})), name);
const run = b.addSystemCommand(&.{ "env", "-i", "setarch", "-R" });
run.addArtifactArg(ztrace);
- run.addArgs(&.{ "record", "--by", r.by, "--stack", "256", "-s", "64" });
+ // More round each stop than the working frame shows: the map of
+ // the whole context wants the words of the stack, 256 bytes round
+ // what a pointer leads to and what a step touches, and 69
+ // instructions round the pc.
+ run.addArgs(&.{ "record", "--by", r.by, "--stack", r.stack, "--around", "256", "--disasm", "69", "-s", "64" });
if (r.from) |place| run.addArgs(&.{ "--from", place });
// What an instrumented program tells of itself comes through a ring.
if (r.instr != null) run.addArg("--ring");
@@ -167,7 +177,7 @@ pub fn build(b: *std.Build) void {
\\trap 'rm -rf "$d"' EXIT
\\cp "$program" "$d/sqlite"
\\cd "$d"
- \\env -i setarch -R "$ztrace" record --by break -b sqlite3_step -b sqlite3BtreeInsert -b unixWrite -b "*$back" --stack 512 -s 4096 -o "$out" -- ./sqlite
+ \\env -i setarch -R "$ztrace" record --by break -b sqlite3_step -b sqlite3BtreeInsert -b unixWrite -b "*$back" --stack 1024 --around 256 --disasm 69 -s 4096 -o "$out" -- ./sqlite
});
run.addArtifactArg(ztrace);
run.addFileArg(program);
diff --git a/anim/scenes/fib.zig b/anim/scenes/fib.zig
index 214f768..7e5380c 100644
--- a/anim/scenes/fib.zig
+++ b/anim/scenes/fib.zig
@@ -32,6 +32,7 @@ fn frame(s: *anim.Frame) void {
const ctx = canim.context(s, at, .{ .split = split });
// The lens: every call of fib as a tree, beside the frames they are on the stack.
const tree = canim.callTree(s, .{ .cursor = at, .stage = ctx.stage, .function = "fib", .focus = true });
+ ctx.map.add(s, canim.CallTree{ .cursor = at, .stage = ctx.map.stage, .function = "fib" });
var says: canim.Narrator = .{};
// Staging: the whole picture, still, before a word; the words, before a step.
diff --git a/anim/scenes/gallery.zig b/anim/scenes/gallery.zig
index fce9d43..7c480ec 100644
--- a/anim/scenes/gallery.zig
+++ b/anim/scenes/gallery.zig
@@ -9,6 +9,7 @@
//! 2 s the frame at rest, `beside`: every panel, the thread (mock 9)
//! 3.6 s a step, mid-way: struck, read, projection, echo (mock 10)
//! 6 s `subject` (mock 11); 8 s `none`, with the backtrace
+//! 10.8 s two loupes in depth, from rax and its node's `next` (mock 21)
const std = @import("std");
const sk = @import("sketch");
const anim = @import("anim");
@@ -60,15 +61,15 @@ fn atoms(u: ui.Ui, p: *const Pages) void {
x += 120;
x = u.address(x, rows.baseline(y), regs.rip, .{ .ink = ui.rgb(region.code_), .name = p.rec.strings.get(regs.rip) orelse "" }) + 40;
x = u.address(x, rows.baseline(y), 0x7ffff7ff0000, .{ .ink = ui.rgb(region.data), .rwx = true }) + 40;
- const struck: ui.Heat = .{ .level = 1, .solid = 1 };
+ const struck: ui.Heat = .struck;
const cell: canim.Rect = .{ .x = x, .y = y, .w = 6 * 12, .h = row };
- _ = u.written(cell, struck, 9);
- _ = u.address(x, rows.baseline(y), 0x407050, .{ .ink = ui.rgb(t.ink), .face = .mono_bold });
+ _ = u.written(cell, struck);
+ _ = u.address(x, rows.baseline(y), 0x407050, .{ .ink = ui.rgb(t.bright), .face = .mono_bold });
x += 112;
u.read(.{ .x = x, .y = y, .w = 72, .h = row }, 1);
_ = u.address(x, rows.baseline(y), 0x407058, .{ .ink = ui.rgb(region.heap) });
x += 112;
- _ = u.written(.{ .x = x, .y = y, .w = 72, .h = row }, .ember, 9);
+ _ = u.written(.{ .x = x, .y = y, .w = 72, .h = row }, .ember);
_ = u.address(x, rows.baseline(y), 0x407030, .{ .ink = ui.rgb(region.heap) });
// value
@@ -121,7 +122,7 @@ fn atoms(u: ui.Ui, p: *const Pages) void {
u.text(.mono_bold, theme.size.mono.context, 64 + 46 - 24, rows.baseline(y), "21", t.ink);
x = 300;
for ([_]ui.Heat{ .{ .arm = 1 }, struck, .ember }) |h| {
- const ink = u.written(.{ .x = x, .y = y, .w = 72, .h = row }, h, 9);
+ const ink = u.written(.{ .x = x, .y = y, .w = 72, .h = row }, h);
_ = u.address(x, rows.baseline(y), 0x407070, .{ .ink = if (ink) |i| i.ink else ui.rgb(region.heap), .face = if (ink) |i| i.face else .mono });
x += 120;
}
@@ -226,19 +227,19 @@ fn rowsPage(u: ui.Ui, p: *const Pages) void {
y += 12;
var panel = u.moved(64, y);
_ = rows.reg(panel, 0, 880, "rsi", m, regs.rsi, .{});
- _ = rows.reg(panel, row, 880, "rdi", m, regs.rdi, .{ .first = .{ .level = 1, .solid = 1 } });
+ _ = rows.reg(panel, row, 880, "rdi", m, regs.rdi, .{ .first = .struck });
_ = rows.reg(panel, 2 * row, 880, "rax", m, regs.rax, .{ .first = .ember });
_ = rows.reg(panel, 3 * row, 880, "rbp", m, regs.rbp, .{ .read = 1, .read_shows = 1 });
rows.rip(panel, 4 * row, 880, m, regs.rip, regs.eflags, 1 << 6, 1, 0);
y = 380;
title(u, 64, y, "slot");
- note(u, 140, y, "its pins in the lane; the chain from 122; `call` spans at the right");
+ note(u, 140, y, "its pins in the lane; the offset from rsp; the address from 184 and its chain; a role; `call` spans at the right");
y += 12;
panel = u.moved(64, y);
for (0..4) |i| {
const addr = regs.rsp + 8 * i;
- _ = rows.slot(panel, @as(f32, @floatFromInt(i)) * row, 880, m, addr, if (i == 0) &.{ "rsp", "rbp" } else &.{}, 1, .{ .lead = ui.shared(&.{ regs.rsp, regs.rsp + 24 }), .first = if (i == 2) .ember else .none });
+ _ = rows.slot(panel, @as(f32, @floatFromInt(i)) * row, 880, m, addr, @intCast(8 * i), if (i == 0) &.{ "rsp", "rbp" } else &.{}, 1, .{ .lead = ui.shared(&.{ regs.rsp, regs.rsp + 24 }), .first = if (i == 2) .ember else .none }, if (i == 0) "saved rbp" else if (i == 1) "cur" else "", i == 1);
}
rows.span(panel, 880, 0, 2 * row, "reverse", true, false);
rows.span(panel, 880, 2 * row, 4 * row, "main", false, true);
@@ -271,7 +272,7 @@ fn rowsPage(u: ui.Ui, p: *const Pages) void {
panel = u.moved(976, y);
var values: [16]u8 = .{ 12, 0, 0, 0, 0, 0, 0, 0, 0x10, 0x70, 0x40, 0, 0, 0, 0, 0 };
var known: [16]bool = @splat(true);
- rows.bytes(panel, 0, 0x407030, &values, &known, &.{ .{ .first = 0, .len = 8, .kind = .number, .read = 1 }, .{ .first = 8, .len = 8, .kind = .pointer, .heat = .{ .level = 1, .solid = 1 } } }, region.heap, 4, true, m);
+ rows.bytes(panel, 0, 0x407030, &values, &known, &.{ .{ .first = 0, .len = 8, .kind = .number, .read = 1 }, .{ .first = 8, .len = 8, .kind = .pointer, .heat = .struck } }, region.heap, 4, true, m);
values[8] = 0x50;
rows.bytes(panel, row, 0x407050, &values, &known, &.{ .{ .first = 0, .len = 8, .kind = .number }, .{ .first = 8, .len = 8, .kind = .pointer, .heat = .ember } }, region.heap, 4, true, m);
known = @splat(false);
@@ -298,6 +299,12 @@ fn frame(s: *anim.Frame) void {
const at = canim.cursor(s, rec, rest);
const ctx = canim.context(s, at, .{ .split = canim.layout.split.beside, .quiet = true });
const list = canim.nodes(s, .{ .cursor = at, .stage = ctx.stage, .root = "head", .track = &.{ "prev", "cur", "next" }, .quiet = true });
+ ctx.map.add(s, canim.Nodes{ .cursor = at, .stage = ctx.map.stage, .root = "head", .track = &.{ "prev", "cur", "next" }, .quiet = true });
+ // A loupe from rax (the last node, whose `next` is NULL by then), and
+ // one from the `next` of the node before it in the first's rows: two in depth.
+ const rax = rec.register(rec.next(.line, rest), "rax");
+ const near = canim.loupe(s, .{ .cursor = at, .stage = ctx.stage, .from = .{ .register = "rax" } });
+ const deeper = canim.loupe(s, .{ .cursor = at, .stage = ctx.stage, .from = .{ .field = .{ .loupe = near, .at = rax - 0x20 + 8 } } });
const joins = ctx.ties(s);
const says = canim.caption(s, "The gallery: the frame, at rest. Every panel, the thread,\nthe lens beside it: the list and the bytes it is drawn from.");
const panels = .{ ctx.clock, ctx.registers, ctx.stack, ctx.backtrace, ctx.source, ctx.disasm, list, joins, says };
@@ -313,4 +320,8 @@ fn frame(s: *anim.Frame) void {
s.wait(7 - s.cursor);
ctx.stage.relayout(s, canim.layout.split.none);
s.wait(9 - s.cursor);
+ near.open(s);
+ s.wait(9.8 - s.cursor);
+ deeper.open(s);
+ s.wait(11 - s.cursor);
}
diff --git a/anim/scenes/list.zig b/anim/scenes/list.zig
index d6f1a76..b7e6c4a 100644
--- a/anim/scenes/list.zig
+++ b/anim/scenes/list.zig
@@ -6,8 +6,10 @@
//! trip round the loop is walked (each local strikes on the stack and in
//! the table, then its tag slides to its node; the pointer's rewrite is
//! armed with its old arrow going dashed, strikes, and the new arrow grows
-//! to the node it lands on); the second trip is hurried, with a rest; the
-//! third is walked again, and `head` takes the last node.
+//! to the node it lands on); after its first load the pointer loaded is
+//! opened in a loupe, and the `next` in it one deeper; the second trip is
+//! hurried, with a rest; the third is walked again, and `head` takes the
+//! last node.
const anim = @import("anim");
const canim = @import("canim");
const recordings = @import("recordings");
@@ -32,17 +34,38 @@ fn frame(s: *anim.Frame) void {
const split = canim.layout.split.subject;
const ctx = canim.context(s, at, .{ .split = split });
const list = canim.nodes(s, .{ .cursor = at, .stage = ctx.stage, .root = "head", .track = &tracked });
+ ctx.map.add(s, canim.Nodes{ .cursor = at, .stage = ctx.map.stage, .root = "head", .track = &tracked });
var says: canim.Narrator = .{};
+ // The pointer just loaded, opened: rax holds `cur->next` after the
+ // first trip's line 21; a loupe under it, and one from that node's `next`.
+ const loaded = rec.lineMoment(22, rec.lineMoment(21, reverse.enter));
+ const near = canim.loupe(s, .{ .cursor = at, .stage = ctx.stage, .from = .{ .register = "rax" } });
+ const deeper = canim.loupe(s, .{ .cursor = at, .stage = ctx.stage, .from = .{ .field = .{ .loupe = near, .at = rec.register(loaded, "rax") + 8 } } });
const joins = ctx.ties(s);
- // The nodes come in beside their bytes, one by one: three of them.
- ctx.establish(s, .{ ctx.clock, ctx.registers, ctx.stack, ctx.source, ctx.disasm, list, joins }, 3);
+ // It opens on the map, the whole context unfolded: the first caption at
+ // 1 s, the dive into the working frame at 2.5 s, the first step at 5 s.
+ ctx.map.show(s, .{ ctx.clock, ctx.registers, ctx.stack, ctx.source, ctx.disasm, list, joins });
+ s.wait(@max(t.establish - s.cursor, 0));
says.line(s, "A list is nodes on the heap, each holding the address of the next.\nReversing it moves no node: it rewrites every `next`.");
+ s.cursor = 2.5;
+ ctx.map.dive(s);
// Three names are set up.
const first_trip = rec.lineMoment(21, reverse.enter);
at.walk(s, .line, first_trip);
// The loop's caption leads the loop.
says.line(s, "`next` remembers the way on, `cur->next` is turned round,\nand `prev` and `cur` each step along.");
+ at.walk(s, .line, loaded);
+ // A beat of its own: the pointer just loaded is opened, and the one in it.
+ says.line(s, "`rax` holds `cur->next`: under it opens the heap round that node,\nand from its `next`, one deeper, the node after it.");
+ near.open(s);
+ s.wait(t.beat);
+ deeper.open(s);
+ s.wait(2 * t.beat + t.loupe.open);
+ deeper.close(s);
+ s.wait(t.stagger * 3);
+ near.close(s);
+ s.wait(t.beat);
const second_trip = rec.lineMoment(21, rec.lineMoment(24, first_trip));
at.walk(s, .line, second_trip);
// Pacing: the second trip is the same, so hurried; it keeps its rest.
diff --git a/anim/scenes/sort.zig b/anim/scenes/sort.zig
index c9b5b07..82a99e1 100644
--- a/anim/scenes/sort.zig
+++ b/anim/scenes/sort.zig
@@ -32,6 +32,7 @@ fn frame(s: *anim.Frame) void {
const ctx = canim.context(s, at, .{ .split = split });
// The lens: the array as cells, and the two indices that walk it.
const cells = canim.array(s, .{ .cursor = at, .stage = ctx.stage, .variable = "a", .indices = &.{ "i", "j" }, .focus = true });
+ ctx.map.add(s, canim.Array{ .cursor = at, .stage = ctx.map.stage, .variable = "a", .indices = &.{ "i", "j" } });
var says: canim.Narrator = .{};
// A swap, start to finish, as one step of sort(): over the call.
const swap = struct {
diff --git a/anim/scenes/syscalls.zig b/anim/scenes/syscalls.zig
index 6e2f0b9..1c875f3 100644
--- a/anim/scenes/syscalls.zig
+++ b/anim/scenes/syscalls.zig
@@ -33,6 +33,7 @@ fn frame(s: *anim.Frame) void {
const ctx = canim.context(s, at, .{ .split = split, .syscalls = true });
// The lens: the kernel's side of each call.
const kernel = canim.crossing(s, .{ .cursor = at, .stage = ctx.stage, .focus = true });
+ ctx.map.add(s, canim.Crossing{ .cursor = at, .stage = ctx.map.stage });
var says: canim.Narrator = .{};
const t = canim.theme.time;
diff --git a/anim/src/array.zig b/anim/src/array.zig
index d9216c3..8bb0a52 100644
--- a/anim/src/array.zig
+++ b/anim/src/array.zig
@@ -81,6 +81,7 @@ pub const Array = struct {
const dump = hexdump.panel(f, at, g.stage, u.print("{x} to {x}, an element a run", .{ v.addr, v.addr + v.size - 1 }), &.{});
const rows_n = @min(dump.rows, (v.addr + v.size - first + 15) / 16);
if (rows_n > 0) hexdump.draw(dump.u, now, 0, m.tag + m.pad, first, rows_n, .{ .array = .{ .addr = v.addr, .len = v.size, .elem = @intCast(elem), .type = elem_type }, .region = context.ink(context.regionOf(moment, v.addr)) });
+ if (rows_n > 0) @import("map.zig").window(.view, first, first + 16 * (rows_n - 1));
dump.veil(now);
u.clip(.{ .x = 0, .y = 0, .w = box.w, .h = box.h });
}
diff --git a/anim/src/context.zig b/anim/src/context.zig
index 9874cd7..e5a226a 100644
--- a/anim/src/context.zig
+++ b/anim/src/context.zig
@@ -16,6 +16,8 @@ const cursors = @import("cursor.zig");
const Recording = @import("Recording.zig");
const syscalls = @import("syscalls.zig");
const ties = @import("ties.zig");
+const hexdump = @import("hexdump.zig");
+const map = @import("map.zig");
const Stage = @import("stage.zig").Stage;
const theme = ui.theme;
const time = theme.time;
@@ -39,9 +41,28 @@ pub const legend = blk: {
};
};
-/// A panel's `Ui`, moved to where the stage has its box now.
+/// While a `dive` or a `surface` plays (`map.Map`): each working panel's
+/// box, and the rect it is drawn into instead, on its way between its
+/// window on the map and its place; its tags, rules and lanes how much shown.
+pub const Zoom = struct { box: Rect, to: Rect, chrome: f32 };
+pub var zoomed: [8]?Zoom = @splat(null);
+
+/// A panel's `Ui`, moved to where the stage has its box now (or, in a
+/// dive, scaled into the rect it is on its way through).
pub fn at(f: *sk.Frame, placed: anim.Placed, box: Rect) ui.Ui {
- return (ui.Ui{ .f = f, .at = placed }).moved(box.x, box.y);
+ var p = placed;
+ ui.chrome = 1;
+ if (!ui.mapping) for (zoomed) |z| if (z) |zz| if (@abs(zz.box.x - box.x) < 0.5 and @abs(zz.box.y - box.y) < 0.5 and @abs(zz.box.h - box.h) < 0.5) {
+ const k = zz.to.w / box.w;
+ p.xf = p.xf.mul(.translate(zz.to.x, zz.to.y)).mul(.scale(k, k)).mul(.translate(-box.x, -box.y));
+ p.scale *= k;
+ // On its way it is opaque, over the panels that set off before it; its tag and rules come in at the end.
+ const u = (ui.Ui{ .f = f, .at = p }).moved(box.x, box.y);
+ u.fill(.{ .x = 0, .y = m.tag, .w = box.w, .h = box.h - m.tag }, theme.color.page);
+ ui.chrome = zz.chrome;
+ return u;
+ };
+ return (ui.Ui{ .f = f, .at = p }).moved(box.x, box.y);
}
pub fn veiled(u: ui.Ui, box: Rect, amount: f32) void {
@@ -106,18 +127,19 @@ pub const Registers = struct {
fn rip(r: *const Registers, u: ui.Ui, now: cursors.Now, y: f32, w: f32, is: Shown, was: Shown) void {
const rec = r.cursor.rec;
const moment = now.marks[if (now.advancing() >= 0.5) 1 else 0];
- // The flags' ticks are secondary: 6 f after the registers strike,
+ // The flags' corners are secondary: 6 f after the registers strike,
// not with them; in a continue's wave, in its place after r15.
const delay = if (now.plan.wave) ties.strikeDelay(now, index("eflags").?) else cursors.write_apart;
const landed = now.landed(.cpu, delay);
const flags = (if (landed) is else was).regs.eflags;
- // The flags a step changed are ticked, for three steps.
+ // The flags a step changed have a turned corner, for three steps.
const eflags_index = comptime index("eflags").?;
- // Until this step's change lands, the ticks are the last one's: no effect before its cause.
+ // Until this step's change lands, the corners are the last one's: no effect before its cause.
const age = if (landed) now.registerAge(eflags_index) else now.registerAgeFrom(eflags_index, 1);
var changed: u64 = 0;
if (age) |a| changed = rec.register(now.stops[a], "eflags") ^ rec.register(now.stops[a + 1], "eflags");
- const held = if (r.quiet) 0 else now.register(eflags_index, delay).level;
+ const heat = now.register(eflags_index, delay);
+ const held = if (r.quiet) 0 else heat.level * heat.corner;
rows.rip(u, y, w, rec.moment(moment), rec.register(moment, "rip"), flags, changed, held, 0);
}
@@ -283,6 +305,8 @@ pub const Stack = struct {
cursor: cursors.Cursor,
stage: *const Stage,
focus: bool = false,
+ /// On the map: the window from this many words above rsp, not scrolled.
+ above: u32 = 0,
pub fn draw(k: *const Stack, f: *sk.Frame, placed: anim.Placed) void {
const box = k.stage.box(placed, .stack);
@@ -301,7 +325,7 @@ pub const Stack = struct {
const hold = placed.value(k.stage.hold);
const held = hold >= 0;
const held_at: u64 = if (held) rec.register(@intFromFloat(hold), "rsp") -% 8 * @as(u64, @intFromFloat(placed.value(k.stage.hold_free))) else 0;
- var window = if (held) [2]u64{ held_at, held_at } else [2]u64{ windowAt(now, is, slots, 0), windowAt(now, was, slots, 1) };
+ var window = if (held) [2]u64{ held_at, held_at } else if (k.above > 0) [2]u64{ is.rsp -% 8 * @as(u64, k.above), was.rsp -% 8 * @as(u64, k.above) } else [2]u64{ windowAt(now, is, slots, 0), windowAt(now, was, slots, 1) };
// A window that goes farther than its own height (a continue to a
// stop deeper or shallower than a call is) does not scroll: the old
// rows fade out before memory strikes and the new ones in after,
@@ -404,6 +428,16 @@ pub const Stack = struct {
}.of;
const size = theme.size.mono.context;
const lone: ?[]const u8 = if (travel.len == 1) travel[0] else null;
+ // The offsets are from the rsp of the rows shown: they change with the slide, not before it.
+ const rsp_shown = if (landed) is.rsp else was.rsp;
+ // What each word is, where the recording says (`zt.telescope.slots`):
+ // a register saved for the caller, a local, the process's first stack.
+ const roles_from = window[0] -% 16;
+ var roles_buf: [80]zt.telescope.Slot = undefined;
+ const roles = zt.telescope.slots(memory, if (landed) &is else &was, roles_from, roles_buf[0..@min(slots + 4, roles_buf.len)]) catch roles_buf[0..0];
+ // The words that point at other words of the window: `arc`s.
+ var at_rows: std.ArrayList(hexdump.RowAt) = .empty;
+ var pointers: std.ArrayList(struct { hexdump.RowAt, bool }) = .empty;
var n: i64 = @as(i64, @intFromFloat(@floor(-slide))) - 1;
while (n <= @as(i64, @intCast(slots)) - @as(i64, @intFromFloat(@floor(slide)))) : (n += 1) {
const y = top + (@as(f32, @floatFromInt(n)) + slide) * m.row;
@@ -416,9 +450,11 @@ pub const Stack = struct {
marks.read = 0;
marks.read_shows = now.reading(.memory, 0);
}
+ const below_rsp: i64 = @bitCast(addr -% rsp_shown);
+ map.row(.stack, addr, u, .{ .x = 0, .y = y, .w = box.w, .h = m.row });
// `free`: above rsp, not yet reached: its address at 60%, its word faint.
- if (held and addr < (if (landed) is.rsp else was.rsp)) {
- rows.free(v, y, memory, addr, lead);
+ if (held and addr < rsp_shown) {
+ rows.free(v, y, memory, addr, below_rsp, lead);
continue;
}
// A frame's name beside this row: the chain ends a character before it.
@@ -435,17 +471,31 @@ pub const Stack = struct {
}
const gapped = gap > 0 and names.names.len > 0 and names.shows > 0;
if (gapped) pinGap(v.faded(names.shows), y, names.names, lone.?, gap);
- const hops = rows.slot(v, y, room_w, memory, addr, if (gapped) &.{} else names.names, names.shows, marks);
+ const k_role = (addr -% roles_from) / 8;
+ const what: zt.telescope.Role = if (k_role < roles.len) roles[k_role].role else .none;
+ const role = roleName(u, what, (Recording.word(memory, addr, 8) catch null) orelse 1);
+ const hops = rows.slot(v, y, room_w, memory, addr, below_rsp, if (gapped) &.{} else names.names, names.shows, marks, role.name, role.local);
+ at_rows.append(u.f.scratch, .{ .addr = addr, .y = y }) catch {};
+ pointers.append(u.f.scratch, .{ .{ .addr = addr, .y = y }, what == .saved and std.mem.eql(u8, what.saved, "rbp") }) catch {};
// Only a row on show is a place a tie can land.
if (y >= top - 1 and y + m.row <= box.h - m.pad + 1) {
- ties.anchor(u, .{ .word = addr }, .{ .x = theme.metric.slot.chain, .y = y, .w = if (hops.n > 0) hops.x[0] + hops.w[0] - theme.metric.slot.chain else 120, .h = m.row });
+ ties.anchor(u, .{ .word = addr }, .{ .x = theme.metric.slot.address, .y = y, .w = if (hops.n > 0) hops.x[0] + hops.w[0] - theme.metric.slot.address else 120, .h = m.row });
ties.anchor(u, .{ .slot_pin = addr }, .{ .x = theme.metric.slot.lane, .y = y, .w = theme.metric.slot.lane_end - theme.metric.slot.lane, .h = m.row });
}
}
+ map.window(.stack, shown_at, shown_at + 8 * (@as(u64, slots) -| 1));
+ // A frame's saved rbp is drawn by its span: its arc only in a step that touches it.
+ var arcs: rows.Arcs = .{};
+ for (pointers.items) |p_| {
+ const word, const saved = p_;
+ if (saved and !(now.writeAge(word.addr, 8) == 0 or now.wasRead(word.addr, 8))) continue;
+ hexdump.pointerArcs(&arcs, now, word.addr, word.y, at_rows.items, 8, .{ top - m.pad, box.h - m.pad }, false);
+ }
+ arcs.draw(v, theme.metric.arc.stack_lanes);
// Where the window is, for a link to a word outside it.
const lane_at = u.at.xf.apply(.{ theme.metric.slot.lane, top });
const row_px = u.at.xf.apply(.{ 0, top + m.row })[1] - lane_at[1];
- ties.stack_window = .{ .first = window[0], .slots = slots, .x = lane_at[0], .top = lane_at[1], .row = row_px };
+ if (!ui.mapping) ties.stack_window = .{ .first = window[0], .slots = slots, .x = lane_at[0], .top = lane_at[1], .row = row_px };
// The travelling tags: both of them at one word share a pin.
var places: [2]f32 = undefined;
for (travel, places[0..travel.len]) |name, *place| {
@@ -465,6 +515,22 @@ pub const Stack = struct {
veiled(u, box, now.veil);
}
+ /// A slot's role as the catalogue writes it: `saved rbx` (dim); a
+ /// local's name (primary, `+8` a word into it); `argc`, `argv[0]`,
+ /// `argv end`, `envp end`, `auxv` (dim). A return address needs none:
+ /// its chain is code, named. `word`: what the slot holds (0 ends argv and envp).
+ fn roleName(u: ui.Ui, role: zt.telescope.Role, word: u64) struct { name: []const u8, local: bool = false } {
+ return switch (role) {
+ .none, .return_address => .{ .name = "" },
+ .saved => |r| .{ .name = u.print("saved {s}", .{r}) },
+ .local => |l| .{ .name = if (l.offset > 0) u.print("{s}+{x}", .{ l.name, @as(u32, @intCast(l.offset)) }) else l.name, .local = true },
+ .argc => .{ .name = "argc" },
+ .argv => |i| .{ .name = if (word == 0) "argv end" else u.print("argv[{d}]", .{i}) },
+ .envp => |i| .{ .name = if (word == 0) "envp end" else u.print("envp[{d}]", .{i}) },
+ .auxv => |i| .{ .name = if (i == 0) "auxv" else "" },
+ };
+ }
+
/// Where `name` goes in a row pin of `others` and it, in the registers' order.
fn pinPlace(u: ui.Ui, others: []const []const u8, name: []const u8) f32 {
const size = theme.size.mono.context;
diff --git a/anim/src/cursor.zig b/anim/src/cursor.zig
index f196fab..6a02948 100644
--- a/anim/src/cursor.zig
+++ b/anim/src/cursor.zig
@@ -596,12 +596,17 @@ 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);
return .{
.level = 1,
- .solid = 1 - glide(std.math.clamp((n.time - n.plan.advance) / s.cool, 0, 1)),
- .in = std.math.clamp(since_strike / s.in, 0, 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),
};
}
@@ -683,8 +688,12 @@ test "a write is armed, strikes, holds, cools with the advance, and leaves after
// Held solid until the mark leaves, then cooled, halfway at the middle.
h = instant(0.89, plan).heat(0, null, 0.59);
try expect(h.solid == 1 and h.in == 1 and h.out == 0);
+ try expect(h.corner == 0);
h = instant(0.90 + s.cool / 2.0, plan).heat(0, null, 0.8);
try std.testing.expectApproxEqAbs(@as(f32, 0.5), h.solid, 1e-3);
+ // The turned corner: none until the cool's last 6 f, then in.
+ try expect(h.corner == 0);
+ try std.testing.expectApproxEqAbs(@as(f32, 0.5), instant(0.90 + s.cool - s.corner / 2.0, plan).heat(0, null, 1).corner, 1e-3);
// At rest, and for the steps after: the ember; then it goes.
const rest = instant(std.math.inf(f32), plan);
try expectEqual(ui.Heat.ember, rest.heat(0, null, std.math.inf(f32)));
diff --git a/anim/src/disasm.zig b/anim/src/disasm.zig
index 6c28516..7f17ed6 100644
--- a/anim/src/disasm.zig
+++ b/anim/src/disasm.zig
@@ -17,6 +17,7 @@ const rows = @import("rows.zig");
const cursors = @import("cursor.zig");
const Recording = @import("Recording.zig");
const ties = @import("ties.zig");
+const map = @import("map.zig");
const context = @import("context.zig");
const Stage = @import("stage.zig").Stage;
const theme = ui.theme;
@@ -157,6 +158,7 @@ pub const Disasm = struct {
break :blk rec.register(at - 1, "rip");
};
+ if (shown.rows.len > 0) map.window(.disasm, shown.rows[0].addr, shown.rows[shown.rows.len - 1].addr);
var last_line: ?u32 = null;
// A source of many lines (SQLite's) has wider numbers, as wide as
// its largest: what is right of them moves right by as much.
@@ -182,6 +184,7 @@ pub const Disasm = struct {
covered -|= 1;
continue;
}
+ map.row(.disasm, row.addr, u, .{ .x = 0, .y = y, .w = box.w, .h = m.row });
const is_pc = row.addr == pc[if (going >= 0.5) 1 else 0];
const was = if (is_pc) null else ran[j];
if (was) |r| lit.trail(c.mark, y, r.k);
diff --git a/anim/src/hexdump.zig b/anim/src/hexdump.zig
index fba212d..f1087ab 100644
--- a/anim/src/hexdump.zig
+++ b/anim/src/hexdump.zig
@@ -147,9 +147,19 @@ pub const View = struct {
/// The dump: `count` rows from `first`, at `x` in `u` (the view's
/// panel), the rows from `y`. The rows of what the drawing draws have
-/// quiet brackets.
+/// quiet brackets; a pointer to another of its rows, an `arc` (full ink
+/// always, with `loud`: a loupe's). `rule`: the panel's top and bottom,
+/// where a stub to a row past the window ends.
pub fn draw(u: ui.Ui, now: cursors.Now, x: f32, y: f32, first: u64, count: usize, of: Of) void {
+ drawArcs(u, now, x, y, first, count, of, false, .{ y - m.pad, y + @as(f32, @floatFromInt(count)) * m.row + m.pad });
+}
+
+pub fn drawArcs(u: ui.Ui, now: cursors.Now, x: f32, y: f32, first: u64, count: usize, of: Of, loud: bool, rule: [2]f32) void {
const v = u.moved(x, 0);
+ var arcs: rows.Arcs = .{};
+ var at_rows: [64]RowAt = undefined;
+ for (at_rows[0..@min(count, at_rows.len)], 0..) |*r, i| r.* = .{ .addr = first + 16 * i, .y = y + @as(f32, @floatFromInt(i)) * m.row };
+ const shown_rows = at_rows[0..@min(count, at_rows.len)];
const moment = now.shown(.memory);
const lead = ui.shared(&.{ first, first + 16 * @as(u64, count -| 1) });
// Room for the addresses, once for the dump: by its widest.
@@ -204,7 +214,9 @@ pub fn draw(u: ui.Ui, now: cursors.Now, x: f32, y: f32, first: u64, count: usize
n += 1;
at += run.len;
}
+ @import("map.zig").row(.view, addr, v, .{ .x = 0, .y = ry, .w = theme.layout.state.w, .h = m.row });
rows.bytesAt(v, ry, addr, &values, &known, runs[0..n], of.region, lead, holds_drawn, moment, shift);
+ for (runs[0..n]) |run| if (run.kind == .pointer and run.len == 8) pointerArcs(&arcs, now, addr + run.first, ry, shown_rows, 16, rule, loud);
const end = reading(v, ry, shift, moment, &values, &known, readings[0..n]);
// The size word of the chunk after: malloc's, a note after the reading.
const last = runs[n - 1];
@@ -213,6 +225,64 @@ pub fn draw(u: ui.Ui, now: cursors.Now, x: f32, y: f32, first: u64, count: usize
v.text(.sans, theme.size.sans.micro, end, rows.baseline(ry) - 1, v.print("malloc's: a chunk of {d}", .{size}), t.faint);
}
}
+ arcs.draw(v, theme.metric.arc.lanes.len);
+}
+
+/// A row of a panel: its first byte's address and its top.
+pub const RowAt = struct { addr: u64, y: f32 };
+
+/// The `arc`s of the pointer at `field` (a word, on the row at `from`)
+/// among `shown` (rows of 16 bytes, or of 8 on the stack): to the row its
+/// target is in, as the step has it. Rewritten: the old arc goes dashed
+/// with the arm, fades from 6 f after the strike as the new one draws at
+/// full ink, and quiets with the cool. Read: full ink while the read is
+/// framed. A target in the same region past the rows shown: a stub to the
+/// panel's rule (`rule`: its top and bottom), only in the step that
+/// touches it. `loud`: full ink always (a loupe's, opened to show them).
+pub fn pointerArcs(arcs: *rows.Arcs, now: cursors.Now, field: u64, from: f32, shown: []const RowAt, size: u64, rule: [2]f32, loud: bool) void {
+ const a = time_arc;
+ const new = (Recording.word(now.moment(), field, 8) catch null) orelse return;
+ const old = (Recording.word(now.before(), field, 8) catch null) orelse new;
+ const written = now.writeAge(field, 8) == 0 and old != new;
+ const read = now.wasRead(field, 8) and !written;
+ const hot = written or read;
+ const full: f32 = if (loud) 1 else if (read) now.reading(.memory, 0) else 0;
+ if (written and now.walking()) {
+ const since = now.since(.memory, now.writeDelay(field, 8));
+ const heat = now.written(field, 8, .memory, 0);
+ const armed = since >= -theme.time.strike.arm;
+ aim(arcs, now, field, old, from, shown, size, rule, .{ .full = full, .dashed = armed, .shows = 1 - std.math.clamp((since - a.after) / a.fade, 0, 1), .hot = true });
+ if (since >= a.after) aim(arcs, now, field, new, from, shown, size, rule, .{ .full = if (loud) 1 else heat.solid, .drawn = cursors.standard(std.math.clamp((since - a.after) / a.draw, 0, 1)), .hot = true });
+ return;
+ }
+ aim(arcs, now, field, if (written and !now.landed(.memory, 0)) old else new, from, shown, size, rule, .{ .full = full, .hot = hot });
+}
+
+const time_arc = theme.time.arc;
+
+/// One arc from the row at `from` to the row of `shown` that holds
+/// `target`; a stub toward the rule for one in the region past them, only
+/// for the step's (`state.hot`).
+fn aim(arcs: *rows.Arcs, now: cursors.Now, field: u64, target: u64, from: f32, shown: []const RowAt, size: u64, rule: [2]f32, state: rows.Arcs.Arc) void {
+ if (target == 0 or shown.len < 2) return;
+ const moment = now.moment();
+ var arc = state;
+ arc.from = from;
+ arc.ink = rows.ink(rows.regionOf(moment, target));
+ for (shown) |r| if (target >= r.addr and target < r.addr + size) {
+ if (r.y == from) return;
+ arc.to = r.y;
+ // A loupe open on both rows carries this arc: the dump withholds it.
+ if (size == 16 and arc.full < 1) for (@import("loupe.zig").holding) |h| if (h) |o| {
+ if (field >= o.lo and field < o.hi and target >= o.lo and target < o.hi) arc.shows *= 1 - o.shows;
+ };
+ return arcs.add(arc);
+ };
+ // Past the rows: a stub, in the step that touches it, when it is the same region's.
+ if (!state.hot or rows.regionOf(moment, target) != rows.regionOf(moment, field) or rows.regionOf(moment, target) == .none) return;
+ arc.stub = true;
+ arc.to = if (target < shown[0].addr) rule[0] else rule[1];
+ arcs.add(arc);
}
/// Whether an allocation the recording has begins just after the word at
@@ -294,6 +364,7 @@ pub fn fielded(v: View, now: cursors.Now, y: f32, of: Fields) void {
}.row;
var ry = y;
var last: ?u64 = null;
+ var at_rows: std.ArrayList(RowAt) = .empty;
for (shown) |r| {
// A stretch left out: one row, three dots and a count.
const gap = if (last) |l| r - l - 1 else r;
@@ -303,9 +374,17 @@ pub fn fielded(v: View, now: cursors.Now, y: f32, of: Fields) void {
}
last = r;
fieldRow(u, now, ry, of.base + 16 * r, moment, of, lead, shift);
+ at_rows.append(u.f.scratch, .{ .addr = of.base + 16 * r, .y = ry }) catch {};
ry += m.row;
}
if (shown[shown.len - 1] < total - 1) more(u, ry, total - 1 - shown[shown.len - 1]);
+ // Its pointers to its own rows: arcs.
+ var arcs: rows.Arcs = .{};
+ if (at_rows.items.len > 1) for (of.fields) |field| if (field.reads == .pointer and field.len == 8) {
+ const addr = of.base + field.at;
+ for (at_rows.items) |r| if (addr >= r.addr and addr < r.addr + 16) pointerArcs(&arcs, now, addr, r.y, at_rows.items, 16, .{ y - m.pad, ry + m.pad }, false);
+ };
+ arcs.draw(u, theme.metric.arc.lanes.len);
}
/// Which of `rs` (rows of fields, the region's last row `last`) a window
diff --git a/anim/src/loupe.zig b/anim/src/loupe.zig
new file mode 100644
index 0000000..99dae71
--- /dev/null
+++ b/anim/src/loupe.zig
@@ -0,0 +1,181 @@
+//! `loupe` (design/README.md, "3. Panels"): the telescope's other form. A
+//! chain says, flat, `rax → 407030 ◂ 12`; a loupe opens the place it points
+//! to: a panel held over the context, lifted (its own surface, the one
+//! shadow there is), with five `bytes` rows round the target, the target
+//! framed bright, its pointers to its own rows as `arc`s at full ink. In
+//! the working frame it hangs from its pointer: its tag's top on the foot
+//! of the pointer's row, its left edge 92 left of the pointer's digits (the
+//! tag's address under them), a bracket under the digits its stem. One
+//! opened from a pointer field of a loupe hangs the same way from that
+//! field, 120 to the right where the stage has room, deeper (its shadow
+//! 20 and 26). Its verbs are `open` and `close`.
+const std = @import("std");
+const sk = @import("sketch");
+const anim = @import("anim");
+const zt = @import("ztrace");
+const ui = @import("ui.zig");
+const rows = @import("rows.zig");
+const cursors = @import("cursor.zig");
+const Recording = @import("Recording.zig");
+const objects = @import("objects.zig");
+const hexdump = @import("hexdump.zig");
+const ties = @import("ties.zig");
+const context = @import("context.zig");
+const Stage = @import("stage.zig").Stage;
+const theme = ui.theme;
+const Rect = ui.Rect;
+const t = theme.color.text;
+const m = theme.metric.context;
+const k = theme.metric.loupe;
+const time = theme.time.loupe;
+
+/// The rows each open loupe shows, and how much it shows: a dump showing
+/// the same rows withholds their arcs while it is open (the loupe carries
+/// them). Set as each draws, read the next frame by the dumps drawn before it.
+/// shortcut: process-wide, a frame behind; two players at once want it on the frame.
+pub var holding: [2]?struct { lo: u64, hi: u64, shows: f32 } = @splat(null);
+
+pub const Loupe = struct {
+ cursor: cursors.Cursor,
+ stage: *const Stage,
+ /// What it opens from: a register, by name; or a pointer field (its
+ /// address) of the loupe it hangs under.
+ from: union(enum) { register: []const u8, field: struct { loupe: *const Loupe, at: u64 } },
+ /// 0 to 1 as it opens (`time.loupe.open`) and as it closes (`close`).
+ opening: anim.Value = undefined,
+ closing: anim.Value = undefined,
+
+ /// `open`: its pointer framed as read; the stem draws and the loupe
+ /// rises with it, its shadow growing; its target's frame lands last.
+ pub fn open(l: *const Loupe, s: *anim.Frame) void {
+ s.play(.{l.opening.to(1)}, .{ .seconds = time.open, .ease = anim.ease.linear });
+ }
+
+ /// `close`: the stem draws back and the loupe sinks, fading as it falls.
+ pub fn close(l: *const Loupe, s: *anim.Frame) void {
+ s.play(.{l.closing.to(1)}, .{ .seconds = time.close, .ease = anim.ease.linear });
+ }
+
+ /// Where it is now (in the working frame's units) and what it shows:
+ /// null while it is shut, or where its pointer is not on screen.
+ const Placed = struct { box: Rect, pointer: Rect, target: u64, first: u64, ink: u24 };
+
+ fn place(l: *const Loupe, u: ui.Ui, now: cursors.Now) ?Placed {
+ const moment = now.moment();
+ var pointer: Rect = undefined;
+ var target: u64 = undefined;
+ var right: f32 = 0;
+ switch (l.from) {
+ .register => |name| {
+ const i = context.index(name) orelse return null;
+ const px = ties.find(.{ .register = i }) orelse return null;
+ const back = u.at.xf.invert();
+ const a = back.apply(.{ px[0], px[1] });
+ const b = back.apply(.{ px[2], px[3] });
+ pointer = .{ .x = a[0], .y = a[1], .w = b[0] - a[0], .h = b[1] - a[1] };
+ const regs = (moment.regs(l.cursor.rec.tid) catch null) orelse return null;
+ target = regs.named(name) orelse return null;
+ },
+ .field => |field| {
+ const parent = field.loupe.place(u, now) orelse return null;
+ const row = @as(f32, @floatFromInt((field.at -| parent.first) / 16));
+ const shift = rows.addressRoom(parent.first + 16 * (k.rows - 1));
+ const at: u8 = @intCast(field.at % 16);
+ pointer = .{ .x = parent.box.x + shift + rows.byteX(at), .y = parent.box.y + m.tag + m.pad + row * m.row, .w = rows.byteX(at + 7) + 24 - rows.byteX(at), .h = m.row };
+ target = (Recording.word(moment, field.at, 8) catch null) orelse return null;
+ right = parent.box.x + 120;
+ },
+ }
+ if (target == 0) return null;
+ // shortcut: it keeps to the stage and does not yet move past the current marks or a changed row; the scene picks a pointer whose loupe covers neither.
+ const stage = theme.canvas.stage;
+ const h = theme.layout.panelH(k.rows);
+ const x = std.math.clamp(@max(pointer.x - k.hang, right), stage.x, stage.x + stage.w - k.width);
+ const y = @min(pointer.y + pointer.h - 1, stage.y + stage.h - h);
+ return .{ .box = .{ .x = x, .y = y, .w = k.width, .h = h }, .pointer = pointer, .target = target, .first = (target & ~@as(u64, 15)) - 16 * (k.rows / 2), .ink = rows.ink(rows.regionOf(moment, target)) };
+ }
+
+ pub fn draw(l: *const Loupe, f: *sk.Frame, placed: anim.Placed) void {
+ const deep = l.from == .field;
+ holding[@intFromBool(deep)] = null;
+ const opened = placed.value(l.opening) * time.open;
+ const closed = placed.value(l.closing);
+ if (opened <= 0 or closed >= 1 or ui.mapping) return;
+ const u: ui.Ui = .{ .f = f, .at = placed };
+ const now = l.cursor.now(placed);
+ const p = l.place(u, now) orelse return;
+ holding[@intFromBool(deep)] = .{ .lo = p.first, .hi = p.first + 16 * k.rows, .shows = std.math.clamp((opened - time.read) / time.rise, 0, 1) * (1 - closed) };
+ // Its pointer framed as read, first.
+ u.read(p.pointer, std.math.clamp(opened / time.read, 0, 1) * (1 - closed));
+ // It rises with the stem: in over 12 f from 8 lower, its shadow growing; it sinks as it closes.
+ const since = opened - time.read;
+ if (since <= 0) return;
+ const rise = std.math.clamp(since / time.rise, 0, 1) * (1 - closed);
+ const lower = (1 - theme.ease(.enter, std.math.clamp(since / time.rise, 0, 1))) * theme.time.caption_rise + closed * theme.time.caption_rise;
+ const grow = cursors.standard(std.math.clamp(since / time.shadow, 0, 1)) * (1 - closed);
+ const off = k.shadow[@intFromBool(deep)];
+ const b = p.box;
+ const v = u.faded(rise).moved(b.x, b.y + lower);
+ v.fill(.{ .x = off[0] * grow, .y = off[1] * grow, .w = b.w, .h = b.h }, theme.color.shade);
+ v.fill(.{ .x = 0, .y = 0, .w = b.w, .h = b.h }, theme.color.lift);
+ v.fill(.{ .x = 0, .y = 0, .w = b.w, .h = m.tag }, theme.color.lift_tag);
+ v.frame(.{ .x = 0, .y = 0, .w = b.w, .h = b.h }, t.dim, theme.stroke.rule);
+ // The tag: the pointer it opens from, and the target in its region's ink; the region and the type.
+ const size = theme.size.mono.context;
+ const base = m.tag - 6;
+ const moment = now.moment();
+ const things = objects.reach(f.scratch, l.cursor.rec, moment, null);
+ const object: ?objects.Object = for (things) |o| {
+ if (o.holds(p.target)) break o;
+ } else null;
+ var x: f32 = m.side;
+ switch (l.from) {
+ .register => |name| {
+ v.text(.mono, size, x, base, name, t.dim);
+ x += v.width(.mono, size, name) + 6;
+ },
+ .field => |field| x = v.address(x, base, field.at, .{ .ink = ui.rgb(rows.ink(rows.regionOf(moment, field.at))) }) + 6,
+ }
+ x = v.arrow(x, m.tag / 2, .points) + 8;
+ _ = v.address(x, base, p.target, .{ .ink = ui.rgb(p.ink) });
+ const region = switch (rows.regionOf(moment, p.target)) {
+ .stack => "stack",
+ .heap => "heap",
+ .code => "code",
+ .data, .rwx => "data",
+ .rodata => "read-only",
+ .none => "",
+ };
+ const note = if (object) |o| v.print("{s} \u{00b7} {s}, {d} bytes", .{ region, if (o.name.len > 0) o.name else "a struct", o.type.record.size }) else region;
+ v.text(.sans, theme.size.sans.micro, b.w - 10 - v.width(.sans, theme.size.sans.micro, note), base, note, t.dim);
+ // Its rows, typed where the recording types them, its own pointers as arcs at full ink.
+ const top = m.tag + m.pad;
+ v.clip(.{ .x = 0, .y = m.tag, .w = b.w, .h = b.h - m.tag });
+ hexdump.drawArcs(v, now, 0, top, p.first, k.rows, .{ .things = things }, true, .{ m.tag, b.h - m.pad });
+ v.unclip();
+ // Its target, framed bright: each field of the struct, or the word.
+ const framed = std.math.clamp((since - time.stem - time.frame) / time.frame, 0, 1);
+ if (framed > 0) {
+ const row_y = top + @as(f32, @floatFromInt((p.target - p.first) / 16)) * m.row;
+ const shift = rows.addressRoom(p.first + 16 * (k.rows - 1));
+ const w = v.faded(framed);
+ if (object) |o| {
+ for (o.type.record.fields) |field| frameRun(w, row_y, shift, o.addr + field.offset - (p.target & ~@as(u64, 15)), field.type.size() orelse 8);
+ } else frameRun(w, row_y, shift, p.target % 16, 8);
+ }
+ // The stem: a bracket under the pointer's digits, lying on the tag, drawn head first.
+ const drawn = cursors.standard(std.math.clamp(since / time.stem, 0, 1)) * (1 - closed);
+ u.faded(@min(rise * 2, 1)).fill(.{ .x = p.pointer.x - 2, .y = p.pointer.y + p.pointer.h - 3, .w = (p.pointer.w + 4) * drawn, .h = k.stem }, p.ink);
+ }
+};
+
+/// `attention` on the bytes `at .. at + len` of a row (from its first
+/// byte, up to its end): a 2-unit bright frame round them.
+fn frameRun(u: ui.Ui, y: f32, shift: f32, at: u64, len: u64) void {
+ if (at >= 16 or len == 0) return;
+ const first: u8 = @intCast(at);
+ const last: u8 = @intCast(@min(at + len, 16) - 1);
+ const x0 = shift + rows.byteX(first) - 4;
+ const x1 = shift + rows.byteX(last) + 28;
+ u.frame(.{ .x = x0 - 3, .y = y - 1, .w = x1 - x0 + 6, .h = m.row + 2 }, theme.mark(.attention).solid, theme.stroke.rule);
+}
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);
+}
diff --git a/anim/src/nodes.zig b/anim/src/nodes.zig
index d5c7613..b4ba951 100644
--- a/anim/src/nodes.zig
+++ b/anim/src/nodes.zig
@@ -76,6 +76,7 @@ pub const Nodes = struct {
const shown = @min(count, (hi - first) / 16);
const v = hexdump.panel(f, placed, g.stage, u.print("the heap, {x} to {x}", .{ first, first + 16 * shown - 1 }), &legend);
if (v.rows > 0) hexdump.draw(v.u, now, 0, m.tag + m.pad, first, @min(shown, v.rows), .{ .things = things });
+ if (v.rows > 0) @import("map.zig").window(.view, first, first + 16 * (@min(shown, v.rows) -| 1));
v.veil(now);
u.clip(.{ .x = 0, .y = 0, .w = box.w, .h = box.h });
}
diff --git a/anim/src/objects.zig b/anim/src/objects.zig
index 0c4f48a..6ee2b4c 100644
--- a/anim/src/objects.zig
+++ b/anim/src/objects.zig
@@ -15,6 +15,8 @@ pub const Object = struct {
slot: ?usize,
/// Its allocation is gone: something still points at freed memory.
freed: bool,
+ /// Its type's name, where the debug info names it (`struct node`).
+ name: []const u8 = "",
pub fn holds(o: Object, addr: u64) bool {
return addr >= o.addr and addr - o.addr < o.type.record.size;
@@ -60,9 +62,14 @@ fn follow(scratch: std.mem.Allocator, rec: *const Recording, m: Recording.Moment
if (t != .record) return;
const addr = (Recording.word(m, at, 8) catch return) orelse return;
if (addr == 0) return;
- for (found.items) |o| if (o.addr == addr) return;
+ const name = if (pointee == .named) pointee.named else "";
+ // Met again through a pointer that names it as C does (`struct node`, not a typedef): that name.
+ for (found.items) |*o| if (o.addr == addr) {
+ if (std.mem.startsWith(u8, name, "struct ") or std.mem.startsWith(u8, name, "union ")) o.name = name;
+ return;
+ };
const live = (m.allocation(addr) catch null) != null;
- found.append(scratch, .{ .addr = addr, .type = t, .slot = slotOf(rec, addr, m), .freed = !live and wasAllocated(rec, addr, m.index) }) catch {};
+ found.append(scratch, .{ .addr = addr, .type = t, .slot = slotOf(rec, addr, m), .freed = !live and wasAllocated(rec, addr, m.index), .name = name }) catch {};
}
/// The place of the allocation at `addr` among every allocation of its
diff --git a/anim/src/root.zig b/anim/src/root.zig
index d68b99c..d8c2c76 100644
--- a/anim/src/root.zig
+++ b/anim/src/root.zig
@@ -44,6 +44,7 @@ const tying = @import("ties.zig");
pub const Ties = tying.Ties;
pub const Place = tying.Place;
pub const Array = @import("array.zig").Array;
+pub const Loupe = @import("loupe.zig").Loupe;
pub const syscalls = @import("syscalls.zig");
pub const Crossing = syscalls.Crossing;
pub const Timeline = syscalls.Timeline;
@@ -206,8 +207,13 @@ pub const Camera = struct {
/// the program column (the whole source in a window, the disassembly at
/// the pc), the ties between them, and the clock. A scene adds its lens in
/// the band (`stage`): a lens is never shown instead of the machine.
+pub const map = @import("map.zig");
+
pub const Context = struct {
stage: *Stage,
+ /// The working frame unfolded (`map.Map`): its panels, on a stage of its
+ /// own; drawn small as the minimap. A lens adds its drawing with `map.add`.
+ map: *map.Map,
clock: anim.Obj,
source: anim.Obj,
disasm: anim.Obj,
@@ -259,8 +265,17 @@ pub fn context(s: *anim.Frame, cursor_: Cursor, options: Context.Options) Contex
const stage = Stage.init(s, options.split);
var at = cursor_;
at.levels.crossings = options.syscalls;
+ // The map first: while it fills the frame or falls to the minimap it is under the panels diving out of it.
+ const whole = s.new(map.Map{ .stage = Stage.init(s, map.split(at.rec, options.split.band.h > 0)), .frame = stage, .t = s.value(map.diving.land + map.diving.still) });
+ whole.obj = s.custom(whole, .{ .x = -640, .y = -360, .scale = ui.scale });
+ whole.add(s, Source{ .cursor = at, .stage = whole.stage });
+ whole.add(s, Disasm{ .cursor = at, .stage = whole.stage });
+ whole.add(s, Registers{ .cursor = at, .stage = whole.stage, .syscalls = options.syscalls, .quiet = options.quiet });
+ whole.add(s, Stack{ .cursor = at, .stage = whole.stage, .above = theme.map.stack_above });
+ whole.add(s, Backtrace{ .cursor = at, .stage = whole.stage });
return .{
.stage = stage,
+ .map = whole,
.cursor = at,
.quiet = options.quiet,
.source = add(s, Source{ .cursor = at, .stage = stage }),
@@ -268,7 +283,7 @@ pub fn context(s: *anim.Frame, cursor_: Cursor, options: Context.Options) Contex
.registers = add(s, Registers{ .cursor = at, .stage = stage, .syscalls = options.syscalls, .quiet = options.quiet }),
.stack = add(s, Stack{ .cursor = at, .stage = stage }),
.backtrace = add(s, Backtrace{ .cursor = at, .stage = stage, .lens = options.backtrace }),
- .clock = add(s, Clock{ .cursor = at }),
+ .clock = add(s, Clock{ .cursor = at, .map = whole }),
};
}
@@ -295,6 +310,17 @@ pub fn crossing(s: *anim.Frame, options: Crossing) anim.Obj {
pub fn timeline(s: *anim.Frame, options: Timeline) anim.Obj {
return add(s, options);
}
+/// A `loupe`, shut until its `open`: add it after the panels and the lens,
+/// a deeper one after the loupe it hangs from, and the ties after them.
+pub fn loupe(s: *anim.Frame, options: Loupe) *Loupe {
+ var l = options;
+ l.opening = s.value(0);
+ l.closing = s.value(0);
+ const made = s.new(l);
+ const o = s.custom(made, .{ .x = -640, .y = -360, .scale = ui.scale });
+ s.play(.{o.fadeIn()}, .{ .seconds = 0 });
+ return made;
+}
pub fn caption(s: *anim.Frame, text: []const u8) anim.Obj {
return add(s, Caption{ .text = text });
}
@@ -323,6 +349,8 @@ test {
_ = calls;
_ = @import("nodes.zig");
_ = @import("array.zig");
+ _ = @import("loupe.zig");
+ _ = map;
_ = @import("syscalls.zig");
_ = objects;
_ = words;
diff --git a/anim/src/rows.zig b/anim/src/rows.zig
index 8446b52..83064a6 100644
--- a/anim/src/rows.zig
+++ b/anim/src/rows.zig
@@ -44,8 +44,8 @@ pub fn baseline(y: f32) f32 {
pub const Marks = struct {
/// The first hop: a register (or a word) written: armed, struck, held.
first: ui.Heat = .none,
- /// A later hop, the memory under a pointer that did not change: its
- /// tick sits before that hop alone.
+ /// A later hop, the memory under a pointer that did not change: the
+ /// turned corner sits on that hop alone.
changed: ?usize = null,
changed_heat: ui.Heat = .ember,
/// A hop read, and how much its frame shows.
@@ -56,9 +56,6 @@ pub const Marks = struct {
extend: ?f32 = null,
/// The first hop's `lead` (a column of addresses).
lead: usize = 0,
- /// Where the first hop's tick goes, left of its digits: 9 after a
- /// name, 5 after an arrow.
- tick: f32 = 9,
};
/// Where a chain's hops were drawn: x and width of each one's digits.
@@ -105,9 +102,9 @@ pub fn chain(u: ui.Ui, x: f32, y: f32, moment: Recording.Moment, value: u64, roo
const marked: Rect = .{ .x = at, .y = y, .w = w, .h = row_h };
var face_ink: ui.Ink = .{ .ink = ui.rgb(if (pointer) ink(link.region) else t.primary) };
if (i == 0) {
- if (v.written(marked, marks.first, marks.tick)) |struck| face_ink = struck;
+ if (v.written(marked, marks.first)) |struck| face_ink = struck;
} else if (marks.changed == i) {
- if (v.written(marked, marks.changed_heat, 5)) |struck| face_ink = struck;
+ if (v.written(marked, marks.changed_heat)) |struck| face_ink = struck;
}
if (marks.read == i) v.read(marked, marks.read_shows);
if (pointer) {
@@ -166,11 +163,12 @@ pub fn reg(u: ui.Ui, y: f32, w: f32, name: []const u8, moment: Recording.Moment,
pub const Flag = struct { name: []const u8, bit: u6 };
pub const flags = [_]Flag{ .{ .name = "CF", .bit = 0 }, .{ .name = "PF", .bit = 2 }, .{ .name = "AF", .bit = 4 }, .{ .name = "ZF", .bit = 6 }, .{ .name = "SF", .bit = 7 }, .{ .name = "IF", .bit = 9 }, .{ .name = "DF", .bit = 10 }, .{ .name = "OF", .bit = 11 } };
-/// `reg` rip: gold plaque on the name, ember across, the address in
+/// `reg` rip: gold plaque on the name, the wash across, the address in
/// code's ink and its name; never struck. At its right end the `flags`,
/// eight names on a pitch of 42: set, upper case on a chip, bold, bright;
-/// clear, lower case, dim; changed, a tick (`changed`: a bit per flag, and
-/// how held). The value of eflags is not drawn: the names are the value.
+/// clear, lower case, dim; changed, a turned corner (`changed`: a bit per
+/// flag, and how much of the corner shows). The value of eflags is not
+/// drawn: the names are the value.
pub fn rip(u: ui.Ui, y: f32, w: f32, moment: Recording.Moment, pc: u64, eflags: u64, changed: u64, held: f32, fire: f32) void {
const gold = theme.mark(.current);
u.current(.{ .x = theme.stroke.rule, .y = y, .w = w - 2 * theme.stroke.rule, .h = row_h }, theme.metric.plaque.rip, fire);
@@ -180,26 +178,37 @@ pub fn rip(u: ui.Ui, y: f32, w: f32, moment: Recording.Moment, pc: u64, eflags:
_ = chain(u, m.chain_x, y, moment, pc, x - 16, .{});
for (flags) |flag| {
const set = eflags >> flag.bit & 1 != 0;
- if (changed >> flag.bit & 1 != 0 and held > 0) u.fill(.{ .x = x - 7, .y = y + 3, .w = m.tick, .h = row_h - 6 }, ui.mix(gold.ember, theme.mark(.write).solid, held));
if (set) {
u.chip(.{ .x = x, .y = y + 2, .w = fl.chip[0], .h = fl.chip[1] });
u.text(.mono_bold, size, x + 4, baseline(y), flag.name, t.bright);
} else u.text(.mono, size, x + 4, baseline(y), u.print("{c}{c}", .{ std.ascii.toLower(flag.name[0]), std.ascii.toLower(flag.name[1]) }), ui.mix(t.dim, gold.ember, 0.2));
+ if (changed >> flag.bit & 1 != 0) u.corner(x, y + 2, m.corner, held);
x += fl.pitch;
}
}
-/// `slot`: a word of the stack: a lane 112 wide for `row` pins (`pins`,
-/// the registers that hold its address), then its chain from 122,
-/// beginning with the slot's own address in stack ink with `lead`, room
-/// to 136 from the right edge `w` (the `call` spans').
-pub fn slot(u: ui.Ui, y: f32, w: f32, moment: Recording.Moment, addr: u64, pins: []const []const u8, pin_shows: f32, marks: Marks) Hops {
+/// `slot`: a word of the stack: a lane to 112 for `row` pins (`pins`, the
+/// registers that hold its address); its offset from rsp (`from_rsp`
+/// bytes), hex, faint, ranged right to 172 (`+18`, `-8` above rsp); its
+/// address in stack ink with `lead` from 184; then its chain, beginning
+/// with the word it holds; and its `role` (what the word is, where the
+/// recording knows it: `saved rbp` dim, a `local`'s name primary), ranged right where the room ends
+/// (136 from the right edge `w`: the `call` spans'), the chain ending a
+/// character before it.
+pub fn slot(u: ui.Ui, y: f32, w: f32, moment: Recording.Moment, addr: u64, from_rsp: i64, pins: []const []const u8, pin_shows: f32, marks: Marks, role: []const u8, local: bool) Hops {
const s = theme.metric.slot;
if (pins.len > 0 and pin_shows > 0) u.faded(pin_shows).pinRow(s.lane, y, pins, theme.color.region.stack);
+ offset(u, y, from_rsp);
var lead = marks;
lead.first = .none;
const base = baseline(y);
- const end = u.address(s.chain, base, addr, .{ .ink = ui.rgb(theme.color.region.stack), .lead = marks.lead });
+ const end = u.address(s.address, base, addr, .{ .ink = ui.rgb(theme.color.region.stack), .lead = marks.lead });
+ var room = w - s.room;
+ if (role.len > 0) {
+ const rx = room - u.width(.mono, size, role);
+ u.text(.mono, size, rx, base, role, if (local) t.primary else t.dim);
+ room = rx - adv;
+ }
const held = (Recording.word(moment, addr, 8) catch null) orelse {
_ = u.arrow(end, y + row_h / 2, .points);
u.unknown(.{ .x = end + m.arrow_w, .y = y, .w = 24, .h = row_h });
@@ -210,17 +219,23 @@ pub fn slot(u: ui.Ui, y: f32, w: f32, moment: Recording.Moment, addr: u64, pins:
const at = u.arrow(end, y + row_h / 2, if (pointer) .points else .holds);
lead.lead = 0;
lead.first = marks.first;
- lead.tick = 5;
- return chain(u, at, y, moment, held, w - s.room, lead);
+ return chain(u, at, y, moment, held, room, lead);
+}
+
+/// A slot's offset from rsp, `from_rsp` bytes: hex, faint, ranged right to 172.
+fn offset(u: ui.Ui, y: f32, from_rsp: i64) void {
+ const text = if (from_rsp < 0) u.print("-{x}", .{@as(u64, @intCast(-from_rsp))}) else u.print("+{x}", .{@as(u64, @intCast(from_rsp))});
+ u.text(.mono, size, theme.metric.slot.offset - u.width(.mono, size, text), baseline(y), text, t.faint);
}
/// `slot` `free`: a word above rsp the stack has not reached, shown while
-/// the window is held for the camera: its address at 60%, its word
-/// faint, no chain, no pin.
-pub fn free(u: ui.Ui, y: f32, moment: Recording.Moment, addr: u64, lead: usize) void {
+/// the window is held for the camera: its offset, its address at 60%, its
+/// word faint, no chain, no pin.
+pub fn free(u: ui.Ui, y: f32, moment: Recording.Moment, addr: u64, from_rsp: i64, lead: usize) void {
const s = theme.metric.slot;
const base = baseline(y);
- const end = u.address(s.chain, base, addr, .{ .ink = ui.mix(theme.color.region.stack, theme.color.page, theme.metric.context.lead_alpha), .lead = lead });
+ offset(u, y, from_rsp);
+ const end = u.address(s.address, base, addr, .{ .ink = ui.mix(theme.color.region.stack, theme.color.page, theme.metric.context.lead_alpha), .lead = lead });
const word = (Recording.word(moment, addr, 8) catch null) orelse return u.unknown(.{ .x = end + m.arrow_w, .y = y, .w = 24, .h = row_h });
u.text(.mono, size, end + m.arrow_w, base, u.print("{x}", .{word}), t.faint);
}
@@ -347,8 +362,8 @@ pub fn bytes(u: ui.Ui, y: f32, addr: u64, values: *const [16]u8, known: *const [
}
/// How far right of their column a dump's bytes (and its reading) go to
-/// leave its widest address room: none for one of eight digits, 42 for a
-/// stack address's twelve. A dump sets it once, so its rows keep one column.
+/// leave its widest address room: none up to seven digits, 58 for a stack
+/// address's twelve. A dump sets it once, so its rows keep one column.
pub fn addressRoom(addr: u64) f32 {
const b = theme.metric.bytes;
return @max(b.address + @as(f32, @floatFromInt(ui.digits(addr))) * adv + adv - b.first, 0);
@@ -367,22 +382,22 @@ pub fn bytesAt(at: ui.Ui, y: f32, addr: u64, values: *const [16]u8, known: *cons
const r: Rect = .{ .x = x0, .y = y + 1, .w = x1 - x0, .h = row_h - 2 };
const field = run.kind == .number or run.kind == .pointer or run.kind == .text;
if (field) u.fill(r, theme.color.raised);
- // Marks per run, never per byte: struck (the paper solid), read (a
- // frame 3 out), held (a tick in the gap at the run's left).
+ // Marks per run, never per byte: struck (the softened paper, the
+ // digits bold and bright), read (a frame 3 out), held (a turned
+ // corner at the run's top left).
var face: ui.Face = .mono;
var struck_ink: ?ui.Color = null;
const h = run.heat;
- const held = h.level * (1 - (if (h.level >= 1) h.solid * h.in else 0));
- if (held > 0) u.fill(.{ .x = x0 - 7, .y = y + 3, .w = m.tick, .h = row_h - 6 }, ui.mix(theme.color.page, theme.mark(.write).solid, held));
if (h.arm > 0) u.faded(h.arm).frame(.{ .x = x0 - 3, .y = y - 1, .w = x1 - x0 + 6, .h = row_h + 2 }, theme.mark(.write).solid, 2);
const solid = if (h.level >= 1) h.solid * h.in else 0;
if (solid > 0) {
- u.fill(.{ .x = r.x - h.out, .y = r.y - h.out, .w = r.w + 2 * h.out, .h = r.h + 2 * h.out }, ui.mix(theme.color.raised, theme.mark(.write).solid, solid));
+ u.fill(.{ .x = r.x - h.out, .y = r.y - h.out, .w = r.w + 2 * h.out, .h = r.h + 2 * h.out }, ui.mix(theme.color.raised, theme.color.struck, solid));
if (solid >= 0.5) {
face = .mono_bold;
- struck_ink = ui.rgb(theme.mark(.write).on_solid);
+ struck_ink = ui.rgb(t.bright);
}
}
+ u.corner(x0, y + 2, m.corner, h.level * h.corner);
if (run.read > 0) u.faded(run.read).frame(.{ .x = x0 - 3, .y = y - 1, .w = x1 - x0 + 6, .h = row_h + 2 }, theme.mark(.read).solid, 2);
// A little-endian word: the bytes above its highest non-zero one are its padding.
var top: usize = 0;
@@ -416,3 +431,100 @@ pub fn byteX(i: u8) f32 {
const b = theme.metric.bytes;
return b.first + @as(f32, @floatFromInt(i)) * b.pitch + @as(f32, if (i >= 8) b.middle else 0);
}
+
+/// `arc`s: the pointers of a panel of rows whose targets are rows of the
+/// same panel, each drawn from its row along a lane at the panel's left
+/// edge to the target's row, head first. A panel adds the pointers it
+/// draws (`add`), then `draw`s them over its rows.
+pub const Arcs = struct {
+ items: [32]Arc = undefined,
+ n: usize = 0,
+
+ pub const Arc = struct {
+ /// The rows' tops: the pointer's, its target's (or the panel's
+ /// rule, for a `stub`: a target in the same region past the window).
+ from: f32 = 0,
+ to: f32 = 0,
+ ink: u24 = 0,
+ /// 0 standing, 1 full ink: the step writes or reads the pointer.
+ full: f32 = 0,
+ /// How much of it is drawn from its pointer (it draws head first),
+ /// and how much shows (it fades).
+ drawn: f32 = 1,
+ shows: f32 = 1,
+ dashed: bool = false,
+ stub: bool = false,
+ /// The step's: its lane comes first.
+ hot: bool = false,
+ };
+
+ pub fn add(a: *Arcs, arc: Arc) void {
+ if (a.n == a.items.len or arc.shows <= 0 or arc.from == arc.to) return;
+ a.items[a.n] = arc;
+ a.n += 1;
+ }
+
+ /// Nested spans take separate lanes, the longest outermost; spans that
+ /// do not overlap share one; past `lanes` the step's come first, then
+ /// the shorter, and the rest are only read.
+ pub fn draw(a: *Arcs, u: ui.Ui, lanes: usize) void {
+ const k = theme.metric.arc;
+ const Span = struct { lo: f32, hi: f32, y0: f32, y1: f32, i: usize };
+ var spans: [32]Span = undefined;
+ for (a.items[0..a.n], spans[0..a.n], 0..) |arc, *sp, i| {
+ const up = arc.to < arc.from;
+ const high: f32 = k.high;
+ const low: f32 = k.low;
+ sp.y0 = arc.from + if (up) high else low;
+ sp.y1 = if (arc.stub) arc.to else arc.to + if (up) low else high;
+ sp.lo = @min(sp.y0, sp.y1);
+ sp.hi = @max(sp.y0, sp.y1);
+ sp.i = i;
+ }
+ // The longest first, so it takes the outermost lane free.
+ std.mem.sort(Span, spans[0..a.n], {}, struct {
+ fn longer(_: void, x: Span, y: Span) bool {
+ return x.hi - x.lo > y.hi - y.lo;
+ }
+ }.longer);
+ var taken: [3][32][2]f32 = undefined;
+ var counts = [3]usize{ 0, 0, 0 };
+ var lane_of: [32]?usize = @splat(null);
+ for ([_]bool{ true, false }) |hot| for (spans[0..a.n]) |sp| {
+ if (a.items[sp.i].hot != hot) continue;
+ lane_of[sp.i] = for (0..@min(lanes, 3)) |l| {
+ const clear = for (taken[l][0..counts[l]]) |t2| {
+ if (!(sp.hi < t2[0] or sp.lo > t2[1])) break false;
+ } else true;
+ if (clear) {
+ taken[l][counts[l]] = .{ sp.lo, sp.hi };
+ counts[l] += 1;
+ break l;
+ }
+ } else null;
+ };
+ for (spans[0..a.n]) |sp| {
+ const arc = a.items[sp.i];
+ const lane = lane_of[sp.i] orelse continue;
+ const x = k.lanes[lane];
+ const shade = ui.mix(arc.ink, theme.color.page, k.standing * (1 - std.math.clamp(arc.full, 0, 1)));
+ const v = u.faded(arc.shows);
+ if (arc.stub) {
+ v.route(&.{ .{ k.out, sp.y0 }, .{ x, sp.y0 }, .{ x, sp.y1 } }, shade, .{ .width = k.width, .head = k.head, .radius = k.radius, .progress = arc.drawn, .dashed = arc.dashed });
+ } else v.route(&.{ .{ k.out, sp.y0 }, .{ x, sp.y0 }, .{ x, sp.y1 }, .{ k.in, sp.y1 } }, shade, .{ .width = k.width, .head = k.head, .radius = k.radius, .progress = arc.drawn, .dashed = arc.dashed });
+ }
+ }
+};
+
+test "arcs of a chain share a lane; nested ones take the next" {
+ var a: Arcs = .{};
+ // 1004090 -> 1004070 -> 1004050, rows 4, 2, 0: one lane.
+ a.add(.{ .from = 96, .to = 48, .ink = 0 });
+ a.add(.{ .from = 48, .to = 0, .ink = 0 });
+ // One across both: the outer lane.
+ a.add(.{ .from = 120, .to = 0, .ink = 0 });
+ const k = theme.metric.arc;
+ const up_from = 96 + k.high;
+ const into = 48 + k.low;
+ try std.testing.expect(into < up_from and 48 + k.high < into);
+}
diff --git a/anim/src/source.zig b/anim/src/source.zig
index 301e8cd..58b9df0 100644
--- a/anim/src/source.zig
+++ b/anim/src/source.zig
@@ -14,6 +14,7 @@ const ui = @import("ui.zig");
const rows = @import("rows.zig");
const context = @import("context.zig");
const ties = @import("ties.zig");
+const map = @import("map.zig");
const cursors = @import("cursor.zig");
const Stage = @import("stage.zig").Stage;
const Cursor = cursors.Cursor;
@@ -100,9 +101,11 @@ pub const Source = struct {
found += 1;
}
+ map.window(.source, shown_first, @min(shown_first + fit - 1, rec.line_count));
var line = @max(from, 1);
while (line <= last) : (line += 1) {
const y = top + (@as(f32, @floatFromInt(line)) - first) * m.row;
+ map.row(.source, line, u, .{ .x = 0, .y = y, .w = box.w, .h = m.row });
const span = text.lines[line - 1];
const k = std.mem.indexOfScalar(u32, trail[0..found], line);
const on = shows >= 0.5 and line == mark_line;
diff --git a/anim/src/theme.zig b/anim/src/theme.zig
index 846014f..5a85f50 100644
--- a/anim/src/theme.zig
+++ b/anim/src/theme.zig
@@ -44,6 +44,31 @@ pub const canvas = struct {
pub const caption_max_width = 1400;
};
+/// The map (design/README.md, "The map and the minimap"): the working
+/// frame unfolded on a stage of 3840 by 2160 at the context's type size,
+/// four columns of 880; the working frame's windows outlined on it (2 in
+/// `dim`, 4 out). The minimap: the map at a twentieth in the caption
+/// band's right end, under the clock's, whose count moves left of it.
+pub const map = struct {
+ pub const width = 3840;
+ pub const height = 2160;
+ pub const stage: Rect = .{ .x = 112, .y = 96, .w = 3616, .h = 1688 };
+ pub const columns = [4]f32{ 112, 1024, 1936, 2848 };
+ pub const column = 880;
+ pub const outline = 2;
+ pub const outline_out = 4;
+ /// The stack's column: from this many words above rsp (the 128 bytes the recording keeps under it).
+ pub const stack_above = 16;
+ pub const disasm_rows = 69;
+ pub const memory_rows = 32;
+};
+pub const minimap = struct {
+ pub const box: Rect = .{ .x = 1664, .y = 912, .w = 192, .h = 108 };
+ pub const scale = 1.0 / 20.0;
+ /// The clock's count, ranged right here.
+ pub const count_end = 1648;
+};
+
/// Left edge of column `i` (0 to 11).
pub fn colX(i: u8) f32 {
return @floatFromInt(@as(u32, canvas.margin_x) + @as(u32, i) * (canvas.column + canvas.gutter));
@@ -219,6 +244,19 @@ pub const color = struct {
/// A node's pointer half.
pub const well: u24 = 0x101a48;
+ /// The current row's band: bright a tenth of the way over the page,
+ /// opaque. Gold is kept for the plaque, the pc's marker, rip's name,
+ /// the thread and the trail (design/README.md, `mark`).
+ pub const wash: u24 = 0x212644;
+ /// A loupe's surface and its tag: lifted off the page, the one
+ /// elevation in the frame; and its shadow, the one shadow there is.
+ pub const lift: u24 = 0x121c52;
+ pub const lift_tag: u24 = 0x22317a;
+ pub const shade: u24 = 0x02061a;
+ /// A strike's paper: vermilion 70% over the page, its digits bold and
+ /// bright. The arm, the turned corner and a projection stay `mark(.write).solid`.
+ pub const struck: u24 = 0xb54f42;
+
/// Drawn over everything that is not the subject, to dim it: for a
/// beat, and (deeper) under the camera.
pub const veil: u24 = page;
@@ -256,9 +294,9 @@ pub const Role = enum {
/// How a role is drawn. No two roles share a form, so none is told by hue alone.
pub const Form = enum {
- /// A solid plaque on the thing's label and its ember across the row.
+ /// A solid plaque on the thing's label and a white wash across the row.
plaque,
- /// A solid fill with ink letters, cooling to its ember and a solid bar along the bottom.
+ /// A softened fill with bright bold letters, cooling to nothing and a turned corner.
fill,
/// A frame, with its ember inside.
frame,
@@ -293,7 +331,7 @@ pub const Mark = struct {
pub fn mark(role: Role) Mark {
const t = color.text;
return switch (role) {
- .current => .{ .solid = 0xe8c46a, .ember = 0x4a3d1c, .on_solid = t.ink, .form = .plaque },
+ .current => .{ .solid = 0xe8c46a, .ember = color.wash, .on_solid = t.ink, .form = .plaque },
.write => .{ .solid = 0xff6a4a, .ember = 0x5a2218, .on_solid = t.ink, .form = .fill },
.read => .{ .solid = 0x6fd6e6, .ember = 0x1c4652, .on_solid = t.ink, .form = .frame },
// Its colour is the region's it points into (`color.region`); this is heap's.
@@ -473,8 +511,9 @@ pub const metric = struct {
/// highest non-zero one, this far.
pub const lead_alpha = 0.6;
pub const pad_alpha = 0.45;
- /// `held`: a tick 4 wide, the row less 6 tall, at the value's left.
- pub const tick = 4;
+ /// `held`: a turned corner, a vermilion right triangle this long on
+ /// its sides at the value's top left (4 left of its digits, 2 down).
+ pub const corner = 9;
/// `read`: a 2-unit frame, 6 out at the sides.
pub const read_frame = 2;
/// `struck`: solid 5 wider each side; its edges pulse out 3.
@@ -499,10 +538,12 @@ pub const metric = struct {
pub const annotation = 564;
};
- /// `bytes`: a hexdump row, from its panel's left edge (the band's right half).
+ /// `bytes`: a hexdump row, from its panel's left edge (the band's right
+ /// half): its `arc` lanes, the quiet bracket at 24, the address at 34,
+ /// the bytes 12 after it and at 132 at least.
pub const bytes = struct {
- pub const bracket = 7;
- pub const address = 18;
+ pub const bracket = 24;
+ pub const address = 34;
pub const first = 132;
/// Two digits in 24 units on a pitch of 30, 12 more after the eighth.
pub const pitch = 30;
@@ -510,12 +551,15 @@ pub const metric = struct {
pub const reading = 640;
};
- /// `slot`: a lane for `row` pins, the chain from 122, room to 136 from
- /// the right edge (which belongs to the `call` spans, 14 in).
+ /// `slot`: two `arc` lanes, a lane for `row` pins from 16 to 112, the offset from rsp
+ /// ranged right to 172, the address from 184 and its chain after it,
+ /// room to 136 from the right edge (which belongs to the `call` spans,
+ /// 14 in), a role ranged right where the room ends.
pub const slot = struct {
- pub const lane = 10;
+ pub const lane = 16;
pub const lane_end = 112;
- pub const chain = 122;
+ pub const offset = 172;
+ pub const address = 184;
pub const room = 136;
pub const span = 14;
};
@@ -573,6 +617,38 @@ pub const metric = struct {
pub const caller = [2]f32{ 64, 28 };
};
+ /// `arc`: a pointer to a row of its own panel, along a lane at the
+ /// panel's left edge (4, 10, 16 in a dump or a loupe; 4, 10 on the
+ /// stack), 2 wide, corners of 4; out of its row at 21, into the
+ /// target's at 22 with a head 7 by 8; going up it leaves its row 9 down
+ /// and arrives 15 down (going down, 15 and 9). Standing, its ink 60%
+ /// toward the page.
+ pub const arc = struct {
+ pub const lanes = [3]f32{ 4, 10, 16 };
+ pub const stack_lanes = 2;
+ pub const out = 21;
+ pub const in = 22;
+ pub const head = [2]f32{ 7, 8 };
+ pub const high = 9;
+ pub const low = 15;
+ pub const width = 2;
+ pub const radius = 4;
+ pub const standing = 0.6;
+ };
+
+ /// `loupe`: 880 wide, five rows round its target in the working frame;
+ /// it hangs from its pointer, its left edge 92 left of the pointer's
+ /// digits, its tag's top on the foot of the pointer's row; its shadow
+ /// 12 right and 16 down (20 and 26 for one opened from a loupe); its
+ /// stem a bracket 4 high under the pointer's digits.
+ pub const loupe = struct {
+ pub const width = 880;
+ pub const rows = 5;
+ pub const hang = 92;
+ pub const shadow = [2][2]f32{ .{ 12, 16 }, .{ 20, 26 } };
+ pub const stem = 4;
+ };
+
/// A lens's lanes: projections 4 under its tag, links 8 above its bottom edge.
pub const lens = struct {
pub const top_lane = 4;
@@ -589,8 +665,9 @@ pub const metric = struct {
pub const projection_radius = 6;
};
+ /// `held` on a lens's cell: the turned corner at its top left.
+ pub const corner_cell = 12;
/// A lens's cell, as the first pass drew them.
- pub const ember_bar = 4;
pub const pointer_frame_outset = 6;
pub const elision_h = 24;
pub const cell = [2]f32{ 96, 84 };
@@ -721,6 +798,8 @@ pub const time = struct {
pub const pulse = 0.20;
pub const hold = 0.50;
pub const cool = 0.40;
+ /// `held`'s turned corner fades in over the cool's last 6 f.
+ pub const corner = 0.10;
pub const ember_steps = 3;
pub const ember_seconds = 4.0;
pub const out = 0.60;
@@ -791,6 +870,31 @@ pub const time = struct {
pub const far = 0.50;
pub const out = 0.30;
};
+ /// `arc`: a pointer rewritten: from 6 f after the strike the old arc
+ /// fades (`fade`) as the new draws (`draw`), at full ink; it quiets
+ /// with the cool (`quiet`); a lane change glides (`lane`).
+ pub const arc = struct {
+ pub const after = 0.10;
+ pub const draw = 0.20;
+ pub const fade = 0.20;
+ pub const quiet = 0.40;
+ pub const lane = 0.20;
+ };
+ /// `open`, a loupe: its pointer framed as read (`read`); the stem
+ /// draws and the loupe rises with it (`stem`; it fades in over `rise`
+ /// from 8 units lower, its shadow grows over `shadow`); its target's
+ /// bright frame lands `frame` after. `close`: the stem draws back and
+ /// the loupe sinks, fading as it falls 8 units, over `close`.
+ pub const loupe = struct {
+ pub const read = 0.10;
+ pub const stem = 0.30;
+ pub const rise = 0.20;
+ pub const shadow = 0.30;
+ pub const frame = 0.10;
+ pub const close = 0.20;
+ /// From its first frame to its target's frame landed: read, stem, a frame's wait and the frame.
+ pub const open = 0.60;
+ };
/// `travel`, for a pin: it sets off `after` the strike that moved it;
/// in a drawing it takes `node` to the next node or cell, `nodes` to
/// one farther; in the stack's lane `row` to the next row and
@@ -921,16 +1025,19 @@ test "every mark stands off the page, and letters read on it" {
const m = mark(r);
try expect(contrast(m.solid, color.page) >= 4.5);
try expect(contrast(m.on_solid, m.solid) >= 4.5);
- // A role with a quiet form: text reads on it, and it is not the page.
+ // A role with a quiet form: text reads on it, and it is not the page
+ // (the current row's wash is the quietest: 1.2 on the page).
if (m.ember != m.solid and r != .freed and r != .fault) {
try expect(contrast(color.text.primary, m.ember) >= 7);
- try expect(contrast(m.ember, color.page) >= 1.4);
+ try expect(contrast(m.ember, color.page) >= @as(f64, if (r == .current) 1.2 else 1.4));
}
}
// The strokes that carry meaning on their own.
for ([_]Role{ .current, .write, .read, .link, .allocated }) |r|
try expect(contrast(mark(r).solid, color.page) >= 6.5);
try expect(contrast(color.text.ink, mark(.write).solid) >= 6.5);
+ // A strike's bright digits on its softened paper.
+ try expect(contrast(color.text.bright, color.struck) >= 4.5);
}
test "no two roles are drawn the same way" {
@@ -984,7 +1091,7 @@ test "easing runs from 0 to 1 without turning back" {
test "durations are whole frames" {
const t = time;
- for ([_]f32{ t.snap, t.quick, t.step, t.step_per_row, t.step_max, t.move, t.travel, t.layout, t.camera, t.camera_far, t.fire, t.cascade, t.read_value, t.read_more, t.rest, t.strike.arm, t.strike.in, t.strike.pulse, t.strike.hold, t.strike.cool, t.strike.out, t.read.out, t.current_jump, t.flight.lift, t.flight.near, t.flight.second, t.veil, t.link.after, t.link.pin_out, t.link.in, t.link.in_far, t.link.settle, t.link.out, t.project.bracket, t.project.draw, t.project.out, t.establish_rise, t.relayout, t.relayout_fade, t.continue_wave, t.badge_after, t.pin.after, t.pin.node, t.pin.nodes, t.pin.row, t.pin.step_per_row, t.pin.row_max, t.pin.in, t.pin.out, t.pin.names, t.caption_in, t.caption_out, t.caption_gap, t.walk, t.run, t.sprint, t.phrase_rest, t.before_cut }) |d| {
+ for ([_]f32{ t.snap, t.quick, t.step, t.step_per_row, t.step_max, t.move, t.travel, t.layout, t.camera, t.camera_far, t.fire, t.cascade, t.read_value, t.read_more, t.rest, t.strike.arm, t.strike.in, t.strike.pulse, t.strike.hold, t.strike.cool, t.strike.corner, t.strike.out, t.loupe.read, t.loupe.stem, t.loupe.rise, t.loupe.shadow, t.loupe.frame, t.loupe.close, t.loupe.open, t.arc.after, t.arc.draw, t.arc.fade, t.arc.quiet, t.arc.lane, t.read.out, t.current_jump, t.flight.lift, t.flight.near, t.flight.second, t.veil, t.link.after, t.link.pin_out, t.link.in, t.link.in_far, t.link.settle, t.link.out, t.project.bracket, t.project.draw, t.project.out, t.establish_rise, t.relayout, t.relayout_fade, t.continue_wave, t.badge_after, t.pin.after, t.pin.node, t.pin.nodes, t.pin.row, t.pin.step_per_row, t.pin.row_max, t.pin.in, t.pin.out, t.pin.names, t.caption_in, t.caption_out, t.caption_gap, t.walk, t.run, t.sprint, t.phrase_rest, t.before_cut }) |d| {
const frames = d * t.fps;
try expect(@abs(frames - @round(frames)) < 1e-3);
}
diff --git a/anim/src/ties.zig b/anim/src/ties.zig
index 0df8e34..323cecf 100644
--- a/anim/src/ties.zig
+++ b/anim/src/ties.zig
@@ -85,14 +85,15 @@ var said: usize = 0;
/// `r` (in `u`'s units) is where `place` is, this frame.
pub fn anchor(u: ui.Ui, place: Place, r: Rect) void {
- if (said == table.len) return;
+ if (said == table.len or ui.mapping) 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 });
table[said] = .{ .key = place.key(), .box = .{ a[0], a[1], b[0], b[1] } };
said += 1;
}
-fn find(place: Place) ?[4]f32 {
+/// Where `place` is this frame, in canvas pixels (left, top, right, bottom), if a panel said.
+pub fn find(place: Place) ?[4]f32 {
for (table[0..said]) |entry| if (entry.key == place.key()) return entry.box;
return null;
}
@@ -175,6 +176,8 @@ pub const Ties = struct {
defer said = 0;
defer stack_window = null;
const now = g.cursor.now(at);
+ // Diving or surfacing, the panels are on their way: no ties.
+ for (@import("context.zig").zoomed) |z| if (z != null) return;
// In canvas pixels, `k` of them a unit: places come from panels anywhere.
var raw: ui.Ui = .{ .f = f, .at = at };
raw.at.xf = .identity;
@@ -317,7 +320,7 @@ pub const Ties = struct {
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;
// 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;
+ const bx = if (stacked) run[0] - (theme.metric.slot.address - 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 cx = (over[0] + over[2]) / 2;
const y = (run[1] + run[3]) / 2;
diff --git a/anim/src/ui.zig b/anim/src/ui.zig
index 6120bbb..cf12914 100644
--- a/anim/src/ui.zig
+++ b/anim/src/ui.zig
@@ -16,6 +16,19 @@ pub const Vec = sk.math.Vec;
/// Scene units to a design unit: `anim` frames 1280 by 720.
pub const scale = 1280.0 / @as(comptime_float, theme.canvas.width);
+/// While the map's panels draw (`map.zig`): they publish their rows, not
+/// their windows and places. `strokes`: the minimap, a twentieth of the
+/// map, where text is a stroke a pixel high in its ink at 45% toward the
+/// page and the marks are blocks a few pixels across.
+/// shortcut: process-wide, for one scene drawn at a time; two players at once want it on the frame.
+pub var mapping = false;
+pub var strokes = false;
+/// How much of a panel's tag and rules shows: less while it dives out of
+/// its window on the map (`context.at` sets it for the panel it hands out).
+pub var chrome: f32 = 1;
+/// The minimap's pixel, in the map's units.
+const px = 20;
+
/// Adds `data` (a component: something with `draw(f, at)`) to the scene,
/// its origin at design `x, y` and its units the design's. Like any
/// object, it shows once something plays it in (`fadeIn`).
@@ -145,8 +158,9 @@ pub const Ui = struct {
u.f.fill(sk.Rect{ .x = x, .y = y, .w = @round(b[0]) - x, .h = @round(b[1]) - y }, u.at.faded(rgb(c)));
}
- /// A stroke `w` wide, wholly inside `r`.
- pub fn frame(u: Ui, r: Rect, c: anytype, w: f32) void {
+ /// A stroke `w` wide, wholly inside `r` (on the minimap, a pixel at least).
+ pub fn frame(u: Ui, r: Rect, c: anytype, w_: f32) void {
+ const w = if (strokes) @max(w_, px) else w_;
u.fill(.{ .x = r.x, .y = r.y, .w = r.w, .h = w }, c);
u.fill(.{ .x = r.x, .y = r.y + r.h - w, .w = r.w, .h = w }, c);
u.fill(.{ .x = r.x, .y = r.y + w, .w = w, .h = r.h - 2 * w }, c);
@@ -164,6 +178,11 @@ pub const Ui = struct {
/// which is the font's ascent above the baseline.
pub fn text(u: Ui, face: Face, size: f32, x: f32, baseline: f32, bytes: []const u8, c: anytype) void {
if (bytes.len == 0) return;
+ if (strokes) {
+ // A run of text: a stroke as long as it is, through its capitals' middle.
+ if (std.mem.indexOfNone(u8, bytes, " ") == null) return;
+ return u.fill(.{ .x = x, .y = baseline - 0.36 * size - px / 2, .w = u.width(face, size, bytes), .h = px }, mix(c, theme.color.page, 0.45));
+ }
// Go's ascent is 0.945 em; JetBrains Mono's, which every monospace is set in, 1.02.
const at = u.point(x, baseline - @as(f32, if (set(face, size) == face) 0.945 else 1.02) * size);
const drawn = size / 13.0 * u.at.scale;
@@ -206,7 +225,7 @@ pub const Ui = struct {
/// from frame to frame: with CANIM_PANELS in the environment, every
/// frame tells where on the canvas (as fractions of it) `r` is.
pub fn region(u: Ui, name: []const u8, r: Rect) void {
- if (u.f.host.env("CANIM_PANELS") == null) return;
+ if (mapping or u.f.host.env("CANIM_PANELS") == null) return;
const a = u.point(r.x, r.y);
const b = u.point(r.x + r.w, r.y + r.h);
const w = @floor(u.f.in.window_width);
@@ -224,6 +243,12 @@ pub const Ui = struct {
/// window `w` by `h` at the origin. Returns the body.
pub fn panel(u: Ui, w: f32, h: f32, title: []const u8, options: struct { focus: bool = false, note: []const u8 = "", legend: []const Legend = &.{} }) Rect {
u.region(title, .{ .x = 0, .y = 0, .w = w, .h = h });
+ if (chrome < 1) return u.faded(chrome).panelChrome(w, h, title, options.focus, options.note, options.legend);
+ return u.panelChrome(w, h, title, options.focus, options.note, options.legend);
+ }
+
+ fn panelChrome(u: Ui, w: f32, h: f32, title: []const u8, focus: bool, note: []const u8, legend: []const Legend) Rect {
+ const options = .{ .focus = focus, .note = note, .legend = legend };
const m = theme.metric.context;
const t = theme.color.text;
u.fill(.{ .x = 0, .y = 0, .w = w, .h = m.tag }, theme.color.raised);
@@ -319,6 +344,7 @@ pub const Ui = struct {
/// on the row whose middle is `mid`, faint: grammar, not data.
/// Returns where it ends.
pub fn arrow(u: Ui, x: f32, mid: f32, kind: Arrow) f32 {
+ if (strokes) return x + theme.metric.context.arrow_w + @as(f32, if (kind == .more) 24 else 0);
const c = theme.color.text.faint;
const head = theme.metric.context.arrow_head;
const pen = u.at.pen(.{ .fill = rgb(c) });
@@ -340,53 +366,72 @@ pub const Ui = struct {
/// `mark` on a value in the context (mono 20), as hot as `h` says:
/// `armed` (a 2-unit vermilion frame round the old value), `struck`
- /// (solid vermilion behind it, 5 wider each side, its edges pulsing out
- /// 3; the digits bold, in ink: the ink this returns), then cooled to
- /// nothing, and `held`: a tick 4 wide at the value's left for three
- /// steps. A held change never sits under the digits it marks, whose
- /// ink is where they point. `r` is the digits: x, width, and the row;
- /// the tick is `tick` units left of them (5 after a chain's arrow).
- pub fn written(u: Ui, r: Rect, h: Heat, tick: f32) ?Ink {
+ /// (the softened vermilion paper behind it, 5 wider each side, its
+ /// edges pulsing out 3; the digits bold and bright: the ink this
+ /// returns), then cooled to nothing, and `held`: a turned corner at
+ /// the value's top left for three steps, fading in over the cool's
+ /// last 6 f. A held change never sits under the digits it marks, whose
+ /// ink is where they point. `r` is the digits: x, width, and the row.
+ pub fn written(u: Ui, r: Rect, h: Heat) ?Ink {
const w = theme.mark(.write);
const m = theme.metric.context;
- // The tick is what a strike cools to: not under it while it is solid.
- const held = h.level * (1 - (if (h.level >= 1) h.solid * h.in else 0));
- if (held > 0) u.fill(.{ .x = r.x - tick, .y = r.y + 3, .w = m.tick, .h = r.h - 6 }, mix(theme.color.page, w.solid, held));
+ if (strokes) {
+ // On the minimap: a strike a block 3 pixels across at the value's start; held, a pixel.
+ const mid = r.y + r.h / 2;
+ if (h.level >= 1 and h.solid * h.in > 0) {
+ u.faded(h.solid * h.in).fill(.{ .x = r.x, .y = mid - 1.5 * px, .w = 3 * px, .h = 3 * px }, w.solid);
+ } else if (h.level * h.corner > 0) u.faded(h.level * h.corner).fill(.{ .x = r.x, .y = mid - px / 2, .w = px, .h = px }, w.solid);
+ return null;
+ }
if (h.arm > 0) u.faded(h.arm).frame(.{ .x = r.x - 6, .y = r.y, .w = r.w + 12, .h = r.h }, w.solid, m.read_frame);
const solid = if (h.level >= 1) h.solid * h.in else 0;
- if (solid <= 0) return null;
- const out = @min(h.out, m.pulse_outset);
- u.fill(.{ .x = r.x - m.strike_out - out, .y = r.y + 1 - out, .w = r.w + 2 * m.strike_out + 2 * out, .h = r.h - 2 + 2 * out }, mix(theme.color.page, w.solid, solid));
- return if (solid >= 0.5) Ink.all(w.on_solid, .mono_bold) else null;
+ if (solid > 0) {
+ const out = @min(h.out, m.pulse_outset);
+ u.fill(.{ .x = r.x - m.strike_out - out, .y = r.y + 1 - out, .w = r.w + 2 * m.strike_out + 2 * out, .h = r.h - 2 + 2 * out }, mix(theme.color.page, theme.color.struck, solid));
+ }
+ u.corner(r.x - 4, r.y + 2, m.corner, h.level * h.corner);
+ return if (solid >= 0.5) Ink.all(theme.color.text.bright, .mono_bold) else null;
+ }
+
+ /// `held`: a turned corner, a vermilion right triangle `side` on its
+ /// sides, its right angle at `x, y` (a value's or a cell's top left),
+ /// `shows` of it.
+ pub fn corner(u: Ui, x: f32, y: f32, side: f32, shows: f32) void {
+ if (shows <= 0) return;
+ sk.draw.polygon(u.f, &.{ .{ x, y }, .{ x + side, y }, .{ x, y + side } }, u.faded(shows).at.pen(.{ .fill = rgb(theme.mark(.write).solid) }));
}
/// `read` in the context: a 2-unit frame in read's colour, 6 out at
/// the sides, no fill; `shows` of it (0 to 1: it fades in and out).
pub fn read(u: Ui, r: Rect, shows: f32) void {
+ if (strokes) {
+ if (shows > 0) u.faded(shows).frame(.{ .x = r.x, .y = r.y + r.h / 2 - 1.5 * px, .w = 3 * px, .h = 3 * px }, theme.mark(.read).solid, px);
+ return;
+ }
if (shows > 0) u.faded(shows).frame(.{ .x = r.x - 6, .y = r.y, .w = r.w + 12, .h = r.h }, theme.mark(.read).solid, theme.metric.context.read_frame);
}
- /// `mark` on a lens's cell: armed (a 3-unit frame), struck (a solid
- /// fill coming in, its edges out 4 and back), cooled to its ember and
- /// a vermilion bar 4 high along its bottom edge (`held`), `ground`
- /// (null: nothing) once that has gone. Returns what to set its digits in.
+ /// `mark` on a lens's cell: armed (a 3-unit frame), struck (the
+ /// softened vermilion coming in, its edges out 4 and back, the digits
+ /// bold and bright), cooled to its ground (`ground`; null: nothing),
+ /// and `held`: a turned corner 12 on its sides at its top left. Returns
+ /// what to set its digits in.
pub fn cellWritten(u: Ui, r: Rect, h: Heat, ground: ?u24) Ink {
- const w = theme.mark(.write);
const under: Color = rgb(ground orelse theme.color.page);
- // No mark under coloured digits but a strike's: it cools to its ground, and the bar stays.
- var body = if (h.level < 1) under else mix(under, w.solid, h.solid);
+ // No mark under coloured digits but a strike's: it cools to its ground, and the corner stays.
+ var body = if (h.level < 1) under else mix(under, theme.color.struck, h.solid);
// Timing: a strike arrives over a tenth of a second, not in a frame.
if (h.in < 1) body = mix(under, body, h.in);
if (h.level > 0 or ground != null) u.fill(.{ .x = r.x - h.out, .y = r.y - h.out, .w = r.w + 2 * h.out, .h = r.h + 2 * h.out }, body);
- const bar = theme.metric.ember_bar;
- if (h.level > 0 and (h.in >= 1 or h.from == .ember)) u.fill(.{ .x = r.x, .y = r.y + r.h - bar, .w = r.w, .h = bar }, mix(under, w.solid, @min(h.level, 1)));
- if (h.arm > 0) u.faded(h.arm).frame(r, w.solid, theme.stroke.line);
- // Bold ink on the solid. The face changes at the middle of the
- // cool, where the colour is moving fastest and hides it.
+ u.corner(r.x, r.y, theme.metric.corner_cell, h.level * h.corner);
+ if (h.arm > 0) u.faded(h.arm).frame(r, theme.mark(.write).solid, theme.stroke.line);
+ // Bold and bright on the paper. The face changes at the middle of
+ // the cool, where the colour is moving fastest and hides it.
const heat = h.solid * h.in;
if (h.level < 1 or heat <= 0) return .{};
const cooled: Ink = .{};
- return .{ .ink = mix(cooled.ink, w.on_solid, heat), .lead = mix(cooled.lead, w.on_solid, heat), .face = if (heat >= 0.5) .mono_bold else .mono };
+ const t = theme.color.text;
+ return .{ .ink = mix(cooled.ink, t.bright, heat), .lead = mix(cooled.lead, t.bright, heat), .face = if (heat >= 0.5) .mono_bold else .mono };
}
/// `read` on a lens's cell: a 2-unit frame 2 out, no fill.
@@ -394,10 +439,12 @@ pub const Ui = struct {
if (shows > 0) u.faded(shows).frame(.{ .x = r.x - 2, .y = r.y - 2, .w = r.w + 4, .h = r.h + 4 }, theme.mark(.read).solid, theme.stroke.rule);
}
- /// `current` on a row: gold ember across `r`, and a gold plaque `w`
- /// wide at its left, its edges out `out` units (the fire).
+ /// `current` on a row: the white wash across `r`, and a gold plaque
+ /// `w` wide at its left, its edges out `out` units (the fire).
pub fn current(u: Ui, r: Rect, w: f32, out: f32) void {
const gold = theme.mark(.current);
+ // On the minimap: a gold stroke across the column, 2 pixels high.
+ if (strokes) return u.fill(.{ .x = r.x, .y = r.y + r.h / 2 - px, .w = r.w, .h = 2 * px }, gold.solid);
u.fill(r, gold.ember);
u.fill(.{ .x = r.x - out, .y = r.y - out, .w = w + 2 * out, .h = r.h + 2 * out }, gold.solid);
}
@@ -683,9 +730,15 @@ pub const Heat = struct {
arm: f32 = 0,
/// The strike's pulse: how far out its edges are, in units.
out: f32 = 0,
+ /// 0 to 1: how much of `held`'s turned corner shows (of `level`): none
+ /// while struck, in over the cool's last 6 f; the old one's going as a
+ /// strike comes in over it.
+ corner: f32 = 1,
pub const none: Heat = .{};
pub const ember: Heat = .{ .level = 1 };
+ /// Struck, at rest: the paper solid, no corner yet.
+ pub const struck: Heat = .{ .level = 1, .solid = 1, .corner = 0 };
};
test "the camera zooms by ratio and ends where it was sent" {
diff --git a/anim/src/words.zig b/anim/src/words.zig
index bec5116..134b42f 100644
--- a/anim/src/words.zig
+++ b/anim/src/words.zig
@@ -22,6 +22,8 @@ const t = theme.color.text;
pub const Clock = struct {
cursor: Cursor,
box: Rect = .{ .x = theme.canvas.stage.x, .y = theme.canvas.clock_y - 12, .w = theme.canvas.stage.w, .h = 24 },
+ /// The map, drawn small under the clock's right end: the minimap.
+ map: ?*const @import("map.zig").Map = null,
pub fn draw(k: *const Clock, f: *sk.Frame, at: anim.Placed) void {
const u = fixed(f, at, 0);
@@ -58,13 +60,15 @@ pub const Clock = struct {
const size = theme.size.mono.context;
const base = c.clock_y + 28;
const count = u.print("moment {d} of {d}", .{ counted -| now.way[0], now.way[1] -| now.way[0] });
- const count_x = stage.x + stage.w - u.width(.mono, size, count);
+ // Ranged right left of the minimap.
+ const count_x = (if (k.map != null) theme.minimap.count_end else stage.x + stage.w) - u.width(.mono, size, count);
u.text(.mono, size, count_x, base, count, t.faint);
// Secondary action: the pace, said quietly. It only fades.
if (now.hurried > 0) {
const steps = if (now.of > 0) u.print("step {d} of {d}", .{ now.count, now.of }) else u.print("step {d}", .{now.count});
u.faded(now.hurried).text(.mono, size, count_x - u.width(.mono, size, steps) - 3 * ui.advance(size), base, steps, t.dim);
}
+ if (k.map) |m| if (m.settled(at)) @import("map.zig").minimap(m, f, at);
}
};
@@ -195,7 +199,7 @@ pub const Legend = struct {
u.label(.mono_bold, size, r, .center, "rip", theme.mark(.current).on_solid);
},
.written, .changed => for ([_]Rect{ half, other }, [_][]const u8{ "2a", "00" }) |cell, digits| {
- const ink = u.cellWritten(cell, if (entry == .written) .{ .level = 1, .solid = 1 } else .ember, theme.color.raised);
+ const ink = u.cellWritten(cell, if (entry == .written) .struck else .ember, theme.color.raised);
u.label(ink.face, size, cell, .center, digits, ink.ink);
},
.read => for ([_]Rect{ half, other }, [_][]const u8{ "2a", "00" }) |cell, digits| {
diff --git a/anim/test/gallery.script b/anim/test/gallery.script
index 01a31d5..fb71697 100644
--- a/anim/test/gallery.script
+++ b/anim/test/gallery.script
@@ -27,3 +27,7 @@ console set t 8.4
screenshot {dir}/none.png
frames 1
expect-same-screenshot {dir}/none.png test/gallery/none.png 24 0 0 1920 1040
+console set t 10.8
+screenshot {dir}/loupe.png
+frames 1
+expect-same-screenshot {dir}/loupe.png test/gallery/loupe.png 24 0 0 1920 1040
diff --git a/anim/test/gallery/atoms.png b/anim/test/gallery/atoms.png
index 819bc91..18b3e8e 100644
--- a/anim/test/gallery/atoms.png
+++ b/anim/test/gallery/atoms.png
Binary files differ
diff --git a/anim/test/gallery/loupe.png b/anim/test/gallery/loupe.png
new file mode 100644
index 0000000..5a8ca4f
--- /dev/null
+++ b/anim/test/gallery/loupe.png
Binary files differ
diff --git a/anim/test/gallery/none.png b/anim/test/gallery/none.png
index 3e8eb0a..79ce087 100644
--- a/anim/test/gallery/none.png
+++ b/anim/test/gallery/none.png
Binary files differ
diff --git a/anim/test/gallery/rest.png b/anim/test/gallery/rest.png
index 25c982e..7cc1ce7 100644
--- a/anim/test/gallery/rest.png
+++ b/anim/test/gallery/rest.png
Binary files differ
diff --git a/anim/test/gallery/rows.png b/anim/test/gallery/rows.png
index cd2cb3e..4ad0d6c 100644
--- a/anim/test/gallery/rows.png
+++ b/anim/test/gallery/rows.png
Binary files differ
diff --git a/anim/test/gallery/step.png b/anim/test/gallery/step.png
index 682a317..2c07506 100644
--- a/anim/test/gallery/step.png
+++ b/anim/test/gallery/step.png
Binary files differ
diff --git a/anim/test/gallery/subject.png b/anim/test/gallery/subject.png
index 6f3230b..0c6d40e 100644
--- a/anim/test/gallery/subject.png
+++ b/anim/test/gallery/subject.png
Binary files differ
diff --git a/anim/tools/chart.py b/anim/tools/chart.py
index 168060a..4f58312 100644
--- a/anim/tools/chart.py
+++ b/anim/tools/chart.py
@@ -34,8 +34,10 @@ def split(drawing, view, source, disasm, slots, backtrace=0):
return out
# The clock is under the name the instrument gives to words that are not panels ("head"):
-# its progress line moves with every step and must not count as a panel starting.
-words = {"head": (0, 888, W, 46), "caption": (0, 934, W, 146)}
+# its progress line moves with every step and must not count as a panel starting. The
+# minimap (1664 to 1856 by 912 to 1020) is in no region: it mirrors the panels' changes,
+# and the instrument has no name for a secondary region.
+words = {"head": (0, 888, 1656, 46), "caption": (0, 934, 1656, 146)}
none, beside, subject = split(0, 0, 14, 17, 8, 4), split(152, 152, 8, 17, 8), split(296, 200, 10, 9, 6)
motion.REGIONS.update({
"fib": {**subject, **words},