summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
authorGabriel Schneider <[email protected]>2026-11-16 22:02:43 -0300
committerGabriel Schneider <[email protected]>2026-11-17 12:15:01 -0300
commit1cb36ee39a8bbc2cf61c28003670d760841d6d3e (patch)
treed7d01eb5b3a40920a8f71d091a106561ca56b282 /src
parent6933f99ddb2d7103515d26838496309a807bba26 (diff)
downloadsketchbook-1cb36ee39a8bbc2cf61c28003670d760841d6d3e.tar.gz
sketchbook-1cb36ee39a8bbc2cf61c28003670d760841d6d3e.zip
gpu: add a post-process pass with optional depth sampling, and describe the executor pardes shares
`f.postProcess(source, target, .{...})` records a fullscreen pass that samples a completed render into a distinct target image: colour at fragment binding 0 and, with `sample_depth`, depth at 1, which needs the source's latest pass to have depth and one sample (missing depth, multisampled depth and feedback loops are rejected). The scene format's version 4 carries it, the executor records it on the caller's command buffer and owns the sampler, the web host does the same with its texture and sampler pairs, and native profiling reports the work as `postprocess`. The README says how to use it. docs/pardes-rendering.md describes the executor as pardes uses it for addon scenes: a borrowed SDL GPU device, `record` into the caller's command buffer, `run`, `output` and `postProcess`. The working copy as it stood on 2026-11-16; message written by Claude from the diff, at the author's request.
Diffstat (limited to 'src')
-rw-r--r--src/abi.zig8
-rw-r--r--src/gpu/Executor.zig41
-rw-r--r--src/gpu/scene.zig55
-rw-r--r--src/host/Host.zig10
-rw-r--r--src/sketch/clock.zig2
-rw-r--r--src/sketch/root.zig27
-rw-r--r--src/sketch/web.zig5
7 files changed, 128 insertions, 20 deletions
diff --git a/src/abi.zig b/src/abi.zig
index d91fa23..7177f14 100644
--- a/src/abi.zig
+++ b/src/abi.zig
@@ -370,6 +370,8 @@ pub const Command = union(enum) {
/// Renders a GPU pass into an image made by `Host.newImage`, when
/// `Host.gpu` says the host can.
gpu: gpu.Pass,
+ /// Fullscreen pass sampling a completed GPU image, into a different image.
+ post_process: struct { source: Image, target: Image, effect: gpu.PostProcess },
/// Bytes into a buffer made by `Host.newBuffer`, at `offset`.
upload: struct { buffer: Buffer, offset: u32 = 0, bytes: []const u8 },
/// Runs a compute shader over buffers (see `abi.gpu`).
@@ -579,8 +581,10 @@ pub const gpu = struct {
draws: []const Draw,
};
- /// A fullscreen triangle sampling one completed pass at fragment binding 0.
+ /// Fullscreen triangle: color at fragment binding 0, optional depth at 1.
pub const PostProcess = struct {
+ /// Requires a preceding single-sample pass with depth enabled.
+ sample_depth: bool = false,
vertex: Shader,
fragment: Shader,
fragment_uniforms: []const u8 = &.{},
@@ -813,7 +817,7 @@ pub const Sketch = struct {
pub const hash: u64 = blk: {
@setEvalBranchQuota(1_000_000);
var h: u64 = 0;
- for (.{ Rect, Color, BlendMode, Corners, Event, Mode, Stream, Input, Image, Audio, Cursor, Voice, Command, gpu.Pass, gpu.Pipeline, gpu.Draw, gpu.Dispatch, Host, Host.VTable, Context, Field, Layout, Info, Memory, Sketch }) |T| {
+ for (.{ Rect, Color, BlendMode, Corners, Event, Mode, Stream, Input, Image, Audio, Cursor, Voice, Command, gpu.Pass, gpu.Pipeline, gpu.Draw, gpu.Dispatch, gpu.PostProcess, Host, Host.VTable, Context, Field, Layout, Info, Memory, Sketch }) |T| {
h = std.hash.Wyhash.hash(h, @typeName(T) ++ layout.signature(T));
}
break :blk h;
diff --git a/src/gpu/Executor.zig b/src/gpu/Executor.zig
index 412d0ed..460b2d5 100644
--- a/src/gpu/Executor.zig
+++ b/src/gpu/Executor.zig
@@ -155,6 +155,8 @@ const Target = struct {
msaa_fresh: bool = true,
stencil_samples: u8 = 0,
stencil: ?*c.SDL_GPUTexture = null,
+ depth_valid: bool = false,
+ depth_sampleable: bool = false,
};
pub fn init(gpa: std.mem.Allocator, device: *c.SDL_GPUDevice) Gpu {
@@ -229,25 +231,41 @@ pub fn run(g: *Gpu, pass: abi.gpu.Pass) !void {
/// Records into the caller's command buffer; the caller submits it.
/// Uploads cycle their buffers, allowing several passes in one frame.
pub fn record(g: *Gpu, cmd: *c.SDL_GPUCommandBuffer, pass: abi.gpu.Pass) !void {
- return g.recordWithInput(cmd, pass, null);
+ return g.recordWithInput(cmd, pass, &.{});
+}
+
+pub fn runPostProcess(g: *Gpu, source: abi.Image, target: abi.Image, post: abi.gpu.PostProcess) !void {
+ const start = g.startTiming();
+ const cmd = c.SDL_AcquireGPUCommandBuffer(g.device) orelse return error.GpuCommandBuffer;
+ errdefer _ = c.SDL_CancelGPUCommandBuffer(cmd);
+ try g.postProcess(cmd, source, target, post);
+ try g.submit(cmd, "postprocess", start);
}
/// A second pass on the same command buffer; input and output must differ.
pub fn postProcess(g: *Gpu, cmd: *c.SDL_GPUCommandBuffer, source: abi.Image, target: abi.Image, post: abi.gpu.PostProcess) !void {
if (source == target) return error.FeedbackLoop;
- const input = g.output(source) orelse return error.MissingImage;
+ const input = g.targets.get(source) orelse return error.MissingImage;
+ var textures: [2]*c.SDL_GPUTexture = undefined;
+ textures[0] = input.texture;
+ if (post.sample_depth) {
+ if (!input.depth_valid or input.stencil == null) return error.MissingDepthAttachment;
+ if (input.stencil_samples != 1) return error.MultisampleDepthUnsupported;
+ if (!input.depth_sampleable) return error.DepthSamplingUnsupported;
+ textures[1] = input.stencil.?;
+ }
try g.recordWithInput(cmd, .{
.image = target,
.width = input.width,
.height = input.height,
.pipelines = &.{.{ .vertex = post.vertex, .fragment = post.fragment, .stride = 0, .attributes = &.{}, .blend = .none }},
.draws = &.{.{ .pipeline = 0, .vertex_count = 3, .fragment_uniforms = post.fragment_uniforms }},
- }, input.texture);
+ }, textures[0 .. 1 + @as(usize, @intFromBool(post.sample_depth))]);
}
-fn recordWithInput(g: *Gpu, cmd: *c.SDL_GPUCommandBuffer, pass: abi.gpu.Pass, input: ?*c.SDL_GPUTexture) !void {
+fn recordWithInput(g: *Gpu, cmd: *c.SDL_GPUCommandBuffer, pass: abi.gpu.Pass, input: []const *c.SDL_GPUTexture) !void {
if (pass.width == 0 or pass.height == 0 or pass.draws.len == 0 and pass.clear == null) return;
- if (input != null and g.post_sampler == null) {
+ if (input.len != 0 and g.post_sampler == null) {
g.post_sampler = c.SDL_CreateGPUSampler(g.device, &std.mem.zeroInit(c.SDL_GPUSamplerCreateInfo, .{
.min_filter = c.SDL_GPU_FILTER_NEAREST,
.mag_filter = c.SDL_GPU_FILTER_NEAREST,
@@ -269,7 +287,7 @@ fn recordWithInput(g: *Gpu, cmd: *c.SDL_GPUCommandBuffer, pass: abi.gpu.Pass, in
if (d.pipeline >= pass.pipelines.len) return error.BadPipeline;
const p = pass.pipelines[d.pipeline];
if ((p.depth_test != null or p.depth_write) and !pass.depth) return error.MissingDepthAttachment;
- if (built[d.pipeline] == null) built[d.pipeline] = try g.pipeline(pass.pipelines[d.pipeline], samples, pass.stencil or pass.depth, @intFromBool(input != null));
+ if (built[d.pipeline] == null) built[d.pipeline] = try g.pipeline(pass.pipelines[d.pipeline], samples, pass.stencil or pass.depth, @intCast(input.len));
}
// Every draw's vertices go up in one copy.
@@ -314,13 +332,14 @@ fn recordWithInput(g: *Gpu, cmd: *c.SDL_GPUCommandBuffer, pass: abi.gpu.Pass, in
depth.texture = t.stencil;
depth.load_op = if (pass.depth) c.SDL_GPU_LOADOP_CLEAR else c.SDL_GPU_LOADOP_DONT_CARE;
depth.clear_depth = 1;
- depth.store_op = c.SDL_GPU_STOREOP_DONT_CARE;
+ depth.store_op = if (pass.depth) c.SDL_GPU_STOREOP_STORE else c.SDL_GPU_STOREOP_DONT_CARE;
depth.stencil_load_op = c.SDL_GPU_LOADOP_CLEAR;
depth.stencil_store_op = c.SDL_GPU_STOREOP_DONT_CARE;
depth.clear_stencil = 0;
}
const rp = c.SDL_BeginGPURenderPass(cmd, &color, 1, if (pass.stencil or pass.depth) &depth else null) orelse return error.GpuRenderPass;
- if (input) |texture_| c.SDL_BindGPUFragmentSamplers(rp, 0, &.{ .texture = texture_, .sampler = g.post_sampler.? }, 1);
+ t.depth_valid = pass.depth;
+ for (input, 0..) |texture_, slot| c.SDL_BindGPUFragmentSamplers(rp, @intCast(slot), &.{ .texture = texture_, .sampler = g.post_sampler.? }, 1);
var bound: ?*c.SDL_GPUGraphicsPipeline = null;
// State already set in this pass, so draws that repeat it skip the call.
var vertex_uniforms: ?[]const u8 = null;
@@ -575,9 +594,13 @@ fn renderTarget(g: *Gpu, image: abi.Image, w: u32, h: u32, samples: u8, stencil:
t.msaa_fresh = true;
}
if (stencil and (t.stencil == null or t.stencil_samples != samples)) {
+ const sampled_usage = c.SDL_GPU_TEXTUREUSAGE_DEPTH_STENCIL_TARGET | c.SDL_GPU_TEXTUREUSAGE_SAMPLER;
+ const sampleable = samples == 1 and c.SDL_GPUTextureSupportsFormat(g.device, g.stencil_format, c.SDL_GPU_TEXTURETYPE_2D, sampled_usage);
+ const replacement = try g.texture(w, h, g.stencil_format, if (sampleable) sampled_usage else c.SDL_GPU_TEXTUREUSAGE_DEPTH_STENCIL_TARGET, samples);
if (t.stencil) |s| c.SDL_ReleaseGPUTexture(g.device, s);
- t.stencil = try g.texture(w, h, g.stencil_format, c.SDL_GPU_TEXTUREUSAGE_DEPTH_STENCIL_TARGET, samples);
+ t.stencil = replacement;
t.stencil_samples = samples;
+ t.depth_sampleable = sampleable;
}
return t;
}
diff --git a/src/gpu/scene.zig b/src/gpu/scene.zig
index e5ff3d0..d5e1db5 100644
--- a/src/gpu/scene.zig
+++ b/src/gpu/scene.zig
@@ -2,6 +2,7 @@
//! Version 1: "SGPU", u32 version, then Pass fields in declaration order.
//! Version 2 appends one fullscreen PostProcess sampling that pass's output.
//! Version 3 adds depth fields and an optional PostProcess after the pass.
+//! Version 4 adds optional depth sampling to PostProcess.
//! Integers/enums/f32 are little endian; slices have a u32 count, optionals
//! and bools a byte (0 or 1). No pointers, native padding, or device handles.
//! Storage buffers are not part of this version: each frame stands alone.
@@ -22,11 +23,12 @@ pub fn encode(w: *std.Io.Writer, pass: abi.gpu.Pass) !void {
pub fn encodePostProcess(w: *std.Io.Writer, pass: abi.gpu.Pass, post: abi.gpu.PostProcess) !void {
try validate(pass);
try validatePostProcess(post);
+ if (post.sample_depth and (!pass.depth or pass.samples != 1)) return error.BadScene;
try w.writeAll("SGPU");
- const version: u32 = if (pass.depth) 3 else 2;
+ const version: u32 = if (post.sample_depth) 4 else if (pass.depth) 3 else 2;
try w.writeInt(u32, version, .little);
try put(w, pass, version);
- if (version == 3) try put(w, @as(?abi.gpu.PostProcess, post), version) else try put(w, post, version);
+ if (version >= 3) try put(w, @as(?abi.gpu.PostProcess, post), version) else try put(w, post, version);
}
/// Allocations belong to the caller's frame arena. Never run unvalidated
@@ -42,13 +44,16 @@ pub fn decodeFrame(arena: std.mem.Allocator, bytes: []const u8) !Frame {
var r: std.Io.Reader = .fixed(bytes);
if (!std.mem.eql(u8, try r.take(4), "SGPU")) return error.BadScene;
const version = try r.takeInt(u32, .little);
- if (version < 1 or version > 3) return error.BadScene;
+ if (version < 1 or version > 4) return error.BadScene;
var budget: usize = max_bytes * 4;
const pass = try get(abi.gpu.Pass, arena, &r, &budget, version);
- const post: ?abi.gpu.PostProcess = if (version == 3) try get(?abi.gpu.PostProcess, arena, &r, &budget, version) else if (version == 2) try get(abi.gpu.PostProcess, arena, &r, &budget, version) else null;
+ const post: ?abi.gpu.PostProcess = if (version >= 3) try get(?abi.gpu.PostProcess, arena, &r, &budget, version) else if (version == 2) try get(abi.gpu.PostProcess, arena, &r, &budget, version) else null;
if (r.end != r.seek) return error.BadScene;
try validate(pass);
- if (post) |p| try validatePostProcess(p);
+ if (post) |p| {
+ try validatePostProcess(p);
+ if (p.sample_depth and (!pass.depth or pass.samples != 1)) return error.BadScene;
+ }
return .{ .pass = pass, .post = post };
}
@@ -57,6 +62,11 @@ fn depthField(comptime T: type, comptime name: []const u8) bool {
(T == abi.gpu.Pipeline and (std.mem.eql(u8, name, "depth_test") or std.mem.eql(u8, name, "depth_write")));
}
+fn absentField(comptime T: type, comptime name: []const u8, version: u32) bool {
+ return (version < 3 and depthField(T, name)) or
+ (version < 4 and T == abi.gpu.PostProcess and std.mem.eql(u8, name, "sample_depth"));
+}
+
fn put(w: *std.Io.Writer, value: anytype, version: u32) anyerror!void {
const T = @TypeOf(value);
switch (@typeInfo(T)) {
@@ -74,7 +84,7 @@ fn put(w: *std.Io.Writer, value: anytype, version: u32) anyerror!void {
for (value) |v| try put(w, v, version);
},
.@"struct" => |s| inline for (s.field_names) |name| {
- if (version >= 3 or !depthField(T, name)) try put(w, @field(value, name), version);
+ if (!absentField(T, name, version)) try put(w, @field(value, name), version);
},
else => @compileError("unsupported scene field"),
}
@@ -117,7 +127,7 @@ fn get(comptime T: type, a: std.mem.Allocator, r: *std.Io.Reader, budget: *usize
.@"struct" => |s| {
var out: T = undefined;
inline for (s.field_names, s.field_types) |name, F| {
- @field(out, name) = if (version < 3 and comptime depthField(T, name)) std.mem.zeroes(F) else try get(F, a, r, budget, version);
+ @field(out, name) = if (absentField(T, name, version)) std.mem.zeroes(F) else try get(F, a, r, budget, version);
}
return out;
},
@@ -227,7 +237,7 @@ test "GPU postprocess keeps v1 readable and validates the complete second pass"
bad = post;
bad.fragment.storage_buffers = 1;
try std.testing.expectError(error.BadShader, validatePostProcess(bad));
- out.written()[4] = 4;
+ out.written()[4] = 5;
try std.testing.expectError(error.BadScene, decodeFrame(arena.allocator(), out.written()));
}
@@ -261,3 +271,32 @@ test "depth uses v3 and requires an attachment; legacy frames keep depth disable
const legacy = try decode(arena.allocator(), out.written());
try std.testing.expect(!legacy.depth and legacy.pipelines[0].depth_test == null and !legacy.pipelines[0].depth_write);
}
+
+test "depth postprocess uses v4 and rejects missing or multisampled source depth" {
+ const code = std.mem.asBytes(&[_]u32{ 0x07230203, 0, 0, 0, 0 });
+ const pipelines = [_]abi.gpu.Pipeline{.{ .vertex = .{ .code = code }, .fragment = .{ .code = code }, .stride = 0, .attributes = &.{} }};
+ var pass: abi.gpu.Pass = .{ .image = .none, .width = 32, .height = 24, .depth = true, .pipelines = &pipelines, .draws = &.{.{ .pipeline = 0, .vertex_count = 3 }} };
+ var post: abi.gpu.PostProcess = .{ .sample_depth = true, .vertex = .{ .code = code }, .fragment = .{ .code = code } };
+ var out: std.Io.Writer.Allocating = .init(std.testing.allocator);
+ defer out.deinit();
+ var arena: std.heap.ArenaAllocator = .init(std.testing.allocator);
+ defer arena.deinit();
+ try encodePostProcess(&out.writer, pass, post);
+ try std.testing.expectEqual(4, out.written()[4]);
+ try std.testing.expect((try decodeFrame(arena.allocator(), out.written())).post.?.sample_depth);
+ for (0..out.written().len) |i| {
+ _ = decodeFrame(arena.allocator(), out.written()[0..i]) catch continue;
+ return error.AcceptedTruncatedScene;
+ }
+ pass.depth = false;
+ try std.testing.expectError(error.BadScene, encodePostProcess(&out.writer, pass, post));
+ pass.depth = true;
+ pass.samples = 4;
+ try std.testing.expectError(error.BadScene, encodePostProcess(&out.writer, pass, post));
+ pass.samples = 1;
+ post.sample_depth = false;
+ out.clearRetainingCapacity();
+ try encodePostProcess(&out.writer, pass, post);
+ try std.testing.expectEqual(3, out.written()[4]);
+ try std.testing.expect(!(try decodeFrame(arena.allocator(), out.written())).post.?.sample_depth);
+}
diff --git a/src/host/Host.zig b/src/host/Host.zig
index 745d9a1..035a004 100644
--- a/src/host/Host.zig
+++ b/src/host/Host.zig
@@ -447,6 +447,7 @@ fn draw(self: *Host, now: u64, started: u64) !u64 {
.audio => |a| self.audio.push(a.key, a.samples, a.clear),
.quit => self.quit = true,
.gpu => |pass| if (self.passes) |*g| self.runGpu(g, pass) catch |err| self.print("gpu pass: {t} ({s})", .{ err, c.SDL_GetError() }),
+ .post_process => |p| if (self.passes) |*g| self.runPostProcess(g, p.source, p.target, p.effect) catch |err| self.print("gpu postprocess: {t} ({s})", .{ err, c.SDL_GetError() }),
.upload => |u| if (self.passes) |*g| g.write(u.buffer, u.offset, u.bytes) catch |err| self.print("gpu upload: {t} ({s})", .{ err, c.SDL_GetError() }),
.compute => |d| if (self.passes) |*g| g.compute(d) catch |err| self.print("gpu compute: {t} ({s})", .{ err, c.SDL_GetError() }),
.microphone => self.audio.listen(),
@@ -981,6 +982,15 @@ fn apiEnv(ctx: *anyopaque, name: []const u8) ?[]const u8 {
return hostOf(ctx).environ.get(name);
}
+fn runPostProcess(self: *Host, g: *Gpu, source: abi.Image, target: abi.Image, post: abi.gpu.PostProcess) !void {
+ const input = g.output(source) orelse return error.MissingImage;
+ const before = g.output(target);
+ const changed = if (before) |t| t.width != input.width or t.height != input.height else true;
+ if (changed) self.images.unwrap(target);
+ try g.runPostProcess(source, target, post);
+ if (g.output(target)) |t| try self.images.wrap(target, t.texture, t.width, t.height);
+}
+
fn runGpu(self: *Host, g: *Gpu, pass: abi.gpu.Pass) !void {
const before = g.output(pass.image);
const changed = if (before) |t| t.width != pass.width or t.height != pass.height else true;
diff --git a/src/sketch/clock.zig b/src/sketch/clock.zig
index e64e2a8..2d63e12 100644
--- a/src/sketch/clock.zig
+++ b/src/sketch/clock.zig
@@ -85,7 +85,7 @@ test "N updates of one tick each step exactly as one update of N ticks" {
var sum: u32 = 0;
for (per) |n| sum += n;
try std.testing.expectEqual(sum, total);
- try std.testing.expectEqual(std.mem.toBytes(one), std.mem.toBytes(all));
+ try std.testing.expectEqualDeep(one, all);
try std.testing.expectEqual(@as(u32, Clock.max_steps), per[300]);
try std.testing.expectEqual(@as(u64, total), all.count);
}
diff --git a/src/sketch/root.zig b/src/sketch/root.zig
index 434478c..cb20ab9 100644
--- a/src/sketch/root.zig
+++ b/src/sketch/root.zig
@@ -232,6 +232,12 @@ pub const Frame = struct {
kept.draws = draws;
f.emit(.{ .gpu = kept });
}
+ /// Samples the source color and optionally depth into a distinct image.
+ pub fn postProcess(f: *Frame, source: Image, destination: Image, post: abi.gpu.PostProcess) void {
+ var kept = post;
+ kept.fragment_uniforms = f.keep(u8, post.fragment_uniforms);
+ f.emit(.{ .post_process = .{ .source = source, .target = destination, .effect = kept } });
+ }
/// `bytes` into a buffer made by `Host.newBuffer`.
pub fn upload(f: *Frame, buffer: abi.Buffer, offset: u32, bytes: []const u8) void {
f.emit(.{ .upload = .{ .buffer = buffer, .offset = offset, .bytes = bytes } });
@@ -469,3 +475,24 @@ test "setup receives session resources without a Frame and reports errors" {
try std.testing.expectEqual(@as(u32, 1), session.calls);
try std.testing.expect(seen);
}
+
+test "postprocess preserves image handles and copies transient uniforms" {
+ var arena: std.heap.ArenaAllocator = .init(std.testing.allocator);
+ defer arena.deinit();
+ var commands: std.ArrayList(abi.Command) = .empty;
+ var ctx: abi.Context = undefined;
+ ctx.commands = &commands;
+ var frame: Frame = undefined;
+ frame.ctx = &ctx;
+ frame.scratch = arena.allocator();
+ var uniforms = [_]u8{ 1, 2, 3, 4 };
+ const source: Image = @fromBackingInt(@intCast(1));
+ const target: Image = @fromBackingInt(@intCast(2));
+ frame.postProcess(source, target, .{ .vertex = .{ .code = "vertex" }, .fragment = .{ .code = "fragment" }, .sample_depth = true, .fragment_uniforms = &uniforms });
+ uniforms[0] = 9;
+ const post = commands.items[0].post_process;
+ try std.testing.expectEqual(source, post.source);
+ try std.testing.expectEqual(target, post.target);
+ try std.testing.expect(post.effect.sample_depth);
+ try std.testing.expectEqualSlices(u8, &.{ 1, 2, 3, 4 }, post.effect.fragment_uniforms);
+}
diff --git a/src/sketch/web.zig b/src/sketch/web.zig
index 682bff6..937b491 100644
--- a/src/sketch/web.zig
+++ b/src/sketch/web.zig
@@ -43,6 +43,7 @@ const js = struct {
/// A `Dispatch` or a `Pass`, described in JSON (see `describe`).
extern "gpu" fn compute(ptr: [*]const u8, len: usize) void;
extern "gpu" fn pass(ptr: [*]const u8, len: usize) void;
+ extern "gpu" fn postProcess(ptr: [*]const u8, len: usize) void;
/// Answers through `sk_download`.
extern "gpu" fn download(id: u32, offset: u32, size: u32, key: u32) void;
extern "audio" fn rate() u32;
@@ -234,6 +235,10 @@ fn Driver(comptime App: type) type {
const json = describe(v);
js.pass(json.ptr, json.len);
},
+ .post_process => |v| {
+ const json = describe(v);
+ js.postProcess(json.ptr, json.len);
+ },
.download => |v| js.download(@backingInt(v.buffer), v.offset, v.size, v.key),
.open_file => |v| js.openFile(v.command.ptr, v.command.len, v.pattern.ptr, v.pattern.len),
// Synthesised voices are not on the web yet; quitting a page