summaryrefslogtreecommitdiff
path: root/design/motion.md
diff options
context:
space:
mode:
authorGabriel Schneider <[email protected]>2026-11-10 17:16:50 -0300
committerGabriel Schneider <[email protected]>2026-11-10 17:56:05 -0300
commit74c45474f7e3e1b3539eb88484e6749082c6addf (patch)
tree29be105369df0b9f5bb92adb50360fd99fd664b8 /design/motion.md
parent47f43f0f26b08901c1ddd16aacbe50c2c843ab8a (diff)
downloadcomputeranim-74c45474f7e3e1b3539eb88484e6749082c6addf.tar.gz
computeranim-74c45474f7e3e1b3539eb88484e6749082c6addf.zip
design: the band is two panels; what the first videos taught
An independent review of the first videos, frame by frame, is placed in the catalogue. A lens is a drawing over the program column and its view over the state column (the dump; the backtrace for calls), which leaves the stack six slots as subject: the frame whole, from rsp to past rbp. Operands are whole. A mark covers the bytes that changed. A pin travels and keeps its side. A call's node is a projection of its return address. Fast passes are veiled. Captions have numbers a scene can be checked by, and a scene's first step comes by four seconds. Effects before causes and panels from different moments are forbidden by name. Mock 12 draws fib(4) calling fib(2) from the recording. Co-Authored-By: Claude Fable 5.2 <[email protected]>
Diffstat (limited to 'design/motion.md')
-rw-r--r--design/motion.md295
1 files changed, 163 insertions, 132 deletions
diff --git a/design/motion.md b/design/motion.md
index 4a22f92..c33a13e 100644
--- a/design/motion.md
+++ b/design/motion.md
@@ -3,8 +3,8 @@
How things move in a canim frame, in what order, and for how long.
[`README.md`](README.md) gave durations and curves. This is the direction
that uses them, written after measuring the first five scenes frame by
-frame. Where the two disagree this one wins; the tokens to change are under
-[Revised tokens](#revised-tokens).
+frame. Where the two disagree this one wins; its figures are tokens, see
+[Tokens](#tokens).
Times are at 60 frames a second: "12 f" is twelve frames, 0.20 s.
@@ -13,10 +13,16 @@ page moves have names there, and its [verbs](README.md#6-verbs) are this
page's charts in one table. The direction below stands. What reads
differently now:
-- There is no head. The step counter and the progress line are the `clock`.
+- There is no head. The step counter and the progress line are the
+ `clock`, and it moves as this page says the progress line does: still
+ through a step at a walk or a run (the step's piece of gold fades in
+ once its mark has landed), sweeping at a sprint.
- In the context a strike arms with a 2-unit frame, pulses out 3 units, and
cools to nothing, leaving the `held` tick where this page says ember and
- bar. A lens's cell cools to a bar along its bottom edge.
+ bar. A lens's cell cools to a bar along its bottom edge. The cool starts
+ with the advance, whenever that is.
+- Tags of variables and registers are `pin`s. A pin is one thing and
+ [`travel`](README.md#6-verbs)s along its lane; it never jumps.
- `extend`: a chain whose first hop is struck is followed again hop by
hop, 4 f apart, each fading in over 6 f.
- `link`: 6 f after a register's strike its old `pin` fades (12 f) and the
@@ -25,15 +31,17 @@ differently now:
head and settles (12 f). At the advance the line draws back into the pin
(18 f). "Its plaque slides" and "its tag travels", below, are this.
- `project`: the idea's slot in the cascade is a tie. When bytes in the
- dump are read or struck, a bracket takes their row (6 f) and a line
- draws from them to the part of the drawing they are (18 f, `standard`).
+ dump, or a frame's return address on the stack, are read or struck, a
+ bracket takes their row (6 f) and a line draws from them to the part of
+ the drawing they are (18 f; 30 f over 600 units; `standard`).
The drawing reacts when the line arrives and not before: its bytes are
always 18 f ahead of it. Out with the advance (18 f).
- `advance`: the `thread` (the bracket on the source line, the brackets on
its instructions, the line between) moves with the plaques and rip, as
one mark, last.
-- `establish`, for a lens: its dump first; then each element rises from
- its row by `project`, 6 f apart in address order, and the lines go.
+- `establish`, for a lens: its view first; then its elements come in
+ beside their rows, 2 f apart in address order, with no lines (six lines
+ at once would break the budget of three).
- The levels of the cascade are places in one frame: the pc's annotation
and the registers (CPU), the stack's slots and the dump's bytes
(memory), the drawing (the idea). The order and the 18 f between them
@@ -124,9 +132,13 @@ A step's length follows from its content:
| only moves the line | 12 fire + 12 advance + 24 rest | 0.8 |
| writes one register (or one word, or one cell) | 18 + 36 + 12 + 24 | 1.5 |
| writes a register and memory | 36 + 48 + 12 + 24 | 2.0 |
-| makes or returns from a call, three levels shown | 54 + 60 + 12 + 24 | 2.5 |
-| swaps two cells | 54 + 36 + 12 + 24 | 2.1 |
-| crosses into the kernel | see the chart | 3.7 to 4.8 |
+| makes a call, three levels shown | 108 + 36 + 12 + 24 | 3.0 |
+| returns from one | 126 + 24 + 12 + 24 | 3.1 |
+| swaps two cells | 90 + 36 + 12 + 24 | 2.7 |
+| crosses into the kernel | see the chart | 3.7 to 5.1 |
+
+A level with nothing on screen to change gives up its slot: a step whose
+writes all land outside every window is a step that only moves the line.
So a walk has the program's rhythm and not a clock's.
@@ -192,11 +204,14 @@ pixels of cartoon.) No anticipation at run or sprint.
- One onset at a time, 18 f apart. Two panels that show the same bytes (the
heap strip and the words) start together; only the one in focus pulses.
-- What cannot be read at the current pace is veiled: registers and bytes
- during a sprint. What is not the subject of a camera move is gone before
- it starts.
+- What cannot be read at the current pace is veiled: the registers, the
+ stack and the disassembly from the first shortened step of a run, and at
+ a sprint the source and the band's view as well (see Pace). What is not
+ the subject of a camera move is gone before it starts.
- The subject is never at the edge. At x2 the rows about to change are in
- the middle of the frame, and no row is cut by the stage's edge.
+ the middle of the frame, and no row is cut by the stage's edge. A stack
+ under the camera holds its window still, so a push fills a row in the
+ middle of the frame instead of scrolling the whole panel at its edge.
- A layout is stable. A row, a node, a card or a divider that appears makes
room first; nothing else jumps because it came.
- One caption at a time. The old one leaves (12 f), six frames of nothing,
@@ -224,11 +239,12 @@ level starts while the one before is still solid. After that:
- A value between cells of an array, or between nodes: an arc a quarter as
high as it is long (34 to 120 units), on `glide`, so it is slowest at
lift-off and landing and quickest over the top. A swap is one over and
- one under.
+ one under. The arc stays inside the drawing's lanes (lowered if it must),
+ and the card passes under names and pins, never hiding them.
- A value between a register and memory, or across the kernel's line: along
a square-cornered path, as a flow arrow draws it. Machines do not lob.
-- A variable following a pointer (`cur = cur->next`): its tag travels the
- arrow it followed.
+- A variable following a pointer (`cur = cur->next`): its pin travels
+ along the drawing's bottom lane, under the arrow it followed.
- The mark moves straight up and down its gutter. The camera moves in a
straight line and zooms by ratio (interpolate the logarithm of the scale),
or the first half of a move to x2 looks twice as fast as the second.
@@ -257,26 +273,37 @@ something is shown.
### The rhythm of a scene
-**Open.** Head and panels fade in 6 f apart, source first (18 f each).
-Then stillness: 1.0 s and 0.5 s a panel. Then the first caption, and 2 s
-more. A scene's first step is never before 4 s.
+**Open.** The opening is read under its first caption, not before it:
+seven seconds of stillness before anything happened was the first
+videos' longest flaw.
+
+| Frames | |
+| --- | --- |
+| 0 to 48 | the panels fade in, 18 f each, 6 f apart: registers, stack, source, disassembly, the band's view, the drawing's panel |
+| 30 to 54 | the drawing's elements fade in rising 8 units, 2 f apart in address order, each with its row's quiet bracket |
+| 60 to 78 | the first caption arrives |
+| 78 to 198 | still: the caption and the picture are read |
+| 198 to 240 | the first step fires, by 240 (4.0 s) at the latest |
**Beats.** The beat is 0.5 s. Steps are as long as their content; a
*phrase* (one trip round a loop, one call and its return) ends with a rest
of one beat. Three steps and a rest is a bar, and a loop is heard as bars.
-**Breath.** A step the narration names has its caption up a second before
-it fires and holds a beat longer after. Captions change only in a rest. No
-caption stands longer than 12 s; if there is nothing to say for longer, the
-scene is too long there.
+**Breath.** A caption is up 60 f before the first step it describes
+fires (120 f for a scene's first), and holds a beat longer after. It is on
+screen at least 1.5 s + 0.06 s a character, and at most 12 s; if there is
+nothing to say for longer, the scene is too long there. Captions change
+only in a rest. A sentence that would need three lines is two captions,
+split at a phrase rest. The numbers an author checks are in the
+catalogue's [caption](README.md#clock-and-caption).
**Pace.**
-| | A step | What is drawn | When |
-| --- | --- | --- | --- |
-| walk | by content, 0.8 to 2.5 s | everything | the first time anything happens, and whatever the narration names |
-| run | 0.30 s | the mark glides (8 f); cards, nodes and arrows ease (8 f); values get embers, never solids; no fire, arm or pulse | a pattern seen once in full; 24 steps at most |
-| sprint | 0.067 s or less | structures grow; embers; the mark only at phrase ends; registers and bytes veiled | everything longer |
+| | 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 |
+| 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.
@@ -286,10 +313,15 @@ A run keeps its bars: 12 f of rest at each phrase end. A sprint does not.
0.32). Out of it: three steps lengthening the same way, then one beat of
stillness before the walked step that the run was heading for.
- On the first shortened step the panels that cannot be read at speed take
- the veil (18 f), and the head's `where` gains a counter, `step 41 of 212`.
-- A 3-unit gold line grows along the head's rule with the cursor's place in
- the recording, linearly. At a walk it is still; in a sprint it sweeps.
- It is the scene's clock, and the only thing on screen that says "fast".
+ the veil (50%, in over 18 f with its fire); on the last step back to a
+ walk it lifts (18 f, with the advance). Under the veil the values go on
+ changing, without marks: the veil says "not now", not "nothing".
+- The clock: at a walk and a run it is still while a step plays, and the
+ step's piece of gold fades in once its mark has landed (12 f; 8 f at a
+ run), the count changing as the fade starts: moving every frame of a
+ walked step it would be a secondary action that never stops. In a
+ sprint it grows linearly with the recording: the only thing on screen
+ that says "fast".
- The caption says it too: "and so on, down to `fib(1)`".
**Close.** The last step's hold, then 2 s on the finished picture. A scene
@@ -305,8 +337,8 @@ always the same sub-chart:
| s-12 to s | arm: a 3-unit frame in write's colour inside the cell's edge, in over 2 f; the old value unchanged |
| s to s+6 | the fill comes in, linear; the digits become the new value, bold, in ink, at s+3 |
| s to s+12 | pulse: the fill's edges go out 4 units and back, sine |
-| s+6 to s+36 | solid |
-| s+36 to s+60 | cool to the ember, on `glide`; the bar is under it from the start; digits to their ordinary face at s+48 |
+| s+6 to the advance | solid (at least to s+36) |
+| the advance to +24 | cool to the ember, on `glide`; the bar is under it from the start; digits to their ordinary face at its middle |
| then | ember and bar for three steps; out over 36 f, linear, in the step after |
### A register written
@@ -320,17 +352,22 @@ always the same sub-chart:
| 66 to 90 | rest |
Two registers by one step: the second is armed and struck 6 f after the
-first, in the order they were written. rip changes with no mark at frame 18.
+first, in the order they were written. rip is not one of them: it is the
+current mark's, and moves with the advance.
### Memory written
The same, one slot later if a register was struck too: arm 24 to 36,
-strike 36. Drawn as bytes, they strike 1 f apart from the low address. The
-heap strip's mark is the same strike at scale, without a pulse. Hold to 84,
-advance to 96, rest to 120.
+strike 36. Drawn as bytes, only the bytes whose value changed are armed
+and struck, 1 f apart from the low address. The heap strip's mark is the
+same strike at scale, without a pulse. Hold to 84, advance to 96, rest to
+120.
-A row that was not in the grid: the rows below glide down 18 f, the row
-fades in 12 f, and only then is it armed. An unknown byte that becomes
+A word outside the window: the window scrolls first (the stack's or the
+dump's, 24 f, `glide`, whole rows, until the word is in its middle rows),
+and only then is the word armed; the level's slot starts after the
+scroll. A row that was not in the grid: the rows below glide down 18 f,
+the row fades in 12 f, and only then is it armed. An unknown byte that becomes
known without being written fades from dots to digits in 12 f, with no mark.
### A value read
@@ -365,29 +402,35 @@ panels (today only the nodes keep it).
| Frames | |
| --- | --- |
-| r to r+6 | the `next` word, and the node's pointer square, framed as read |
-| r+12 to r+36 | `cur`'s tag travels the arrow from node to node, `glide`; in memory its plaque slides down the mark lane |
-| r+36 | the variable's own cell (a local, a register) is struck: it is where the address was written |
+| r to r+6 | the `next` word, and the node's pointer half, framed as read |
+| s = r+18 | the variable's own word (a local on the stack) is struck: it is where the address was written |
+| s+18 to s+48 | `cur`'s pin travels along the drawing's bottom lane to the node it now points at, `glide`: 30 f to the next node, 36 f to one farther |
-36 f of travel when the arrow is longer than 400 units.
+Low level first: the word changes, then the pin moves. Where the variable
+is a register, its strike is in the CPU's slot and a `link` carries the
+pin instead. A pin that appears (`next` the first time) fades in rising 8
+units over 12 f; two names that meet on one node keep their sides, and a
+name that joins or leaves cross-fades over 12 f.
### A call pushed
-Three levels shown.
+Three levels shown: the registers, the stack, the tree
+([mock 12](mock/12-calls-subject.png) is its frame 108).
| Frames | |
| --- | --- |
| 0 to 12 | fire on the line that calls |
| 6 to 18, 18 | arm, strike: `rdi`, the argument |
-| 24 to 36, 36 | arm, strike: `rsp`; in memory the return address |
-| 42 to 60 | the cards below move down one place, `standard` |
-| 48 to 60 | the new card fades in, 12 units above its place and coming down |
-| 42 to 54 | in the tree, the edge draws from the caller's node |
-| 54 to 60 | the callee's node fades in gold; the caller's goes from gold to a waiting ring |
-| 60 to 114 | hold |
-| 114 to 120 | the mark on the calling line cools to the trail |
-| 120 to 126 | the mark fades in on the callee's first line (the panel scrolls first if it must) |
-| 126 to 150 | rest |
+| 12 to 24, 24 | arm, strike: `rsp`. Its pin stays on the window's top row: no link |
+| 30 to 48 | the stack's rows slide down one slot, `glide`, as rows making room do: the new top row comes in with them |
+| 48 to 60, 60 | arm, strike: the return address, in the new top row; the new frame's `call` span (gold, `fib(2)`) and its `backtrace` row fade in with the strike, the old ones going to rule and dim |
+| 66 to 72 | the return address's bracket (`project`) |
+| 72 to 102 | the projection draws from it up the gutter and along the drawing's bottom lane to the place of the new node, 30 f, `standard` |
+| 90 to 102 | the edge draws from the caller's node, arriving with the line |
+| 102 to 108 | the callee's node fades in gold; the caller's goes from gold to a waiting ring |
+| 108 to 144 | hold |
+| 144 to 156 | the advance: the mark on the calling line cools to the trail, out 6 f; in 6 f on the callee's first line (the panel scrolls first if it must); the projection draws back out (18 f) |
+| 156 to 180 | rest |
A call is a jump: the mark does not cross the lines between
([sheet](motion/sheets/fib-02.2-mark-crosses-seven-lines.png): seven lines
@@ -398,15 +441,20 @@ in five frames).
| Frames | |
| --- | --- |
| 0 to 12 | fire on the `return` |
-| 6 to 18, 18 | `rax`: the answer |
-| 24 to 36, 36 | `rsp` |
-| 42 | the top card's result is struck at its right end |
-| 54 | the tree node's badge is struck; the node goes from gold to done |
-| 66 to 78 | the card fades out, rising 12 units, `exit` |
-| 78 to 96 | the cards below move up, `standard` |
-| 96 to 114 | hold |
-| 114 to 126 | the mark jumps back to the caller's line |
-| 126 to 150 | rest |
+| 6 to 18, 18 | arm, strike: `rax`, the answer |
+| 12 to 24, 24 | arm, strike: `rsp` |
+| 42 to 48 | the return address framed as read (`ret` reads it), with its bracket |
+| 48 to 78 | the projection, in read's colour, draws from it to the node, 30 f |
+| 78 to 90, 90 | arm, strike: the node's result on its shoulder, rax's digits; the node goes from gold to done, the caller from waiting to gold |
+| 96 to 108 | the frame's span and backtrace row fade out, `exit` |
+| 108 to 126 | the stack's rows slide up to the new rsp, `glide` |
+| 126 to 150 | hold |
+| 150 to 162 | the mark jumps back to the caller's line; the projection draws back |
+| 162 to 186 | rest |
+
+The answer's tie is its digits: rax's and the badge's are the same
+number, struck one level apart. A line from rax would be a sixth thing in
+the frame saying what the digits say.
### The line changes
@@ -437,9 +485,13 @@ arrives.
| 186 to 210 | the arrow back draws up |
| 198 to 210, 210 | arm, strike: `rax` |
| 216 | the `returns` row takes the value |
-| 216 to 252 | hold |
-| 252 to 264 | advance |
-| 264 to 288 | rest |
+| 222 to 234, 234 | arm, strike: the word the line stores the result in (`n = read(…)`), when it does |
+| 234 to 270 | hold |
+| 270 to 282 | advance |
+| 282 to 306 | rest |
+
+The result is stored only after the kernel has given it: `returns` has
+the value before the local does, never the other way round.
For `write` the work runs the other way: the user's bytes framed as read
(120 to 126), a flow down (126 to 150), the kernel's cells filling 2 f
@@ -450,21 +502,27 @@ kernel does not know the call until it has crossed.
### A swap
The compare in the step before is its anticipation: both cells framed as
-read.
+read. Low level first: the bytes change, the tie carries it, the cards
+fly.
| Frames | |
| --- | --- |
| 0 to 12 | fire on the `swap` |
-| 12 to 18 | the first value lifts |
-| 18 to 24 | the second lifts |
-| 18 to 48 | the first flies over, `glide`, 30 f for neighbours |
-| 24 to 54 | the second flies under |
-| 48, 54 | each lands: back to size on its last 6 f, then its cell is struck |
-| 54 to 90 | hold |
-| 90 to 102 | advance |
-| 102 to 126 | rest |
+| 6 to 18, 18 | arm, strike: the first element's bytes in the dump (a run of its type; only the bytes that change) |
+| 12 to 24, 24 | arm, strike: the second's |
+| 24 to 30 | the first run's bracket; the second's echoes on its own row at 30, with no line |
+| 30 to 48 | the projection draws from the first run to its cell, 18 f |
+| 48 to 54 | the first card lifts (1.12, 6 units off its cell) |
+| 54 to 60 | the second lifts |
+| 54 to 84 | the first flies over, `glide`, 30 f for neighbours |
+| 60 to 90 | the second flies under, under the index pins' names |
+| 84, 90 | each lands: back to size on its last 6 f, then its cell is struck |
+| 90 to 126 | hold |
+| 126 to 138 | advance |
+| 138 to 162 | rest |
-Each cell keeps its old digits, faint, until its own landing.
+Each cell keeps its old digits, faint, until its own landing. Its bar
+(`held`) is on the cells whose value changed, and on no other.
### A node linked
@@ -496,6 +554,12 @@ apart, then 36 f still. Sideways at x2 (registers to stack) is not out and
in: the target fades out (12 f), the next fades in at x2 (12 f), the rail's
square slides. 0.5 s instead of 2.6.
+On the stack the window holds still from the frame on the target to the
+way back: it is set before the move so that the slots the visit's steps
+will write are in its middle, with `free` slots above rsp for the pushes.
+A push fills one of them; rsp's pin climbs to it (24 f, `glide`), rbp's
+travels the same way, and no row of the panel moves.
+
The frame at x2 is 896 by 384 units, on the 24-unit grid: the panel's tag
and as many whole rows as fit, with the rows the next steps will change in
the middle third. If they move out of it the frame glides a whole row
@@ -509,57 +573,20 @@ the middle third. If they move out of it the frame glides a whole row
| a caption leaves | 12, `exit` |
| nothing | 6 |
| a caption arrives, rising 8 units | 18, `enter` |
+| on screen, from arrived to leaving | at least 90 + 3.6 a character; at most 720 |
| the stage stays still after it | 60; 120 after a scene's first |
-| panels arrive at the opening | 18 each, 6 apart, source first |
-| still before the first caption | 60 + 30 a panel |
-| still on the last picture | 120 |
-
-## Revised tokens
+| panels arrive at the opening | 18 each, 6 apart, all by 48; the drawing's elements by 54 |
+| a scene's first caption arrives | at 60 |
+| a scene's first step fires | by 240 |
+| still on the last picture | 120, after the last caption's reading time |
-In `anim/src/theme.zig` (the verbs of `design/README.md` use the same
-figures):
-
-| Token | Was | Is |
-| --- | --- | --- |
-| `bezier(.standard)` | 0.2, 0, 0, 1 | 0.3, 0, 0.2, 1 |
-| `bezier(.camera)` | 0.65, 0, 0.35, 1 | 0.45, 0, 0.55, 1 (and call it `glide`) |
-| `pulse(t)` | a scale, 1 + 0.08 sin | an outset in units, 4 sin(pi t) |
-| `time.step` | 0.25 | 0.20 |
-| `time.step_per_row` | | 2 f (0.0333) |
-| `time.step_max` | | 0.40 |
-| `time.fire` | | 0.20; the first arm starts at 0.10 |
-| `time.cascade` | | 0.30 between levels |
-| `time.strike.arm` | | 0.20 |
-| `time.strike.in` | 0.10, a wait | 0.10, the fill fading in |
-| `time.strike.cool` | 0.40, linear | 0.40, on `glide`; starts with the advance |
-| `time.read_value` | | 0.60 after the last strike |
-| `time.read_more` | | 0.20 a further value, 1.40 in all |
-| `time.rest` | | 0.40 |
-| `time.walk` | 1.50, every step | 1.50, what a one-value step comes to; not a pace |
-| `time.run` | 0.25 | 0.30 |
-| `time.run_max_steps` | | 24 |
-| `time.sprint` | 0.05 | 0.0667 |
-| `time.phrase_rest` | | 0.50 walking, 0.20 running |
-| `time.ramp` | | 0.6: each step of a change of pace, of the one before |
-| `time.stagger` | 0.03 (1.8 frames) | 2 f (0.0333); bytes of one write 1 f |
-| `time.flight` duration | `travel`, 0.60 | 0.50 to 200 units, 0.60 to 400, 0.80 beyond |
-| `time.flight.second` | | 0.10 after the first |
-| `time.redirect.landing` | | 0.20 |
-| `time.caption_in` | 0.25 | 0.30 |
-| `time.caption_out` | | 0.20 |
-| `time.caption_gap` | | 0.10 |
-| `time.caption_lead` | | 1.00; 2.00 for a scene's first |
-| `time.establish` | `settle`, 0.80 | 1.00 + 0.50 a panel, at a scene's opening |
-| `time.before_cut` | 1.00 | 2.00 |
-| `time.camera_clear` | | 0.30 |
-| `time.camera_dwell_max` | | 2.00 without a change at x2 |
+## Tokens
-In `anim/src/cursor.zig`: `lead` becomes slots (`0.30` for the first level
-a step touches and `0.30` more for each after it, in the order CPU,
-memory, idea) and the source line goes last; `anticipation` goes; `glide`
-is the curve above; `reading` is the table under "A step is a sentence".
-In `anim/src/syscalls.zig`: `enters` 0.80, `cross` 0.40, the work 2 f a
-byte, `returns` at the frame the chart gives.
+Every figure on this page is a token in `anim/src/theme.zig` (`time`,
+`bezier`, `pulse`), and the verbs of the [catalogue](README.md#6-verbs)
+use the same figures. Where the file and the documents still differ is
+listed once, under the catalogue's
+[Token changes](README.md#token-changes).
Every figure is an even number of frames at 60, so a 30 fps export keeps
them whole. Review at 60 all the same: at 30, today's 0.25 s run alternates
@@ -588,8 +615,8 @@ In each, most valuable first. Times are seconds into the exported file.
Sequence them as "A call pushed".
4. **Nothing is established.** Panels are whole at 0.43, the caption at
0.73, the first step at 0.77
- ([sheet](motion/sheets/fib-00.0-opening.png)). Four panels need 3 s and the caption 2 s
- before anything moves.
+ ([sheet](motion/sheets/fib-00.0-opening.png)). The panels must be in and the first
+ caption read before anything moves: see [Open](#the-rhythm-of-a-scene).
5. **1.5 s for everything.** 5.27 and 9.77 move one line and then wait
1.23 s; 2.27 pushes a call through four panels in the same time.
6. **The mark sweeps seven lines in five frames** at 2.27, 6.77, 11.27. A
@@ -742,9 +769,11 @@ Seen while looking at motion; against `README.md`.
eased and values as embers; 24 steps at most; sprint beyond; ramp in over
four steps and out over three; veil what cannot be read; counter and
progress line.
-4. **Let the picture and the caption be read.** 1.0 s and 0.5 s a panel at
- the opening; 2 s after a scene's first caption, 1 s after any other;
- captions leave, pause, arrive; 2 s on the last picture.
+4. **Let the picture and the caption be read.** The panels in by 0.9 s,
+ the first caption at 1.0 s, the first step by 4.0 s; 2 s after a
+ scene's first caption, 1 s after any other; each caption up for its
+ reading time and at most 12 s; captions leave, pause, arrive; 2 s on
+ the last picture.
5. **Walk the point of each scene once**: a return, each pointer turning, a
swap by 10 s, each system call under its own caption.
6. **Anticipate every write**: the arm, the fill over six frames, the pulse
@@ -799,7 +828,9 @@ Limits: regions are fixed on the screen, so under a camera move their
names stop meaning panels; `track` follows a colour, so crop to one object
(its box columns are the honest ones when two share the colour); the
thresholds suit x264 at the export's quality and will need loosening for a
-harder encode.
+harder encode. x264's default keyframe every 250 frames shows as a
+one-frame change in every region every 4.17 s: the encoder, not the
+scene; export with `-g 600`.
What is kept: `motion/charts/` (chart, events and per-frame counts for the
five scenes as reviewed) and `motion/sheets/` (the sheets this page