//! 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 tracy = @import("tracy");
const c = @import("c");
const abi = @import("abi");
const memory = @import("memory.zig");
const playback = @import("timeline.zig");
const Timeline = playback.Timeline;
const mapRecordings = playback.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,
/// Time every GPU command alone and print the times at exit.
profile_gpu: bool = false,
/// Export every frame: PNGs `
/000000.png`, ..., or for "-" raw RGBA
/// rows on stdout. Frames run on a clock of their own (see `fps`).
export_to: ?[]const u8 = null,
/// Export: frame k is k/fps seconds in, each tick exactly 1/fps.
fps: u32 = 60,
/// Export: stop after this many frames; null: when the sketch quits.
frames: ?u64 = null,
/// The first canvas and, headless, the room for it (`window_width`).
size: ?[2]u32 = null,
};
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,
/// GPU canvas, shared by native/headless drawing, backdrop filters and screenshots.
offscreen: ?*c.SDL_Texture = null,
pointer_cursor: ?*c.SDL_Cursor = null,
images: gfx.Images,
/// Plays the 2D commands: targets, blend, antialiased shapes.
painter: gfx.Painter,
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 = .{},
sketch: abi.Sketch,
library: ?Library = null,
watch: ?Watch = null,
reloads: usize = 0,
/// Identifies the running build of the sketch (a hash of its library or
/// executable file): recordings carry it, and `play` warns on a mismatch.
build: u64 = 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,
/// For `Input.jumped`: state changed other than by `update` since the
/// last `draw` (a seek, a load, a `set`...). The first frame is one.
jumped: bool = true,
started: bool = true,
last_now: u64 = 0,
/// Saved after the next frame is drawn (scripts).
screenshot: ?[:0]const u8 = null,
/// Frames exported so far (`Options.export_to`).
exported: u64 = 0,
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) {
// Overriding: a plain hint loses to the environment, and a user's
// SDL_VIDEO_DRIVER=wayland would open real windows during tests.
_ = c.SDL_SetHintWithPriority(c.SDL_HINT_VIDEO_DRIVER, "offscreen", c.SDL_HINT_OVERRIDE);
_ = c.SDL_SetHintWithPriority(c.SDL_HINT_AUDIO_DRIVER, "dummy", c.SDL_HINT_OVERRIDE);
_ = c.SDL_SetHintWithPriority(c.SDL_HINT_RENDER_DRIVER, "software", c.SDL_HINT_OVERRIDE);
}
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.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
// passes; without one, SDL picks whatever renderer works. Headless, it
// gets no window (an offscreen window has no Vulkan surface everywhere)
// and draws into a texture instead (`setCanvas`).
var gpu = c.SDL_CreateGPUDevice(c.SDL_GPU_SHADERFORMAT_SPIRV, false, null);
var renderer: ?*c.SDL_Renderer = if (gpu) |device| c.SDL_CreateGPURenderer(device, if (options.headless) null else 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");
}
// Deferred in reverse: the renderer goes first, then the device it
// draws through (the other order crashed in SDL_DestroyRenderer).
errdefer if (gpu) |device| c.SDL_DestroyGPUDevice(device);
errdefer c.SDL_DestroyRenderer(renderer);
if (!options.headless) _ = c.SDL_SetRenderVSync(renderer, 1);
// Colors carry alpha: fills blend, as they do on the web.
_ = c.SDL_SetRenderDrawBlendMode(renderer, c.SDL_BLENDMODE_BLEND);
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.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,
.io = io,
.environ = environ,
.options = options,
.window = window,
.renderer = renderer.?,
.gpu = gpu,
.images = .{ .gpa = gpa, .renderer = renderer.? },
.painter = .{ .renderer = renderer.?, .images = undefined, .smooth = gpu != null },
.audio = .{ .gpa = gpa },
.state = state,
.session = .init(gpa),
.store = store,
.recordings = recordings,
.timeline = undefined,
.sketch = sketch,
.library = library,
.info_arena = .init(gpa),
.frame_arena = .init(gpa),
.input = .{ .exporting = options.export_to != null },
};
self.timeline = .{ .bank = .{ .state = &self.state, .inputs = recordings } };
self.painter.images = &self.images;
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;
};
const size = options.size orelse [2]u32{ info.width, info.height };
self.setCanvas(size[0], size[1]);
_ = c.SDL_StartTextInput(self.window);
self.build = fileHash(options.library orelse "/proc/self/exe");
try self.adopt(sketch);
if (options.fresh) {
self.state.header().used = 0;
@memset(self.recordings, 0);
self.resetState();
}
}
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);
self.painter.deinit();
self.images.deinit();
if (self.pointer_cursor) |cursor| c.SDL_DestroyCursor(cursor);
if (self.offscreen) |texture| c.SDL_DestroyTexture(texture);
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.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();
self.info_arena.deinit();
if (self.library) |*l| l.close();
c.SDL_Quit();
}
/// The interactive loop. An export runs it on a clock of its own, frame k
/// at k/fps seconds (from 1 s, as scripts do), whatever the wall clock says.
pub fn run(self: *Host) !void {
while (!self.quit) {
try self.poll();
try self.frame(if (self.options.export_to == null) c.SDL_GetTicksNS() else std.time.ns_per_s + self.exported * std.time.ns_per_s / self.options.fps);
}
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 {
const zone = tracy.zone(@src(), "frame");
tracy.frameMark();
defer zone.end();
_ = 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 => {
// One frame: what was routed since the last one, then its tick.
// Recorded first, so `update` sees the times a replay will.
var tick = abi.Event.tick(now, dt);
// An export's tick is 1/fps itself, not whole nanoseconds of it.
if (self.options.export_to != null and dt != 0) tick.x = 1 / @as(f32, @floatFromInt(self.options.fps));
try self.pending.append(self.gpa, tick);
h.capture(self.pending.items) catch |err| self.print("Recording stopped: {t}", .{err});
self.update(self.pending.items);
},
}
self.pending.clearRetainingCapacity();
try self.draw(if (h.mode == .live or h.mode == .recording) now else h.position);
}
/// Feeds whole frames to the sketch's deterministic `update`, one call per
/// frame (events up to and including a tick), live or replayed alike.
pub fn update(self: *Host, events: []const abi.Event) void {
var frames = playback.frames(events);
while (frames.next()) |one| {
// Input follows the events actually fed, frame by frame.
for (one) |e| self.input.track(e);
const tick = one[one.len - 1];
self.input.now = tick.time;
self.input.dt = tick.tickDt();
self.input.events = one;
self.input.mode = self.timeline.mode;
self.input.started = self.started;
self.started = false;
const ctx = self.context();
self.sketch.update(&ctx, self.live().ptr);
}
self.input.events = &.{};
}
/// After live state was restored from a snapshot: the pointer, buttons and
/// keys tracked so far belong to other bytes, so they start over. A new
/// recording then begins with events that bring back what is held now, so
/// its replay starts from the same input (they are fed and recorded as the
/// first frame's first events).
fn restoredInput(self: *Host, now: u64) !void {
const h = &self.timeline;
if (!h.restored) return;
h.restored = false;
const was = self.input;
self.input.mouse_x = 0;
self.input.mouse_y = 0;
self.input.buttons = 0;
self.input.keys = .empty;
if (h.mode != .recording or h.bank.recording(h.selected).count != 0) return;
var seed: std.ArrayList(abi.Event) = .empty;
defer seed.deinit(self.gpa);
if (was.mouse_x != 0 or was.mouse_y != 0) try seed.append(self.gpa, .{ .kind = .mouse_move, .time = now, .x = was.mouse_x, .y = was.mouse_y });
for (0..32) |bit| if (was.buttons & (@as(u32, 1) << @intCast(bit)) != 0) {
try seed.append(self.gpa, .{ .kind = .mouse_down, .time = now, .x = was.mouse_x, .y = was.mouse_y, .code = @intCast(bit + 1) });
};
var keys = was.keys.iterator(.{});
while (keys.next()) |key| try seed.append(self.gpa, .{ .kind = .key_down, .time = now, .code = @intCast(key) });
try self.pending.insertSlice(self.gpa, 0, seed.items);
}
fn draw(self: *Host, now: u64) !void {
const zone = tracy.zone(@src(), "Host.zig:draw");
defer zone.end();
const arena = self.frame_arena.allocator();
self.input.now = now;
self.input.mode = self.timeline.mode;
self.input.reloaded = self.reloaded;
self.input.jumped = self.jumped or self.reloaded;
self.reloaded = false;
self.jumped = false;
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,
// unless `--size` gives one.
const room = if (self.options.size) |size| size else self.canvas;
self.input.window_width = @floatFromInt(room[0]);
self.input.window_height = @floatFromInt(room[1]);
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);
_ = c.SDL_SetRenderTarget(self.renderer, self.offscreen);
_ = c.SDL_SetRenderClipRect(self.renderer, null);
_ = c.SDL_SetRenderDrawColor(self.renderer, 0, 0, 0, 255);
_ = c.SDL_RenderClear(self.renderer);
self.audio.beginFrame();
self.painter.begin(self.offscreen, self.canvas, arena);
var lines: std.ArrayList([]const u8) = .empty;
{
const paint_zone = tracy.zone(@src(), "paint commands");
defer paint_zone.end();
for (self.commands.items) |command| switch (command) {
.canvas => |size| {
self.painter.end();
self.setCanvas(size.w, size.h);
self.painter.begin(self.offscreen, self.canvas, arena);
},
.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() }),
.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 => self.painter.draw(command),
};
self.painter.end();
self.audio.endFrame();
}
for (lines.items) |line| self.runLine(line, now) catch {};
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| self.painter.draw(command);
self.painter.end();
self.applyCursor();
if (self.screenshot != null or self.options.export_to != null) {
const surface = c.SDL_RenderReadPixels(self.renderer, null) orelse return sdlError("SDL_RenderReadPixels");
defer c.SDL_DestroySurface(surface);
if (self.screenshot) |path| {
self.screenshot = null;
if (!c.SDL_SavePNG(surface, path.ptr)) return sdlError("SDL_SavePNG");
}
if (self.options.export_to) |to| try self.exportFrame(surface, to);
}
if (!self.options.headless) if (self.offscreen) |canvas| {
_ = c.SDL_SetRenderTarget(self.renderer, null);
_ = c.SDL_SetTextureBlendMode(canvas, c.SDL_BLENDMODE_NONE);
_ = c.SDL_RenderTexture(self.renderer, canvas, null, null);
};
const present_zone = tracy.zone(@src(), "present");
_ = c.SDL_RenderPresent(self.renderer);
present_zone.end();
if (self.passes) |*g| g.endFrame();
}
/// One exported frame: `/.png`, or for "-" its
/// RGBA rows on stdout (`ffmpeg -f rawvideo -pix_fmt rgba`).
fn exportFrame(self: *Host, surface: *c.SDL_Surface, to: []const u8) !void {
if (std.mem.eql(u8, to, "-")) {
// The offscreen canvas is RGBA already; a renderer without a GPU may not be.
const rgba = if (surface.*.format == c.SDL_PIXELFORMAT_RGBA32) surface else c.SDL_ConvertSurface(surface, c.SDL_PIXELFORMAT_RGBA32) orelse return sdlError("SDL_ConvertSurface");
defer if (rgba != surface) c.SDL_DestroySurface(rgba);
const pixels: [*]const u8 = @ptrCast(rgba.*.pixels.?);
const row: usize = @intCast(rgba.*.w * 4);
const pitch: usize = @intCast(rgba.*.pitch);
const rows: usize = @intCast(rgba.*.h);
const out = std.Io.File.stdout();
if (pitch == row) try out.writeStreamingAll(self.io, pixels[0 .. row * rows]) else for (0..rows) |y| try out.writeStreamingAll(self.io, pixels[y * pitch ..][0..row]);
} else {
var buf: [std.fs.max_path_bytes]u8 = undefined;
const path = std.mem.printSentinel(&buf, "{s}/{d:0>6}.png", .{ to, self.exported }, 0) catch return error.NameTooLong;
if (!c.SDL_SavePNG(surface, path.ptr)) return sdlError("SDL_SavePNG");
}
self.exported += 1;
if (self.options.frames) |n| if (self.exported >= n) {
self.quit = true;
};
}
/// 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,
/// " " 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,
.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,
};
}
/// 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 == @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 });
}
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) catch {};
return;
},
.key_up => return,
.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 => {},
};
try self.pending.append(self.gpa, e);
}
/// Runs a console line now, replaying whatever a seek asks for. An error is
/// printed to the console, and returned for scripts to fail on.
pub fn runLine(self: *Host, line: []const u8, now: u64) !void {
const zone = tracy.zone(@src(), "Host.zig:runLine");
defer zone.end();
const replay = self.console.execute(self, line, now) catch |err| {
// The sketch has printed its own error already.
if (err != error.CommandFailed) self.console.print("{t}. Type help for usage.", .{err});
if (self.timeline.restored) self.jumped = true;
try self.restoredInput(now);
return err;
};
if (self.timeline.restored or movesState(line)) self.jumped = true;
try self.restoredInput(now);
if (self.timeline.mode == .paused) self.update(replay);
}
/// Whether a console line that succeeded may have changed State other than
/// through `update` (restoring a snapshot is caught apart from this).
fn movesState(line: []const u8) bool {
var words = std.mem.tokenizeAny(u8, line, " \t");
const verb = words.next() orelse return false;
const still = [_][]const u8{ "help", "overlay", "get", "snapshot", "recording", "diff", "stop", "pause", "save", "quit", "exit" };
for (still) |w| if (std.mem.eql(u8, verb, w)) return false;
return true;
}
/// Offers a line to the sketch.
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, &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.build = fileHash(path);
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);
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);
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", .{});
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 {
if (w == 0 or h == 0 or (self.canvas[0] == w and self.canvas[1] == h)) return;
self.canvas = .{ w, h };
_ = c.SDL_SetRenderTarget(self.renderer, null);
_ = c.SDL_SetRenderLogicalPresentation(self.renderer, @intCast(w), @intCast(h), c.SDL_LOGICAL_PRESENTATION_LETTERBOX);
if (self.gpu != null) {
if (self.offscreen) |texture| c.SDL_DestroyTexture(texture);
self.offscreen = c.SDL_CreateTexture(self.renderer, c.SDL_PIXELFORMAT_RGBA32, c.SDL_TEXTUREACCESS_TARGET, @intCast(w), @intCast(h));
_ = c.SDL_SetRenderTarget(self.renderer, self.offscreen);
}
_ = 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.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});
}
/// Translates SDL events into sketch events and routes them.
pub fn poll(self: *Host) !void {
const zone = tracy.zone(@src(), "Host.zig:poll");
defer zone.end();
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, .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 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,
.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 => {},
}
}
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 {
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 = @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;
return switch (key) {
.left => .left,
.right => .right,
.home => .home,
.end => .end,
.backspace => .backspace,
.delete => .delete,
.escape => .clear,
.tab => .tab,
else => null,
};
}
/// A hash of a file's bytes; 0 when it cannot be read.
fn fileHash(path: []const u8) u64 {
const bytes = memory.mapReadOnly(path);
if (bytes.len == 0) return 0;
defer std.posix.munmap(bytes);
return std.hash.Wyhash.hash(0, bytes) | 1;
}
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,
.newBuffer = apiNewBuffer,
.freeBuffer = apiFreeBuffer,
.imageSize = apiImageSize,
.textSize = apiTextSize,
.loadSound = apiLoadSound,
.decodeSound = apiDecodeSound,
.samples = apiSamples,
.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 {
const self = hostOf(ctx);
return self.remember(.images, self.images.decode(png));
}
fn apiNewImage(ctx: *anyopaque, w: u32, h: u32) abi.Image {
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);
}
fn apiTextSize(ctx: *anyopaque, scale: f32, bytes: []const u8, face: abi.Face) [2]f32 {
return gfx.textSize(hostOf(ctx).renderer, scale, bytes, face);
}
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);
}