summaryrefslogtreecommitdiff
path: root/design/motion.md
diff options
context:
space:
mode:
authorGabriel Schneider <[email protected]>2026-11-11 02:11:12 -0300
committerGabriel Schneider <[email protected]>2026-11-11 02:11:12 -0300
commit64e64c74be6a3e46abeae8a30dd42efff91aaf91 (patch)
treee41a4eaa789eca76f07e8c06dca1fbf0caf6c2fa /design/motion.md
parentc3d9f7ba5effd615374b1359ad98ecf801559f83 (diff)
downloadcomputeranim-64e64c74be6a3e46abeae8a30dd42efff91aaf91.tar.gz
computeranim-64e64c74be6a3e46abeae8a30dd42efff91aaf91.zip
design: what the second review found, placed
A caller keeps one row after its call and its callee sits under it; opening and closing fade what is given up before what is kept glides, and nothing changes in one frame. A system call stepped over is three parts: the registers set, the crossing from the call row, the stores after it. A loupe never covers a row its step changes, hangs over the stack when opened from a view, and closes with the advance. A run draws no strikes and no arcs, and a caption never names what the pace veils; the heap scene's captions have landing and leaving frames. The map's boxes are as tall as their rows. The veiled map travels into the minimap. The motion instrument checks captions and fires POP on any one-frame change after stillness. Co-Authored-By: Claude Fable 5.2 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNCKgYCGiANnEwcEQxa
Diffstat (limited to 'design/motion.md')
-rw-r--r--design/motion.md156
1 files changed, 112 insertions, 44 deletions
diff --git a/design/motion.md b/design/motion.md
index 16a3e28..afc3b08 100644
--- a/design/motion.md
+++ b/design/motion.md
@@ -313,7 +313,7 @@ catalogue's [caption](README.md#clock-and-caption).
| | A step | What is drawn | Veiled | When |
| --- | --- | --- | --- | --- |
| walk | by content, 0.8 to 3.0 s | everything | nothing | the first time anything happens, and whatever the narration names |
-| run | 0.30 s | the mark glides (8 f); cards, nodes, arrows and pins ease (8 f); values get embers, never solids; no fire, arm, pulse, link or projection | registers, stack, disassembly | a pattern seen once in full; 24 steps at most |
+| run | 0.30 s | the mark glides (8 f); cards, nodes, arrows and pins ease (8 f); no strikes, no held corners, no arcs drawing: values change in place under 8 f crossfades, and what the run changed is shown settled when it ends (its arcs fade in, 8 f); no fire, arm, pulse, link or projection | registers, stack, disassembly | a pattern seen once in full; 24 steps at most |
| sprint | 0.067 s or less | the drawing grows; embers; the mark and the pins only at phrase ends; the clock sweeps | the same, and the source and the band's view | everything longer |
A run keeps its bars: 12 f of rest at each phrase end. A sprint does not.
@@ -505,8 +505,40 @@ under the call row instead.
The result is stored only after the kernel has given it: `returns` has
the value before rax, and rax before anything the caller does with it,
-never the other way round. A call with no work (`open`, `close`) goes from
-84 straight to `returns` at 108 and is 3.6 s; one that moves bytes, 4.9 s.
+never the other way round. A call with no bytes to move (`open`,
+`close`) does not wait: it goes from 84 straight to `returns` at 108, the
+answer climbs 108 to 132 in its full 24 f, and the step is 3.6 s; one that
+moves bytes, 4.9 s. The band's view changes with the arguments' framing
+(18 to 36): the last call's bytes out (12 f), this one's in (12 f), a path
+or a buffer handed in whole, a buffer the kernel fills as dots until 144
+to 176; it is cleared when the log takes the row.
+
+**Stepped over.** A line that calls libc's wrapper (`n = read(f, buf,
+32);`) is three parts, in the order the machine does them; the kernel's
+window opens under the call row, and the wrapper is not shown.
+
+| Frames | |
+| --- | --- |
+| 0 to 12 | 1, the instructions before the call, a cascade: fire on the line |
+| 6 to 18, 18 · 12 to 24, 24 · 18 to 30, 30 | arm, strike: the argument registers, in the order the instructions set them (`rdx` 32, `rsi` buf, `rdi` 3), the disassembly's trail following them |
+| 36 to 48, 48 | a store the line makes before the call, in memory's slot |
+| 60 to 72 | the plaque advances onto the call row; the line stays current |
+| 72 to 90 | 2, the crossing, on the chart above with its frame 18 at 72 (no second fire): the arguments framed with their new values, 6 f apart, the view's bytes changing with them |
+| 102 to 126 | the crossing lane, from the call row's plaque down to the kernel's window under it |
+| 120 to 132 | the window opens and its call fades in |
+| 198 to 230 | the bytes the kernel fills strike, 2 f apart (none for `open` or `close`, whose `returns` comes at 162) |
+| 234 | `returns` |
+| 240 to 264 | the answer climbs to the call row |
+| 264 | rax struck as it lands |
+| 270, 276 | `rcx`, `r11` |
+| 270 to 282, 282 | 3, the stores after the call, in their own slot 18 f after rax: `n`, `[rbp - 0x34]` |
+| 282 to 318 | hold |
+| 318 to 330 | advance; the kernel's window draws back up into the lane |
+| 330 to 354 | rest: 5.9 s for `read`; `close`, with no bytes and no store, 4.5 s |
+
+The order is the claim: no register is framed as an argument before the
+instruction that set it has struck, the kernel shows nothing before the
+lane lands, and nothing the caller does with the result moves before rax.
A step that makes more than one call (a continue through a library) is
not a crossing: the log takes the calls, oldest first, 2 f apart, and the
step is a `continue`. Nothing on the kernel's side changes before frame
@@ -523,20 +555,23 @@ step is a `continue`. Nothing on the kernel's side changes before frame
| 12 to 24, 24 | arm, strike: `rsp`. Its pin stays on the window's top row |
| 30 to 48 | the stack's rows slide down one slot, `glide` |
| 48 to 60, 60 | arm, strike: the return address, `main+48` |
-| 66 to 78 | the caller's window closes round its call row: the rows it gives up fade out |
-| 72 to 84 | the call row's gold plaque becomes the waiting ring, and the remaining three rows glide to the window's top (18 f to 90) |
-| 84 to 102 | the call lane draws down from the ring, head first, `standard` |
-| 96 to 108 | the callee's head fades in rising 8 units as the lane reaches it |
-| 102 to 126 | its rows fade in top down, 2 f apart, 12 f each |
-| 126 to 138 | the advance: the plaque lands on the callee's first row; the source's line goes `waiting` (6 f) where the callee has no source |
-| 138 to 162 | rest |
+| 66 to 78 | the caller's window closes round its call row, first move: the rows it gives up fade out (those after its return row, and from its top as many as the callee needs) |
+| 78 to 96 | second move: the rows it keeps glide up to their places, `glide`, where they move at all. Never both at once: a row gliding over a row fading is text on text |
+| 84 to 96 | the call row's gold plaque becomes the waiting ring |
+| 96 to 114 | the call lane draws down from the ring, head first, `standard`, to the head's place directly under the return row |
+| 108 to 120 | the callee's head fades in rising 8 units as the lane reaches it |
+| 114 to 138 | its rows fade in top down, 2 f apart, 12 f each |
+| 138 to 150 | the advance: the plaque lands on the callee's first row; the source's line goes `waiting` (6 f) where the callee has no source |
+| 150 to 174 | rest: 2.9 s |
The stub's `jmp`, the next step, reads its GOT slot: fire (0 to 12); the
slot framed as read in memory, on the map or in a loupe, and the row's
-annotation names it (18 to 24); the stub's window shrinks to that row,
-`pass` (24 to 42, `glide`); the lane runs on from it to `open`'s head (42
-to 60); `open`'s head and rows come in as above (54 to 84); advance (84
-to 96). A jump is not a call: nothing is pushed.
+annotation names it (18 to 24); the stub's other rows fade (24 to 36),
+then its `jmp` row, `pass`, glides to its place (36 to 54, `glide`); the
+lane runs on from it to `open`'s head (54 to 72); `open`'s head and rows
+come in as above (66 to 96); the stack span's name and the source's tag
+crossfade to `open`'s (84 to 96, 12 f, never in a frame); advance (96 to
+108). A jump is not a call: nothing is pushed.
**Back up.** `open`'s `ret`:
@@ -547,9 +582,10 @@ to 96). A jump is not a call: nothing is pushed.
| 24 to 36, 36 | arm, strike: `rsp` |
| 48 to 72 | `open`'s window closes, its rows fading bottom up, 2 f apart, 12 f each, its head last; the stub's `pass` row with it: the return skips the stub |
| 72 to 84 | the lane draws back up into the ring |
-| 84 to 102 | main's window grows back to the panel, `glide`; the rows it gave up fade in |
-| 102 to 114 | the ring becomes a trail bar, the call's annotation takes its result (`= 3`, 6 f), and the plaque lands on the row after the call; the source's line from `waiting` to `current` |
-| 114 to 138 | rest |
+| 84 to 102 | main's window opens in the reverse of its closing, first move: the rows it kept glide back down to their places, `glide` |
+| 102 to 114 | second move: the rows it gave up fade in |
+| 114 to 126 | the ring becomes a trail bar, the call's annotation takes its result (`= 3`, 6 f), and the plaque lands on the row after the call; the source's line from `waiting` to `current`, its tag crossfading |
+| 126 to 150 | rest: 2.5 s |
A descent is a beat the narration names, and each of its steps is walked:
at a run the windows open and close in 8 f with no lane drawn, and at a
@@ -699,7 +735,8 @@ own path and its own scale.
| before | the map is still and the caption that says where we are going has been up 60 f |
| 0 to 6 | the windows' outlines go bright |
| 6 to 24 | the rest of the map takes the veil, 50% |
-| 24 to 96 | each window travels to its panel's place, its scale from a half to whole on its logarithm, `glide`; the panels set off 6 f apart in the frame's reading order (drawing, view, source, registers, disassembly, stack), each drawn over the ones before, so that two crossing are seen to cross. The map, veiled, travels the same 72 f to the minimap's place, its scale from a half to a twentieth |
+| 24 to 96 | each window travels to its panel's place, its scale from a half to whole on its logarithm, `glide`; the panels set off 6 f apart in the frame's reading order (drawing, view, source, registers, disassembly, stack), each drawn over the ones before, so that two crossing are seen to cross. The map, veiled, travels the same 72 f to the minimap's rect (1664, 912, 192 by 108), its scale from a half to a twentieth on its logarithm: continuously, never dropped or hidden on the way |
+| 90 to 96 | as it lands, the falling map crossfades into the minimap's own drawing |
| 72 to 96 | the drawing crossfades from the map's size to the frame's within its box |
| 84 to 102 | the working frame's tags, rules and lanes fade in; the veil on the map lifts as it lands; the clock's count fades in |
| 102 to 138 | still |
@@ -725,8 +762,8 @@ What is played on the map, and why:
In the working frame the minimap is secondary action: its windows glide
with their scrolls (24 f), a mark no window shows `flash`es on it once
-(12 f) as it is struck, and nothing on it ever starts on a primary
-onset's frame. A scene that opens on the map establishes it (0 to 48), its
+(12 f) as it is struck, and every change on it starts 6 f after the
+primary onset it follows, never on that frame. A scene that opens on the map establishes it (0 to 48), its
first caption at 60, dives at 150, and has its first step by 300 (5.0 s).
### Captions, opening, closing
@@ -926,38 +963,67 @@ heads. On the minimap those three are where they sit; a strike on one no
window shows (the top's header moving down when the tcache is cut from
it) flashes there.
-**The beats.**
+**The beats.** Each `free` and the `malloc` that takes the head back are
+walked; pushes 2 and 3 are a run, which draws no strikes and no arcs and
+shows what it did settled at its end.
-| | Stop | Caption | What plays |
+| | Stop | Pace | What plays |
| --- | --- | --- | --- |
-| 1 | the first `malloc` returns | malloc(16) cut a chunk of 0x20 off the top: its size word, 0x21, then the 16 bytes rax points at. The top is 0x20 smaller. | `fire`; `rax` struck and its `link` to the pin under a node that fades in on the program's row (12 f); the view's rows come in unmarked, the region being new (a dump that comes in after its step has no marks); the `bin` dashed, `dummy tcache`: before the first free the thread's tcache is a read-only dummy in libc |
-| 2 | after `push(9)` | Three pushes, three chunks in a row, each with P: the chunk before it is in use. The list's next pointers are arcs in the bytes. | the second and third pushes at a run (8 f eases), each `next` written struck and its `arc` drawn (12 f), quieting with the cool; `head`'s pin travels to the newest node (30 f) |
-| 3 | the first `free` returns | free gave 9's chunk to the tcache, malloc's bin for 0x20. Its first word is the link now: 405, which is NULL, safe-linked. | the chart below: the tcache made, the loupe opened on it, the node travelling down to the bin's row |
-| 4 | the second `free` returns | The second chains to the first: 405455 is 405050 xor 405, the chunk's own address shifted 12. The arc is the pointer it hides. | the same, shorter: the chunk's first word struck (`55 54 40`) and its key; in the loupe `entries[0]` struck on its low byte alone (`50` to `30`) and `num_slots[0]` 15 to 14; the free node glides one place right (18 f) and the new one lands at the bin's head; the `arc` from 405030 to 405050 draws at full ink (12 f); the count 1 to 2 |
-| 5 | the next `malloc` returns | malloc(16) took the bin's head, 405030: the tcache points at 405050 again, the key is wiped, and the old link stays until push writes. | `rax` struck and its link to the node; the key's 8 bytes struck to zero; the loupe's head and count struck back; the arc from 405030 fades (the word is the program's again, read as `bytes`, `the old link`); the node travels up to the program's row (36 f) and its halves turn back, the old link faint in the value's half; the count 2 to 1. Then `push` writes 25 and its `next`, and that arc draws |
+| 1 | the first `malloc` returns | walked | `fire`; `rax` struck and its `link` to the pin under the chunk, which fades in on the program's row, in neither list: no arrow into it (12 f); the view's rows come in unmarked, the region being new; the `bin` dashed, `dummy tcache` (before the first free the thread's tcache is a read-only dummy in libc). Then push's three stores walked: the value struck, `next` struck, `head`'s pin travelling to the node |
+| 2 | after `push(9)` | a run | pushes 2 and 3, twelve steps at a run: the nodes come in (8 f), values change in place unmarked; when the run ends the arcs of the `next`s fade in standing (8 f) |
+| 3 | the first `free` returns | walked | the chart below: the tcache made, the loupe opened on it, the node travelling to the bin's row |
+| 4 | the second `free` returns | walked | the chunk's first word struck on its three bytes that changed (`55 54 40`), then the key; the loupe opens again in the idea's slot (36 f) and in it `entries[0]` struck on its low byte alone (`50` to `30`), `num_slots[0]` 15 to 14 on its one byte; the free node glides one place right (18 f) and the new one travels down to the bin's head; the `arc` from 405030 to 405050 draws at full ink (12 f); the count 1 to 2, struck |
+| 5 | the next `malloc` returns | walked | `rax` struck and its link; the key's 8 bytes struck to zero; the loupe opens again, its head and count struck back on the bytes that changed; the arc from 405030 fades (the word is the program's again, read as `bytes`, `the old link`); the node travels up to the program's row (36 f), in neither list, its old link faint in the value's half; the count 2 to 1. Then `push` writes 25 and its `next`, walked, and that arc draws |
-The first free, frame by frame:
+The loupe on the tcache hangs over the stack, never over the registers
+(the free's register wave and malloc's `rax` are what the captions are
+about); it opens in each step that changes the tcache (3, 4, 5), in its
+idea slot, and closes at that step's advance: it is never open over a
+step it does not concern. Its tag reads `tcache_perthread_struct ·
+0x2f8 bytes` (76 two-byte counts and 76 pointers: 760), and a note that
+does not fit is cut with `…`, never in mid-word without it.
+
+**The captions**, on the rules (`say`; at least 90 f + 3.6 f a character,
+at most 720 f, arriving at least 60 f before the step they describe, in a
+rest). Frames from the scene's first; "lands" is when the caption has
+arrived, "leaves" when it starts to go.
+
+| Lands | Leaves | Least | Caption | The step it leads, at |
+| --- | --- | --- | --- | --- |
+| 78 | 396 | 317 | Three pushes and two pops: what malloc and free do to the heap. | main's `push(7)`, 198 |
+| 414 | 954 | 529 | malloc(16) cut a chunk of 0x20 off the top: its size word, 0x21, then the 16 bytes rax points at. The top is 0x20 smaller. | the malloc line, 474; push's stores to 954 |
+| 972 | 1570 | 428 | Two more pushes, at a run: three chunks in a row, each with P set, the chunk before it in use. | the run, 1032 to 1522 |
+| 1588 | 2068 | 263 | pop takes the head off the list: head = n->next. | the call to pop, 1648 |
+| 2086 | 2615 | 529 | free gave 9's chunk to the tcache, malloc's bin for 0x20. Its first word is the link now: 405, which is NULL, safe-linked. | the free, 2146 |
+| 2633 | 3113 | 245 | The second pop: head moves on, to 7's node. | the call to pop, 2693 |
+| 3131 | 3693 | 562 | The second free chains to the first: 405455 is 405050 xor 405, the chunk's own address shifted 12. The arc is the pointer it hides. | the free, 3191 |
+| 3711 | 4204 | 493 | malloc(16) took the bin's head, 405030: the tcache points at 405050 again, the key is wiped, the old link stays. | the call to push, 3771; its malloc, 3951 |
+| 4222 | the cut, 4762 | 295 | push writes 25 over the old link: the list is 25, then 7. | push's stores, 4282 to 4642 |
+
+Each caption leaves 18 f before the next lands (12 out, 6 of nothing) and
+only in a rest; none is up more than 598 f; the scene is 79.4 s, its last
+120 f the finished picture. This replaces the rendered scene's caption up
+31 s and the two that arrived after their steps.
+
+The first free, frame by frame, from its fire:
| Frames | |
| --- | --- |
| 0 to 12 | fire on `free(n);` |
-| 18 to 30 | the registers `free` left changed, struck in a wave 2 f apart (`rax`, `rcx` 405, `rdx`, `rsi` the key, `r8`, `r10`): it was stepped over, so as a `continue` |
-| 54 to 66, 66 | memory: the chunk's first word armed and struck, its two bytes that changed 1 f apart (`05 04`) |
-| 72 to 80 | its second word, the key, 8 bytes 1 f apart |
-| 90 to 102 | the next chunk's header struck (`01 03`): the tcache's chunk, cut from the top at this first free; the top's own header has left the window, and flashes on the minimap |
-| 102 to 138 | `open`: the loupe on the tcache, hung from that row: the row framed as read, the stem, the rise, its two fields framed |
-| 144, 150 | in the loupe: `num_slots[0]` struck (16 to 15), then `entries[0]` (`50 50 40`) |
-| 162 to 174 | the idea: the `bin`'s box goes from dashed to raised, `tcache 0x20` |
+| 18 to 30 | the registers `free` left changed, struck in a wave 2 f apart (`rax`, `rcx` 405, `rdx`, `rsi`, `r8`, `r10`): it was stepped over, so as a `continue` |
+| 54 to 66, 66 | memory: the chunk's first word armed and struck on its two bytes that changed (`05 04`), 1 f apart, the held corner to come on the first |
+| 72 to 80 | its second word, the key, its 8 bytes 1 f apart |
+| 90 to 102 | the next chunk's header struck on its three bytes that changed (`01 03 00`): the tcache's chunk, cut from the top at this first free; the top's own header has left the window and flashes on the minimap (6 f after) |
+| 102 to 138 | `open`: the loupe on the tcache, over the stack, its stem down the gutter from that row; its two fields framed |
+| 144, 150 | in the loupe: `num_slots[0]` struck on its one byte (16 to 15), then `entries[0]` on its three (`50 50 40`) |
+| 162 to 174 | the idea: the `bin`'s box crossfades from dashed to raised, `dummy tcache` to `tcache 0x20`, and the top's box crossfades to its new place and size, `0x20ca0` struck |
| 168 to 210 | the node lifts (6 f) and travels down to the bin's row (36 f, `glide`); as it lands its outline goes dashed and its halves turn (12 f): the first word's half the link's well, the second hatched, `key`. `rdi`'s pin rides with it: the pointer was freed, not cleared |
-| 210 to 222 | the count lands on the bin's shoulder, struck: 1 |
+| 204 to 210 | the count fades in on the bin's shoulder |
+| 210 to 222, 222 | arm, strike: the count, 1 |
| 222 to 258 | hold |
-| 258 to 270 | advance |
+| 258 to 270 | advance; the loupe closes with it |
| 270 to 294 | rest: 4.9 s |
-The loupe stays open while the caption names the tcache (beats 3 to 5),
-each of its changes a strike in it; it closes with the advance after beat
-5's push.
-
**What the scene's author writes.** A sketch in the shape of
`anim/scenes/sqlite.zig`'s fields:
@@ -1095,7 +1161,9 @@ python3 motion.py track VIDEO f139 f158 --color e8c46a # a colour's b
`chart` compares each frame with the one before, in each region of the
scene's layout (a table at the top of the script, keyed by the video's
-name; add a scene there). A pixel *moved* if a channel changed by more than
+name; add a scene there). Any other name gets the working frame's: the
+program column, the state column, the caption's text alone (64 to 1464,
+906 to 1032, clear of the clock's count), the clock and the minimap. A pixel *moved* if a channel changed by more than
24 of 255 and is *fading* if by more than 6. The picture is one bar a
frame and one strip a region: solid for moving, outlined for fading, holds
shaded with their length. The text lists every event with the first and
@@ -1104,10 +1172,10 @@ ends with the checks:
| Check | Fires when | Wants |
| --- | --- | --- |
-| POP | over 0.2% of the frame changes within two frames, still either side | easing, or a smaller change |
+| POP | a region still for 12 frames or more changes in one frame and is still again, at any size (a label swapped, a count appearing, a box gone, a window that jumped); or over 0.2% of the frame changes within two frames, still either side. The clock's count is exempt: it is time | a crossfade, a fade, an arm and a strike |
| CROWD | three or more panels begin within two frames of each other | the cascade |
| METRONOME | seven or more events of over 0.5% of the frame, evenly spaced | content-timed steps, phrase rests |
-| RUSH | a panel moves within a second of a caption arriving | the caption's lead |
+| CAPTION | a caption is on screen over 720 f, or under 90 f + 3.6 f a character, or the picture moves less than 60 f after it arrives. Its time on screen runs from the end of the change that brought it to the start of the next. `design/motion/motion.py` reads the video only, so it holds a caption to 90 f; `anim/tools/chart.py`, which has the scene's captions, counts their characters | a second caption, a shorter scene, a later step |
| AIR | nothing changes for three seconds | a shorter hold, or something to say |
A scene is ready for eyes when all five are empty or each remaining line