diff options
| author | Gabriel Schneider <[email protected]> | 2026-10-28 21:07:13 -0300 |
|---|---|---|
| committer | Gabriel Schneider <[email protected]> | 2026-11-12 13:22:02 -0300 |
| commit | 590ba7b9b579b97e34b51ab7e3460ebc85713343 (patch) | |
| tree | 6a73a7570ff4f79f41deff078455877b9bc6571b /src/host/Host.zig | |
| parent | bc8e6eb1bfef0c5e9b3c40fc1e4fd5a1659e2b03 (diff) | |
| download | sketchbook-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.zig | 198 |
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); } |
