summaryrefslogtreecommitdiff
path: root/examples/live/src/main.zig
Commit message (Collapse)AuthorAge
* examples/live: drag a number, the program following as it movesGabriel Schneider41 hours
| | | | | | | | | | | | | | | | | | | | | | | | | The left button pressed on a number token (the grammar's `number` node at the byte under the pointer, found with the module's parse) starts a drag kept in State: the literal's bytes, the value, its precision. Each pointer move rewrites the literal through the editor's `replace`: a step for every 4 pixels right of where it was pressed (left, down), the step from the literal's own precision (`220` by ones, `0.25` by hundredths), printed with as many decimals. The first rewrite is a step to undo and the rest join it, so one `u` takes the whole drag back. The text changes, so the program is compiled and heard as it moves. A literal with an exponent is not dragged (marked ponytail). `update` finds the byte under the pointer as `code` lays the text out: a character is 10 by 22 pixels, measured once (the code face at 1.25, natively: ten M are 100) and now a constant both use, where `code` asked the host each frame. Test: test/live.script presses 220, drags 40 pixels right (230), back to 12 left of the press (217), lets go and undoes the drag in one step (220). zig build test: 85 of 85 steps. Co-Authored-By: Claude Opus 5.5 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNBECMWcJD5pdS4SR6T
* examples/live: hear this, the expression a node walk leaves the selection onGabriel Schneider41 hours
| | | | | | | | | | | | | | | | | | | | | | | | | | | | After Alt-o, Alt-i, Alt-n or Alt-p (helix's node walks, run in the editor on the module's parse) the primary range is read back and the text compiled again with it as a probe: Lang.compile takes the bytes of a selection and compiles the smallest expression holding them into a third tape, `Program.probe`. The compiler learns each expression's bytes as it parses (`spanned`: a number, a name used, a call, parentheses, a unary minus, each binary operation, a whole line), keeping the smallest that holds the probe: no table of spans. A name used is the line that defines it, so a walk onto `kick` hears kick. State keeps the probe's tape (`probe`, empty when there is none). While it is set, `draw` hears it as `out` (through the crossfade, as any change) and sees it as the picture, grey unless it is a colour. Any other key empties it, so Escape or an edit goes back to the program. It is in State, so a replay probes where the session did. Test: Lang.zig, a probe on an argument, a number, a cursor on one of its digits, a name used, a line's name, a selection Alt-o grew to, and between two lines (none); test/live.script, Alt-o twice from the 2 of 220 (`220`, then `tau * 220`), then Escape. Lang.compile takes the probe as a second argument; the other calls pass null. zig build test: 85 of 85 steps, 8 of 8 tests. Co-Authored-By: Claude Opus 5.5 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNBECMWcJD5pdS4SR6T
* examples/live: the language's grammar, its colours and a new line's indentGabriel Schneider41 hours
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | grammar/grammar.js is the language as src/Lang.zig parses it, for tree-sitter (24 lines): lines of `name = expression` parted by newlines, `+ -` below `* /` below unary `-`, calls, parentheses, numbers (Lang's digits, point and `e`), names, `#` comments as extras. `tree-sitter generate` (tree-sitter 0.26.9; ABI 14, the CLI's without a tree-sitter.json) wrote grammar/src/parser.c (918 lines) and its tree_sitter/ headers, committed: the build compiles them into the sketch as a static library and never runs the generator. The `Language` is handed to the editor at run time (`tree_sitter_live`, queries/highlights.scm and queries/indents.scm embedded). The parse is a module's `Syntax`, kept between calls so Alt-i goes back the way Alt-o came, handed to every key, forgotten at a jump (in `draw`, `in.jumped`) and started again by a reload (the tree a reload leaves is leaked: marked ponytail). `code` colours each run of bytes by `Syntax.colors` in pardes's own theme (orchard, the first): a defined name as a keyword, a called builtin as a string, numbers and comments as theirs, the rest in the theme's ink. indents.scm gives a new line no indent outside an open call or parenthesis: pardes's plain indent is a level more after `)`, so every line of this language that ends in a call pushed the next one in. The library now reads a handed-in language's indent query (pardes, its own change). Test: test/grammar.zig parses with the grammar and compiles with Lang.zig 22 texts: the survey's program and two others both take; eleven broken lines both refuse (an unclosed or extra parenthesis, a missing operand or `=`, two numbers, `1.2.3`, a stray `$`); eight both parse but only Lang.zig refuses, as only it knows names, builtins, arities and where a colour may stand (a name used before it is defined or defined twice, a builtin redefined or called with too few arguments, an unknown call, a colour outside the color line, a name called). Lang.zig's survey is public for it. zig build test: 85 of 85 steps. Co-Authored-By: Claude Opus 5.5 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNBECMWcJD5pdS4SR6T
* examples/live: the editor's text drawn, its ranges, caret and modeGabriel Schneider41 hours
| | | | | | | | | | | | | | | | | | | One function, `code`, draws what the editor holds over the picture on a dark band: its lines, every range under its bytes (the primary stronger than the rest), a caret at each range's head that says the mode (a block in normal and select mode, a bar in insert mode, the primary's brighter), and the mode's name (NOR, INS, SEL) in the corner before the replay's state and the time; the problem as before, a red mark under its byte and its words under the text. One face at one size, so a byte of this ASCII language is a column of a fixed advance: marked ponytail as the place sketchbook's paragraph call (spans, any byte's place) takes. zig build test: 81 of 81 steps, 6 of 6 tests (test/live.script's screenshots compare the picture, and the sought moment's code band with the live one's). Co-Authored-By: Claude Opus 5.5 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNBECMWcJD5pdS4SR6T
* examples/live: pardes's editor in State, typed with helix's keysGabriel Schneider41 hours
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | The plain buffer of part 1 gives way to pardes's text pane as a library (`pardes-editor`, src/lib_editor.zig there): `Editor(.{ .text = 4096, .undo = 16 KiB, .registers = 1024, .selections = 64 })`, a value of plain data, 39,264 bytes of a State of 43,480. The package takes pardes by path (`../../../02-pardes-code`, the checkout beside sketchbook's) with `.editor = true` and its smallest tree-sitter set; sketchbook is spelled `../../../sketchbook` as pardes spells it, since a package is told by its path's spelling and sketchbook's build.zig cannot be two modules. `update` turns events into keys: printables from `text` events only, specials (Escape, Return, Backspace, Tab, arrows, Home, End, pages, Delete) and ctrl or alt chords (helix's `A-I` an upper-case letter) from `key_down`, a chord's letter dropped if it also comes as text. Each call into the editor thaws the value into a static 128 KiB buffer reset for the call (`update` may not allocate from the host; a key at 4 KiB of text took 29 KiB of it). The text is compiled when the editor's `revision` moves. Measured (a scratch bench through `update`, the survey's program, 646 bytes, a key typed into its middle, 400 times): a typed key, edit and compile, 59.5 us best and 78.8 mean in Debug, 7.4 and 7.8 in ReleaseFast; a motion 6.4 and 0.3. The package's cold `zig build lib` went from 3.1 s to 6.6 s, its first build under `--watch -fincremental` from 4.0 to 5.9 s, and an edit of main.zig rebuilt under it from 0.062-0.067 s to 0.067-0.092 s. Test: test/live.script types through helix now (`i`, the text, Escape, `gl`, `h`, `rx` for the edit, `l` `d` to break the line, `u` to mend it) and still replays to equal text, tapes and screenshots, its seeks moved to the marks' new times. zig build test: 81 of 81 steps, 6 of 6 tests. Co-Authored-By: Claude Opus 5.5 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNBECMWcJD5pdS4SR6T
* examples/live: the scripted proof, a session played back and soughtGabriel Schneider41 hours
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | test/live.script now ends with the run's own session replayed: `play session 0` from its start, then `seek` to the two moments marked as they happened (the gradient just typed, and the end after an edit, a broken line and its mend). At each, the State equals the mark leaf by leaf (`expect-snapshot`: the text, both tapes, the problem, the time), and at the first the screenshot equals the live one over the text and the picture (0,0 1000x600, without the scope and the status line). `stop` then goes on live from that moment: the typed program, before its edit. What a script could not do: a `record` clip ends at the first mark (Console.zig's `save` stops it), so the clip cannot be marked while it is made: the session is replayed instead. A mark is State before its frame's tick, so its time is the printed time less a frame, and `seek MS` lands on the last frame at or before MS: the script seeks 5 ms past each mark's time (272 and 488). The sound at a jump: `want` counted the queue the clear is about to drop, so a seek starved the device for a frame; now it counts from empty. And the block after a jump crosses from the old tape at where the device was (the clock less what was queued) to the tape at the new time (Synth.old_start). Not measured: a capture records every block made, including the tail the jump drops, so it cannot show what was heard across a seek. zig build test: 68 of 68 steps, 6 of 6 tests. Co-Authored-By: Claude Opus 5.5 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNBECMWcJD5pdS4SR6T
* examples/live: the sound, the out tape on the GPU per sampleGabriel Schneider41 hours
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | `pub const audio_pull = 256`; each frame `draw` runs synth.comp over as many samples as keep the host's lead queued (`in.lead -| queued`, 8192 at most) and streams the block with f.audioBuffer, as spheres does. Time is a sample clock in Session: set from State's time at every jump (a seek, a step, a replay's start; the queue is dropped then, so the jump is heard at once), and free-running otherwise, so a paused replay keeps sounding its moment. When the out tape differs from the one the last block played, the block crosses from the old tape to the new over its length (`set crossfade false` turns that off, to hear what it saves). The blocks are read back for the scope (an oscilloscope and a spectrum along the bottom) and, after the console's `capture`, appended to the sketch's capture.f32 beside its save. The status line shows the lead. The tapes reach synth.comp in a storage buffer, uploaded per block: two tapes are 4 KiB, and SDL_GPU's Vulkan backend binds a uniform block 4 KiB at a time (MAX_UBO_SECTION_SIZE), so a 4128-byte Synth block read its count as 0 past the cut and the kernel wrote nothing, silently: the probe's first synth numbers timed that. Measured again (RTX 3050, Debug host, two runs): every synth dispatch 0.08-0.14 ms, 60 or 128 instructions, 256 or 1024 samples, fading or not, the empty pass's cost alone; the 4 KiB upload 0.07-0.08. Measured on SDL's dummy driver (nothing audible) from captures: out = 0.3 * sin(t * tau * 220): peak 0.3000, RMS 0.2121, fundamental 220.000 Hz; edited to 330 in one keystroke, 330.000 Hz. The largest sample-to-sample step across the edit: 0.0131 with the crossfade (a 330 Hz sine's own steepest step is 0.0130), 0.3725 without; into the first sound, 0.0011 and 0.2967. The survey's program: peak 0.50, RMS 0.16, its bass at 55.0 Hz. Test: live.script also expects the stream to receive the GPU's blocks, and compares screenshots above the scope. zig build test: 68 of 68 steps. Co-Authored-By: Claude Opus 5.5 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNBECMWcJD5pdS4SR6T
* examples/live: the picture, typed over itselfGabriel Schneider41 hours
The sketch: State holds the text (a plain 4 KiB buffer, typed characters appended, backspace deleting the last, return a newline: marked ponytail, the place pardes's editor takes in part 2), the last good out and color tapes, the problem and the time, summed from recorded ticks. `update` compiles the text at every keystroke; a program that parses replaces the tapes and clears the problem, one that does not sets the problem and changes nothing else, so the last good picture stays. `draw` runs picture.frag over the color tape into an image the size of the canvas, 1280x720, or half of it when the tape is longer than 64 instructions (the probe: 128 took 2.7 ms at full size, 0.85 at half), and scales it up. The text is drawn over it on a dark band with the library's text calls (the code face at 1.25, a column a fixed advance), the caret at the end, the problem as a red mark under its byte and its words under the text, and live/recording/replay/paused with the time in a corner. Test: test/live.script, the start of the scripted proof: a tone typed (its eight instructions asserted), a gradient (hsv over x and y, four), an edit (y to x: three, the picture different), a broken line (the problem at byte 52, the tape and the picture the same) and its mend. zig build test: 56 of 56 steps, 6 of 6 tests. Co-Authored-By: Claude Opus 5.5 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNBECMWcJD5pdS4SR6T