summaryrefslogtreecommitdiff
path: root/src/sketch/web.zig
diff options
context:
space:
mode:
Diffstat (limited to 'src/sketch/web.zig')
-rw-r--r--src/sketch/web.zig201
1 files changed, 201 insertions, 0 deletions
diff --git a/src/sketch/web.zig b/src/sketch/web.zig
new file mode 100644
index 0000000..7246c0d
--- /dev/null
+++ b/src/sketch/web.zig
@@ -0,0 +1,201 @@
+//! Runs a sketch in a browser. `web/host.js` forwards input and implements a
+//! handful of drawing imports; state, `update` and `draw` are the same Zig as
+//! on native. There is no console, timeline or persistence on the web.
+const std = @import("std");
+const abi = @import("abi");
+const root = @import("root.zig");
+
+const js = struct {
+ extern "host" fn log(ptr: [*]const u8, len: usize) void;
+ extern "host" fn loadImage(ptr: [*]const u8, len: usize) u32;
+ extern "host" fn imageWidth(image: u32) u32;
+ extern "host" fn imageHeight(image: u32) u32;
+ extern "host" fn newImage(w: u32, h: u32) u32;
+ extern "host" fn clock() f64;
+ extern "canvas" fn clear(r: u32, g: u32, b: u32, a: u32) void;
+ extern "canvas" fn fill(x: f32, y: f32, w: f32, h: f32, r: u32, g: u32, b: u32, a: u32) void;
+ extern "canvas" fn image(id: u32, x: f32, y: f32, w: f32, h: f32, sx: f32, sy: f32, sw: f32, sh: f32, alpha: u32) void;
+ extern "canvas" fn text(x: f32, y: f32, scale: f32, ptr: [*]const u8, len: usize, r: u32, g: u32, b: u32, a: u32) void;
+ extern "canvas" fn clip(enabled: u32, x: f32, y: f32, w: f32, h: f32) void;
+ extern "canvas" fn canvas(w: u32, h: u32) void;
+ extern "canvas" fn cursor(kind: u32) void;
+ extern "canvas" fn pixels(id: u32, w: u32, h: u32, ptr: [*]const u8, len: usize, premultiplied: u32) void;
+};
+
+/// Exports `App` for `web/host.js`: `sk_init`, `sk_event`, `sk_frame`, and
+/// `sk_field` for tests to read state by path.
+pub fn exportWeb(comptime App: type) void {
+ const D = Driver(App);
+ @export(&D.init, .{ .name = "sk_init" });
+ @export(&D.event, .{ .name = "sk_event" });
+ @export(&D.frame, .{ .name = "sk_frame" });
+ @export(&D.buffer, .{ .name = "sk_buffer" });
+ @export(&D.field, .{ .name = "sk_field" });
+}
+
+fn Driver(comptime App: type) type {
+ const G = root.Glue(App);
+ return struct {
+ var state: G.State = undefined;
+ var session: G.Session = undefined;
+ var events: [1024]abi.Event = undefined;
+ var event_count: usize = 0;
+ var input: abi.Input = .{};
+ var commands: std.ArrayList(abi.Command) = .empty;
+ var arena: std.heap.ArenaAllocator = .init(std.heap.wasm_allocator);
+ var session_heap: std.heap.ArenaAllocator = .init(std.heap.wasm_allocator);
+ var last: u64 = 0;
+ var path: [256]u8 = undefined;
+
+ fn context() abi.Context {
+ return .{
+ .host = .{ .ctx = @ptrCast(&input), .vtable = &vtable },
+ .input = &input,
+ .arena = arena.allocator(),
+ .gpa = session_heap.allocator(),
+ .commands = &commands,
+ };
+ }
+
+ fn init() callconv(.c) void {
+ G.defaults(.state, std.mem.asBytes(&state));
+ G.defaults(.session, std.mem.asBytes(&session));
+ input.width = G.description.width;
+ input.height = G.description.height;
+ js.canvas(G.description.width, G.description.height);
+ const ctx = context();
+ G.init(&ctx, std.mem.asBytes(&state));
+ }
+
+ fn event(kind: u32, code: u32, x: f32, y: f32, value: u32) callconv(.c) void {
+ const k = std.enums.fromInt(abi.Event.Kind, kind) orelse return;
+ if (event_count == events.len) {
+ // Never leave a gesture armed when the queue overflows.
+ events[0] = .{ .kind = .cancel };
+ event_count = 1;
+ }
+ events[event_count] = .{ .kind = k, .code = @intCast(code), .x = x, .y = y, .value = value };
+ event_count += 1;
+ }
+
+ fn frame(ms: f64) callconv(.c) void {
+ const now: u64 = @intFromFloat(@max(0, ms) * std.time.ns_per_ms);
+ const dt = if (last == 0) 0 else now -| last;
+ last = now;
+ if (event_count < events.len) {
+ events[event_count] = .{ .kind = .tick, .x = @floatCast(@as(f64, @floatFromInt(dt)) / std.time.ns_per_s) };
+ event_count += 1;
+ }
+ for (events[0..event_count]) |*e| {
+ e.time = now;
+ input.track(e.*);
+ }
+ _ = arena.reset(.retain_capacity);
+ commands = .empty;
+ input.now = now;
+ input.dt = dt;
+ input.frame += 1;
+ input.events = events[0..event_count];
+ const ctx = context();
+ G.update(&ctx, std.mem.asBytes(&state));
+ input.events = &.{};
+ event_count = 0;
+ G.draw(&ctx, std.mem.asBytes(&state), std.mem.asBytes(&session));
+ js.clip(0, 0, 0, 0, 0);
+ for (commands.items) |command| submit(command);
+ }
+
+ fn submit(command: abi.Command) void {
+ switch (command) {
+ .clear => |v| js.clear(v.r, v.g, v.b, v.a),
+ .rect => |v| js.fill(v.dst.x, v.dst.y, v.dst.w, v.dst.h, v.color.r, v.color.g, v.color.b, v.color.a),
+ .image => |v| js.image(@intFromEnum(v.image), v.dst.x, v.dst.y, v.dst.w, v.dst.h, v.src.x, v.src.y, v.src.w, v.src.h, v.tint.a),
+ .text => |v| js.text(v.x, v.y, v.scale, v.bytes.ptr, v.bytes.len, v.color.r, v.color.g, v.color.b, v.color.a),
+ .clip => |v| if (v) |r| js.clip(1, r.x, r.y, r.w, r.h) else js.clip(0, 0, 0, 0, 0),
+ .canvas => |v| {
+ input.width = @floatFromInt(v.w);
+ input.height = @floatFromInt(v.h);
+ js.canvas(v.w, v.h);
+ },
+ .cursor => |v| js.cursor(@intFromEnum(v)),
+ .pixels => |v| js.pixels(@intFromEnum(v.image), v.w, v.h, v.rgba.ptr, v.rgba.len, @intFromBool(v.premultiplied)),
+ // No sound or GPU passes on the web yet (Host.gpu says so);
+ // quitting a page means nothing.
+ .voice, .audio, .gpu, .quit => {},
+ }
+ }
+
+ fn buffer() callconv(.c) [*]u8 {
+ return &path;
+ }
+
+ /// The state field at the path written into `sk_buffer`, as a number
+ /// (enums by value); NaN when there is no such scalar field.
+ fn field(len: usize) callconv(.c) f64 {
+ const name = path[0..@min(len, path.len)];
+ const bytes = std.mem.asBytes(&state);
+ for (G.description.state.fields) |f| {
+ if (!std.mem.eql(u8, std.mem.span(f.path), name)) continue;
+ const raw = bytes[f.offset..][0..f.size];
+ var value: u64 = 0;
+ for (raw[0..@min(raw.len, 8)], 0..) |b, i| value |= @as(u64, b) << @intCast(i * 8);
+ return switch (f.kind) {
+ .float => if (f.size == 4) @as(f32, @bitCast(@as(u32, @truncate(value)))) else @bitCast(value),
+ .int => blk: {
+ const shift: u6 = @intCast(64 - f.size * 8);
+ break :blk @floatFromInt(@as(i64, @bitCast(value << shift)) >> shift);
+ },
+ .uint, .@"enum", .bool => @floatFromInt(value),
+ else => std.math.nan(f64),
+ };
+ }
+ return std.math.nan(f64);
+ }
+
+ const vtable: abi.Host.VTable = .{
+ .log = log,
+ .loadImage = loadImage,
+ .decodeImage = unsupportedImage,
+ .newImage = newImage,
+ .freeImage = freeImage,
+ .gpu = gpu,
+ .imageSize = imageSize,
+ .loadSound = unsupportedSound,
+ .decodeSound = unsupportedSound,
+ .readFile = readFile,
+ .env = env,
+ .clock = clock,
+ };
+ fn log(_: *anyopaque, message: []const u8) void {
+ js.log(message.ptr, message.len);
+ }
+ fn loadImage(_: *anyopaque, p: []const u8) abi.Image {
+ return @enumFromInt(js.loadImage(p.ptr, p.len));
+ }
+ fn unsupportedImage(_: *anyopaque, _: []const u8) abi.Image {
+ return .none;
+ }
+ fn newImage(_: *anyopaque, w: u32, h: u32) abi.Image {
+ return @enumFromInt(js.newImage(w, h));
+ }
+ fn freeImage(_: *anyopaque, _: abi.Image) void {}
+ fn gpu(_: *anyopaque) bool {
+ return false;
+ }
+ fn imageSize(_: *anyopaque, img: abi.Image) [2]u32 {
+ return .{ js.imageWidth(@intFromEnum(img)), js.imageHeight(@intFromEnum(img)) };
+ }
+ fn unsupportedSound(_: *anyopaque, _: []const u8) abi.Audio {
+ return .none;
+ }
+ fn readFile(_: *anyopaque, _: []const u8) []const u8 {
+ return &.{};
+ }
+ fn env(_: *anyopaque, _: []const u8) ?[]const u8 {
+ return null;
+ }
+ fn clock(_: *anyopaque) u64 {
+ return @intFromFloat(@max(js.clock(), 0) * std.time.ns_per_ms);
+ }
+ };
+}