summaryrefslogtreecommitdiff
path: root/design/motion.md
diff options
context:
space:
mode:
authorGabriel Schneider <[email protected]>2026-11-11 14:17:43 -0300
committerGabriel Schneider <[email protected]>2026-11-11 14:17:51 -0300
commit4862e778af7779bbdb047b9c71adfb62add319b2 (patch)
tree669715d535fe1a381adf95e053ba6a2986039de9 /design/motion.md
parent5941372c6c153ad595236193e61ea027a40a9950 (diff)
downloadcomputeranim-4862e778af7779bbdb047b9c71adfb62add319b2.tar.gz
computeranim-4862e778af7779bbdb047b9c71adfb62add319b2.zip
design: the disassembly stays under the source; the graph as a track
From the user, on the sort render. Registers a scene never changes fold three to a row, so the stack is twelve to fifteen slots and the disassembly keeps its place under the source with eleven to seventeen rows; a blocks lens has no view. The graph leaves the layered picture of the reverse-engineering tools: blocks are pills on one line in the order they run, a loop an arch over its blocks with the turn count at its centre, every bend a quarter circle; sort's eleven blocks and both loops are seen whole across the band. Sheets 42 and 43 set the layouts and the graph's forms side by side. 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.md76
1 files changed, 44 insertions, 32 deletions
diff --git a/design/motion.md b/design/motion.md
index 90da023..6e68c29 100644
--- a/design/motion.md
+++ b/design/motion.md
@@ -602,7 +602,7 @@ The levels are the cascade's; what is in them is not one write each.
| --- | --- |
| 0 to 12 | fire on the line the program left from |
| 18 to 18 + 2n + 6 | the n registers that changed strike in a wave, top to bottom in pwndbg's order, 2 f apart; the fill in over 6 f; no arm, no pulse |
-| then 18 f | memory: the stack's window scrolls to the new frame (24 f) when that is within six slots, else fades out (12 f) and in (12 f) with no marks; a dump the scene keeps follows its region the same way |
+| then 18 f | memory: the stack's window scrolls to the new frame (24 f) when that is within its own height (twelve slots as the subject), else fades out (12 f) and in (12 f) with no marks; a dump the scene keeps follows its region the same way |
| with it | the backtrace: frames that end fade out (12 f); frames both stops share slide to their new depth (24 f, `glide`); new ones fade in (12 f) |
| then 18 f | the idea: the lens's drawing reacts, or a lens the scene brings comes in |
| 36 f after the last strike | hold |
@@ -631,42 +631,53 @@ target is in the same region but out of the window.
### A block left
-On a function's graph ([`graph`](README.md#graph); mock 24 is reverse's
-loop): `jg` decides between the swap and the next pass.
+On a function's graph, the track ([`graph`](README.md#graph); mock 24 is
+reverse's loop, 25 sort in the frame): in sort, `jne` decides between the
+swap and the inner loop's way out. The cause is in the disassembly under
+the source; the decision is told in the band.
| Frames | |
| --- | --- |
-| 0 to 12 | fire on the `jg` row |
-| 18 to 24 | the compare's chips (`zf sf of`), on the `cmp` row above, framed as read: what decides |
-| 24 to 42 | the edge it takes draws gold, 3 units, from the port on its target's side to the target's top, `standard` |
-| 42 to 66 | the mark travels the edge: the plaque leaves the row, `glide`, 12 f and 2 f a 100 units (30 f at most); the row it left cools to the trail |
-| 66 | it lands on the target's first row: the advance |
-| 60 to 72, 72 | arm, strike: the target's count, `×5` to `×6` |
-| 66 to 84 | the oldest of the three trail edges cools to `dim` |
-| 84 to 108 | rest: 1.8 s |
+| 0 to 12 | fire on the `jne` row under the source; the pc's pill's gold frame pulses with it |
+| 18 to 24 | the chips it reads (`zf`), on the `test` row above, framed as read: what decides |
+| 24 to 42 | the edge it takes draws gold, 3 units, head first, `standard`: along the line from the pill's end (taken, to the swap's block, 40 units), or out of its foot into a dip (not taken: under the swap's block to `+5d`, 331 units) |
+| 42 to 54 (60) | the mark travels the edge: the gold plaque, its point the way it goes, leaves the pill, `glide`, 12 f and 2 f a 100 units (42 f at most): 12 f along the line, 18 f through the dip; the pill it left cools to the trail; the disassembly's plaque moves with the advance as ever |
+| 54 (60) | it lands on the target's pill: the advance |
+| 48 to 60, 60 | arm, strike: the target's count, `×5` to `×6` |
+| 54 to 72 | the oldest of the three trail edges cools to `dim` |
+| 72 to 96 | rest: 1.6 s (1.7 through the dip, every time after the landing 6 f later) |
-**A loop's turn** is the same along the back edge: down out of the block,
-out to the lane, up the lane (the one thing that climbs), in at the
-header's head; the lane's count, `×2` to `×3`, is struck as the mark goes
-in. The mark keeps its speed on the climb: a lane of 400 units is 20 f.
+**A loop's turn** is the same over the arch: up out of the latch's top,
+back over the loop's own blocks, down into the header's top; the one
+thing that goes back. The mark keeps its speed: sort's inner arch in the
+lens is 672 units, 26 f; the outer 1433, 40 f (on the map, 966 and 1516,
+the cap: 42 f). The loop's count at its centre, under the arch, is armed
+as the mark comes over its top and struck as it lands, `×2` to `×3`: the
+mark going round the loop's closed shape and the number in its middle
+going up are one picture, the picture of iteration.
-**Rows into blocks** (`spread`, and back, `gather`): a scene that shows
-its disassembly as a graph on the map, or a `dive` and a `surface` between
-the map's graph and the working frame's rows. What persists slides: every
-row travels from its place in the column to its place in its block (36 f,
-`glide`, the blocks 4 f apart in layer order), and only then do the
-blocks' frames and heads fade in round them (12 f) and the edges draw,
-layer by layer (2 f apart, 12 f each). Backwards, the edges and frames go
-first and the rows glide home last. No text is ever over text: a row moves
-only over page.
+**Rows into cards** (`spread`, and back, `gather`): a scene that shows
+its disassembly as a track on the map, or a `dive` and a `surface`
+between the map's track and the working frame's rows. The track's order
+is the column's but where a loop keeps its blocks together, so what
+persists barely moves: the column parts at each block's first row (24 f,
+`glide`, the rows under each break gliding down to make the break and
+the card's head, top down, 2 f apart), a block whose place on the line is
+not its place in memory gliding to it over page on the same 24 f; then
+the cards' frames and heads fade in round their rows (12 f) and the edges
+draw, the line top down, then the lanes and the channels (2 f apart, 12 f
+each). Backwards, the edges and frames go first and the rows close up
+last. No text is ever over text: a row moves only over page.
-**At a run and a sprint** the graph is at its best: a pass is a path. At a
-run the mark goes block to block in 8 f, each edge it takes flashes gold
-and cools in 8 f, the counts change in place; nothing is struck. At a
-sprint, on the map, the gold moves only when the block changes (4 f at
-most), the three trail edges follow it, the loops' lanes count, and the
-picture settles at the phrase's end: the counts are where the run left
-them, the heat of the path in their numbers.
+**At a run and a sprint** the track is at its best: a pass is a path, and
+a loop is the mark going round. At a run the mark goes pill to pill in 8
+f (over an arch, 12), each edge it takes flashes gold and cools in 8 f,
+the counts change in place; nothing is struck. At a sprint, on the map,
+the gold moves only when the card changes (4 f at most), the three trail
+edges follow it, the loops' counts tick in their lobes, and the picture
+settles at the phrase's end: the counts are where the run left them, the
+heat of the path in their numbers. In the lens (a sprint the scene keeps
+in the working frame) the same, the source and the disassembly veiled.
### A pointer opened
@@ -842,7 +853,8 @@ own path and its own scale.
| 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. With each, the same 72 f and the same stagger, the rest of its column (the map's panel it is a window on: the file, the 69 instructions, the stack from 16 words above rsp, the region's dump) squeezes into the pane's strip: from its place at half size to the strip's rect, its width and its height each on its logarithm (to 36 of 880; to 4 of 24 a row), its window's outline riding on it. The registers' and the drawing's windows are their panels whole and bring no column |
| 24 to 72 | the map's parts no pane takes (the backtrace, the key, the memory round the pointers, a loupe's panel) fade where they are, veiled |
-| 72 to 96 | the drawing crossfades from the map's size to the frame's within its box |
+| 24 to 96 | with the move, the registers fold: the map's panel has every register and every chain; as it lands each quiet register's row glides into its cell, three to a row, its chain past the first hop fading over the first 24 f, so the panel arrives at its height in the frame and the stack's window at its own, the longer one |
+| 72 to 96 | the drawing crossfades from the map's size to the frame's within its box; the `blocks` lens's track, which is not a window of the map (the map's disassembly column is the track with its rows, and `gather`s into the pane's rows on its way), fades in across the band |
| 84 to 102 | each squeezed column crossfades into its strip's strokes (12 f); the working frame's tags, rules and lanes fade in; the clock's count fades in (mock 20) |
| 102 to 138 | still |