summaryrefslogtreecommitdiff
path: root/examples/live/src
diff options
context:
space:
mode:
Diffstat (limited to 'examples/live/src')
-rw-r--r--examples/live/src/Lang.zig754
-rw-r--r--examples/live/src/main.zig494
-rw-r--r--examples/live/src/probe.zig133
3 files changed, 1381 insertions, 0 deletions
diff --git a/examples/live/src/Lang.zig b/examples/live/src/Lang.zig
new file mode 100644
index 0000000..4ce504e
--- /dev/null
+++ b/examples/live/src/Lang.zig
@@ -0,0 +1,754 @@
+//! The language: lines of `name = expression` over `t`, `x` and `y`,
+//! compiled into two tapes, `out` (heard, -1..1) and `color` (seen), that
+//! one interpreter (shaders/vm.glsl) runs per sample and per pixel. Names
+//! are shared by both lines; a name is defined once, before it is used, so
+//! a program is a graph without cycles and every program ends.
+//!
+//! beat = t * 2
+//! kick = exp(-7 * fract(beat))
+//! out = sin(tau * 48 * t) * kick # heard
+//! color = hsv(x, 0.5, y * kick) # seen
+//!
+//! `+ - * /`, unary `-` and parentheses; numbers like 0.5, 120, 1e-3;
+//! `#` to the end of the line is a comment; the builtins are `builtins`.
+//!
+//! A tape is at most `max_tape` instructions, holding only what its line
+//! reaches; instruction i writes register i from earlier ones. Its GPU
+//! form is the uniform blocks at the end of this file, and build.zig
+//! writes `Op` out as ops.glsl for the shaders: this file is the one
+//! definition of both. `compile` allocates nothing: its work is a few
+//! fixed arrays on the stack (`max_terms`, `max_names`, `max_depth`), and a
+//! program past any of them is a problem like any other, in words.
+const std = @import("std");
+
+pub const max_tape = 128;
+/// Numbers, names used and operations in the whole text.
+pub const max_terms = 512;
+/// Lines that define a name.
+pub const max_names = 128;
+/// Parentheses and unary minuses inside each other.
+pub const max_depth = 32;
+/// seq's index and values.
+pub const max_args = 17;
+
+/// By how many registers an instruction reads: none, one, two, three.
+pub const Op = enum(u32) {
+ /// `a` is the value's bits.
+ constant,
+ t,
+ x,
+ y,
+ neg,
+ sin,
+ cos,
+ exp,
+ log,
+ sqrt,
+ abs,
+ floor,
+ fract,
+ saw,
+ sqr,
+ tri,
+ /// Register `a`, so that seq's values sit side by side.
+ copy,
+ /// Register `b + floor(a) mod c`: `b` and `c` are numbers, not
+ /// registers it reads, and registers b.. hold the values.
+ seq,
+ add,
+ sub,
+ mul,
+ div,
+ pow,
+ min,
+ max,
+ step,
+ atan2,
+ clamp,
+ mix,
+ smoothstep,
+ noise,
+ /// A colour, only as the color tape's last instruction.
+ hsv,
+ rgb,
+};
+
+pub const Builtin = struct {
+ /// As it is called, for the manual.
+ call: []const u8,
+ op: Op,
+ /// Arguments; 0 for an input or a constant, used without parentheses.
+ min: u8 = 0,
+ max: u8 = 0,
+ value: f32 = 0,
+ doc: []const u8,
+
+ pub fn name(b: Builtin) []const u8 {
+ return b.call[0 .. std.mem.indexOfScalar(u8, b.call, '(') orelse b.call.len];
+ }
+};
+
+/// The builtins, the one table: a name is added here and in vm.glsl's
+/// switch, and only for a program that needs it.
+pub const builtins = [_]Builtin{
+ .{ .call = "t", .op = .t, .doc = "seconds" },
+ .{ .call = "x", .op = .x, .doc = "across, in half the window's height: 0 at the centre, -1.78 to 1.78 on 16:9; 0 in sound" },
+ .{ .call = "y", .op = .y, .doc = "up, in half the window's height: -1 at the bottom, 0 at the centre, 1 at the top; 0 in sound" },
+ .{ .call = "tau", .op = .constant, .value = std.math.tau, .doc = "a turn in radians, 6.283..." },
+ .{ .call = "pi", .op = .constant, .value = std.math.pi, .doc = "half a turn, 3.141..." },
+ .{ .call = "sin(a)", .op = .sin, .min = 1, .max = 1, .doc = "sine, of radians" },
+ .{ .call = "cos(a)", .op = .cos, .min = 1, .max = 1, .doc = "cosine, of radians" },
+ .{ .call = "exp(a)", .op = .exp, .min = 1, .max = 1, .doc = "e to the a" },
+ .{ .call = "log(a)", .op = .log, .min = 1, .max = 1, .doc = "natural logarithm" },
+ .{ .call = "pow(a, b)", .op = .pow, .min = 2, .max = 2, .doc = "a to the b (a not negative)" },
+ .{ .call = "sqrt(a)", .op = .sqrt, .min = 1, .max = 1, .doc = "square root" },
+ .{ .call = "abs(a)", .op = .abs, .min = 1, .max = 1, .doc = "a without its sign" },
+ .{ .call = "floor(a)", .op = .floor, .min = 1, .max = 1, .doc = "the whole number at or below a" },
+ .{ .call = "fract(a)", .op = .fract, .min = 1, .max = 1, .doc = "a - floor(a): 0..1, again every 1" },
+ .{ .call = "min(a, b)", .op = .min, .min = 2, .max = 2, .doc = "the smaller" },
+ .{ .call = "max(a, b)", .op = .max, .min = 2, .max = 2, .doc = "the larger" },
+ .{ .call = "clamp(v, lo, hi)", .op = .clamp, .min = 3, .max = 3, .doc = "v kept between lo and hi" },
+ .{ .call = "mix(a, b, w)", .op = .mix, .min = 3, .max = 3, .doc = "a + (b - a) * w" },
+ .{ .call = "step(edge, v)", .op = .step, .min = 2, .max = 2, .doc = "0 below edge, 1 from it on" },
+ .{ .call = "smoothstep(lo, hi, v)", .op = .smoothstep, .min = 3, .max = 3, .doc = "0 to 1, smoothly, as v goes from lo to hi (either way round)" },
+ .{ .call = "atan2(y, x)", .op = .atan2, .min = 2, .max = 2, .doc = "the angle of the point (x, y), radians" },
+ .{ .call = "noise(x, y, z)", .op = .noise, .min = 1, .max = 3, .doc = "smooth noise, -1..1, a new value about every 1; y and z are 0 when left out" },
+ .{ .call = "saw(p)", .op = .saw, .min = 1, .max = 1, .doc = "a sawtooth, -1..1, of period 1 (cycles, not radians), rising through 0 at 0" },
+ .{ .call = "sqr(p)", .op = .sqr, .min = 1, .max = 1, .doc = "a square wave, 1 then -1, of period 1" },
+ .{ .call = "tri(p)", .op = .tri, .min = 1, .max = 1, .doc = "a triangle wave, -1..1, of period 1, rising through 0 at 0" },
+ .{ .call = "seq(i, v0, v1, ...)", .op = .seq, .min = 2, .max = max_args, .doc = "the value at floor(i), round the list: a step pattern (16 values at most)" },
+ .{ .call = "hsv(h, s, v)", .op = .hsv, .min = 3, .max = 3, .doc = "a colour: hue round the wheel 0..1, saturation, value; only as the whole color line" },
+ .{ .call = "rgb(r, g, b)", .op = .rgb, .min = 3, .max = 3, .doc = "a colour, red, green and blue 0..1; only as the whole color line" },
+};
+
+fn builtin(name: []const u8) ?Builtin {
+ for (builtins) |b| if (std.mem.eql(u8, b.name(), name)) return b;
+ return null;
+}
+
+pub const Instruction = extern struct {
+ op: Op = .constant,
+ a: u32 = 0,
+ b: u32 = 0,
+ c: u32 = 0,
+};
+
+pub const Tape = struct {
+ len: u32 = 0,
+ code: Code = @splat(.{}),
+
+ pub const Code = [max_tape]Instruction;
+
+ pub fn slice(tape: *const Tape) []const Instruction {
+ return tape.code[0..@min(tape.len, max_tape)];
+ }
+};
+
+/// What is wrong with a program, and where: a byte of its text.
+pub const Problem = struct {
+ at: u32 = 0,
+ len: u32 = 0,
+ words: [96]u8 = @splat(0),
+
+ pub fn text(p: *const Problem) []const u8 {
+ return p.words[0..@min(p.len, p.words.len)];
+ }
+};
+
+/// `probe` is what is heard and seen instead of the program while a
+/// selection is on an expression (main.zig): empty when none is asked for,
+/// none holds it, or it is longer than a tape.
+pub const Program = struct { out: Tape = .{}, color: Tape = .{}, probe: Tape = .{} };
+
+pub const Result = union(enum) { program: Program, problem: Problem };
+
+/// `probe`: bytes from..to of the text, a selection; the smallest
+/// expression holding them is compiled as `Program.probe`.
+pub fn compile(text: []const u8, probe: ?[2]u32) Result {
+ var c: Compiler = .{ .text = text, .probe = probe };
+ var program: Program = .{};
+ c.lines() catch return .{ .problem = c.problem };
+ for ([_]struct { *Tape, []const u8 }{ .{ &program.out, "out" }, .{ &program.color, "color" } }) |line| {
+ const name = c.lookup(line[1]) orelse continue;
+ var registers: [max_terms]u16 = @splat(none);
+ _ = c.emit(line[0], name.term, &registers) catch
+ return .{ .problem = (c.fail(name.at, "the {s} line needs more than {d} instructions", .{ line[1], max_tape }) catch c.problem) };
+ }
+ if (c.heard != none) {
+ var registers: [max_terms]u16 = @splat(none);
+ _ = c.emit(&program.probe, c.heard, &registers) catch {
+ program.probe = .{};
+ };
+ }
+ return .{ .program = program };
+}
+
+const none = std.math.maxInt(u16);
+
+const Term = struct {
+ op: Op,
+ value: f32 = 0,
+ /// Where it was written.
+ at: u32,
+ len: u8 = 0,
+ args: [max_args]u16 = undefined,
+};
+
+const Name = struct { text: []const u8, term: u16, at: u32 };
+
+const Token = struct {
+ kind: enum { name, number, symbol, newline, end },
+ at: u32,
+ end: u32,
+ symbol: u8 = 0,
+
+ fn is(tok: Token, symbol: u8) bool {
+ return tok.kind == .symbol and tok.symbol == symbol;
+ }
+};
+
+const Compiler = struct {
+ text: []const u8,
+ pos: u32 = 0,
+ terms: [max_terms]Term = undefined,
+ term_count: u16 = 0,
+ names: [max_names]Name = undefined,
+ name_count: u16 = 0,
+ /// The term of t, x and y, made once.
+ inputs: [3]u16 = .{ none, none, none },
+ depth: u8 = 0,
+ /// The line's hsv or rgb, if it called one.
+ colour: u16 = none,
+ problem: Problem = .{},
+ /// The bytes probed, and the smallest expression found holding them.
+ probe: ?[2]u32 = null,
+ heard: u16 = none,
+ heard_len: u32 = std.math.maxInt(u32),
+
+ /// The expression from byte `from` to where the parse is, its term `t`:
+ /// the probe's, if it is the smallest yet that holds the probed bytes.
+ fn spanned(c: *Compiler, from: u32, t: u16) u16 {
+ const p = c.probe orelse return t;
+ if (from <= p[0] and p[1] <= c.pos and c.pos - from < c.heard_len) {
+ c.heard = t;
+ c.heard_len = c.pos - from;
+ }
+ return t;
+ }
+
+ fn fail(c: *Compiler, at: u32, comptime fmt: []const u8, args: anytype) error{Problem} {
+ c.problem = .{ .at = at };
+ var w: std.Io.Writer = .fixed(&c.problem.words);
+ w.print(fmt, args) catch {};
+ c.problem.len = @intCast(w.end);
+ return error.Problem;
+ }
+
+ fn span(c: *const Compiler, tok: Token) []const u8 {
+ return c.text[tok.at..tok.end];
+ }
+
+ fn next(c: *Compiler) Token {
+ const s = c.text;
+ var i = c.pos;
+ while (i < s.len and (s[i] == ' ' or s[i] == '\t' or s[i] == '\r')) i += 1;
+ if (i < s.len and s[i] == '#') while (i < s.len and s[i] != '\n') : (i += 1) {};
+ const at = i;
+ defer c.pos = i;
+ if (i == s.len) return .{ .kind = .end, .at = at, .end = at };
+ switch (s[i]) {
+ '\n' => {
+ i += 1;
+ return .{ .kind = .newline, .at = at, .end = i };
+ },
+ 'a'...'z', 'A'...'Z', '_' => {
+ while (i < s.len and (std.ascii.isAlphanumeric(s[i]) or s[i] == '_')) i += 1;
+ return .{ .kind = .name, .at = at, .end = i };
+ },
+ '0'...'9', '.' => {
+ while (i < s.len and (std.ascii.isDigit(s[i]) or s[i] == '.' or s[i] == 'e' or
+ ((s[i] == '-' or s[i] == '+') and s[i - 1] == 'e'))) i += 1;
+ return .{ .kind = .number, .at = at, .end = i };
+ },
+ else => {
+ i += 1;
+ return .{ .kind = .symbol, .at = at, .end = i, .symbol = s[at] };
+ },
+ }
+ }
+
+ fn peek(c: *Compiler) Token {
+ const pos = c.pos;
+ defer c.pos = pos;
+ return c.next();
+ }
+
+ fn describe(c: *const Compiler, tok: Token) []const u8 {
+ return switch (tok.kind) {
+ .newline, .end => "the end of the line",
+ else => c.span(tok),
+ };
+ }
+
+ fn term(c: *Compiler, t: Term) !u16 {
+ if (c.term_count == max_terms) return c.fail(t.at, "the program is longer than {d} terms", .{max_terms});
+ c.terms[c.term_count] = t;
+ c.term_count += 1;
+ return c.term_count - 1;
+ }
+
+ fn call(c: *Compiler, op: Op, at: u32, args: []const u16) !u16 {
+ var t: Term = .{ .op = op, .at = at, .len = @intCast(args.len) };
+ @memcpy(t.args[0..args.len], args);
+ return c.term(t);
+ }
+
+ fn lookup(c: *const Compiler, name: []const u8) ?Name {
+ for (c.names[0..c.name_count]) |n| if (std.mem.eql(u8, n.text, name)) return n;
+ return null;
+ }
+
+ fn lines(c: *Compiler) !void {
+ while (true) {
+ const first = c.next();
+ switch (first.kind) {
+ .end => return,
+ .newline => continue,
+ .name => {},
+ else => return c.fail(first.at, "a line is a name, =, and an expression", .{}),
+ }
+ const name = c.span(first);
+ const eq = c.next();
+ if (!eq.is('=')) return c.fail(eq.at, "expected = after {s}, found {s}", .{ name, c.describe(eq) });
+ if (builtin(name) != null) return c.fail(first.at, "{s} is a builtin: call yours something else", .{name});
+ if (c.lookup(name) != null) return c.fail(first.at, "{s} is defined twice: a name is given once", .{name});
+ c.colour = none;
+ const root = c.spanned(first.at, try c.expr());
+ const after = c.next();
+ if (after.kind != .newline and after.kind != .end) return c.fail(after.at, "expected the end of the line, found {s}", .{c.describe(after)});
+ if (c.colour != none and (c.colour != root or !std.mem.eql(u8, name, "color")))
+ return c.fail(c.terms[c.colour].at, "a colour (hsv, rgb) can only be the whole color line", .{});
+ if (c.name_count == max_names) return c.fail(first.at, "more than {d} names", .{max_names});
+ c.names[c.name_count] = .{ .text = name, .term = root, .at = first.at };
+ c.name_count += 1;
+ }
+ }
+
+ fn enter(c: *Compiler, at: u32) !void {
+ if (c.depth == max_depth) return c.fail(at, "nested more than {d} deep", .{max_depth});
+ c.depth += 1;
+ }
+
+ fn expr(c: *Compiler) error{Problem}!u16 {
+ const from = c.peek().at;
+ try c.enter(from);
+ defer c.depth -= 1;
+ var left = try c.product();
+ while (true) {
+ const tok = c.peek();
+ const op: Op = if (tok.is('+')) .add else if (tok.is('-')) .sub else return left;
+ _ = c.next();
+ left = c.spanned(from, try c.call(op, tok.at, &.{ left, try c.product() }));
+ }
+ }
+
+ fn product(c: *Compiler) !u16 {
+ const from = c.peek().at;
+ var left = try c.unary();
+ while (true) {
+ const tok = c.peek();
+ const op: Op = if (tok.is('*')) .mul else if (tok.is('/')) .div else return left;
+ _ = c.next();
+ left = c.spanned(from, try c.call(op, tok.at, &.{ left, try c.unary() }));
+ }
+ }
+
+ fn unary(c: *Compiler) error{Problem}!u16 {
+ const tok = c.peek();
+ if (!tok.is('-')) return c.primary();
+ _ = c.next();
+ try c.enter(tok.at);
+ defer c.depth -= 1;
+ const a = try c.unary();
+ // A negative number is a number (each literal is a term of its own).
+ if (c.terms[a].op == .constant) {
+ c.terms[a].value = -c.terms[a].value;
+ return c.spanned(tok.at, a);
+ }
+ return c.spanned(tok.at, try c.call(.neg, tok.at, &.{a}));
+ }
+
+ fn primary(c: *Compiler) !u16 {
+ const tok = c.next();
+ switch (tok.kind) {
+ .number => {
+ const value = std.fmt.parseFloat(f32, c.span(tok)) catch return c.fail(tok.at, "{s} is not a number", .{c.span(tok)});
+ return c.spanned(tok.at, try c.term(.{ .op = .constant, .value = value, .at = tok.at }));
+ },
+ .name => {
+ const name = c.span(tok);
+ if (c.peek().is('(')) return c.spanned(tok.at, try c.callOf(tok));
+ if (c.lookup(name)) |n| {
+ if (c.terms[n.term].op == .hsv or c.terms[n.term].op == .rgb) return c.fail(tok.at, "{s} is a colour: only the color line can be one", .{name});
+ return c.spanned(tok.at, n.term);
+ }
+ const b = builtin(name) orelse return c.fail(tok.at, "{s} is not defined above", .{name});
+ if (b.max > 0) return c.fail(tok.at, "{s} takes arguments: {s}", .{ name, b.call });
+ const input: ?usize = switch (b.op) {
+ .t => 0,
+ .x => 1,
+ .y => 2,
+ else => null,
+ };
+ const i = input orelse return c.spanned(tok.at, try c.term(.{ .op = b.op, .value = b.value, .at = tok.at }));
+ if (c.inputs[i] == none) c.inputs[i] = try c.term(.{ .op = b.op, .at = tok.at });
+ return c.spanned(tok.at, c.inputs[i]);
+ },
+ .newline, .end => return c.fail(tok.at, "expected an expression before the end of the line", .{}),
+ .symbol => {
+ if (!tok.is('(')) {
+ if (c.text[tok.at] < 0x20 or c.text[tok.at] > 0x7e) return c.fail(tok.at, "byte 0x{x:0>2} is not part of the language", .{c.text[tok.at]});
+ return c.fail(tok.at, "expected an expression, found {s}", .{c.span(tok)});
+ }
+ const inner = try c.expr();
+ const close = c.next();
+ if (!close.is(')')) return c.fail(close.at, "expected ) to close the ( at byte {d}, found {s}", .{ tok.at, c.describe(close) });
+ return c.spanned(tok.at, inner);
+ },
+ }
+ }
+
+ /// `name(args)`, `name` being `tok`.
+ fn callOf(c: *Compiler, tok: Token) !u16 {
+ const name = c.span(tok);
+ _ = c.next();
+ const b = builtin(name) orelse {
+ if (c.lookup(name) != null) return c.fail(tok.at, "{s} is a name, not a builtin: it takes no ( )", .{name});
+ return c.fail(tok.at, "{s} is not a builtin", .{name});
+ };
+ if (b.max == 0) return c.fail(tok.at, "{s} takes no arguments", .{name});
+ var args: [max_args]u16 = undefined;
+ var n: u8 = 0;
+ if (c.peek().is(')')) {
+ _ = c.next();
+ } else while (true) {
+ const at = c.peek().at;
+ if (n == b.max) return c.fail(at, "{s} takes at most {d} arguments: {s}", .{ name, b.max, b.call });
+ args[n] = try c.expr();
+ n += 1;
+ const sep = c.next();
+ if (sep.is(')')) break;
+ if (!sep.is(',')) return c.fail(sep.at, "expected , or ) in {s}(...), found {s}", .{ name, c.describe(sep) });
+ }
+ if (n < b.min) return c.fail(tok.at, "{s} takes {d} arguments, not {d}: {s}", .{ name, b.min, n, b.call });
+ if (b.op == .noise) while (n < 3) : (n += 1) {
+ args[n] = try c.term(.{ .op = .constant, .at = tok.at });
+ };
+ const t = try c.call(b.op, tok.at, args[0..n]);
+ if (b.op == .hsv or b.op == .rgb) c.colour = t;
+ return t;
+ }
+
+ fn push(into: *Tape, i: Instruction) !u32 {
+ if (into.len == max_tape) return error.Full;
+ into.code[into.len] = i;
+ into.len += 1;
+ return into.len - 1;
+ }
+
+ fn emit(c: *const Compiler, into: *Tape, at: u16, registers: *[max_terms]u16) error{Full}!u32 {
+ if (registers[at] != none) return registers[at];
+ const t = c.terms[at];
+ var r: [max_args]u32 = @splat(0);
+ for (t.args[0..t.len], 0..) |arg, i| r[i] = try c.emit(into, arg, registers);
+ const i: Instruction = switch (t.op) {
+ .constant => .{ .op = .constant, .a = @bitCast(t.value) },
+ .seq => seq: {
+ // The values in registers side by side: as they are when
+ // each was emitted just now, else copied.
+ const values = r[1..t.len];
+ var first = values[0];
+ for (values, 0..) |v, k| {
+ if (v != values[0] + k) {
+ first = @intCast(into.len);
+ for (values) |each| _ = try push(into, .{ .op = .copy, .a = each });
+ break;
+ }
+ }
+ break :seq .{ .op = .seq, .a = r[0], .b = first, .c = @intCast(values.len) };
+ },
+ else => .{ .op = t.op, .a = r[0], .b = r[1], .c = r[2] },
+ };
+ const register = try push(into, i);
+ registers[at] = @intCast(register);
+ return register;
+ }
+};
+
+/// picture.frag's uniforms (SDL_GPU's fragment set).
+pub const Picture = extern struct {
+ tape: [max_tape][4]u32,
+ len: u32,
+ /// Seconds.
+ time: f32,
+ /// The target, pixels.
+ size: [2]f32,
+
+ pub const glsl = .{ .uniform = .{ .set = 3, .instance = "u" } };
+};
+
+/// synth.comp's uniforms (SDL_GPU's compute set). Its tapes, the new one
+/// and the one it replaces, which the first `fade` samples cross from, are
+/// a storage buffer: SDL_GPU's Vulkan backend binds a uniform block 4 KiB
+/// at a time, and two tapes are 4 KiB alone.
+pub const Synth = extern struct {
+ len: u32,
+ old_len: u32,
+ /// Samples in the block.
+ count: u32,
+ fade: u32,
+ /// The block's first sample, seconds; the old tape's, which differs
+ /// after a jump (a seek: the old tape where the device was).
+ start: f32,
+ old_start: f32,
+ rate: f32,
+ pad: f32 = 0,
+
+ pub const glsl = .{ .uniform = .{ .set = 2, .instance = "u" } };
+};
+
+// ---------------------------------------------------------------------------
+// Tests.
+
+const testing = std.testing;
+
+fn compiled(text: []const u8) !Program {
+ return switch (compile(text, null)) {
+ .program => |p| p,
+ .problem => |p| {
+ std.debug.print("unexpected problem at {d}: {s}\n", .{ p.at, p.text() });
+ return error.TestUnexpectedResult;
+ },
+ };
+}
+
+fn ops(tape: Tape) [max_tape]Op {
+ var out: [max_tape]Op = @splat(.constant);
+ for (tape.slice(), 0..) |i, k| out[k] = i.op;
+ return out;
+}
+
+fn expectOps(tape: Tape, want: []const Op) !void {
+ try testing.expectEqualSlices(Op, want, ops(tape)[0..tape.len]);
+}
+
+/// The survey's program (reports/demo1.md, ยง1 A); main.zig's test of the
+/// grammar parses it too.
+pub const survey =
+ \\# the beat, shared by sound and picture
+ \\bpm = 120
+ \\beat = t * bpm / 60
+ \\kick = exp(-7 * fract(beat))
+ \\bar = beat / 4
+ \\# sound: out is what you hear, -1..1
+ \\root = seq(bar, 55, 55, 65.4, 49)
+ \\bass = saw(root * t) * (1 - kick) * 0.25
+ \\thump = sin(tau * 48 * t * (1 + 2 * kick)) * kick * 0.5
+ \\hat = noise(t * 9000) * exp(-30 * fract(beat * 2 + 0.5)) * 0.08
+ \\out = bass + thump + hat
+ \\# picture: color is what you see; x and y run 0..1
+ \\dx = x - 0.5
+ \\dy = y - 0.5
+ \\r = sqrt(dx * dx + dy * dy)
+ \\ring = smoothstep(0.03, 0, abs(r - 0.2 - 0.1 * kick))
+ \\glow = 0.15 * noise(x * 6, y * 6, t * 0.5)
+ \\color = hsv(fract(bar / 4 + r), 0.6, ring + glow)
+ \\
+;
+
+test "a tone, instruction by instruction" {
+ const p = try compiled("out = sin(tau * 220 * t) * 0.3");
+ try expectOps(p.out, &.{ .constant, .constant, .mul, .t, .mul, .sin, .constant, .mul });
+ const code = p.out.slice();
+ try testing.expectEqual(@as(u32, @bitCast(@as(f32, std.math.tau))), code[0].a);
+ try testing.expectEqual(@as(u32, @bitCast(@as(f32, 220))), code[1].a);
+ try testing.expectEqual(Instruction{ .op = .mul, .a = 0, .b = 1 }, code[2]);
+ try testing.expectEqual(Instruction{ .op = .mul, .a = 2, .b = 3 }, code[4]);
+ try testing.expectEqual(Instruction{ .op = .sin, .a = 4 }, code[5]);
+ try testing.expectEqual(Instruction{ .op = .mul, .a = 5, .b = 6 }, code[7]);
+ try testing.expectEqual(@as(u32, 0), p.color.len);
+}
+
+test "the survey's program: each tape holds only what its line reaches" {
+ const p = try compiled(survey);
+ const heard = ops(p.out)[0..p.out.len];
+ const seen = ops(p.color)[0..p.color.len];
+ // The sound never reads x or y, nor is coloured; the picture has no
+ // bass line or hat.
+ for (heard) |op| try testing.expect(op != .x and op != .y and op != .hsv);
+ for (seen) |op| try testing.expect(op != .saw and op != .seq and op != .sin);
+ try testing.expectEqual(Op.add, heard[heard.len - 1]);
+ try testing.expectEqual(Op.hsv, seen[seen.len - 1]);
+ // t is one instruction however often it is named; seq's four numbers
+ // were emitted side by side, so there are no copies.
+ try testing.expectEqual(@as(usize, 1), std.mem.count(Op, heard, &.{.t}));
+ try testing.expectEqual(@as(usize, 0), std.mem.count(Op, heard, &.{.copy}));
+ try testing.expectEqual(@as(u32, 54), p.out.len);
+ try testing.expectEqual(@as(u32, 46), p.color.len);
+ // Every operand is an earlier register.
+ for ([_]Tape{ p.out, p.color }) |tape| for (tape.slice(), 0..) |i, k| {
+ if (@backingInt(i.op) < @backingInt(Op.neg)) continue;
+ try testing.expect(i.a < k);
+ if (i.op == .seq) {
+ try testing.expect(i.b + i.c <= k);
+ } else if (@backingInt(i.op) >= @backingInt(Op.add)) try testing.expect(i.b < k);
+ };
+}
+
+test "every builtin" {
+ for (builtins) |b| {
+ var buf: [128]u8 = undefined;
+ var w: std.Io.Writer = .fixed(&buf);
+ try w.print("{s} = {s}", .{ if (b.op == .hsv or b.op == .rgb) "color" else "out", b.name() });
+ if (b.max > 0) {
+ try w.writeAll("(t");
+ for (1..b.min) |_| try w.writeAll(", t * 2");
+ try w.writeAll(")");
+ }
+ const p = try compiled(w.buffered());
+ const tape = if (b.op == .hsv or b.op == .rgb) p.color else p.out;
+ const last = tape.slice()[tape.len - 1];
+ try testing.expectEqual(b.op, last.op);
+ if (b.op == .constant) try testing.expectEqual(@as(u32, @bitCast(b.value)), last.a);
+ }
+ // noise's missing arguments are 0; seq copies values that were not
+ // emitted side by side.
+ const p = try compiled("a = t * 3\nout = noise(t) + seq(t, 1, a, 2)");
+ try expectOps(p.out, &.{ .t, .constant, .constant, .noise, .constant, .constant, .mul, .constant, .copy, .copy, .copy, .seq, .add });
+ try testing.expectEqual(Instruction{ .op = .seq, .a = 0, .b = 8, .c = 3 }, p.out.slice()[11]);
+ try testing.expectEqual(Instruction{ .op = .copy, .a = 6 }, p.out.slice()[9]);
+}
+
+test "precedence, unary minus, numbers, comments, blank lines" {
+ const p = try compiled("\n # nothing\n a = 1 + 2 * -t / 4 - (5 - -6) # trailing\n\nout = a + 1e-3\n");
+ // 1 + ((2 * -t) / 4) - (5 - -6)
+ try expectOps(p.out, &.{ .constant, .constant, .t, .neg, .mul, .constant, .div, .add, .constant, .constant, .sub, .sub, .constant, .add });
+ try testing.expectEqual(@as(u32, @bitCast(@as(f32, -6))), p.out.slice()[9].a);
+ try testing.expectEqual(@as(u32, @bitCast(@as(f32, 1e-3))), p.out.slice()[12].a);
+}
+
+test "every problem, with its byte" {
+ const cases = [_]struct { text: []const u8, at: u32, words: []const u8 }{
+ .{ .text = "= 1", .at = 0, .words = "a line is a name, =, and an expression" },
+ .{ .text = "out 1", .at = 4, .words = "expected = after out, found 1" },
+ .{ .text = "out", .at = 3, .words = "expected = after out, found the end of the line" },
+ .{ .text = "sin = 1", .at = 0, .words = "sin is a builtin: call yours something else" },
+ .{ .text = "a = 1\na = 2", .at = 6, .words = "a is defined twice: a name is given once" },
+ .{ .text = "out = 1 2", .at = 8, .words = "expected the end of the line, found 2" },
+ .{ .text = "out = rgb(1, 1, 1)", .at = 6, .words = "a colour (hsv, rgb) can only be the whole color line" },
+ .{ .text = "color = hsv(1, 1, 1) * 2", .at = 8, .words = "a colour (hsv, rgb) can only be the whole color line" },
+ .{ .text = "color = hsv(1, 1, 1)\nout = color", .at = 27, .words = "color is a colour: only the color line can be one" },
+ .{ .text = "out = 1.2.3", .at = 6, .words = "1.2.3 is not a number" },
+ .{ .text = "out = kick\nkick = 1", .at = 6, .words = "kick is not defined above" },
+ .{ .text = "out = sin", .at = 6, .words = "sin takes arguments: sin(a)" },
+ .{ .text = "out = 1 +", .at = 9, .words = "expected an expression before the end of the line" },
+ .{ .text = "out = * 2", .at = 6, .words = "expected an expression, found *" },
+ .{ .text = "out = 1 $ 2", .at = 8, .words = "expected the end of the line, found $" },
+ .{ .text = "out = \x01", .at = 6, .words = "byte 0x01 is not part of the language" },
+ .{ .text = "out = (1 + 2", .at = 12, .words = "expected ) to close the ( at byte 6, found the end of the line" },
+ .{ .text = "a = 1\nout = a(2)", .at = 12, .words = "a is a name, not a builtin: it takes no ( )" },
+ .{ .text = "out = foo(2)", .at = 6, .words = "foo is not a builtin" },
+ .{ .text = "out = t(2)", .at = 6, .words = "t takes no arguments" },
+ .{ .text = "out = sin(1, 2)", .at = 13, .words = "sin takes at most 1 arguments: sin(a)" },
+ .{ .text = "out = sin(1 2)", .at = 12, .words = "expected , or ) in sin(...), found 2" },
+ .{ .text = "out = mix(1, 2)", .at = 6, .words = "mix takes 3 arguments, not 2: mix(a, b, w)" },
+ .{ .text = "out = sin()", .at = 6, .words = "sin takes 1 arguments, not 0: sin(a)" },
+ };
+ for (cases) |case| switch (compile(case.text, null)) {
+ .program => {
+ std.debug.print("{s}: no problem\n", .{case.text});
+ return error.TestUnexpectedResult;
+ },
+ .problem => |p| {
+ testing.expectEqualStrings(case.words, p.text()) catch |e| {
+ std.debug.print("in {s}\n", .{case.text});
+ return e;
+ };
+ try testing.expectEqual(case.at, p.at);
+ },
+ };
+}
+
+test "past the capacities: problems in words" {
+ var buf: [8192]u8 = undefined;
+ // A tape of 128 fits; one more instruction does not.
+ var w: std.Io.Writer = .fixed(&buf);
+ try w.writeAll("out = t");
+ for (0..63) |_| try w.writeAll(" + 1");
+ const fits = try compiled(w.buffered());
+ try testing.expectEqual(@as(u32, 127), fits.out.len);
+ try w.writeAll(" + 1");
+ switch (compile(w.buffered(), null)) {
+ .program => return error.TestUnexpectedResult,
+ .problem => |p| {
+ try testing.expectEqualStrings("the out line needs more than 128 instructions", p.text());
+ try testing.expectEqual(@as(u32, 0), p.at);
+ },
+ }
+ // More terms than the compiler keeps, though no tape reaches them.
+ w = .fixed(&buf);
+ for (0..300) |_| try w.writeAll("1+");
+ try w.writeAll("1");
+ const long = w.buffered();
+ var text: [8192]u8 = undefined;
+ const unused = try std.fmt.bufPrint(&text, "a = {s}\n", .{long});
+ switch (compile(unused, null)) {
+ .program => return error.TestUnexpectedResult,
+ .problem => |p| try testing.expectEqualStrings("the program is longer than 512 terms", p.text()),
+ }
+ // Names.
+ w = .fixed(&buf);
+ for (0..max_names + 1) |i| try w.print("n{d} = {d}\n", .{ i, i });
+ switch (compile(w.buffered(), null)) {
+ .program => return error.TestUnexpectedResult,
+ .problem => |p| try testing.expectEqualStrings("more than 128 names", p.text()),
+ }
+ // Depth.
+ w = .fixed(&buf);
+ try w.writeAll("out = ");
+ for (0..40) |_| try w.writeAll("(");
+ try w.writeAll("1");
+ for (0..40) |_| try w.writeAll(")");
+ switch (compile(w.buffered(), null)) {
+ .program => return error.TestUnexpectedResult,
+ .problem => |p| try testing.expectEqualStrings("nested more than 32 deep", p.text()),
+ }
+}
+
+test "a probe: the smallest expression holding the bytes, its own tape" {
+ const text = "kick = exp(-7 * fract(t * 2))\nout = sin(tau * 220 * t) * kick";
+ for ([_]struct { [2]u32, []const Op }{
+ // `tau * 220 * t`, a selection Alt-o grew to
+ .{ .{ 40, 53 }, &.{ .constant, .constant, .mul, .t, .mul } },
+ // `220` alone, and a cursor on its `2`
+ .{ .{ 46, 49 }, &.{.constant} },
+ .{ .{ 46, 47 }, &.{.constant} },
+ // `kick` where it is used: the line that defines it
+ .{ .{ 57, 61 }, &.{ .constant, .t, .constant, .mul, .fract, .mul, .exp } },
+ // an argument
+ .{ .{ 22, 27 }, &.{ .t, .constant, .mul } },
+ // the out line from its name, and the whole of it
+ .{ .{ 30, 33 }, &.{ .constant, .constant, .mul, .t, .mul, .sin, .constant, .constant, .mul, .fract, .mul, .exp, .mul } },
+ }) |case| {
+ const p = try switch (compile(text, case[0])) {
+ .program => |p| p,
+ .problem => error.TestUnexpectedResult,
+ };
+ expectOps(p.probe, case[1]) catch |e| {
+ std.debug.print("probe {any}\n", .{case[0]});
+ return e;
+ };
+ }
+ // nothing holds the newline between the lines: no probe
+ try testing.expectEqual(@as(u32, 0), compile(text, .{ 29, 30 }).program.probe.len);
+}
diff --git a/examples/live/src/main.zig b/examples/live/src/main.zig
new file mode 100644
index 0000000..5e7fe64
--- /dev/null
+++ b/examples/live/src/main.zig
@@ -0,0 +1,494 @@
+//! 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 `<stem>.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 });
+}
diff --git a/examples/live/src/probe.zig b/examples/live/src/probe.zig
new file mode 100644
index 0000000..4f816b2
--- /dev/null
+++ b/examples/live/src/probe.zig
@@ -0,0 +1,133 @@
+//! The probe: the interpreter alone over made-up tapes of 60 and 128
+//! instructions, each pass at 1280x720 and 1920x1080 (and 128 at half of
+//! 1280x720, as the sketch draws a long tape), and the synth kernel over
+//! blocks of 256 and 1024 samples. `zig build probe` plays
+//! test/probe.script with `--profile-gpu`, which prints each label's time
+//! at exit; the empty tape's is the cost of a pass doing nothing.
+const std = @import("std");
+const sk = @import("sketch");
+const gpu = sk.abi.gpu;
+const Lang = @import("Lang");
+const shaders = @import("shaders");
+
+pub const name = "live-probe";
+pub const width = 640;
+pub const height = 360;
+
+pub const Session = struct {
+ images: [3]sk.Image = .{ .none, .none, .none },
+ block: sk.Buffer = .none,
+ tapes: sk.Buffer = .none,
+ time: f32 = 0,
+};
+
+const sizes = [3][2]u32{ .{ 1280, 720 }, .{ 1920, 1080 }, .{ 640, 360 } };
+
+const Picture = struct { label: []const u8, len: u32, size: u2 };
+const pictures = [_]Picture{
+ .{ .label = "picture 0 720p", .len = 0, .size = 0 },
+ .{ .label = "picture 60 720p", .len = 60, .size = 0 },
+ .{ .label = "picture 128 720p", .len = 128, .size = 0 },
+ .{ .label = "picture 0 1080p", .len = 0, .size = 1 },
+ .{ .label = "picture 60 1080p", .len = 60, .size = 1 },
+ .{ .label = "picture 128 1080p", .len = 128, .size = 1 },
+ .{ .label = "picture 128 360p", .len = 128, .size = 2 },
+};
+
+const Block = struct { label: []const u8, len: u32, count: u32, fade: bool = false };
+const blocks = [_]Block{
+ .{ .label = "synth 60 x256", .len = 60, .count = 256 },
+ .{ .label = "synth 128 x256", .len = 128, .count = 256 },
+ .{ .label = "synth 60 x1024", .len = 60, .count = 1024 },
+ .{ .label = "synth 128 x1024", .len = 128, .count = 1024 },
+ .{ .label = "synth 128 x1024 fading", .len = 128, .count = 1024, .fade = true },
+};
+
+/// `len` instructions, every one reaching the last: x, y, t and a
+/// constant, then a cycle of ops over the three before, a noise every
+/// tenth, and hsv.
+fn madeUp(comptime len: u32) [Lang.max_tape][4]u32 {
+ @setEvalBranchQuota(10_000);
+ var code: [Lang.max_tape][4]u32 = @splat(.{ 0, 0, 0, 0 });
+ const cycle = [_]Lang.Op{ .mul, .add, .sin, .fract, .sub, .smoothstep, .abs, .mix, .cos };
+ for (0..len) |i| {
+ const op: Lang.Op = switch (i) {
+ 0 => .x,
+ 1 => .y,
+ 2 => .t,
+ 3 => .constant,
+ else => if (i == len - 1) .hsv else if (i % 10 == 9) .noise else cycle[i % cycle.len],
+ };
+ const a: u32 = if (op == .constant) @bitCast(@as(f32, 6)) else @intCast(i -| 1);
+ code[i] = .{ @backingInt(op), a, @intCast(i -| 2), @intCast(i -| 3) };
+ }
+ return code;
+}
+
+const tapes = .{ madeUp(0), madeUp(60), madeUp(128) };
+
+fn tape(len: u32) [Lang.max_tape][4]u32 {
+ return switch (len) {
+ 0 => tapes[0],
+ 60 => tapes[1],
+ else => tapes[2],
+ };
+}
+
+const pipeline: gpu.Pipeline = .{
+ .vertex = .{ .code = shaders.fullscreen_vert },
+ .fragment = .{ .code = shaders.picture_frag, .uniform_buffers = 1 },
+ .stride = 0,
+ .attributes = &.{},
+ .blend = .none,
+};
+const kernel: gpu.Kernel = .{ .code = shaders.synth_comp, .readonly_buffers = 1, .readwrite_buffers = 1, .uniform_buffers = 1 };
+
+pub fn draw(ss: *Session, f: *sk.Frame) void {
+ f.clear(0x000000);
+ if (!f.host.gpu()) return f.text(8, 8, 2, "no GPU here", 0xffffff);
+ if (ss.block == .none) {
+ for (&ss.images, sizes) |*image, size| image.* = f.host.newImage(size[0], size[1]);
+ ss.block = f.host.newBuffer(1024 * @sizeOf(f32));
+ ss.tapes = f.host.newBuffer(2 * Lang.max_tape * 16);
+ }
+ ss.time += @floatCast(@as(f64, @floatFromInt(f.in.dt)) / std.time.ns_per_s);
+ for (pictures) |p| {
+ const size = sizes[p.size];
+ f.gpu(.{
+ .label = p.label,
+ .image = ss.images[p.size],
+ .width = size[0],
+ .height = size[1],
+ .pipelines = &.{pipeline},
+ .draws = &.{.{ .pipeline = 0, .vertex_count = 3, .fragment_uniforms = gpu.uniform(f.scratch, Lang.Picture{
+ .tape = tape(p.len),
+ .len = p.len,
+ .time = ss.time,
+ .size = .{ @floatFromInt(size[0]), @floatFromInt(size[1]) },
+ }) }},
+ });
+ }
+ for (blocks) |k| {
+ const both = f.scratch.create([2][Lang.max_tape][4]u32) catch return;
+ both.* = .{ tape(k.len), tape(k.len) };
+ f.upload(ss.tapes, 0, std.mem.asBytes(both));
+ f.compute(.{
+ .label = k.label,
+ .kernel = kernel,
+ .readonly = &.{ss.tapes},
+ .readwrite = &.{ss.block},
+ .uniforms = gpu.uniform(f.scratch, Lang.Synth{
+ .len = k.len,
+ .old_len = k.len,
+ .count = k.count,
+ .fade = if (k.fade) k.count else 0,
+ .start = ss.time,
+ .old_start = ss.time,
+ .rate = 48000,
+ }),
+ .groups = .{ (k.count + 63) / 64, 1, 1 },
+ });
+ }
+ f.image(ss.images[0], .{ .x = 0, .y = 0, .w = f.in.width, .h = f.in.height }, .{});
+}