summaryrefslogtreecommitdiff
path: root/src/host/Host.zig
diff options
context:
space:
mode:
authorGabriel Schneider <[email protected]>2026-10-28 21:07:13 -0300
committerGabriel Schneider <[email protected]>2026-11-12 13:22:02 -0300
commit590ba7b9b579b97e34b51ab7e3460ebc85713343 (patch)
tree6a73a7570ff4f79f41deff078455877b9bc6571b /src/host/Host.zig
parentbc8e6eb1bfef0c5e9b3c40fc1e4fd5a1659e2b03 (diff)
downloadsketchbook-590ba7b9b579b97e34b51ab7e3460ebc85713343.tar.gz
sketchbook-590ba7b9b579b97e34b51ab7e3460ebc85713343.zip
sketchbook: Zig 0.17, a Store on disk, requests, a scope (waveform, spectrum, spectrogram), audio codecs and fonts, web host
Diffstat (limited to 'src/host/Host.zig')
-rw-r--r--src/host/Host.zig198
1 files changed, 182 insertions, 16 deletions
diff --git a/src/host/Host.zig b/src/host/Host.zig
index d511099..7ebe54a 100644
--- a/src/host/Host.zig
+++ b/src/host/Host.zig
@@ -25,6 +25,8 @@ pub const Options = struct {
headless: bool = false,
/// Forget the state file's contents: scripts start from a known place.
fresh: bool = false,
+ /// Time every GPU command alone and print the times at exit.
+ profile_gpu: bool = false,
};
gpa: std.mem.Allocator,
@@ -45,6 +47,10 @@ images: gfx.Images,
audio: sound.Audio,
state: memory.StateFile,
session: memory.Session,
+store: memory.StoreFile,
+/// Images and buffers the sketch made (`newImage`, `decodeImage`,
+/// `newBuffer`): Session holds their handles, so they go when it resets.
+made: struct { images: std.ArrayList(abi.Image) = .empty, buffers: std.ArrayList(abi.Buffer) = .empty } = .{},
recordings: []align(memory.page) u8,
timeline: Timeline,
console: Console = .{},
@@ -71,6 +77,7 @@ started: bool = true,
last_now: u64 = 0,
/// Saved after the next frame is drawn (scripts).
screenshot: ?[:0]const u8 = null,
+dialog: Dialog = .{},
pub fn init(self: *Host, gpa: std.mem.Allocator, io: std.Io, environ: *const std.process.Environ.Map, options: Options, linked: ?abi.Sketch) !void {
if (options.headless) {
@@ -93,7 +100,7 @@ pub fn init(self: *Host, gpa: std.mem.Allocator, io: std.Io, environ: *const std
const info = sketch.info();
var title_buf: [256]u8 = undefined;
- const title = std.fmt.bufPrintZ(&title_buf, "{s}", .{info.name}) catch "sketch";
+ const title = std.mem.printSentinel(&title_buf, "{s}", .{info.name}, 0) catch "sketch";
const window = c.SDL_CreateWindow(title.ptr, @intCast(info.width), @intCast(info.height), c.SDL_WINDOW_RESIZABLE) orelse return sdlError("SDL_CreateWindow");
errdefer c.SDL_DestroyWindow(window);
// The 2D renderer runs on the GPU device that also runs sketches' GPU
@@ -117,8 +124,14 @@ pub fn init(self: *Host, gpa: std.mem.Allocator, io: std.Io, environ: *const std
var state = try memory.StateFile.open(gpa, options.state);
errdefer state.close();
var inputs_buf: [std.fs.max_path_bytes]u8 = undefined;
- const recordings = try mapRecordings(try std.fmt.bufPrint(&inputs_buf, "{s}.inputs", .{options.state}));
+ const recordings = try mapRecordings(try std.mem.print(&inputs_buf, "{s}.inputs", .{options.state}));
errdefer std.posix.munmap(recordings);
+ var store_buf: [std.fs.max_path_bytes]u8 = undefined;
+ var store = memory.StoreFile.open(gpa, try std.mem.print(&store_buf, "{s}.store", .{options.state}), options.fresh) catch |err| {
+ if (err == error.StoreInUse) std.log.err("{s}.store is open in another process", .{options.state});
+ return err;
+ };
+ errdefer store.close();
self.* = .{
.gpa = gpa,
@@ -132,6 +145,7 @@ pub fn init(self: *Host, gpa: std.mem.Allocator, io: std.Io, environ: *const std
.audio = .{ .gpa = gpa },
.state = state,
.session = .init(gpa),
+ .store = store,
.recordings = recordings,
.timeline = undefined,
.sketch = sketch,
@@ -141,6 +155,9 @@ pub fn init(self: *Host, gpa: std.mem.Allocator, io: std.Io, environ: *const std
};
self.timeline = .{ .bank = .{ .state = &self.state, .inputs = recordings } };
if (gpu) |device| self.passes = .init(gpa, device);
+ if (options.profile_gpu) if (self.passes) |*g| {
+ g.profile = .init(gpa);
+ };
self.audio.open() catch |err| std.log.warn("audio unavailable: {t}", .{err});
if (options.library) |path| if (linked == null) {
self.watch = Watch.init(path) catch null;
@@ -156,6 +173,7 @@ pub fn init(self: *Host, gpa: std.mem.Allocator, io: std.Io, environ: *const std
}
pub fn deinit(self: *Host) void {
+ self.dialog.deinit();
if (self.watch) |w| w.deinit();
self.audio.deinit();
if (self.passes) |*g| g.deinit(&self.images);
@@ -173,6 +191,9 @@ pub fn deinit(self: *Host) void {
self.files.deinit(self.gpa);
std.posix.munmap(self.recordings);
self.session.deinit(self.gpa);
+ self.store.close();
+ self.made.images.deinit(self.gpa);
+ self.made.buffers.deinit(self.gpa);
self.state.close();
self.pending.deinit(self.gpa);
self.frame_arena.deinit();
@@ -242,16 +263,30 @@ fn draw(self: *Host, now: u64) !void {
self.input.console = self.console.visible;
self.input.width = @floatFromInt(self.canvas[0]);
self.input.height = @floatFromInt(self.canvas[1]);
+ // Headless runs have no window to fill: the canvas is all the room.
+ self.input.window_width = self.input.width;
+ self.input.window_height = self.input.height;
+ if (!self.options.headless) {
+ var w: c_int = 0;
+ var h: c_int = 0;
+ if (c.SDL_GetWindowSize(self.window, &w, &h) and w > 0 and h > 0) {
+ self.input.window_width = @floatFromInt(w);
+ self.input.window_height = @floatFromInt(h);
+ }
+ }
self.input.streams = self.audio.streamStatus();
self.input.sample_rate = sound.sample_rate;
+ self.input.microphone = self.audio.record(arena);
+ self.input.downloads = if (self.passes) |*g| try g.collect(arena) else &.{};
self.input.frame += 1;
const ctx = self.context();
- self.sketch.draw(&ctx, self.live().ptr, self.session.bytes.ptr);
+ self.sketch.draw(&ctx, self.live().ptr);
_ = c.SDL_SetRenderClipRect(self.renderer, null);
_ = c.SDL_SetRenderDrawColor(self.renderer, 0, 0, 0, 255);
_ = c.SDL_RenderClear(self.renderer);
self.audio.beginFrame();
+ var lines: std.ArrayList([]const u8) = .empty;
for (self.commands.items) |command| switch (command) {
.canvas => |size| self.setCanvas(size.w, size.h),
.cursor => |kind| self.cursor = kind,
@@ -259,9 +294,16 @@ fn draw(self: *Host, now: u64) !void {
.audio => |a| self.audio.push(a.key, a.samples, a.clear),
.quit => self.quit = true,
.gpu => |pass| if (self.passes) |*g| g.run(&self.images, pass) catch |err| self.print("gpu pass: {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(),
+ .download => |d| if (self.passes) |*g| g.download(d) catch |err| self.print("gpu download: {t} ({s})", .{ err, c.SDL_GetError() }),
+ .open_file => |o| self.openFile(o.command, o.pattern),
+ .run => |line| try lines.append(arena, line),
else => gfx.draw(self.renderer, &self.images, command),
};
self.audio.endFrame();
+ for (lines.items) |line| self.runLine(line, now) catch {};
_ = c.SDL_SetRenderClipRect(self.renderer, null);
var extra: std.ArrayList(abi.Command) = .empty;
@@ -284,12 +326,72 @@ fn draw(self: *Host, now: u64) !void {
if (self.passes) |*g| g.endFrame();
}
+/// A file dialog: shown on request, its answer run as a console line from
+/// the main loop. SDL may answer on another thread.
+const Dialog = struct {
+ mutex: ?*c.SDL_Mutex = null,
+ /// Shown and not yet answered (main thread only).
+ showing: bool = false,
+ command: [64]u8 = undefined,
+ command_len: usize = 0,
+ /// The filter SDL reads until it answers.
+ pattern: [128:0]u8 = @splat(0),
+ filter: c.SDL_DialogFileFilter = undefined,
+ /// "<command> <path>" once answered; empty when cancelled.
+ answer: [std.fs.max_path_bytes + 64]u8 = undefined,
+ answer_len: ?usize = null,
+
+ fn deinit(self: *Dialog) void {
+ if (self.mutex) |m| c.SDL_DestroyMutex(m);
+ self.mutex = null;
+ }
+
+ fn callback(userdata: ?*anyopaque, files: [*c]const [*c]const u8, _: c_int) callconv(.c) void {
+ const self: *Dialog = @ptrCast(@alignCast(userdata orelse return));
+ const m = self.mutex orelse return;
+ c.SDL_LockMutex(m);
+ defer c.SDL_UnlockMutex(m);
+ const first = if (files != null and files[0] != null) std.mem.span(files[0]) else "";
+ const line = if (first.len == 0) "" else std.mem.print(&self.answer, "{s} {s}", .{ self.command[0..self.command_len], first }) catch "";
+ self.answer_len = line.len;
+ }
+
+ /// The answer's console line, once; empty when cancelled.
+ fn take(self: *Dialog, out: []u8) ?[]const u8 {
+ const m = self.mutex orelse return null;
+ c.SDL_LockMutex(m);
+ defer c.SDL_UnlockMutex(m);
+ const len = self.answer_len orelse return null;
+ self.answer_len = null;
+ self.showing = false;
+ @memcpy(out[0..len], self.answer[0..len]);
+ return out[0..len];
+ }
+};
+
+fn openFile(self: *Host, command: []const u8, pattern: []const u8) void {
+ const d = &self.dialog;
+ if (self.options.headless or d.showing) return;
+ if (command.len > d.command.len or pattern.len > d.pattern.len) return self.print("open_file: command or pattern too long", .{});
+ if (d.mutex == null) d.mutex = c.SDL_CreateMutex() orelse return self.print("open_file: {s}", .{c.SDL_GetError()});
+ @memcpy(d.command[0..command.len], command);
+ d.command_len = command.len;
+ @memset(&d.pattern, 0);
+ @memcpy(d.pattern[0..pattern.len], pattern);
+ d.filter = .{ .name = "Files", .pattern = &d.pattern };
+ d.showing = true;
+ c.SDL_ShowOpenFileDialog(Dialog.callback, d, self.window, if (pattern.len > 0) &d.filter else null, @intFromBool(pattern.len > 0), null, false);
+}
+
fn context(self: *Host) abi.Context {
return .{
.host = .{ .ctx = self, .vtable = &api },
.input = &self.input,
- .arena = self.frame_arena.allocator(),
- .gpa = self.session.heap.allocator(),
+ .scratch = self.frame_arena.allocator(),
+ .session = self.session.heap.allocator(),
+ .store = self.store.allocator(),
+ .session_root = self.session.bytes.ptr,
+ .store_root = self.store.root(),
.commands = &self.commands,
};
}
@@ -298,7 +400,7 @@ fn context(self: *Host) abi.Context {
/// console; while it is open it owns the keyboard, and pointer events over it
/// become a cancel, so a half-made click never lands behind it.
pub fn route(self: *Host, e: abi.Event) !void {
- if (e.kind == .key_down and e.code == @intFromEnum(abi.Key.grave)) {
+ if (e.kind == .key_down and e.code == @backingInt(abi.Key.grave)) {
if (e.flags & abi.Event.repeat != 0) return;
self.console.visible = !self.console.visible;
return self.pending.append(self.gpa, .{ .kind = .cancel, .time = e.time });
@@ -316,7 +418,7 @@ pub fn route(self: *Host, e: abi.Event) !void {
return;
},
.key_up => return,
- .mouse_move, .mouse_down, .mouse_up, .wheel => if (e.y >= @as(f32, @floatFromInt(self.canvas[1])) - Console.panel_height) {
+ .mouse_move, .mouse_down, .mouse_up, .wheel, .wheel_horizontal => if (e.y >= @as(f32, @floatFromInt(self.canvas[1])) - Console.panel_height) {
return self.pending.append(self.gpa, .{ .kind = .cancel, .time = e.time });
},
else => {},
@@ -339,7 +441,7 @@ pub fn runLine(self: *Host, line: []const u8, now: u64) !void {
pub fn forward(self: *Host, _: *Console, line: []const u8, now: u64) abi.Outcome {
self.input.now = now;
const ctx = self.context();
- return self.sketch.command(&ctx, self.live().ptr, self.session.bytes.ptr, &line);
+ return self.sketch.command(&ctx, self.live().ptr, &line);
}
/// Fresh state: declared defaults, then the sketch's `init`.
@@ -373,6 +475,8 @@ fn adopt(self: *Host, sketch: abi.Sketch) !void {
if (info.abi != abi.hash) return error.AbiMismatch;
const adoption = try self.state.adopt(self.gpa, info.state, sketch.defaults);
const session_reset = try self.session.adopt(self.gpa, info.session, sketch.defaults);
+ if (session_reset) self.releaseMade();
+ const stored = try self.store.adopt(self.gpa, info.store, sketch.defaults);
_ = self.info_arena.reset(.retain_capacity);
const arena = self.info_arena.allocator();
self.name = try arena.dupe(u8, info.name);
@@ -388,6 +492,33 @@ fn adopt(self: *Host, sketch: abi.Sketch) !void {
}
if (!self.state.used(0)) self.resetState();
if (session_reset and self.reloads > 0) self.print("session layout changed: session reset", .{});
+ switch (stored) {
+ .unchanged, .created => {},
+ .migrated => |m| self.print("store layout changed: kept {d} fields, reset {d} to defaults", .{ m.kept, m.reset }),
+ }
+}
+
+/// Frees what the old Session made: its handles are gone with it.
+fn releaseMade(self: *Host) void {
+ for (self.made.images.items) |image| {
+ if (self.passes) |*g| g.forget(&self.images, image);
+ self.images.free(image);
+ }
+ if (self.passes) |*g| for (self.made.buffers.items) |buffer| g.freeBuffer(buffer);
+ self.made.images.clearRetainingCapacity();
+ self.made.buffers.clearRetainingCapacity();
+}
+
+fn remember(self: *Host, comptime kind: enum { images, buffers }, handle: anytype) @TypeOf(handle) {
+ if (handle != .none) @field(self.made, @tagName(kind)).append(self.gpa, handle) catch {};
+ return handle;
+}
+
+fn forget(list: anytype, handle: anytype) void {
+ for (list.items, 0..) |h, i| if (h == handle) {
+ _ = list.swapRemove(i);
+ return;
+ };
}
fn setCanvas(self: *Host, w: u32, h: u32) void {
@@ -421,7 +552,7 @@ fn applyCursor(self: *Host) void {
pub fn print(self: *Host, comptime fmt: []const u8, args: anytype) void {
var buf: [512]u8 = undefined;
- const message = std.fmt.bufPrint(&buf, fmt, args) catch "(message too long)";
+ const message = std.mem.print(&buf, fmt, args) catch "(message too long)";
self.console.log(message);
// Headless runs are tests: they report through their own results.
if (!self.options.headless) std.debug.print("{s}\n", .{message});
@@ -436,18 +567,21 @@ pub fn poll(self: *Host) !void {
switch (event.type) {
c.SDL_EVENT_QUIT => self.quit = true,
c.SDL_EVENT_WINDOW_FOCUS_LOST => try self.route(.{ .kind = .cancel, .time = time }),
- c.SDL_EVENT_MOUSE_MOTION => try self.route(.{ .kind = .mouse_move, .time = time, .x = event.motion.x, .y = event.motion.y }),
+ c.SDL_EVENT_MOUSE_MOTION => try self.route(.{ .kind = .mouse_move, .time = time, .x = event.motion.x, .y = event.motion.y, .flags = held() }),
c.SDL_EVENT_MOUSE_BUTTON_DOWN, c.SDL_EVENT_MOUSE_BUTTON_UP => try self.route(.{
.kind = if (event.type == c.SDL_EVENT_MOUSE_BUTTON_DOWN) .mouse_down else .mouse_up,
.time = time,
.x = event.button.x,
.y = event.button.y,
.code = event.button.button,
+ .flags = held(),
}),
c.SDL_EVENT_MOUSE_WHEEL => {
- const delta = event.wheel.y * @as(f32, if (event.wheel.direction == c.SDL_MOUSEWHEEL_FLIPPED) -1 else 1);
- if (!std.math.isFinite(delta) or delta == 0) continue;
- try self.route(.{ .kind = .wheel, .time = time, .x = event.wheel.mouse_x, .y = event.wheel.mouse_y, .value = @bitCast(delta) });
+ const direction: f32 = if (event.wheel.direction == c.SDL_MOUSEWHEEL_FLIPPED) -1 else 1;
+ const dx = event.wheel.x * direction;
+ const dy = event.wheel.y * direction;
+ if (std.math.isFinite(dy) and dy != 0) try self.route(.{ .kind = .wheel, .time = time, .x = event.wheel.mouse_x, .y = event.wheel.mouse_y, .value = @bitCast(dy), .flags = held() });
+ if (std.math.isFinite(dx) and dx != 0) try self.route(.{ .kind = .wheel_horizontal, .time = time, .x = event.wheel.mouse_x, .y = event.wheel.mouse_y, .value = @bitCast(dx), .flags = held() });
},
c.SDL_EVENT_KEY_DOWN, c.SDL_EVENT_KEY_UP => try self.route(.{
.kind = if (event.type == c.SDL_EVENT_KEY_DOWN) .key_down else .key_up,
@@ -463,6 +597,16 @@ pub fn poll(self: *Host) !void {
else => {},
}
}
+ var buf: [@sizeOf(@FieldType(Dialog, "answer"))]u8 = undefined;
+ if (self.dialog.take(&buf)) |line| if (line.len > 0) {
+ self.console.print("> {s}", .{line});
+ self.runLine(line, c.SDL_GetTicksNS()) catch {};
+ };
+}
+
+/// The modifiers held now, for a pointer event's `flags`.
+fn held() u8 {
+ return abi.Event.withModifiers(modifiers(c.SDL_GetModState()));
}
fn modifiers(mod: c.SDL_Keymod) u32 {
@@ -475,7 +619,7 @@ fn modifiers(mod: c.SDL_Keymod) u32 {
}
fn consoleKey(e: abi.Event) ?Console.Key {
- const key: abi.Key = @enumFromInt(@as(u8, @truncate(e.code)));
+ const key: abi.Key = @fromBackingInt(@intCast(@as(u8, @truncate(e.code))));
if (key == .u and e.value & abi.Key.Mod.ctrl != 0) return .clear;
if (e.flags & abi.Event.repeat != 0 and key.isEnter()) return null;
if (key.isEnter()) return .submit;
@@ -509,9 +653,12 @@ const api: abi.Host.VTable = .{
.newImage = apiNewImage,
.freeImage = apiFreeImage,
.gpu = apiGpu,
+ .newBuffer = apiNewBuffer,
+ .freeBuffer = apiFreeBuffer,
.imageSize = apiImageSize,
.loadSound = apiLoadSound,
.decodeSound = apiDecodeSound,
+ .samples = apiSamples,
.readFile = apiReadFile,
.env = apiEnv,
.clock = apiClock,
@@ -527,19 +674,38 @@ fn apiLoadImage(ctx: *anyopaque, path: []const u8) abi.Image {
return hostOf(ctx).images.load(path);
}
fn apiDecodeImage(ctx: *anyopaque, png: []const u8) abi.Image {
- return hostOf(ctx).images.decode(png);
+ const self = hostOf(ctx);
+ return self.remember(.images, self.images.decode(png));
}
fn apiNewImage(ctx: *anyopaque, w: u32, h: u32) abi.Image {
- return hostOf(ctx).images.new(w, h);
+ const self = hostOf(ctx);
+ return self.remember(.images, self.images.new(w, h));
}
fn apiFreeImage(ctx: *anyopaque, image: abi.Image) void {
const self = hostOf(ctx);
+ forget(&self.made.images, image);
if (self.passes) |*g| g.forget(&self.images, image);
self.images.free(image);
}
fn apiGpu(ctx: *anyopaque) bool {
return hostOf(ctx).gpu != null;
}
+fn apiNewBuffer(ctx: *anyopaque, size: u32) abi.Buffer {
+ const self = hostOf(ctx);
+ const g = &(self.passes orelse return .none);
+ return self.remember(.buffers, g.newBuffer(size) catch |err| blk: {
+ self.print("gpu buffer: {t} ({s})", .{ err, c.SDL_GetError() });
+ break :blk .none;
+ });
+}
+fn apiFreeBuffer(ctx: *anyopaque, buffer: abi.Buffer) void {
+ const self = hostOf(ctx);
+ forget(&self.made.buffers, buffer);
+ if (self.passes) |*g| g.freeBuffer(buffer);
+}
+fn apiSamples(ctx: *anyopaque, audio: abi.Audio) []const f32 {
+ return hostOf(ctx).audio.samplesOf(audio);
+}
fn apiImageSize(ctx: *anyopaque, image: abi.Image) [2]u32 {
return hostOf(ctx).images.size(image);
}