diff options
| author | Gabriel Schneider <[email protected]> | 2026-09-25 21:47:58 -0300 |
|---|---|---|
| committer | Gabriel Schneider <[email protected]> | 2026-09-25 21:48:16 -0300 |
| commit | 9c33714591a2147f7e5879e77212ca9886d0c967 (patch) | |
| tree | d250be9d9bc365d7894d49455c0f6376966b58be /src/host/Host.zig | |
| download | sketchbook-9c33714591a2147f7e5879e77212ca9886d0c967.tar.gz sketchbook-9c33714591a2147f7e5879e77212ca9886d0c967.zip | |
Put the game first: lib/sketchbook, sketches/vecanim
The root is the game. The platform library moves to lib/sketchbook (with
serve_web.py, which serves any sketch's web build, as a tool of it), and
vecanim to sketches/vecanim, still its own package on the same library.
Diffstat (limited to 'src/host/Host.zig')
| -rw-r--r-- | src/host/Host.zig | 545 |
1 files changed, 545 insertions, 0 deletions
diff --git a/src/host/Host.zig b/src/host/Host.zig new file mode 100644 index 0000000..41597a6 --- /dev/null +++ b/src/host/Host.zig @@ -0,0 +1,545 @@ +//! The runtime around a sketch: window, memory, audio, timeline and console. +//! One `frame` serves both the interactive loop and test scripts, so scripts +//! exercise exactly what a player does. +const Host = @This(); +const std = @import("std"); +const c = @import("c"); +const abi = @import("abi"); +const memory = @import("memory.zig"); +const Timeline = @import("timeline.zig").Timeline; +const mapRecordings = @import("timeline.zig").mapRecordings; +const gfx = @import("gfx.zig"); +const sound = @import("audio.zig"); +const Gpu = @import("gpu.zig"); +const overlay = @import("overlay.zig"); +const Console = @import("Console.zig"); +const Library = @import("library.zig").Library; +const Watch = @import("library.zig").Watch; + +pub const Options = struct { + /// A hot-reloaded sketch library. Unused when a sketch is linked in. + library: ?[]const u8 = null, + /// State file; recordings go next to it with an `.inputs` suffix. + state: []const u8 = "sketch.state", + /// Offscreen video, silent audio, no vsync: for scripts and CI. + headless: bool = false, + /// Forget the state file's contents: scripts start from a known place. + fresh: bool = false, +}; + +gpa: std.mem.Allocator, +io: std.Io, +environ: *const std.process.Environ.Map, +options: Options, +window: *c.SDL_Window, +renderer: *c.SDL_Renderer, +/// Runs sketches' GPU passes, and the 2D renderer draws through it too. +/// Null when the machine has no usable GPU driver. +gpu: ?*c.SDL_GPUDevice, +passes: ?Gpu = null, +pointer_cursor: ?*c.SDL_Cursor = null, +images: gfx.Images, +audio: sound.Audio, +state: memory.StateFile, +session: memory.Session, +recordings: []align(memory.page) u8, +timeline: Timeline, +console: Console = .{}, +sketch: abi.Sketch, +library: ?Library = null, +watch: ?Watch = null, +reloads: usize = 0, +/// Copies of the sketch's info strings, replaced on every load. +info_arena: std.heap.ArenaAllocator, +name: []const u8 = "", +completions: []const []const u8 = &.{}, +/// Frame lifetime: sketch scratch and this frame's commands. +frame_arena: std.heap.ArenaAllocator, +commands: std.ArrayList(abi.Command) = .empty, +/// Events routed since the last frame, fed to `update` by the next one. +pending: std.ArrayList(abi.Event) = .empty, +input: abi.Input = .{}, +files: std.StringHashMapUnmanaged([]align(memory.page) const u8) = .empty, +canvas: [2]u32 = .{ 0, 0 }, +cursor: abi.Cursor = .arrow, +quit: bool = false, +reloaded: bool = true, +last_now: u64 = 0, +/// Saved after the next frame is drawn (scripts). +screenshot: ?[:0]const u8 = null, + +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) { + _ = c.SDL_SetHint(c.SDL_HINT_VIDEO_DRIVER, "offscreen"); + _ = c.SDL_SetHint(c.SDL_HINT_AUDIO_DRIVER, "dummy"); + _ = c.SDL_SetHint(c.SDL_HINT_RENDER_DRIVER, "software"); + } + if (!c.SDL_Init(c.SDL_INIT_VIDEO | c.SDL_INIT_EVENTS | c.SDL_INIT_AUDIO)) return sdlError("SDL_Init"); + errdefer c.SDL_Quit(); + + var library: ?Library = null; + const sketch = linked orelse blk: { + const path = options.library orelse return error.NoSketch; + library = try Library.openCopy(io, path, scratchDir(environ), 0); + break :blk library.?.sketch; + }; + errdefer if (library) |*l| l.close(); + const info = sketch.info(); + + var title_buf: [256]u8 = undefined; + const title = std.fmt.bufPrintZ(&title_buf, "{s}", .{info.name}) 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 + // passes; without one, SDL picks whatever renderer works. + var gpu = c.SDL_CreateGPUDevice(c.SDL_GPU_SHADERFORMAT_SPIRV, false, null); + var renderer: ?*c.SDL_Renderer = if (gpu) |device| c.SDL_CreateGPURenderer(device, window) else null; + if (renderer == null) { + if (gpu) |device| c.SDL_DestroyGPUDevice(device); + gpu = null; + std.log.warn("no GPU renderer ({s}); drawing without one", .{c.SDL_GetError()}); + renderer = c.SDL_CreateRenderer(window, null) orelse return sdlError("SDL_CreateRenderer"); + } + errdefer c.SDL_DestroyRenderer(renderer); + errdefer if (gpu) |device| c.SDL_DestroyGPUDevice(device); + if (!options.headless) _ = c.SDL_SetRenderVSync(renderer, 1); + + 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})); + errdefer std.posix.munmap(recordings); + + self.* = .{ + .gpa = gpa, + .io = io, + .environ = environ, + .options = options, + .window = window, + .renderer = renderer.?, + .gpu = gpu, + .images = .{ .gpa = gpa, .renderer = renderer.? }, + .audio = .{ .gpa = gpa }, + .state = state, + .session = .init(gpa), + .recordings = recordings, + .timeline = undefined, + .sketch = sketch, + .library = library, + .info_arena = .init(gpa), + .frame_arena = .init(gpa), + }; + self.timeline = .{ .bank = .{ .state = &self.state, .inputs = recordings } }; + if (gpu) |device| self.passes = .init(gpa, device); + 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; + }; + self.setCanvas(info.width, info.height); + _ = c.SDL_StartTextInput(self.window); + try self.adopt(sketch); + if (options.fresh) { + self.state.header().used = 0; + @memset(self.recordings, 0); + self.resetState(); + } +} + +pub fn deinit(self: *Host) void { + if (self.watch) |w| w.deinit(); + self.audio.deinit(); + if (self.passes) |*g| g.deinit(&self.images); + self.images.deinit(); + if (self.pointer_cursor) |cursor| c.SDL_DestroyCursor(cursor); + c.SDL_DestroyRenderer(self.renderer); + if (self.gpu) |device| c.SDL_DestroyGPUDevice(device); + c.SDL_DestroyWindow(self.window); + var files = self.files.iterator(); + while (files.next()) |entry| { + self.gpa.free(entry.key_ptr.*); + std.posix.munmap(entry.value_ptr.*); + } + self.files.deinit(self.gpa); + std.posix.munmap(self.recordings); + self.session.deinit(self.gpa); + self.state.close(); + self.pending.deinit(self.gpa); + self.frame_arena.deinit(); + self.info_arena.deinit(); + if (self.library) |*l| l.close(); + c.SDL_Quit(); +} + +/// The interactive loop. +pub fn run(self: *Host) !void { + while (!self.quit) { + try self.poll(); + try self.frame(c.SDL_GetTicksNS()); + } + self.timeline.stop(c.SDL_GetTicksNS()); +} + +pub fn live(self: *Host) []u8 { + return self.state.slot(0); +} + +/// One frame: reload if a build replaced the library, feed input through +/// `update`, then `draw` and present. +pub fn frame(self: *Host, now: u64) !void { + _ = self.frame_arena.reset(.retain_capacity); + self.commands = .empty; + if (self.watch) |w| if (w.changed()) self.reload() catch |err| self.print("reload failed: {t}", .{err}); + + const dt = if (self.last_now == 0) 0 else now -| self.last_now; + self.last_now = now; + const h = &self.timeline; + switch (h.mode) { + .playing => self.update(h.tick(now)), + .paused => {}, + .live, .recording => { + try self.pending.append(self.gpa, .{ .kind = .tick, .time = now, .x = @floatCast(@as(f64, @floatFromInt(dt)) / std.time.ns_per_s) }); + for (self.pending.items) |e| h.capture(e) catch |err| self.print("Recording stopped: {t}", .{err}); + self.input.now = now; + self.input.dt = dt; + self.update(self.pending.items); + }, + } + self.pending.clearRetainingCapacity(); + try self.draw(if (h.mode == .live or h.mode == .recording) now else h.position); +} + +/// Feeds events to the sketch's deterministic `update`. +pub fn update(self: *Host, events: []const abi.Event) void { + // Input follows the events actually fed, live or replayed. + for (events) |e| self.input.track(e); + if (events.len > 0 and self.timeline.mode != .live and self.timeline.mode != .recording) self.input.now = events[events.len - 1].time; + self.input.events = events; + self.input.mode = self.timeline.mode; + const ctx = self.context(); + self.sketch.update(&ctx, self.live().ptr); + self.input.events = &.{}; +} + +fn draw(self: *Host, now: u64) !void { + const arena = self.frame_arena.allocator(); + self.input.now = now; + self.input.mode = self.timeline.mode; + self.input.reloaded = self.reloaded; + self.reloaded = false; + self.input.console = self.console.visible; + self.input.width = @floatFromInt(self.canvas[0]); + self.input.height = @floatFromInt(self.canvas[1]); + self.input.streams = self.audio.streamStatus(); + self.input.sample_rate = sound.sample_rate; + self.input.frame += 1; + const ctx = self.context(); + self.sketch.draw(&ctx, self.live().ptr, self.session.bytes.ptr); + + _ = c.SDL_SetRenderClipRect(self.renderer, null); + _ = c.SDL_SetRenderDrawColor(self.renderer, 0, 0, 0, 255); + _ = c.SDL_RenderClear(self.renderer); + self.audio.beginFrame(); + for (self.commands.items) |command| switch (command) { + .canvas => |size| self.setCanvas(size.w, size.h), + .cursor => |kind| self.cursor = kind, + .voice => |voice| self.audio.declare(voice), + .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() }), + else => gfx.draw(self.renderer, &self.images, command), + }; + self.audio.endFrame(); + _ = c.SDL_SetRenderClipRect(self.renderer, null); + + var extra: std.ArrayList(abi.Command) = .empty; + if (self.console.overlay_memory) try overlay.drawMemory(&extra, arena, self.state.layout, self.live(), self.input.width); + if (self.console.overlay_sound) { + const samples = self.audio.scope.snapshot(); + try overlay.drawScope(&extra, arena, &samples, self.audio.scope.rate, self.canvas); + } + if (self.console.visible) try self.console.draw(self, &extra, arena); + for (extra.items) |command| gfx.draw(self.renderer, &self.images, command); + self.applyCursor(); + + if (self.screenshot) |path| { + self.screenshot = null; + const surface = c.SDL_RenderReadPixels(self.renderer, null) orelse return sdlError("SDL_RenderReadPixels"); + defer c.SDL_DestroySurface(surface); + if (!c.SDL_SavePNG(surface, path.ptr)) return sdlError("SDL_SavePNG"); + } + _ = c.SDL_RenderPresent(self.renderer); + if (self.passes) |*g| g.endFrame(); +} + +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(), + .commands = &self.commands, + }; +} + +/// Sends one event to the console or towards the sketch. Backtick toggles the +/// 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.flags & abi.Event.repeat != 0) return; + self.console.visible = !self.console.visible; + return self.pending.append(self.gpa, .{ .kind = .cancel, .time = e.time }); + } + if (self.console.visible) switch (e.kind) { + .text => { + var buf: [4]u8 = undefined; + const len = std.unicode.utf8Encode(@intCast(@min(e.value, 0x10ffff)), &buf) catch return; + self.console.insert(buf[0..len]); + return; + }, + .key_down => { + const key = consoleKey(e) orelse return; + if (self.console.edit(key, self.completions)) |line| self.runLine(line, e.time); + return; + }, + .key_up => return, + .mouse_move, .mouse_down, .mouse_up, .wheel => if (e.y >= @as(f32, @floatFromInt(self.canvas[1])) - Console.panel_height) { + return self.pending.append(self.gpa, .{ .kind = .cancel, .time = e.time }); + }, + else => {}, + }; + try self.pending.append(self.gpa, e); +} + +/// Runs a console line now, replaying whatever a seek asks for. +pub fn runLine(self: *Host, line: []const u8, now: u64) void { + const replay = self.console.execute(self, line, now) catch |err| { + self.console.print("{t}. Type help for usage.", .{err}); + return; + }; + if (self.timeline.mode == .paused) self.update(replay); +} + +/// Offers a line to the sketch; false if it did not take it. +pub fn forward(self: *Host, _: *Console, line: []const u8, now: u64) bool { + self.input.now = now; + const ctx = self.context(); + return self.sketch.command(&ctx, self.live().ptr, self.session.bytes.ptr, &line); +} + +/// Fresh state: declared defaults, then the sketch's `init`. +pub fn resetState(self: *Host) void { + const bytes = self.live(); + @memset(bytes, 0); + self.sketch.defaults(.state, bytes.ptr); + const ctx = self.context(); + self.sketch.init(&ctx, bytes.ptr); + self.state.markUsed(0, true); +} + +/// Loads the watched library again. +pub fn reload(self: *Host) !void { + try self.load(self.options.library orelse return error.NoLibrary); +} + +/// Replaces the running sketch with the library at `path`, keeping state. +pub fn load(self: *Host, path: []const u8) !void { + var library = try Library.openCopy(self.io, path, scratchDir(self.environ), self.reloads + 1); + errdefer library.close(); + try self.adopt(library.sketch); + if (self.library) |*old| old.close(); + self.library = library; + self.reloads += 1; + self.print("reload {d}: {s}", .{ self.reloads, path }); +} + +fn adopt(self: *Host, sketch: abi.Sketch) !void { + const info = sketch.info(); + 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); + _ = self.info_arena.reset(.retain_capacity); + const arena = self.info_arena.allocator(); + self.name = try arena.dupe(u8, info.name); + const completions = try arena.alloc([]const u8, info.commands.len); + for (completions, info.commands) |*to, from| to.* = try arena.dupe(u8, from); + self.completions = completions; + self.sketch = sketch; + self.reloaded = true; + switch (adoption) { + .unchanged => {}, + .created => {}, + .migrated => |m| self.print("state layout changed: kept {d} fields, reset {d} to defaults", .{ m.kept, m.reset }), + } + if (!self.state.used(0)) self.resetState(); + if (session_reset and self.reloads > 0) self.print("session layout changed: session reset", .{}); +} + +fn setCanvas(self: *Host, w: u32, h: u32) void { + if (w == 0 or h == 0 or (self.canvas[0] == w and self.canvas[1] == h)) return; + self.canvas = .{ w, h }; + _ = c.SDL_SetRenderLogicalPresentation(self.renderer, @intCast(w), @intCast(h), c.SDL_LOGICAL_PRESENTATION_LETTERBOX); + _ = c.SDL_SetWindowSize(self.window, @intCast(w), @intCast(h)); +} + +fn applyCursor(self: *Host) void { + const kind: abi.Cursor = if (self.console.visible) .arrow else self.cursor; + switch (kind) { + .hidden => _ = c.SDL_HideCursor(), + .arrow => { + _ = c.SDL_SetCursor(c.SDL_GetDefaultCursor()); + _ = c.SDL_ShowCursor(); + }, + .pointer => { + if (self.pointer_cursor == null) self.pointer_cursor = c.SDL_CreateSystemCursor(c.SDL_SYSTEM_CURSOR_POINTER); + _ = c.SDL_SetCursor(self.pointer_cursor orelse c.SDL_GetDefaultCursor()); + _ = c.SDL_ShowCursor(); + }, + } +} + +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)"; + self.console.log(message); + // Headless runs are tests: they report through their own results. + if (!self.options.headless) std.debug.print("{s}\n", .{message}); +} + +/// Translates SDL events into sketch events and routes them. +pub fn poll(self: *Host) !void { + var event: c.SDL_Event = undefined; + while (c.SDL_PollEvent(&event)) { + _ = c.SDL_ConvertEventToRenderCoordinates(self.renderer, &event); + const time = event.common.timestamp; + 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_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, + }), + 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) }); + }, + 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, + .time = time, + .code = @intCast(event.key.scancode), + .flags = if (event.key.repeat) abi.Event.repeat else 0, + .value = modifiers(event.key.mod), + }), + c.SDL_EVENT_TEXT_INPUT => { + var it = (std.unicode.Utf8View.init(std.mem.span(event.text.text)) catch continue).iterator(); + while (it.nextCodepoint()) |cp| try self.route(.{ .kind = .text, .time = time, .value = cp }); + }, + else => {}, + } + } +} + +fn modifiers(mod: c.SDL_Keymod) u32 { + var m: u32 = 0; + if (mod & c.SDL_KMOD_SHIFT != 0) m |= abi.Key.Mod.shift; + if (mod & c.SDL_KMOD_CTRL != 0) m |= abi.Key.Mod.ctrl; + if (mod & c.SDL_KMOD_ALT != 0) m |= abi.Key.Mod.alt; + if (mod & c.SDL_KMOD_GUI != 0) m |= abi.Key.Mod.gui; + return m; +} + +fn consoleKey(e: abi.Event) ?Console.Key { + const key: abi.Key = @enumFromInt(@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; + return switch (key) { + .left => .left, + .right => .right, + .home => .home, + .end => .end, + .backspace => .backspace, + .delete => .delete, + .escape => .clear, + .tab => .tab, + else => null, + }; +} + +fn scratchDir(environ: *const std.process.Environ.Map) []const u8 { + return environ.get("XDG_RUNTIME_DIR") orelse "/tmp"; +} + +fn sdlError(what: []const u8) error{Sdl} { + std.log.err("{s}: {s}", .{ what, c.SDL_GetError() }); + return error.Sdl; +} + +// Host services, as seen by sketches. +const api: abi.Host.VTable = .{ + .log = apiLog, + .loadImage = apiLoadImage, + .decodeImage = apiDecodeImage, + .newImage = apiNewImage, + .freeImage = apiFreeImage, + .gpu = apiGpu, + .imageSize = apiImageSize, + .loadSound = apiLoadSound, + .decodeSound = apiDecodeSound, + .readFile = apiReadFile, + .env = apiEnv, + .clock = apiClock, +}; + +fn hostOf(ctx: *anyopaque) *Host { + return @ptrCast(@alignCast(ctx)); +} +fn apiLog(ctx: *anyopaque, message: []const u8) void { + hostOf(ctx).print("{s}", .{message}); +} +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); +} +fn apiNewImage(ctx: *anyopaque, w: u32, h: u32) abi.Image { + return hostOf(ctx).images.new(w, h); +} +fn apiFreeImage(ctx: *anyopaque, image: abi.Image) void { + const self = hostOf(ctx); + if (self.passes) |*g| g.forget(&self.images, image); + self.images.free(image); +} +fn apiGpu(ctx: *anyopaque) bool { + return hostOf(ctx).gpu != null; +} +fn apiImageSize(ctx: *anyopaque, image: abi.Image) [2]u32 { + return hostOf(ctx).images.size(image); +} +fn apiLoadSound(ctx: *anyopaque, path: []const u8) abi.Audio { + return hostOf(ctx).audio.load(path); +} +fn apiDecodeSound(ctx: *anyopaque, wav: []const u8) abi.Audio { + return hostOf(ctx).audio.decode(wav); +} +fn apiReadFile(ctx: *anyopaque, path: []const u8) []const u8 { + const self = hostOf(ctx); + if (self.files.get(path)) |bytes| return bytes; + const bytes = memory.mapReadOnly(path); + if (bytes.len == 0) return &.{}; + const key = self.gpa.dupe(u8, path) catch return bytes; + self.files.put(self.gpa, key, bytes) catch self.gpa.free(key); + return bytes; +} +fn apiClock(_: *anyopaque) u64 { + return c.SDL_GetTicksNS(); +} +fn apiEnv(ctx: *anyopaque, name: []const u8) ?[]const u8 { + return hostOf(ctx).environ.get(name); +} |
