//! live: a program typed over its own picture and heard. Each line is //! `name = expression` over t, x and y (src/Lang.zig); the `out` line is //! what is heard, the `color` line what is seen. At every keystroke that //! leaves a program that parses, `update` compiles it into two tapes kept //! in State, which one interpreter on the GPU (shaders/vm.glsl) runs per //! pixel and per sample. While a line is broken the last good tapes keep //! playing and the problem is marked at its byte. //! //! State is the text, the tapes, the problem and the time, all changed by //! `update` from recorded keys and ticks, so a replay or a seek brings back //! the text, the tape and the picture of that moment. The sound runs on a //! sample clock in Session, set from State's time at every jump (a seek, //! a replay's start) and free-running otherwise, so a paused replay keeps //! sounding its moment. Session holds it, the GPU objects and the scope. const std = @import("std"); const sk = @import("sketch"); const gpu = sk.abi.gpu; const Lang = @import("Lang"); const shaders = @import("shaders"); const scope = @import("scope"); const pe = @import("pardes-editor"); pub const name = "live"; pub const width = 1280; pub const height = 720; /// A change is heard about 6.5 ms after `draw`, not 19-27 (README, sound). pub const audio_pull = 256; pub const commands = .{"capture"}; /// The sound's stream, and its readback's key. const stream = 1; /// The most samples synthesised in one frame. const max_block = 8192; /// The text: pardes's editor, helix's keys over a value of plain data /// (src/lib_editor.zig in pardes), its capacities sized to the language's /// 4 KiB of text. The undo ring keeps whole texts, the oldest dropped: four /// at the most text, hundreds of a short program. 39,264 bytes in all, of a /// State of 43,480. pub const Editor = pe.Editor(.{ .text = 4096, .undo = 16 * 1024, .registers = 1024, .selections = 64 }); pub const State = struct { ed: Editor = .{}, /// The last program that parsed. out: Lang.Tape = .{}, color: Lang.Tape = .{}, /// Hear this: after a node walk (Alt-o, Alt-i, Alt-n, Alt-p), the /// expression the primary range is on, heard and seen (grey) instead of /// out and color until the next key; empty otherwise. probe: Lang.Tape = .{}, /// A number the pointer was pressed on and drags. drag: Drag = .{}, /// What is wrong with the text, if it does not parse (`len` 0: nothing). problem: Lang.Problem = .{}, /// Seconds, from recorded ticks: a replay draws the same frames. time: f32 = 0, /// A new out tape crosses from the old one over a block; `set /// crossfade false` hears (and measures) the click it saves. crossfade: bool = true, }; /// Drag a number: its literal's bytes, at..at + len, rewritten as the /// pointer moves, a step for every 4 pixels to the right (left, down) from /// where it was pressed: its own precision, `220` by ones, `0.25` by /// hundredths. The drag is one step to undo. pub const Drag = struct { active: bool = false, /// Rewritten once: the next frames join its step to undo. moved: bool = false, at: u32 = 0, len: u32 = 0, x: f32 = 0, value: f64 = 0, decimals: u8 = 0, }; pub const Session = struct { picture: sk.Image = .none, size: [2]u32 = .{ 0, 0 }, block: sk.Buffer = .none, /// The out tape and the one it replaces, for synth.comp. tapes: sk.Buffer = .none, /// Seconds: where the next block starts. clock: f64 = 0, /// The tape the last block played. heard: Lang.Tape = .{}, scope: scope.Scope = .{}, /// `capture` appends what is heard to `.capture.f32`. capturing: bool = false, /// Each byte's place in the code as drawn, and the text's revision they /// were laid out at: a layout shapes every piece of the text, and the /// text moves at a key, not at a frame. places: [Editor.capacity.text + 1]sk.text.Caret = undefined, laid: sk.text.Layout = .{}, laid_at: ?u32 = null, }; /// `capture` starts or stops appending what is heard to the sketch's file /// `capture.f32` (mono f32 at the device's rate, beside its save). pub fn command(ss: *Session, c: *sk.Console, line: []const u8) !bool { if (!std.mem.eql(u8, std.mem.trim(u8, line, " \t"), "capture")) return false; ss.capturing = !ss.capturing; c.log(if (ss.capturing) "capturing what is heard to capture.f32" else "capture stopped"); return true; } /// What the editor thaws its value into for each call, reset after it: /// `update` may not allocate from the host, and a fixed buffer keeps a /// call deterministic and bounded. A key at the most text took 29 KiB of it. var scratch: [128 * 1024]u8 = undefined; /// The language's grammar (grammar/, its parser.c compiled in by build.zig), /// handed to the editor at run time. pub extern fn tree_sitter_live() *const pe.syntax.ts.Language; pub fn language() pe.Language { return .{ .name = "live", .ext = ".live", .ts = tree_sitter_live(), .highlights = @embedFile("highlights.scm"), .indents = @embedFile("indents.scm") }; } /// The text's parse, for the editor's node walks (Alt-o, Alt-i, ...): /// derived, so not in State, and kept between calls, as Alt-i goes back the /// way Alt-o came only through its history; forgotten at a jump (`draw`). /// A reload starts it again, with the code its grammar is in. // ponytail: the tree a reload leaves behind is leaked (tree-sitter's // malloc, a few KiB a reload). var syn: pe.Syntax = .{}; pub fn update(s: *State, in: *const sk.Input) void { const revision = s.ed.revision; syn.lang = language(); // a chord's key_down may come with its letter as text too: not typed var chord = false; for (in.events) |e| { var fba: std.heap.FixedBufferAllocator = .init(&scratch); var utf8: [4]u8 = undefined; const k: pe.Key = switch (e.kind) { .tick => { s.time += e.x; continue; }, .mouse_down => { // the byte under the pointer, laid out as `code` draws it, // and the number token there, by the grammar's parse if (e.code != 1) continue; var text: [Editor.capacity.text]u8 = undefined; const t = s.ed.read(&text); const at = fba.allocator().alloc(sk.text.Caret, t.len + 1) catch continue; _ = sk.text.places(t, paragraph(fba.allocator(), &s.ed, t), at); var hit: ?usize = null; for (at[0..t.len], 0..) |c, i| { if (e.y - margin >= c.y and e.y - margin < c.y + c.h and e.x - margin >= c.x) hit = i; } const b = hit orelse continue; if (t[b] == '\n') continue; const tree = syn.parse(fba.allocator(), &s.ed, language()) orelse continue; const n = tree.rootNode().descendantForByteRange(@intCast(b), @intCast(b + 1)) orelse continue; if (!std.mem.eql(u8, n.kind(), "number")) continue; const literal = t[n.startByte()..n.endByte()]; // ponytail: a number with an exponent is not dragged if (std.mem.indexOfScalar(u8, literal, 'e') != null) continue; const point = std.mem.indexOfScalar(u8, literal, '.'); s.drag = .{ .active = true, .at = n.startByte(), .len = @intCast(literal.len), .x = e.x, .value = std.fmt.parseFloat(f64, literal) catch continue, .decimals = @intCast(if (point) |p| literal.len - p - 1 else 0), }; continue; }, .mouse_move => { if (!s.drag.active) continue; const d = &s.drag; const steps = @round((e.x - d.x) / 4); var buf: [32]u8 = undefined; const num = std.fmt.bufPrint(&buf, "{[0]d:.[1]}", .{ d.value + steps * std.math.pow(f64, 10, -@as(f64, @floatFromInt(d.decimals))), d.decimals }) catch continue; var text: [Editor.capacity.text]u8 = undefined; if (std.mem.eql(u8, s.ed.read(&text)[d.at..][0..d.len], num)) continue; if (s.ed.replace(fba.allocator(), d.at, d.at + d.len, num, d.moved) != .done) continue; d.len = @intCast(num.len); d.moved = true; continue; }, .mouse_up, .cancel => { s.drag.active = false; continue; }, .text => text: { const n = std.unicode.utf8Encode(@intCast(@min(e.value, 0x10ffff)), &utf8) catch continue; if (chord) { chord = false; continue; } break :text .{ .cp = @intCast(@min(e.value, 0x10ffff)), .text = utf8[0..n] }; }, .key_down => chord: { const k = key(e) orelse continue; chord = (k.ctrl or k.alt) and k.cp >= ' ' and k.cp < 0x7f; break :chord k; }, else => continue, }; // ponytail: a key the text has no room for is dropped, as part 1's // buffer dropped it; the editor leaves the value as it was. const outcome = s.ed.key(fba.allocator(), &syn, k); s.probe = .{}; if (k.alt and outcome == .done and (k.cp == 'o' or k.cp == 'i' or k.cp == 'n' or k.cp == 'p')) probe: { fba.reset(); const ranges = fba.allocator().create([pe.max_selections]pe.Selection) catch break :probe; const got = s.ed.ranges(fba.allocator(), ranges) catch break :probe; const r = ranges[got.primary]; var text: [Editor.capacity.text]u8 = undefined; switch (Lang.compile(s.ed.read(&text), .{ @intCast(@min(r.anchor, r.head)), @intCast(@max(r.anchor, r.head)) })) { .program => |p| s.probe = p.probe, .problem => {}, } } } if (s.ed.revision == revision) return; var text: [Editor.capacity.text]u8 = undefined; switch (Lang.compile(s.ed.read(&text), null)) { .program => |p| { s.out = p.out; s.color = p.color; s.problem = .{}; }, .problem => |p| s.problem = p, } } /// A key_down as the editor takes it: the specials, and chords (ctrl or alt /// with a letter, digit or sign), helix's `A-I` an upper-case letter with /// alt. A printable without a chord comes as `text`, so it is not one here. fn key(e: sk.Event) ?pe.Key { const mods = e.value; const ctrl = mods & sk.Key.Mod.ctrl != 0; const alt = mods & sk.Key.Mod.alt != 0; const shift = mods & sk.Key.Mod.shift != 0; const special: u21 = switch (e.key()) { .escape => pe.Key.escape, .@"return", .keypad_enter, .return2 => pe.Key.enter, .backspace => pe.Key.backspace, .tab => pe.Key.tab, .delete => pe.Key.delete, .left => pe.Key.left, .right => pe.Key.right, .up => pe.Key.up, .down => pe.Key.down, .home => pe.Key.home, .end => pe.Key.end, .page_up => pe.Key.page_up, .page_down => pe.Key.page_down, else => 0, }; if (special != 0) return .{ .cp = special, .ctrl = ctrl, .alt = alt, .shift = shift }; if (!ctrl and !alt) return null; const scan = @backingInt(e.key()); const cp: u21 = switch (e.key()) { .a, .b, .c, .d, .e, .f, .g, .h, .i, .j, .k, .l, .m, .n, .o, .p, .q, .r, .s, .t, .u, .v, .w, .x, .y, .z => @as(u21, if (shift) 'A' else 'a') + scan - @backingInt(sk.Key.a), .@"1", .@"2", .@"3", .@"4", .@"5", .@"6", .@"7", .@"8", .@"9" => '1' + @as(u21, scan - @backingInt(sk.Key.@"1")), .@"0" => '0', .space => ' ', .minus => '-', .equals => '=', .left_bracket => '[', .right_bracket => ']', .semicolon => ';', .comma => ',', .period => '.', .slash => '/', else => return null, }; return .{ .cp = cp, .ctrl = ctrl, .alt = alt }; } const synth: gpu.Kernel = .{ .code = shaders.synth_comp, .readonly_buffers = 1, .readwrite_buffers = 1, .uniform_buffers = 1 }; const picture_pipeline: gpu.Pipeline = .{ .vertex = .{ .code = shaders.fullscreen_vert }, .fragment = .{ .code = shaders.picture_frag, .uniform_buffers = 1 }, .stride = 0, .attributes = &.{}, .blend = .none, }; pub fn draw(s: *const State, ss: *Session, f: *sk.Frame) void { if (f.in.jumped) syn.forget(); // The canvas is the window's own pixels: text lands on whole pixels // of the display, where a fixed canvas the window scales would blur it. const room: [2]f32 = .{ @max(f.in.window_width, 640), @max(f.in.window_height, 360) }; f.canvas(@intFromFloat(room[0]), @intFromFloat(room[1])); f.clear(0x000000); if (!f.host.gpu()) { f.text(16, 16, 2, "live needs a GPU: the host has none.", 0xff8080); return; } // A tape past 64 instructions is drawn at half resolution: at 1280x720 // 128 instructions took 2.7 ms of the GPU, at half 0.85 (the probe). // A window taller than 720 has the picture at 720 rows, scaled up, so // the GPU's time stays that. const seen = if (s.probe.len > 0) &s.probe else &s.color; const rows = @min(room[1], 720) / @as(f32, if (seen.len > 64) 2 else 1); const size: [2]u32 = .{ @intFromFloat(@round(room[0] * rows / room[1])), @intFromFloat(rows) }; if (!std.meta.eql(ss.size, size)) { if (ss.picture != .none) f.host.freeImage(ss.picture); ss.picture = f.host.newImage(size[0], size[1]); ss.size = size; } f.gpu(.{ .label = "picture", .image = ss.picture, .width = size[0], .height = size[1], .pipelines = &.{picture_pipeline}, .draws = &.{.{ .pipeline = 0, .vertex_count = 3, .fragment_uniforms = gpu.uniform(f.scratch, Lang.Picture{ .tape = std.mem.bytesToValue([Lang.max_tape][4]u32, &seen.code), .len = seen.len, .time = s.time, .size = .{ @floatFromInt(size[0]), @floatFromInt(size[1]) }, }) }}, }); f.image(ss.picture, .{ .x = 0, .y = 0, .w = room[0], .h = room[1] }, .{}); sound(s, ss, f, room); code(s, ss, f, room); } /// The out tape over the sample clock, as much as keeps the host's lead /// queued, streamed from the GPU's block; and read back for the scope. fn sound(s: *const State, ss: *Session, f: *sk.Frame, room: [2]f32) void { const in = f.in; for (in.downloads) |d| if (d.key == stream) { const samples = f.scratch.alloc(f32, d.bytes.len / 4) catch continue; @memcpy(std.mem.sliceAsBytes(samples), d.bytes[0 .. samples.len * 4]); ss.scope.push(samples); if (ss.capturing) _ = f.host.appendFile("capture.f32", d.bytes); }; if (ss.block == .none) { ss.block = f.host.newBuffer(max_block * @sizeOf(f32)); ss.tapes = f.host.newBuffer(2 * @sizeOf(Lang.Tape.Code)); } // A jump is heard at once: what was queued from before it is dropped, // and the block crosses from where the device was to the new time. const rate: f64 = @floatFromInt(in.sample_rate); var queued = in.stream(stream).queued; const was = ss.clock - @as(f64, @floatFromInt(queued)) / rate; if (in.jumped) { ss.clock = s.time; queued = 0; f.audio(stream, &.{}, .{ .clear = true }); } const want: u32 = @min(in.lead -| queued, max_block); if (want > 0) { const heard = if (s.probe.len > 0) &s.probe else &s.out; const new = std.mem.sliceAsBytes(heard.slice()); const changed = in.jumped or !std.mem.eql(u8, new, std.mem.sliceAsBytes(ss.heard.slice())); const tapes = f.scratch.create([2]Lang.Tape.Code) catch return; tapes.* = .{ heard.code, ss.heard.code }; f.upload(ss.tapes, 0, std.mem.asBytes(tapes)); f.compute(.{ .label = "synth", .kernel = synth, .readonly = &.{ss.tapes}, .readwrite = &.{ss.block}, .uniforms = gpu.uniform(f.scratch, Lang.Synth{ .len = heard.len, .old_len = ss.heard.len, .count = want, .fade = if (changed and s.crossfade) want else 0, .start = @floatCast(ss.clock), .old_start = @floatCast(if (in.jumped) was else ss.clock), .rate = @floatCast(rate), }), .groups = .{ (want + 63) / 64, 1, 1 }, }); f.audioBuffer(stream, ss.block, .{ .count = want }); f.download(ss.block, .{ .size = want * @sizeOf(f32), .key = stream }); ss.clock += @as(f64, @floatFromInt(want)) / rate; ss.heard = heard.*; } ss.scope.draw(f, .{ .oscilloscope = .{ .rect = .{ .x = 16, .y = room[1] - 104, .w = 480, .h = 88 }, .samples = 1024 }, .spectrum = .{ .x = 512, .y = room[1] - 104, .w = 480, .h = 88 }, }); } const scale = 1.25; /// The name a line defines is this much larger than the rest. const step = 1.2; const margin = 16; const ink = 0xe8e8e8; const red = 0xff5a50; const selected: sk.Color = .{ .r = 0x3c, .g = 0x6e, .b = 0xc8, .a = 170 }; const also_selected: sk.Color = .{ .r = 0x3c, .g = 0x6e, .b = 0xc8, .a = 90 }; /// pardes's own theme: its text's ink and a class's. const theme = &pe.syntax.themes[0]; /// The code as a paragraph in the code face: a span in its class's ink /// where the grammar's class changes, in `a`. `code` draws it and `update` /// lays out the same to find the byte under the pointer. fn paragraph(a: std.mem.Allocator, ed: *const Editor, text: []const u8) sk.text.Paragraph { const base = pe.syntax.ink(theme); var p: sk.text.Paragraph = .{ .face = .code, .scale = scale, .color = .{ .r = base[0], .g = base[1], .b = base[2] } }; // a class a byte, from the grammar's highlights (none if it fails) const classes = pe.Syntax.colors(a, ed, language(), 0, text.len) catch return p; var runs: usize = 0; for (classes, 0..) |class, i| runs += @intFromBool(i == 0 or classes[i - 1] != class); const spans = a.alloc(sk.text.Span, runs) catch return p; var n: usize = 0; for (classes, 0..) |class, i| { if (i > 0 and classes[i - 1] == class) continue; const c = pe.syntax.synInk(theme, class) orelse base; // the name a line defines, a step larger: the class the grammar's // highlights give a definition's name node, and it alone // (queries/highlights.scm) spans[n] = .{ .start = @intCast(i), .color = .{ .r = c[0], .g = c[1], .b = c[2] }, .scale = if (class == .keyword) scale * step else null }; n += 1; } p.spans = spans; return p; } /// Byte `i`'s box, laid out at `margin`: from its place to the next byte's /// on its line; a `\n` and the end are `space` wide. fn box(at: []const sk.text.Caret, i: usize, space: f32) sk.Rect { const right = if (i + 1 < at.len and at[i + 1].y == at[i].y) at[i + 1].x else at[i].x + space; return .{ .x = margin + at[i].x, .y = margin + at[i].y, .w = right - at[i].x, .h = at[i].h }; } /// The editor's text over the picture on a dark band: its lines coloured /// by the grammar in pardes's theme, every range (the primary stronger), a /// caret at each range's head that says the mode (a block in normal and /// select, a bar in insert), the mode's name in the corner; the problem as /// a red mark under its byte and its words under the text. Every place is /// measured: one layout gives each byte's (kept until the text moves), /// another draws. fn code(s: *const State, ss: *Session, f: *sk.Frame, room: [2]f32) void { const text = s.ed.bytes(f.scratch) catch return; const ranges = f.scratch.create([pe.max_selections]pe.Selection) catch return; const got = s.ed.ranges(f.scratch, ranges) catch return; const p = paragraph(f.scratch, &s.ed, text); const at = ss.places[0 .. text.len + 1]; // a revision counts keys, it does not name a text: a jump can land on // another text with the same count if (ss.laid_at != s.ed.revision or f.in.jumped) { ss.laid = sk.text.places(text, p, at); ss.laid_at = s.ed.revision; } const laid = ss.laid; const space = sk.text.size(.code, scale, " ")[0]; const problem = s.problem.len > 0; const words: [2]f32 = if (problem) sk.text.size(.code, scale, s.problem.text()) else .{ 0, 0 }; f.fill(.{ .x = 0, .y = 0, .w = @max(24 * space, laid.w + space, words[0]) + 2 * margin, .h = laid.h + words[1] + 2 * margin }, sk.Color{ .r = 0, .g = 0, .b = 0, .a = 150 }); // a range a run of boxes on each line it covers for (ranges[0..got.n], 0..) |r, n| { var i: usize = @min(r.anchor, r.head); const to = @max(r.anchor, r.head); while (i < to) { var j = i + 1; while (j < to and at[j].y == at[i].y) j += 1; const first = box(at, i, space); const last = box(at, j - 1, space); f.fill(.{ .x = first.x, .y = first.y, .w = last.x + last.w - first.x, .h = first.h }, if (n == got.primary) selected else also_selected); i = j; } } _ = f.paragraph(margin, margin, text, p); for (ranges[0..got.n], 0..) |r, n| { // the head's character: the one before it in a range that grows // forward const b = box(at, if (r.head > r.anchor) r.head - 1 else r.head, space); const caret: sk.Color = .{ .r = 0xe8, .g = 0xe8, .b = 0xe8, .a = if (n == got.primary) 200 else 110 }; if (s.ed.mode() == .insert) { f.fill(.{ .x = b.x - 1, .y = b.y, .w = 2, .h = b.h }, caret); } else f.fill(b, caret.alpha(caret.a / 2)); } if (problem) { const b = box(at, @min(s.problem.at, text.len), space); f.fill(.{ .x = b.x, .y = b.y + b.h - 2, .w = b.w, .h = 2 }, red); f.textIn(.code, margin, margin + laid.h, scale, s.problem.text(), red); } const mode = switch (f.in.mode) { .live => "live", .recording => "recording", .playing => "replay", .paused => "paused", }; const lead = @as(f32, @floatFromInt(f.in.lead)) / @as(f32, @floatFromInt(f.in.sample_rate)) * 1000; f.print(room[0] - 300, 12, 1, ink, "{s} {s} {d:.1} s lead {d:.1} ms", .{ switch (s.ed.mode()) { .normal => "NOR", .insert => "INS", .select => "SEL", }, mode, s.time, lead }); }