//! 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");
const overlay = @import("overlay.zig");
const Console = @import("Console.zig");
const Timing = @import("Timing.zig");
const Presentation = @import("Presentation.zig");
const timing_marker = @import("timing_marker.zig");
const Control = @import("control.zig").Control;
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,
/// Local 9P control socket, opt-in.
ninep: ?[]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,
/// Binary frame/time marker for external video measurements.
timing_marker: 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,
presentation: ?*Presentation = null,
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,
/// A failed resource setup disables app callbacks while keeping host controls alive.
session_ready: bool = false,
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 = .{},
timing: Timing = .{},
timing_atlas: overlay.TimingAtlas = .{},
sketch: abi.Sketch,
library: ?Library = null,
watch: ?Watch = null,
reloads: usize = 0,
/// Identifies the running build of the sketch (its library or executable
/// file's inode, size and modification time): 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,
last_frame_end: 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 = .{},
control: ?*Control = 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) {
// 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.openFresh(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 = fileId(io, options.library orelse "/proc/self/exe");
try self.adopt(sketch);
if (options.fresh) {
self.state.header().used = 0;
@memset(self.recordings, 0);
self.resetState();
}
if (!options.headless and options.export_to == null) {
self.presentation = Presentation.init(gpa, self.window) catch null;
if (options.timing_marker) self.print("presentation tracing: {s}", .{if (self.presentation) |p| p.status else "disabled_or_allocation_failed"});
}
}
pub fn deinit(self: *Host) void {
if (self.control) |control| control.deinit();
self.dialog.deinit();
if (self.watch) |w| w.deinit();
self.audio.deinit();
self.painter.deinit();
self.images.deinit();
if (self.passes) |*g| g.deinit();
if (self.pointer_cursor) |cursor| c.SDL_DestroyCursor(cursor);
if (self.offscreen) |texture| c.SDL_DestroyTexture(texture);
if (self.presentation) |p| p.deinit(self.gpa);
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 {
if (self.options.ninep) |path| self.control = try Control.init(self.gpa, path);
while (!self.quit) {
if (self.control) |control| control.poll(self);
try self.poll();
if (self.presentation) |p| p.poll();
if (!self.options.headless and self.options.export_to == null and
c.SDL_GetWindowFlags(self.window) & (c.SDL_WINDOW_OCCLUDED | c.SDL_WINDOW_MINIMIZED | c.SDL_WINDOW_HIDDEN) != 0 and
self.screenshot == null and !(self.control != null and self.control.?.capture_pending))
{
// Occluded Wayland presentation can block for a second; keep controls alive and resume without a camera jump.
self.last_now = 0;
self.last_frame_end = 0;
_ = c.SDL_Delay(10);
continue;
}
// GPU fences do not limit presentation rate; follow the measured display clock.
const wait_ns = if (self.presentation) |p| p.waitNs() else 0;
if (wait_ns != 0) {
c.SDL_DelayPrecise(@min(wait_ns, std.time.ns_per_ms));
continue;
}
const wall = c.SDL_GetTicksNS();
const now = if (self.options.export_to != null)
std.time.ns_per_s + self.exported * std.time.ns_per_s / self.options.fps
else
frameTime(wall, if (self.presentation) |p| p.sampleNs(wall) else wall, self.last_now, self.timeline.mode, self.pending.items);
try self.frame(now);
}
self.timeline.stop(c.SDL_GetTicksNS());
}
// Live animation uses the display clock, but a tick must not predate its input.
fn frameTime(wall: u64, scheduled: u64, previous: u64, mode: abi.Mode, events: []const abi.Event) u64 {
if (mode != .live and mode != .recording) return wall;
var now = @max(scheduled, previous);
for (events) |event| now = @max(now, event.time);
return now;
}
test "timing clock drives ordinary ticks without moving input or replay time" {
const expectEqual = std.testing.expectEqual;
try expectEqual(@as(u64, 100), frameTime(103, 100, 80, .live, &.{}));
try expectEqual(@as(u64, 120), frameTime(127, 120, 100, .recording, &.{}));
const events = [_]abi.Event{ .{ .kind = .key_down, .time = 102 }, .{ .kind = .key_up, .time = 101 } };
try expectEqual(@as(u64, 102), frameTime(103, 100, 80, .live, &events));
try expectEqual(@as(u64, 102), events[0].time);
try expectEqual(@as(u64, 101), events[1].time);
try expectEqual(@as(u64, 103), frameTime(103, 103, 80, .live, &.{})); // No feedback.
try expectEqual(@as(u64, 110), frameTime(103, 100, 110, .live, &.{})); // Clock reversal.
for ([_]abi.Mode{ .playing, .paused }) |mode| try expectEqual(@as(u64, 103), frameTime(103, 100, 110, mode, &events));
}
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 started = c.SDL_GetTicksNS();
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();
const work = try self.draw(if (h.mode == .live or h.mode == .recording) now else h.position, started);
const ended = c.SDL_GetTicksNS();
self.timing.add(.{ .frame = ended - (if (self.last_frame_end == 0) started else self.last_frame_end), .work = work });
self.last_frame_end = ended;
}
/// 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 {
if (!self.session_ready) return;
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, started: u64) !u64 {
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();
if (self.session_ready) 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| self.runGpu(g, pass) catch |err| self.print("gpu pass: {t} ({s})", .{ err, c.SDL_GetError() }),
.post_process => |p| if (self.passes) |*g| self.runPostProcess(g, p.source, p.target, p.effect) catch |err| self.print("gpu postprocess: {t} ({s})", .{ err, c.SDL_GetError() }),
.upload => |u| if (self.passes) |*g| g.write(u.buffer, u.offset, u.bytes) catch |err| self.print("gpu upload: {t} ({s})", .{ err, c.SDL_GetError() }),
.compute => |d| if (self.passes) |*g| g.compute(d) catch |err| self.print("gpu compute: {t} ({s})", .{ err, c.SDL_GetError() }),
.microphone => self.audio.listen(),
.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.timing.visible) {
if (self.timing_atlas.image == .none) self.timing_atlas = try overlay.TimingAtlas.init(&self.images, &self.painter);
for (extra.items) |command| self.painter.draw(command);
extra.clearRetainingCapacity();
try overlay.drawTiming(&self.painter, &self.timing, self.canvas, self.timing_atlas);
}
if (self.console.visible) try self.console.draw(self, &extra, arena);
if (self.options.timing_marker) try timing_marker.draw(&extra, arena, self.canvas, self.input.frame, self.input.now);
for (extra.items) |command| self.painter.draw(command);
self.painter.end();
self.applyCursor();
if (self.screenshot != null or self.options.export_to != null or (self.control != null and self.control.?.capture_pending)) {
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.control) |control| if (control.capture_pending) control.capture(surface);
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);
};
// Present otherwise encodes the deferred 2D commands after the work timestamp.
if (!c.SDL_FlushRenderer(self.renderer)) return sdlError("SDL_FlushRenderer");
const work = c.SDL_GetTicksNS() - started;
const present_zone = tracy.zone(@src(), "present");
if (self.presentation) |p| p.request(self.input.frame, self.input.now);
_ = c.SDL_RenderPresent(self.renderer);
present_zone.end();
if (self.passes) |*g| g.endFrame();
return work;
}
/// 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", "timing", "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 {
if (!self.session_ready) {
self.print("session setup failed; restart after fixing the resource error", .{});
return .failed;
}
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.openFresh(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 = fileId(self.io, 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) {
const ctx = self.context();
self.session_ready = self.sketch.setup(&ctx);
if (!self.session_ready) self.console.visible = true;
}
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| {
self.images.unwrap(image);
if (self.passes) |*g| g.forget(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,
};
}
/// Identifies the file at `path` without reading it (a Debug library is tens
/// of megabytes): a hash of its inode, size and modification time; 0 when
/// there is none. A build replaces the file, so each build gets a new one.
fn fileId(io: std.Io, path: []const u8) u64 {
const stat = std.Io.Dir.cwd().statFile(io, path, .{}) catch return 0;
const id = [3]u64{ stat.inode, stat.size, @truncate(@as(u96, @bitCast(stat.mtime.nanoseconds))) };
return std.hash.Wyhash.hash(0, std.mem.asBytes(&id)) | 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,
.writeBuffer = apiWriteBuffer,
.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);
self.images.unwrap(image);
if (self.passes) |*g| g.forget(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 = if (self.passes) |*passes| passes else 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 apiWriteBuffer(ctx: *anyopaque, buffer: abi.Buffer, offset: u32, bytes: []const u8) !void {
const self = hostOf(ctx);
const gpu = if (self.passes) |*passes| passes else return error.GpuUnavailable;
try gpu.write(buffer, offset, bytes);
}
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);
}
fn runPostProcess(self: *Host, g: *Gpu, source: abi.Image, target: abi.Image, post: abi.gpu.PostProcess) !void {
const input = g.output(source) orelse return error.MissingImage;
const before = g.output(target);
const changed = if (before) |t| t.width != input.width or t.height != input.height else true;
if (changed) self.images.unwrap(target);
try g.runPostProcess(source, target, post);
if (g.output(target)) |t| try self.images.wrap(target, t.texture, t.width, t.height);
}
fn runGpu(self: *Host, g: *Gpu, pass: abi.gpu.Pass) !void {
const before = g.output(pass.image);
const changed = if (before) |t| t.width != pass.width or t.height != pass.height else true;
if (changed) self.images.unwrap(pass.image);
try g.run(pass);
if (g.output(pass.image)) |t| try self.images.wrap(pass.image, t.texture, t.width, t.height);
}
test "session setup runs for restored state and layout reset, not same-layout reload or state reset" {
const Fixture = struct {
const State = extern struct { value: u32 = 1 };
const Session1 = extern struct { ready: u32 = 0 };
const Session2 = extern struct { ready: u32 = 0, extra: u32 = 0 };
const Store = struct {};
var setup_calls: usize = 0;
var init_calls: usize = 0;
var fail_setup = false;
const description: abi.Info = .{ .abi = abi.hash, .name = "setup-test", .width = 1, .height = 1, .state = abi.layout.of(State, .state), .session = abi.layout.of(Session1, .session), .store = abi.layout.of(Store, .store) };
const changed: abi.Info = blk: {
var value = description;
value.session = abi.layout.of(Session2, .session);
break :blk value;
};
fn info() callconv(.c) *const abi.Info {
return &description;
}
fn info2() callconv(.c) *const abi.Info {
return &changed;
}
fn defaults(kind: abi.Memory, ptr: [*]u8) callconv(.c) void {
switch (kind) {
.state => @as(*State, @ptrCast(@alignCast(ptr))).* = .{},
.session => @as(*Session1, @ptrCast(@alignCast(ptr))).* = .{},
.store => {},
}
}
fn defaults2(kind: abi.Memory, ptr: [*]u8) callconv(.c) void {
if (kind == .session) @as(*Session2, @ptrCast(@alignCast(ptr))).* = .{} else defaults(kind, ptr);
}
fn init(_: *const abi.Context, _: [*]u8) callconv(.c) void {
init_calls += 1;
}
fn setup(ctx: *const abi.Context) callconv(.c) bool {
setup_calls += 1;
@as(*u32, @ptrCast(@alignCast(ctx.session_root))).* += 1;
return !fail_setup;
}
fn update(_: *const abi.Context, _: [*]u8) callconv(.c) void {}
fn draw(_: *const abi.Context, _: [*]const u8) callconv(.c) void {}
fn command(_: *const abi.Context, _: [*]u8, _: *const []const u8) callconv(.c) abi.Outcome {
return .unknown;
}
const sketch: abi.Sketch = .{ .info = info, .defaults = defaults, .init = @This().init, .setup = setup, .update = @This().update, .draw = @This().draw, .command = command };
};
Fixture.setup_calls = 0;
Fixture.init_calls = 0;
Fixture.fail_setup = false;
const a = std.testing.allocator;
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
var state_buf: [std.fs.max_path_bytes]u8 = undefined;
var store_buf: [std.fs.max_path_bytes]u8 = undefined;
const state_path = try std.mem.print(&state_buf, ".zig-cache/tmp/{s}/setup.state", .{&tmp.sub_path});
const store_path = try std.mem.print(&store_buf, ".zig-cache/tmp/{s}/setup.store", .{&tmp.sub_path});
{
var state = try memory.StateFile.open(a, state_path);
defer state.close();
_ = try state.adopt(a, Fixture.description.state, Fixture.defaults);
@as(*Fixture.State, @ptrCast(state.slot(0).ptr)).value = 77;
state.markUsed(0, true);
}
// Exercise adoption with real persisted memory, without opening SDL devices.
var host: Host = undefined;
host.gpa = a;
host.state = try memory.StateFile.open(a, state_path);
defer host.state.close();
host.store = try memory.StoreFile.open(a, store_path, false);
defer host.store.close();
host.session = .init(a);
defer host.session.deinit(a);
host.info_arena = .init(a);
defer host.info_arena.deinit();
host.frame_arena = .init(a);
defer host.frame_arena.deinit();
host.options = .{ .headless = true };
host.console = .{};
host.reloads = 0;
host.made = .{};
host.passes = null;
host.input = .{};
host.commands = .empty;
try host.adopt(Fixture.sketch);
try std.testing.expectEqual(@as(u32, 77), @as(*Fixture.State, @ptrCast(@alignCast(host.live().ptr))).value);
try std.testing.expectEqual(@as(usize, 0), Fixture.init_calls);
try std.testing.expectEqual(@as(usize, 1), Fixture.setup_calls);
const session_ptr = host.session.bytes.ptr;
try host.adopt(Fixture.sketch);
try std.testing.expectEqual(session_ptr, host.session.bytes.ptr);
try std.testing.expectEqual(@as(usize, 1), Fixture.setup_calls);
host.resetState();
try std.testing.expectEqual(@as(usize, 1), Fixture.init_calls);
try std.testing.expectEqual(@as(usize, 1), Fixture.setup_calls);
var changed = Fixture.sketch;
changed.info = Fixture.info2;
changed.defaults = Fixture.defaults2;
try host.adopt(changed);
try std.testing.expectEqual(@as(usize, 2), Fixture.setup_calls);
try std.testing.expectEqual(@as(u32, 1), @as(*Fixture.Session2, @ptrCast(host.session.bytes.ptr)).ready);
try std.testing.expect(host.session_ready);
Fixture.fail_setup = true;
defer Fixture.fail_setup = false;
try host.adopt(Fixture.sketch);
try std.testing.expect(!host.session_ready);
try std.testing.expect(host.console.visible);
try std.testing.expectEqual(abi.Outcome.failed, host.forward(&host.console, "anything", 0));
try host.adopt(Fixture.sketch);
try std.testing.expect(!host.session_ready); // A compatible reload cannot bless partial resources.
try std.testing.expectEqual(@as(usize, 3), Fixture.setup_calls);
}
test "setup writeBuffer propagates unavailable, unknown and out-of-bounds upload errors" {
const a = std.testing.allocator;
var host: Host = undefined;
host.passes = null;
const client: abi.Host = .{ .ctx = &host, .vtable = &api };
try std.testing.expectError(error.GpuUnavailable, client.writeBuffer(.none, 0, "data"));
host.passes = .{ .gpa = a, .device = undefined, .stencil_format = undefined };
defer host.passes.?.buffers.deinit(a);
try std.testing.expectError(error.UnknownBuffer, client.writeBuffer(.none, 0, "data"));
try host.passes.?.buffers.append(a, .{ .buffer = undefined, .size = 4 });
try std.testing.expectError(error.UploadOutOfBounds, client.writeBuffer(@fromBackingInt(@intCast(1)), 2, "data"));
}