diff options
Diffstat (limited to 'examples/live/src')
| -rw-r--r-- | examples/live/src/Lang.zig | 754 | ||||
| -rw-r--r-- | examples/live/src/main.zig | 458 | ||||
| -rw-r--r-- | examples/live/src/probe.zig | 133 |
3 files changed, 1345 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, ®isters) 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, ®isters) 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..d7a514f --- /dev/null +++ b/examples/live/src/main.zig @@ -0,0 +1,458 @@ +//! 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, +}; + +/// `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 number token under the pointer, by the grammar's parse + if (e.code != 1 or e.x < margin or e.y < margin) continue; + var text: [Editor.capacity.text]u8 = undefined; + const t = s.ed.read(&text); + const row: usize = @intFromFloat((e.y - margin) / cell[1]); + const col: usize = @intFromFloat((e.x - margin) / cell[0]); + var start: usize = 0; + for (0..row) |_| start = (std.mem.indexOfScalarPos(u8, t, start, '\n') orelse t.len) + 1; + if (start > t.len) continue; + const end = std.mem.indexOfScalarPos(u8, t, start, '\n') orelse t.len; + if (start + col >= end) continue; + const tree = syn.parse(fba.allocator(), &s.ed, language()) orelse continue; + const n = tree.rootNode().descendantForByteRange(@intCast(start + col), @intCast(start + col + 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(); + 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). + const seen = if (s.probe.len > 0) &s.probe else &s.color; + const half: u32 = if (seen.len > 64) 2 else 1; + const size: [2]u32 = .{ width / half, height / half }; + 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 = width, .h = height }, .{}); + sound(s, ss, f); + code(s, f); +} + +/// 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) 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 = height - 104, .w = 480, .h = 88 }, .samples = 1024 }, + .spectrum = .{ .x = 512, .y = height - 104, .w = 480, .h = 88 }, + }); +} + +const scale = 1.25; +/// A character of the code face at `scale`, wide and high, in pixels: +/// measured (`f.host.textSizeIn(.code, 1.25, "M")` natively, and ten of +/// them are 100), so `update` finds the byte under the pointer as `code` +/// lays it out. +const cell: [2]f32 = .{ 10, 22 }; +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 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. +// ponytail: one face at one size, a column a fixed advance and a byte of +// this ASCII language a column; sketchbook's paragraph call (spans, any +// byte's place) takes the place of the measuring and the textIn here. +fn code(s: *const State, f: *sk.Frame) 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; + // a class a byte, from the grammar's highlights (none if it fails) + const colors = pe.Syntax.colors(f.scratch, &s.ed, language(), 0, text.len) catch &.{}; + const problem = s.problem.len > 0; + var lines: usize = 1; + var widest: usize = 24; + var it = std.mem.splitScalar(u8, text, '\n'); + while (it.next()) |line| : (lines += 1) widest = @max(widest, line.len + 1); + if (problem) widest = @max(widest, s.problem.len); + f.fill(.{ .x = 0, .y = 0, .w = @as(f32, @floatFromInt(widest)) * cell[0] + 2 * margin, .h = @as(f32, @floatFromInt(lines - 1 + @intFromBool(problem))) * cell[1] + 2 * margin }, sk.Color{ .r = 0, .g = 0, .b = 0, .a = 150 }); + + var y: f32 = margin; + var start: usize = 0; + it = std.mem.splitScalar(u8, text, '\n'); + while (it.next()) |line| : (y += cell[1]) { + // a line's bytes and its newline, start..end + const end = start + line.len + 1; + for (ranges[0..got.n], 0..) |r, i| { + const from = @max(@min(r.anchor, r.head), start); + const to = @min(@max(r.anchor, r.head), end); + if (from < to) f.fill(.{ .x = margin + @as(f32, @floatFromInt(from - start)) * cell[0], .y = y, .w = @as(f32, @floatFromInt(to - from)) * cell[0], .h = cell[1] }, if (i == got.primary) selected else also_selected); + } + // a run of bytes of one class at a time, in the theme's inks + var a: usize = 0; + while (a < line.len) { + const class = if (start + a < colors.len) colors[start + a] else .none; + var b = a + 1; + while (b < line.len and (if (start + b < colors.len) colors[start + b] else .none) == class) b += 1; + const c = pe.syntax.synInk(theme, class) orelse pe.syntax.ink(theme); + f.textIn(.code, margin + @as(f32, @floatFromInt(a)) * cell[0], y, scale, line[a..b], sk.Color{ .r = c[0], .g = c[1], .b = c[2] }); + a = b; + } + for (ranges[0..got.n], 0..) |r, i| { + // the head's character: the one before it in a range that + // grows forward + const at = if (r.head > r.anchor) r.head - 1 else r.head; + if (at < start or at >= end) continue; + const x = margin + @as(f32, @floatFromInt(at - start)) * cell[0]; + const caret: sk.Color = .{ .r = 0xe8, .g = 0xe8, .b = 0xe8, .a = if (i == got.primary) 200 else 110 }; + if (s.ed.mode() == .insert) { + f.fill(.{ .x = x - 1, .y = y, .w = 2, .h = cell[1] }, caret); + } else f.fill(.{ .x = x, .y = y, .w = cell[0], .h = cell[1] }, caret.alpha(caret.a / 2)); + } + if (problem and s.problem.at >= start and s.problem.at < end) + f.fill(.{ .x = margin + @as(f32, @floatFromInt(s.problem.at - start)) * cell[0], .y = y + cell[1] - 2, .w = cell[0], .h = 2 }, red); + start = end; + } + if (problem) f.textIn(.code, margin, y, 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(width - 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 }, .{}); +} |
