summaryrefslogtreecommitdiff
path: root/src/anim
diff options
context:
space:
mode:
Diffstat (limited to 'src/anim')
-rw-r--r--src/anim/Painter.zig256
-rw-r--r--src/anim/player.zig386
-rw-r--r--src/anim/root.zig819
3 files changed, 1125 insertions, 336 deletions
diff --git a/src/anim/Painter.zig b/src/anim/Painter.zig
new file mode 100644
index 0000000..b5d492f
--- /dev/null
+++ b/src/anim/Painter.zig
@@ -0,0 +1,256 @@
+//! Draws a scene's `Shot` with the vector library, on the GPU (or the CPU),
+//! the scene's frame fitted into the canvas, and the canvas the room the
+//! host has: the window, or an export's `--size`. The player paints with
+//! one, and so does a sketch that runs a `Deck` itself: a `Painter` in its
+//! Session, and `paint` once a frame.
+const std = @import("std");
+const sk = @import("sketch");
+const vector = @import("vector");
+const anim = @import("root.zig");
+const geom = vector.geom;
+
+const Painter = @This();
+
+/// A renderer per run of vector objects between custom ones (`paint`).
+gpu: std.ArrayList(vector.Renderer(.gpu)) = .empty,
+cpu: std.ArrayList(vector.Renderer(.cpu)) = .empty,
+/// Drawings by what they look like (`Object.id`), built on first use and
+/// dropped on reload, since the code that builds them may have changed.
+/// Their memory is the host's, kept across reloads.
+arena: ?std.heap.ArenaAllocator = null,
+drawings: std.AutoHashMapUnmanaged(u64, Built) = .empty,
+/// Shapes drawn in the last frame.
+shapes: usize = 0,
+
+pub const Options = struct {
+ /// The viewer's own pan and zoom, on top of the scene's camera.
+ view: sk.Camera = .{},
+ backend: vector.Backend = .gpu,
+ /// Boxes, origins and axes, in scene units, with their numbers.
+ guides: bool = false,
+ /// The page (0xRRGGBB).
+ background: u32 = anim.background,
+};
+
+const Built = struct { drawing: vector.Drawing, bounds: geom.Rect };
+
+/// Sets the canvas to the window and draws `shot` on it. `svgs` has
+/// `find(source) ?[]const u8` for its Typst objects (`sb.addTypst`).
+pub fn paint(p: *Painter, f: *sk.Frame, shot: anim.Shot, svgs: anytype, options: Options) !void {
+ // All the room there is: the window, or the size an export asks for.
+ const canvas: sk.Rect = .{ .w = @max(@floor(f.in.window_width), 1), .h = @max(@floor(f.in.window_height), 1) };
+ f.canvas(@intFromFloat(canvas.w), @intFromFloat(canvas.h));
+ if (p.arena == null) p.arena = .init(f.session);
+ // A live scene may make new drawings every frame: start over now and then.
+ if (f.in.reloaded or p.drawings.count() > 1024) {
+ _ = p.arena.?.reset(.retain_capacity);
+ p.drawings = .empty;
+ }
+ // Use the host's GPU when it has one.
+ if (options.backend == .gpu and f.host.gpu()) try p.paintLayers(&p.gpu, f, shot, svgs, canvas, options) else try p.paintLayers(&p.cpu, f, shot, svgs, canvas, options);
+}
+
+/// Canvas pixels per scene unit: the scene's frame, fitted into `canvas`.
+pub fn fit(canvas: sk.Rect) f32 {
+ return @min(canvas.w / anim.width, canvas.h / anim.height);
+}
+
+/// Object `o`'s drawing, centered on its origin, and its bounds.
+fn built(p: *Painter, o: anim.Object, svgs: anytype) !Built {
+ const id = o.id();
+ if (p.drawings.get(id)) |b| return b;
+ const arena = p.arena.?.allocator();
+ const d = try anim.build(arena, o, svgs);
+ const b: Built = .{ .drawing = d, .bounds = d.bounds().rect() };
+ try p.drawings.put(arena, id, b);
+ return b;
+}
+
+/// Scene units to canvas pixels: the scene's camera, then the viewer's.
+/// The scene's origin is the canvas center.
+fn stage(view: sk.Camera, cam: anim.Camera, canvas: sk.Rect) geom.Affine {
+ const k = fit(canvas) * cam.zoom;
+ return geom.Affine.translate(view.x, view.y)
+ .mul(.scale(view.zoom, view.zoom))
+ .mul(.translate(canvas.w / 2, canvas.h / 2))
+ .mul(.scale(k, k))
+ .mul(.rotate(-cam.rotation))
+ .mul(.translate(-cam.x, -cam.y));
+}
+
+/// The next of `layers`, begun: a renderer the size of the canvas.
+fn begun(layers: anytype, used: *usize, f: *sk.Frame, canvas: sk.Rect, clear: vector.Drawing.Color) !*@TypeOf(layers.items[0]) {
+ if (used.* == layers.items.len) try layers.append(f.session, try .init(f.session, f.host, @intFromFloat(canvas.w), @intFromFloat(canvas.h)));
+ const r = &layers.items[used.*];
+ used.* += 1;
+ r.begin(f, clear);
+ return r;
+}
+
+/// Draws `shot` with the renderers in `layers` (either backend), objects
+/// in the order they were added. Vector objects go into a renderer's image,
+/// which is then drawn on the canvas; a custom object draws on the canvas
+/// itself. So the vector objects before a custom one and those after it
+/// are separate images, one renderer each: every GPU pass of a frame runs
+/// before its first 2D command, and one image could only show the last.
+fn paintLayers(p: *Painter, layers: anytype, f: *sk.Frame, shot: anim.Shot, svgs: anytype, canvas: sk.Rect, options: Options) !void {
+ if (layers.items.len > 0 and (layers.items[0].width() != @as(u32, @intFromFloat(canvas.w)) or layers.items[0].height() != @as(u32, @intFromFloat(canvas.h)))) {
+ for (layers.items) |*r| r.deinit(f.host);
+ layers.clearRetainingCapacity();
+ }
+ const world = stage(options.view, shot.camera, canvas);
+ var used: usize = 0;
+ // The first layer is the background too.
+ var open: ?*@TypeOf(layers.items[0]) = try begun(layers, &used, f, canvas, anim.color(options.background));
+ var shapes: usize = 0;
+ for (shot.objects, shot.poses, 0..) |o, pose, i| {
+ if (!pose.visible or pose.opacity <= 0) continue;
+ const m = world.mul(model(pose));
+ if (o.source == .custom) {
+ if (open) |r| r.present(f, canvas);
+ open = null;
+ o.source.custom.draw(o.source.custom.ctx, f, .{ .t = shot.t, .pose = pose, .xf = m, .scale = m.scaleFactor(), .stage = world, .values = shot.values });
+ // It leaves no target, clip or blend behind.
+ f.target(.none);
+ f.blend(.alpha);
+ continue;
+ }
+ const r = open orelse try begun(layers, &used, f, canvas, .{ 0, 0, 0, 0 });
+ open = r;
+ const d = (try p.built(o, svgs)).drawing;
+ if (pose.into != anim.Pose.none and pose.morph > 0 and pose.morph < 1 and shot.objects[pose.into].source != .custom) {
+ // Morphing: from where this object began the transform to where
+ // its target will stand.
+ const morph = shot.morphs[i];
+ const target = (try p.built(shot.objects[pose.into], svgs)).drawing;
+ const between = try vector.morph.between(f.scratch, d, world.mul(model(morph.from)), target, world.mul(model(morph.to)), pose.morph);
+ try r.draw(between, .identity, pose.opacity);
+ shapes += between.shapes.len;
+ continue;
+ }
+ try reveal(r, d, m, pose, fit(canvas));
+ shapes += d.shapes.len;
+ }
+ if (options.guides) {
+ const r = open orelse try begun(layers, &used, f, canvas, .{ 0, 0, 0, 0 });
+ open = r;
+ try r.draw(try p.guides(f.scratch, shot, svgs, world, canvas), .identity, 1);
+ }
+ if (open) |r| r.present(f, canvas);
+ p.shapes = shapes;
+ if (options.guides) try p.labels(f, shot, svgs, world);
+}
+
+fn model(p: anim.Pose) geom.Affine {
+ return geom.Affine.translate(p.x, p.y).mul(.rotate(p.rotation)).mul(.scale(p.scale, p.scale));
+}
+
+/// manim's reveals, shape by shape with a stagger: Write traces each outline
+/// then fills it; Create draws strokes along their length, then fills.
+/// Outlines are `k` canvas pixels to the scene unit wide.
+fn reveal(r: anytype, d: vector.Drawing, m: geom.Affine, pose: anim.Pose, k: f32) !void {
+ const n: f32 = @floatFromInt(d.shapes.len);
+ const lag: f32 = if (pose.drawn >= 1) 0 else 0.08;
+ const window = 1 / (1 + lag * @max(n - 1, 0));
+ const glow = pose.highlight;
+ for (d.shapes, 0..) |shape, i| {
+ const local = std.math.clamp((pose.drawn - @as(f32, @floatFromInt(i)) * lag * window) / window, 0, 1);
+ if (local <= 0) continue;
+ var o: vector.Options = .{ .alpha = pose.opacity };
+ switch (pose.reveal) {
+ .write => if (local < 1) {
+ o.trim = @min(local * 2, 1);
+ o.outline = .{ .width = 1.5 * k, .alpha = 1 - std.math.clamp(local * 2 - 1, 0, 1) };
+ o.stroke = false;
+ // Fill arrives in the second half.
+ var fill = o;
+ fill.outline = null;
+ fill.alpha = pose.opacity * std.math.clamp(local * 2 - 1, 0, 1);
+ try r.drawShape(d, shape, m, fill);
+ o.fill = false;
+ },
+ .create => if (local < 1) {
+ o.trim = local;
+ if (shape.style.stroke == .none) o.outline = .{ .width = 2 * k };
+ var fill = o;
+ fill.stroke = false;
+ fill.outline = null;
+ fill.alpha = pose.opacity * std.math.clamp(local * 3 - 2, 0, 1);
+ try r.drawShape(d, shape, m, fill);
+ o.fill = false;
+ },
+ }
+ try r.drawShape(d, shape, m, o);
+ if (glow > 0) {
+ // Indicate: a yellow glow over the shape.
+ var hot = shape;
+ hot.style.fill = if (shape.style.fill != .none) .{ .color = anim.color(anim.yellow) } else .none;
+ hot.style.stroke = if (shape.style.stroke != .none) .{ .color = anim.color(anim.yellow) } else .none;
+ try r.drawShape(d, hot, m, .{ .alpha = pose.opacity * glow });
+ }
+ }
+}
+
+/// Spacing of the guides' ticks, in scene units.
+const tick = 100;
+
+fn guideStyle(c: u32, w: f32) vector.Drawing.Style {
+ return .{ .fill = .none, .stroke = .{ .color = anim.color(c) }, .stroke_width = w };
+}
+
+/// The scene's axes with ticks, and each visible object's bounding box (a
+/// custom object has none) and origin, in canvas pixels.
+fn guides(p: *Painter, arena: std.mem.Allocator, shot: anim.Shot, svgs: anytype, world: geom.Affine, canvas: sk.Rect) !vector.Drawing {
+ var b: vector.Drawing.Builder = .init(arena);
+ const far = 100 * tick;
+ try b.lineTo(world.apply(.{ -far, 0 }), world.apply(.{ far, 0 }));
+ try b.closeSubpath(false);
+ try b.endShape(.identity, guideStyle(anim.red, 1.5));
+ try b.lineTo(world.apply(.{ 0, -far }), world.apply(.{ 0, far }));
+ try b.closeSubpath(false);
+ try b.endShape(.identity, guideStyle(anim.green, 1.5));
+ var i: f32 = -20;
+ while (i <= 20) : (i += 1) {
+ const x = world.apply(.{ i * tick, 0 });
+ const y = world.apply(.{ 0, i * tick });
+ try b.lineTo(x - geom.Vec{ 0, 5 }, x + geom.Vec{ 0, 5 });
+ try b.closeSubpath(false);
+ try b.lineTo(y - geom.Vec{ 5, 0 }, y + geom.Vec{ 5, 0 });
+ try b.closeSubpath(false);
+ }
+ try b.endShape(.identity, guideStyle(0x8c8c8c, 1));
+
+ for (shot.objects, shot.poses) |o, pose| {
+ if (!pose.visible or pose.opacity <= 0) continue;
+ const m = world.mul(model(pose));
+ if (o.source != .custom) {
+ const r = (try p.built(o, svgs)).bounds;
+ try b.polyline(&.{ m.apply(.{ r.x, r.y }), m.apply(.{ r.x + r.w, r.y }), m.apply(.{ r.x + r.w, r.y + r.h }), m.apply(.{ r.x, r.y + r.h }) }, true);
+ }
+ // The object's origin: where its pose puts it.
+ const c = m.apply(.{ 0, 0 });
+ try b.lineTo(c - geom.Vec{ 6, 0 }, c + geom.Vec{ 6, 0 });
+ try b.closeSubpath(false);
+ try b.lineTo(c - geom.Vec{ 0, 6 }, c + geom.Vec{ 0, 6 });
+ try b.closeSubpath(false);
+ }
+ try b.endShape(.identity, guideStyle(anim.yellow, 1));
+ return b.finish(.{ .w = canvas.w, .h = canvas.h }, canvas.w, canvas.h);
+}
+
+/// The guides' numbers: tick values, and each object's index and position.
+fn labels(p: *Painter, f: *sk.Frame, shot: anim.Shot, svgs: anytype, world: geom.Affine) !void {
+ var i: f32 = -20;
+ while (i <= 20) : (i += 2) {
+ const x = world.apply(.{ i * tick, 0 });
+ const y = world.apply(.{ 0, i * tick });
+ f.print(x[0] + 3, x[1] + 8, 1, 0x8c8c8c, "{d}", .{i * tick});
+ if (i != 0) f.print(y[0] + 8, y[1] - 3, 1, 0x8c8c8c, "{d}", .{i * tick});
+ }
+ for (shot.objects, shot.poses, 0..) |o, pose, n| {
+ if (!pose.visible or pose.opacity <= 0) continue;
+ const r: geom.Rect = if (o.source == .custom) .{} else (try p.built(o, svgs)).bounds;
+ const corner = world.mul(model(pose)).apply(.{ r.x, r.y });
+ f.print(corner[0], corner[1] - 11, 1, anim.yellow, "#{d} {d:.0},{d:.0}", .{ n, pose.x, pose.y });
+ }
+}
diff --git a/src/anim/player.zig b/src/anim/player.zig
index 090b6cb..b329714 100644
--- a/src/anim/player.zig
+++ b/src/anim/player.zig
@@ -1,20 +1,26 @@
//! The `anim` module's player: plays the scene file it is built around
//! (`sb.addScene`), compiled or live, as a manim-style animation drawn by
-//! the vector library on the GPU (or the CPU, with B). Time is state;
-//! everything else is a function of it (and, for a live scene, of the
-//! input).
+//! the vector library on the GPU (or the CPU, with B). Its state is an
+//! `anim.Deck`, the playhead and the gates opened, and the viewer's own
+//! settings; the picture is a function of them (and, for a live scene, of
+//! the input). A scene that pauses is a talk, and steps:
//!
-//! space pause / play left/right previous / next play
-//! click continue after a pause (`s.pause()` in the scene)
+//! click, space, page down next step: open the pause the talk waits at,
+//! or finish the step under way (in a scene with
+//! no pause, space plays or pauses)
+//! page up, backspace back a step: the picture before the last click
+//! ] / [ next / previous slide (`s.slide()`), at rest
+//! P play / pause left/right previous / next play
//! ,/. step back / ahead home/end start / end
//! up/down speed B GPU or CPU renderer
-//! G guides: boxes, origins and axes, in scene units
+//! L loop (not a talk) G guides: boxes, origins, axes
//! drag, wheel: look around R reset the view
//!
//! The scene's frame, 1280x720 scene units around its origin, is fitted
//! into the canvas, and the canvas is the room the host has: the window, or
//! an export's `--size`. Exported (`in.exporting`), the scene plays through
-//! once, without pauses or controls, and the player quits.
+//! once without controls, each pause held for the scene file's `hold`
+//! seconds (1 without one), and the player quits at the end.
const std = @import("std");
const sk = @import("sketch");
const vector = @import("vector");
@@ -23,71 +29,67 @@ const scene_file = @import("scene");
const scene = scene_file.scene;
/// The scene's Typst sources, compiled at build time.
const typst = @import("typst");
-const geom = vector.geom;
pub const name = if (@hasDecl(scene_file, "name")) scene_file.name else "anim";
/// The page: the scene file's `background` (0xRRGGBB), or manim's.
const background: u32 = if (@hasDecl(scene_file, "background")) scene_file.background else anim.background;
+/// Exported, how long each pause holds.
+const hold: f32 = if (@hasDecl(scene_file, "hold")) scene_file.hold else 1;
/// The scene's frame, in scene units: what shows at camera zoom 1.
-pub const width = 1280;
-pub const height = 720;
+pub const width = anim.width;
+pub const height = anim.height;
pub const State = struct {
- t: f32 = 0,
- playing: bool = true,
- speed: f32 = 1,
+ deck: anim.Deck = .{ .hold = hold },
looping: bool = true,
backend: vector.Backend = .gpu,
/// The viewer's own pan and zoom, on top of the scene's camera.
view: sk.Camera = .{},
dragging: bool = false,
- /// Where the left button went down: a click, not a drag, continues.
+ /// Where the left button went down: a click, not a drag, steps.
press: [2]f32 = .{ 0, 0 },
guides: bool = false,
};
pub const Session = struct {
- /// A renderer per run of vector objects between custom ones (`paint`).
- gpu: std.ArrayList(vector.Renderer(.gpu)) = .empty,
- cpu: std.ArrayList(vector.Renderer(.cpu)) = .empty,
- /// Drawings by what they look like (`Object.id`), built on first use and
- /// dropped on reload, since the code that builds them may have changed.
- /// Their memory is the host's, kept across reloads.
- arena: ?std.heap.ArenaAllocator = null,
- drawings: std.AutoHashMapUnmanaged(u64, Built) = .empty,
- /// Smoothed time to record a frame, and its shape count.
+ painter: anim.Painter = .{},
+ /// Smoothed time to record a frame.
render_ns: f32 = 0,
- shapes: usize = 0,
};
-const Built = struct { drawing: vector.Drawing, bounds: geom.Rect };
+/// A live scene's frame, or a compiled scene as a talk without gates.
+const talk = if (@hasDecl(scene, "frame")) scene.frame else struct {
+ fn frame(s: *anim.Frame) void {
+ s.cursor = scene.duration;
+ }
+}.frame;
pub fn update(s: *State, in: *const sk.Input) void {
- // The timeline as it stands: a live scene builds it as it runs.
- var arena: std.heap.ArenaAllocator = .init(std.heap.page_allocator);
- defer arena.deinit();
- const shot = scene.shot(arena.allocator(), .{ .t = s.t }) catch return;
+ const d = &s.deck;
+ // A scene that waits somewhere is a talk: clicks and space step it.
+ const talking = d.gates > 0;
+ var ask: anim.Ask = .{};
+ var mark: enum { none, previous, next } = .none;
for (in.events) |e| switch (e.kind) {
- // Exported: nobody clicks, so straight through, once.
- .tick => if (in.exporting) {
- s.t += e.x;
- } else if (s.playing and !held(s.t, shot)) {
- const next = s.t + e.x * s.speed;
- s.t = stopBetween(s.t, next, shot) orelse next;
- if (s.t > shot.duration + 1) s.t = if (s.looping) 0 else shot.duration;
- },
- .key_down => if (e.flags & sk.Event.repeat == 0 or key(e) == .left or key(e) == .right or key(e) == .comma or key(e) == .period) switch (key(e)) {
- .space => if (s.playing and held(s.t, shot)) proceed(s) else {
- s.playing = !s.playing;
+ .key_down => if (e.flags & sk.Event.repeat == 0 or e.key() == .left or e.key() == .right or e.key() == .comma or e.key() == .period) switch (e.key()) {
+ .space => if (talking) {
+ ask.next = true;
+ } else {
+ d.playing = !d.playing;
},
- .home => s.t = 0,
- .end => s.t = shot.duration,
- .left => s.t = previousMark(s.t, shot),
- .right => s.t = nextMark(s.t, shot),
- .comma => s.t = @max(s.t - 1.0 / 30.0, 0),
- .period => s.t = @min(s.t + 1.0 / 30.0, shot.duration),
- .up => s.speed = @min(s.speed * 2, 8),
- .down => s.speed = @max(s.speed / 2, 0.125),
+ .page_down => ask.next = true,
+ .page_up, .backspace => ask.back = true,
+ .right_bracket => ask.next_slide = true,
+ .left_bracket => ask.back_slide = true,
+ .p => d.playing = !d.playing,
+ .home => ask.to = 0,
+ .end => ask.end = true,
+ .left => mark = .previous,
+ .right => mark = .next,
+ .comma => ask.to = @max((ask.to orelse d.t) - 1.0 / 30.0, 0),
+ .period => ask.to = @min((ask.to orelse d.t) + 1.0 / 30.0, d.duration),
+ .up => d.speed = @min(d.speed * 2, 8),
+ .down => d.speed = @max(d.speed / 2, 0.125),
.b => s.backend = if (s.backend == .gpu) .cpu else .gpu,
.g => s.guides = !s.guides,
.l => s.looping = !s.looping,
@@ -100,7 +102,7 @@ pub fn update(s: *State, in: *const sk.Input) void {
},
.mouse_up => {
const click = @abs(e.x - s.press[0]) + @abs(e.y - s.press[1]) < 4;
- if (s.dragging and click and held(s.t, shot)) proceed(s);
+ if (s.dragging and click and talking) ask.next = true;
s.dragging = false;
},
.cancel => s.dragging = false,
@@ -108,28 +110,26 @@ pub fn update(s: *State, in: *const sk.Input) void {
.wheel => s.view.zoomAt(e, e.wheel(), .{ .min = 0.2, .max = 20 }),
else => {},
};
+ if (mark != .none) {
+ // The plays as the scene lays them now.
+ var arena: std.heap.ArenaAllocator = .init(std.heap.page_allocator);
+ defer arena.deinit();
+ if (shotNow(s, arena.allocator(), in, .{ 0, 0 })) |shot| {
+ ask.to = if (mark == .previous) previousMark(d.t, shot) else nextMark(d.t, shot);
+ } else |_| {}
+ }
+ // Played past the end: from the start again, or held there (a talk
+ // holds its last picture).
+ if (!in.exporting and d.t > d.duration + 1) {
+ if (s.looping and !talking) ask.to = 0 else d.t = d.duration;
+ }
+ d.update(in, ask, talk, .{});
}
-fn key(e: sk.Event) sk.Key {
- return @fromBackingInt(@intCast(@as(u8, @truncate(e.code))));
-}
-
-/// Waiting at a pause for a click.
-fn held(t: f32, shot: anim.Shot) bool {
- for (shot.stops) |stop| if (stop == t) return true;
- return false;
-}
-
-/// The first pause in `(from, to]`.
-fn stopBetween(from: f32, to: f32, shot: anim.Shot) ?f32 {
- for (shot.stops) |stop| if (stop > from and stop <= to) return stop;
- return null;
-}
-
-/// Past the pause the player waits at.
-fn proceed(s: *State) void {
- s.t += 1e-3;
- s.playing = true;
+/// The scene at the deck's `t`: a live one through the deck, with its gates.
+fn shotNow(s: *const State, arena: std.mem.Allocator, in: *const sk.Input, mouse: [2]f32) !anim.Shot {
+ if (@hasDecl(scene, "frame")) return s.deck.shot(arena, in, mouse, scene.frame, .{});
+ return scene.shot(arena, .{ .t = s.deck.t, .in = in, .pointer = mouse });
}
fn previousMark(t: f32, shot: anim.Shot) f32 {
@@ -145,33 +145,22 @@ fn nextMark(t: f32, shot: anim.Shot) f32 {
return shot.duration;
}
-/// Canvas pixels per scene unit: the scene's frame, fitted into `canvas`.
-fn fit(canvas: sk.Rect) f32 {
- return @min(canvas.w / width, canvas.h / height);
-}
-
/// The mouse in scene units from the canvas center, before the scene's
/// camera: the viewer's pan and zoom undone.
fn pointer(s: *const State, in: *const sk.Input, canvas: sk.Rect) [2]f32 {
- const k = fit(canvas);
+ const k = anim.Painter.fit(canvas);
return .{ ((in.mouse_x - s.view.x) / s.view.zoom - canvas.w / 2) / k, ((in.mouse_y - s.view.y) / s.view.zoom - canvas.h / 2) / k };
}
pub fn draw(s: *const State, ss: *Session, f: *sk.Frame) void {
// All the room there is: the window, or the size an export asks for.
const canvas: sk.Rect = .{ .w = @max(@floor(f.in.window_width), 1), .h = @max(@floor(f.in.window_height), 1) };
- f.canvas(@intFromFloat(canvas.w), @intFromFloat(canvas.h));
const started = f.host.clock();
- const shot = scene.shot(f.scratch, .{
- .t = s.t,
- .clock = @floatCast(@mod(@as(f64, @floatFromInt(f.in.now)) / std.time.ns_per_s, 3600)),
- .in = f.in,
- .pointer = pointer(s, f.in, canvas),
- }) catch |err| return f.host.print("scene: {t}", .{err});
- render(s, ss, f, shot, canvas) catch |err| f.host.print("render: {t}", .{err});
+ const shot = shotNow(s, f.scratch, f.in, pointer(s, f.in, canvas)) catch |err| return f.host.print("scene: {t}", .{err});
+ ss.painter.paint(f, shot, typst, .{ .view = s.view, .backend = s.backend, .guides = s.guides, .background = background }) catch |err| f.host.print("render: {t}", .{err});
if (f.in.exporting) {
// The frame that shows the end is the last.
- if (s.t >= shot.duration) f.quit();
+ if (s.deck.t >= shot.duration) f.quit();
return;
}
const elapsed: f32 = @floatFromInt(f.host.clock() -| started);
@@ -179,234 +168,31 @@ pub fn draw(s: *const State, ss: *Session, f: *sk.Frame) void {
hud(s, ss, f, shot, canvas);
}
-fn render(s: *const State, ss: *Session, f: *sk.Frame, shot: anim.Shot, canvas: sk.Rect) !void {
- if (ss.arena == null) ss.arena = .init(f.session);
- // A live scene may make new drawings every frame: start over now and then.
- if (f.in.reloaded or ss.drawings.count() > 1024) {
- _ = ss.arena.?.reset(.retain_capacity);
- ss.drawings = .empty;
- }
- // Use the host's GPU when it has one.
- if (s.backend == .gpu and f.host.gpu()) try paint(s, ss, &ss.gpu, f, shot, canvas) else try paint(s, ss, &ss.cpu, f, shot, canvas);
-}
-
-/// Object `o`'s drawing, centered on its origin, and its bounds.
-fn built(ss: *Session, o: anim.Object) !Built {
- const id = o.id();
- if (ss.drawings.get(id)) |b| return b;
- const arena = ss.arena.?.allocator();
- const d = try anim.build(arena, o, typst);
- const b: Built = .{ .drawing = d, .bounds = d.bounds().rect() };
- try ss.drawings.put(arena, id, b);
- return b;
-}
-
-/// Scene units to canvas pixels: the scene's camera, then the viewer's.
-/// The scene's origin is the canvas center.
-fn stage(s: *const State, cam: anim.Camera, canvas: sk.Rect) geom.Affine {
- const k = fit(canvas) * cam.zoom;
- return geom.Affine.translate(s.view.x, s.view.y)
- .mul(.scale(s.view.zoom, s.view.zoom))
- .mul(.translate(canvas.w / 2, canvas.h / 2))
- .mul(.scale(k, k))
- .mul(.rotate(-cam.rotation))
- .mul(.translate(-cam.x, -cam.y));
-}
-
-/// The next of `layers`, begun: a renderer the size of the canvas.
-fn begun(layers: anytype, used: *usize, f: *sk.Frame, canvas: sk.Rect, clear: vector.Drawing.Color) !*@TypeOf(layers.items[0]) {
- if (used.* == layers.items.len) try layers.append(f.session, try .init(f.session, f.host, @intFromFloat(canvas.w), @intFromFloat(canvas.h)));
- const r = &layers.items[used.*];
- used.* += 1;
- r.begin(f, clear);
- return r;
-}
-
-/// Draws `shot` with the renderers in `layers` (either backend), objects
-/// in the order they were added. Vector objects go into a renderer's image,
-/// which is then drawn on the canvas; a custom object draws on the canvas
-/// itself. So the vector objects before a custom one and those after it
-/// are separate images, one renderer each: every GPU pass of a frame runs
-/// before its first 2D command, and one image could only show the last.
-fn paint(s: *const State, ss: *Session, layers: anytype, f: *sk.Frame, shot: anim.Shot, canvas: sk.Rect) !void {
- if (layers.items.len > 0 and (layers.items[0].width() != @as(u32, @intFromFloat(canvas.w)) or layers.items[0].height() != @as(u32, @intFromFloat(canvas.h)))) {
- for (layers.items) |*r| r.deinit(f.host);
- layers.clearRetainingCapacity();
- }
- const world = stage(s, shot.camera, canvas);
- var used: usize = 0;
- // The first layer is the background too.
- var open: ?*@TypeOf(layers.items[0]) = try begun(layers, &used, f, canvas, anim.color(background));
- var shapes: usize = 0;
- for (shot.objects, shot.poses, 0..) |o, pose, i| {
- if (!pose.visible or pose.opacity <= 0) continue;
- const m = world.mul(model(pose));
- if (o.source == .custom) {
- if (open) |r| r.present(f, canvas);
- open = null;
- o.source.custom.draw(o.source.custom.ctx, f, .{ .t = s.t, .pose = pose, .xf = m, .scale = m.scaleFactor(), .stage = world, .values = shot.values });
- // It leaves no target, clip or blend behind.
- f.target(.none);
- f.blend(.alpha);
- continue;
- }
- const r = open orelse try begun(layers, &used, f, canvas, .{ 0, 0, 0, 0 });
- open = r;
- const d = (try built(ss, o)).drawing;
- if (pose.into != anim.Pose.none and pose.morph > 0 and pose.morph < 1 and shot.objects[pose.into].source != .custom) {
- // Morphing: from where this object began the transform to where
- // its target will stand.
- const morph = shot.morphs[i];
- const target = (try built(ss, shot.objects[pose.into])).drawing;
- const between = try vector.morph.between(f.scratch, d, world.mul(model(morph.from)), target, world.mul(model(morph.to)), pose.morph);
- try r.draw(between, .identity, pose.opacity);
- shapes += between.shapes.len;
- continue;
- }
- try reveal(r, d, m, pose, fit(canvas));
- shapes += d.shapes.len;
- }
- if (s.guides) {
- const r = open orelse try begun(layers, &used, f, canvas, .{ 0, 0, 0, 0 });
- open = r;
- try r.draw(try guides(ss, f.scratch, shot, world, canvas), .identity, 1);
- }
- if (open) |r| r.present(f, canvas);
- ss.shapes = shapes;
- if (s.guides) try labels(ss, f, shot, world);
-}
-
-fn model(p: anim.Pose) geom.Affine {
- return geom.Affine.translate(p.x, p.y).mul(.rotate(p.rotation)).mul(.scale(p.scale, p.scale));
-}
-
-/// manim's reveals, shape by shape with a stagger: Write traces each outline
-/// then fills it; Create draws strokes along their length, then fills.
-/// Outlines are `k` canvas pixels to the scene unit wide.
-fn reveal(r: anytype, d: vector.Drawing, m: geom.Affine, pose: anim.Pose, k: f32) !void {
- const n: f32 = @floatFromInt(d.shapes.len);
- const lag: f32 = if (pose.drawn >= 1) 0 else 0.08;
- const window = 1 / (1 + lag * @max(n - 1, 0));
- const glow = pose.highlight;
- for (d.shapes, 0..) |shape, i| {
- const local = std.math.clamp((pose.drawn - @as(f32, @floatFromInt(i)) * lag * window) / window, 0, 1);
- if (local <= 0) continue;
- var o: vector.Options = .{ .alpha = pose.opacity };
- switch (pose.reveal) {
- .write => if (local < 1) {
- o.trim = @min(local * 2, 1);
- o.outline = .{ .width = 1.5 * k, .alpha = 1 - std.math.clamp(local * 2 - 1, 0, 1) };
- o.stroke = false;
- // Fill arrives in the second half.
- var fill = o;
- fill.outline = null;
- fill.alpha = pose.opacity * std.math.clamp(local * 2 - 1, 0, 1);
- try r.drawShape(d, shape, m, fill);
- o.fill = false;
- },
- .create => if (local < 1) {
- o.trim = local;
- if (shape.style.stroke == .none) o.outline = .{ .width = 2 * k };
- var fill = o;
- fill.stroke = false;
- fill.outline = null;
- fill.alpha = pose.opacity * std.math.clamp(local * 3 - 2, 0, 1);
- try r.drawShape(d, shape, m, fill);
- o.fill = false;
- },
- }
- try r.drawShape(d, shape, m, o);
- if (glow > 0) {
- // Indicate: a yellow glow over the shape.
- var hot = shape;
- hot.style.fill = if (shape.style.fill != .none) .{ .color = anim.color(anim.yellow) } else .none;
- hot.style.stroke = if (shape.style.stroke != .none) .{ .color = anim.color(anim.yellow) } else .none;
- try r.drawShape(d, hot, m, .{ .alpha = pose.opacity * glow });
- }
- }
-}
-
-/// Spacing of the guides' ticks, in scene units.
-const tick = 100;
-
-fn guideStyle(c: u32, w: f32) vector.Drawing.Style {
- return .{ .fill = .none, .stroke = .{ .color = anim.color(c) }, .stroke_width = w };
-}
-
-/// The scene's axes with ticks, and each visible object's bounding box (a
-/// custom object has none) and origin, in canvas pixels.
-fn guides(ss: *Session, arena: std.mem.Allocator, shot: anim.Shot, world: geom.Affine, canvas: sk.Rect) !vector.Drawing {
- var b: vector.Drawing.Builder = .init(arena);
- const far = 100 * tick;
- try b.lineTo(world.apply(.{ -far, 0 }), world.apply(.{ far, 0 }));
- try b.closeSubpath(false);
- try b.endShape(.identity, guideStyle(anim.red, 1.5));
- try b.lineTo(world.apply(.{ 0, -far }), world.apply(.{ 0, far }));
- try b.closeSubpath(false);
- try b.endShape(.identity, guideStyle(anim.green, 1.5));
- var i: f32 = -20;
- while (i <= 20) : (i += 1) {
- const x = world.apply(.{ i * tick, 0 });
- const y = world.apply(.{ 0, i * tick });
- try b.lineTo(x - geom.Vec{ 0, 5 }, x + geom.Vec{ 0, 5 });
- try b.closeSubpath(false);
- try b.lineTo(y - geom.Vec{ 5, 0 }, y + geom.Vec{ 5, 0 });
- try b.closeSubpath(false);
- }
- try b.endShape(.identity, guideStyle(0x8c8c8c, 1));
-
- for (shot.objects, shot.poses) |o, pose| {
- if (!pose.visible or pose.opacity <= 0) continue;
- const m = world.mul(model(pose));
- if (o.source != .custom) {
- const r = (try built(ss, o)).bounds;
- try b.polyline(&.{ m.apply(.{ r.x, r.y }), m.apply(.{ r.x + r.w, r.y }), m.apply(.{ r.x + r.w, r.y + r.h }), m.apply(.{ r.x, r.y + r.h }) }, true);
- }
- // The object's origin: where its pose puts it.
- const c = m.apply(.{ 0, 0 });
- try b.lineTo(c - geom.Vec{ 6, 0 }, c + geom.Vec{ 6, 0 });
- try b.closeSubpath(false);
- try b.lineTo(c - geom.Vec{ 0, 6 }, c + geom.Vec{ 0, 6 });
- try b.closeSubpath(false);
- }
- try b.endShape(.identity, guideStyle(anim.yellow, 1));
- return b.finish(.{ .w = canvas.w, .h = canvas.h }, canvas.w, canvas.h);
-}
-
-/// The guides' numbers: tick values, and each object's index and position.
-fn labels(ss: *Session, f: *sk.Frame, shot: anim.Shot, world: geom.Affine) !void {
- var i: f32 = -20;
- while (i <= 20) : (i += 2) {
- const x = world.apply(.{ i * tick, 0 });
- const y = world.apply(.{ 0, i * tick });
- f.print(x[0] + 3, x[1] + 8, 1, 0x8c8c8c, "{d}", .{i * tick});
- if (i != 0) f.print(y[0] + 8, y[1] - 3, 1, 0x8c8c8c, "{d}", .{i * tick});
- }
- for (shot.objects, shot.poses, 0..) |o, pose, n| {
- if (!pose.visible or pose.opacity <= 0) continue;
- const r: geom.Rect = if (o.source == .custom) .{} else (try built(ss, o)).bounds;
- const corner = world.mul(model(pose)).apply(.{ r.x, r.y });
- f.print(corner[0], corner[1] - 11, 1, anim.yellow, "#{d} {d:.0},{d:.0}", .{ n, pose.x, pose.y });
- }
-}
-
fn hud(s: *const State, ss: *const Session, f: *sk.Frame, shot: anim.Shot, canvas: sk.Rect) void {
const w = canvas.w;
const h = canvas.h;
+ const d = &s.deck;
var play: usize = 0;
- for (shot.marks, 1..) |m, i| if (m <= s.t) {
+ for (shot.marks, 1..) |m, i| if (m <= d.t) {
play = i;
};
+ var buf: [64]u8 = undefined;
+ const steps = (if (d.slides > 0)
+ std.fmt.bufPrint(&buf, " slide {d}/{d} step {d}/{d}", .{ d.slide, d.slides, d.log.count(), d.gates })
+ else if (d.gates > 0)
+ std.fmt.bufPrint(&buf, " step {d}/{d}", .{ d.log.count(), d.gates })
+ else
+ std.fmt.bufPrint(&buf, "", .{})) catch "";
const backend = if (s.backend == .gpu and f.host.gpu()) "GPU" else "CPU";
- const status = if (!s.playing) " paused" else if (held(s.t, shot)) " click to continue" else "";
+ const status = if (!d.playing) " paused" else if (d.waiting) " click to continue" else "";
f.fill(sk.Rect{ .y = h - 28, .w = w, .h = 28 }, sk.Color{ .r = 0, .g = 0, .b = 0, .a = 150 });
- f.print(12, h - 19, 1, 0xece6e2, "{d:5.2}s / {d:.2}s play {d}/{d} {s} record {d:.3}ms {d} shapes speed x{d}{s}", .{
- s.t, shot.duration, play, shot.marks.len, backend, ss.render_ns / 1e6, ss.shapes, s.speed, status,
+ f.print(12, h - 19, 1, 0xece6e2, "{d:5.2}s / {d:.2}s play {d}/{d}{s} {s} record {d:.3}ms {d} shapes speed x{d}{s}", .{
+ d.t, shot.duration, play, shot.marks.len, steps, backend, ss.render_ns / 1e6, ss.painter.shapes, d.speed, status,
});
if (s.guides) {
const p = pointer(s, f.in, canvas);
f.print(w - 540, h - 19, 1, anim.yellow, "pointer {d:.0},{d:.0}", .{ p[0], p[1] });
}
- f.text(w - 400, h - 19, 1, "space click <- -> , . B G drag wheel", 0x8c8c8c);
+ f.text(w - 400, h - 19, 1, "click space pgup [ ] P <- -> , . B G drag", 0x8c8c8c);
f.cursor(.arrow);
}
diff --git a/src/anim/root.zig b/src/anim/root.zig
index a676f38..4acecb3 100644
--- a/src/anim/root.zig
+++ b/src/anim/root.zig
@@ -44,13 +44,20 @@
//! Both are functions of time (and a live one, of the input too), so
//! scrubbing, seeking and hot reload are free.
//!
+//! **Talks** are live scenes with gates: `pause` waits for the presenter's
+//! click, `gate` for any condition, and time runs on while they wait, so
+//! loops (`loop`) and plays already running carry on. A talk is a function
+//! of its time and of the gates opened so far, both plain data in a `Deck`,
+//! which the stock player keeps and any sketch can keep in its own State.
+//!
//! Animations, as methods of an object handle: `write`, `create`,
//! `fadeIn`, `fadeOut`, `transformInto` (morph), `move`, `scaleTo`,
//! `rotate`, `indicate`; and `camera`, `Value.to`. `play` runs a tuple of
//! them together, with options `.seconds`, `.ease` (any `fn (f32) f32`,
//! `ease.smooth` by default) and `.lag`. `wait` moves time on; `pause`
-//! holds the player there until a click, like a slide. Typst is compiled
-//! at build time (`sb.addScene`), from the scene's `typst_sources`.
+//! makes what follows wait for a click, like a slide step. Typst is
+//! compiled at build time (`sb.addScene`), from the scene's
+//! `typst_sources`.
//!
//! **Custom objects** (`s.custom(&data, .{ .x = 100 })`) are drawn by the
//! scene's own code, with `sketch.Frame` commands, in their place among
@@ -62,6 +69,7 @@ const tween = sk.tween;
const Drawing = vector.Drawing;
pub const ease = tween.ease;
+pub const Painter = @import("Painter.zig");
// manim's palette.
pub const blue: u32 = 0x58c4dd;
@@ -545,7 +553,6 @@ pub const Builder = struct {
values: []const f32 = &.{},
plays: []const Play = &.{},
updaters: []const Updater = &.{},
- stops: []const f32 = &.{},
/// Where the next play starts.
cursor: f32 = 0,
@@ -580,11 +587,6 @@ pub const Builder = struct {
b.cursor += seconds;
}
- /// The player holds here until a click.
- pub fn pause(b: *Builder) void {
- b.stops = b.stops ++ .{b.cursor};
- }
-
/// From now on, every frame, `o`'s pose is `update(now, args...)`:
/// `args` (a tuple) is bound here, like a closure's captures, so an
/// updater can follow other objects or read values.
@@ -641,7 +643,6 @@ pub fn Scene(comptime construct: fn (*Builder) void) type {
const frozen_objects = recorded.objects[0..n].*;
const frozen_values = recorded.values[0..recorded.values.len].*;
const frozen_updaters = recorded.updaters[0..recorded.updaters.len].*;
- const frozen_stops = recorded.stops[0..recorded.stops.len].*;
const frozen_keys = compiled.keys;
const frozen_value_keys = compiled.value_keys;
const frozen_camera_keys = compiled.camera_keys[0..compiled.camera_keys.len].*;
@@ -663,7 +664,6 @@ pub fn Scene(comptime construct: fn (*Builder) void) type {
pub const camera_keys: []const Key(Camera) = &frozen_camera_keys;
/// Start times of every play, for chapter-style seeking.
pub const marks: []const f32 = &frozen_marks;
- pub const stops: []const f32 = &frozen_stops;
pub const duration: f32 = recorded.cursor;
/// Every Typst source, for the build step that compiles them.
pub const typst_sources: []const []const u8 = &typst_list;
@@ -678,7 +678,7 @@ pub fn Scene(comptime construct: fn (*Builder) void) type {
m.* = .{ .from = k.from, .to = pose(p.into, k.end) };
};
}
- return .{ .objects = objects, .poses = poses, .morphs = morphs, .values = try arena.dupe(f32, &values(now.t)), .camera = view(now.t), .duration = duration, .marks = marks, .stops = stops };
+ return .{ .t = now.t, .objects = objects, .poses = poses, .morphs = morphs, .values = try arena.dupe(f32, &values(now.t)), .camera = view(now.t), .duration = duration, .marks = marks, .stops = &.{} };
}
/// The key shaping object `i` at `t`: the last one to have started.
@@ -816,40 +816,68 @@ pub fn color(c: u32) Drawing.Color {
/// A live scene: `frame` runs every frame, at runtime, and the scene is
/// whatever it builds. `typst` is a namespace whose declarations are the
-/// Typst sources `frame` uses, for the build to compile.
-pub fn Live(comptime frame: fn (*Frame) void, comptime typst: type) type {
- const decls = @typeInfo(typst).@"struct".decl_names;
- var sources: [decls.len][]const u8 = undefined;
- for (&sources, decls) |*s, name| s.* = @field(typst, name);
- const frozen_sources = sources;
+/// Typst sources `frame` uses, or a tuple of them (`sources`), for the
+/// build to compile.
+pub fn Live(comptime frame_fn: fn (*Frame) void, comptime typst: anytype) type {
return struct {
- pub const typst_sources: []const []const u8 = &frozen_sources;
+ pub const frame = frame_fn;
+ pub const typst_sources: []const []const u8 = sources(typst);
- /// The scene at `now`, for the player: `frame`, run once.
+ /// The scene at `now`, `frame` run once, its gates all closed.
pub fn shot(arena: std.mem.Allocator, now: Instant) !Shot {
- var s: Frame = .{ .t = now.t, .clock = now.clock, .in = now.in, .pointer = now.pointer, .arena = arena };
- frame(&s);
- const values = try arena.alloc(f32, s.values.items.len);
- for (values, s.values.items) |*v, own| v.* = own.shown;
- return .{ .objects = s.objects.items, .poses = s.shown.items, .morphs = s.morphs.items, .values = values, .camera = s.view, .duration = s.cursor, .marks = s.marks.items, .stops = s.stops.items };
+ var s: Frame = .{ .t = now.t, .in = now.in, .pointer = now.pointer, .arena = arena };
+ frame_fn(&s);
+ return s.shot();
}
};
}
+/// Every declaration of `namespaces` (a namespace, or a tuple of them),
+/// each a Typst source, for the build to compile: a sketch that draws
+/// Typst itself declares `pub const scene = struct { pub const
+/// typst_sources = anim.sources(.{typst}); };` for `sb.addTypst`.
+pub fn sources(comptime namespaces: anytype) []const []const u8 {
+ const frozen = comptime blk: {
+ const all = if (@TypeOf(namespaces) == type) .{namespaces} else namespaces;
+ var out: []const []const u8 = &.{};
+ for (all) |namespace| for (@typeInfo(namespace).@"struct".decl_names) |name| {
+ out = out ++ .{@as([]const u8, @field(namespace, name))};
+ };
+ break :blk out[0..out.len].*;
+ };
+ return &frozen;
+}
+
/// What a live scene's `frame` gets: the time, the input, and the same calls
/// as `Builder`, which take effect at `t` right away.
pub const Frame = struct {
- /// Scene time, in seconds.
+ /// Scene time, in seconds. In a talk it runs on through gates.
t: f32,
- /// Seconds on the wall clock, which runs on while the player pauses:
- /// for motion that should not stop.
- clock: f32,
in: *const sk.Input,
/// The mouse, in scene units from the canvas center (before the scene's
/// own camera).
pointer: [2]f32,
/// Lives for this frame.
arena: std.mem.Allocator,
+ /// The gates opened so far, in order (the deck's log).
+ gates: []const Gate = &.{},
+ /// The presenter asked for the next step (`Ask.next`) and nothing has
+ /// taken it yet: the `pause` it reaches opens. Code laid out before
+ /// that pause takes the click for itself by setting it false (a widget
+ /// the click landed on).
+ next: bool = false,
+ /// This update's events, pointer positions in scene units
+ /// (`Deck.pointer`): in the deck's `update` run only, empty when drawn.
+ events: []const sk.Event = &.{},
+ /// Where `gate` writes a gate that opens: the deck's `update` run only.
+ log: ?*Log = null,
+ /// Open every gate laid before `slides` slides, `hold` after it is
+ /// reached (or now, if that is later): `Ask.end`, `next_slide`, export.
+ lay: ?Lay = null,
+ /// A gate opened in this run: one click opens one gate.
+ opened: bool = false,
+ /// Where the first gate still closed is laid.
+ closed: ?f32 = null,
/// Where the next play starts.
cursor: f32 = 0,
objects: std.ArrayList(Object) = .empty,
@@ -861,7 +889,12 @@ pub const Frame = struct {
settled_view: Camera = .{},
view: Camera = .{},
marks: std.ArrayList(f32) = .empty,
+ /// Where each gate is laid: the cursor when the code reached it.
stops: std.ArrayList(f32) = .empty,
+ /// Where each `slide` begins, and how many gates come before it.
+ slides: std.ArrayList(struct { at: f32, gates: u32 }) = .empty,
+
+ const Lay = struct { hold: f32, slides: usize };
pub fn add(s: *Frame, o: Object) Obj {
s.push(&s.objects, o);
@@ -904,10 +937,14 @@ pub const Frame = struct {
/// they stand at `t`, then moves the cursor past them.
pub fn play(s: *Frame, animations: anytype, options: anytype) void {
const all = list(animations);
- const p = Play.of(s.cursor, &all, options);
- const started = s.t >= p.start;
var buf: [2 * all.len]Change = undefined;
- const touched = changes(&buf, s.settled.items, &all);
+ s.playAll(&all, &buf, Play.of(s.cursor, &all, options));
+ }
+
+ /// `play`, of animations known at runtime; `buf` holds two changes each.
+ fn playAll(s: *Frame, all: []const Animation, buf: []Change, p: Play) void {
+ const started = s.t >= p.start;
+ const touched = changes(buf, s.settled.items, all);
for (touched) |c| {
const k = p.key(Pose, c.from, c.to, c.ease);
s.settled.items[c.obj] = k.at(k.end);
@@ -923,7 +960,7 @@ pub const Frame = struct {
v.settled = a.value.to;
if (started) v.shown = k.at(s.t);
};
- if (aim(s.settled_view, &all)) |to| {
+ if (aim(s.settled_view, all)) |to| {
const k = p.key(Camera, s.settled_view, to, null);
s.settled_view = to;
if (started) s.view = k.at(s.t);
@@ -936,9 +973,85 @@ pub const Frame = struct {
s.cursor += seconds;
}
- /// The player holds here until a click, like a slide.
- pub fn pause(s: *Frame) void {
+ /// A gate: the plays after it wait until it opens, while time runs on,
+ /// so plays already running, loops and code reading `t` carry on. It
+ /// opens in the deck's `update`, on the first frame at or after it is
+ /// reached on which `open` is not null, and from then on returns that
+ /// value, a choice to branch on; closed, it returns null. The cursor
+ /// moves to where it opened, or, closed, just past `t`, so what follows
+ /// waits in the future. Gates are known by the order they are reached.
+ pub fn gate(s: *Frame, open: ?u16) ?u16 {
+ const k = s.stops.items.len;
s.push(&s.stops, s.cursor);
+ if (k < s.gates.len) {
+ s.cursor += s.gates[k].wait;
+ return s.gates[k].value;
+ }
+ if (s.closed == null) if (s.log) |log| {
+ const laying = if (s.lay) |lay| s.slides.items.len < lay.slides else false;
+ const opens = if (laying) open orelse 0 else if (!s.opened and s.t >= s.cursor) open else null;
+ if (opens) |v| {
+ const wait_for = if (laying) @max(s.lay.?.hold, s.t - s.cursor) else s.t - s.cursor;
+ if (log.appendBounded(.{ .wait = wait_for, .value = v })) {
+ s.opened = true;
+ s.cursor += wait_for;
+ return v;
+ } else |_| {}
+ }
+ };
+ if (s.closed == null) s.closed = s.cursor;
+ s.cursor = @max(s.cursor, s.t + 1.0 / 60.0);
+ return null;
+ }
+
+ /// A gate the presenter opens (`Ask.next`: a click, space, page down),
+ /// like a slide's next step.
+ pub fn pause(s: *Frame) void {
+ _ = s.gate(if (s.next) 0 else null);
+ }
+
+ /// A slide begins: `Ask.next_slide` and `back_slide` go from slide to
+ /// slide, each shown at rest, held at its first gate.
+ pub fn slide(s: *Frame) void {
+ s.push(&s.slides, .{ .at = s.cursor, .gates = @intCast(s.stops.items.len) });
+ }
+
+ /// `f(s, args...)` beside the main line: its plays start at the cursor,
+ /// and the cursor is left where it was, so what follows runs alongside.
+ pub fn beside(s: *Frame, comptime f: anytype, args: anytype) void {
+ const at = s.cursor;
+ @call(.auto, f, .{s} ++ args);
+ s.cursor = at;
+ }
+
+ /// `f(s, args...)`, a run of plays that ends where it began, again and
+ /// again from the cursor until the gate laid right after it opens (for
+ /// ever while it is closed); the cycle running then completes. The
+ /// cursor is left where it was. `f` only plays: objects are made
+ /// outside it. It costs two runs of `f` a frame at most.
+ pub fn loop(s: *Frame, comptime f: anytype, args: anytype) void {
+ const start = s.cursor;
+ @call(.auto, f, .{s} ++ args); // the first cycle, which measures it
+ const period = s.cursor - start;
+ const k = s.stops.items.len;
+ const until = if (k < s.gates.len) start + s.gates[k].wait else std.math.inf(f32);
+ if (period > 0 and s.t >= start + period) {
+ var cycle = @floor((@min(s.t, until) - start) / period);
+ // One that would begin as the gate opens never runs.
+ if (cycle > 0 and start + cycle * period >= until) cycle -= 1;
+ s.cursor = start + cycle * period;
+ @call(.auto, f, .{s} ++ args); // the cycle in progress, which wins
+ }
+ s.cursor = start;
+ }
+
+ /// Fades out everything that shows once the plays so far are done, on
+ /// the main line (`play`'s options): the end of a slide.
+ pub fn clear(s: *Frame, options: anytype) void {
+ var all: std.ArrayList(Animation) = .empty;
+ for (s.settled.items, 0..) |p, i| if (p.visible and p.opacity > 0) s.push(&all, .{ .fade_out = @fromBackingInt(@intCast(i)) });
+ const buf = s.arena.alloc(Change, 2 * all.items.len) catch @panic("anim: out of memory");
+ s.playAll(all.items, buf, Play.of(s.cursor, all.items, options));
}
/// `data` in the arena, to change until the frame ends: what a custom
@@ -949,6 +1062,22 @@ pub const Frame = struct {
return kept;
}
+ /// What the run built, for the player.
+ fn shot(s: *Frame) !Shot {
+ const values = try s.arena.alloc(f32, s.values.items.len);
+ for (values, s.values.items) |*v, own| v.* = own.shown;
+ return .{ .t = s.t, .objects = s.objects.items, .poses = s.shown.items, .morphs = s.morphs.items, .values = values, .camera = s.view, .duration = s.cursor, .marks = s.marks.items, .stops = s.stops.items };
+ }
+
+ /// Slide `j`'s resting picture: where its first gate is laid, or, with
+ /// no gate of its own, where the next slide begins or the talk ends.
+ fn rest(s: *const Frame, j: usize) f32 {
+ const first = s.slides.items[j].gates;
+ const after = if (j + 1 < s.slides.items.len) s.slides.items[j + 1] else null;
+ if (first < s.stops.items.len and (after == null or first < after.?.gates)) return s.stops.items[first];
+ return if (after) |a| a.at else s.cursor;
+ }
+
/// Keeps scene code free of error handling: the frame arena running out
/// is fatal anyway.
fn push(s: *Frame, items: anytype, item: @TypeOf(items.items[0])) void {
@@ -957,13 +1086,215 @@ pub const Frame = struct {
};
// ---------------------------------------------------------------------------
+// Talks: a live scene with gates, and its playhead
+
+/// A gate opened: how long after it was reached, and the value it opened with.
+pub const Gate = struct { wait: f32 = 0, value: u16 = 0 };
+
+const Log = sk.List(Gate, 256);
+
+/// What the presenter asks of a deck this frame. The sketch decides which
+/// keys and clicks they are: the deck owns no input.
+pub const Ask = struct {
+ /// The next step: opens the pause the deck waits at, or, during a
+ /// step, finishes it (the playhead jumps to where the next gate is
+ /// laid; at the last step, to the end). A paused deck plays on.
+ next: bool = false,
+ /// Back a step: the picture held before the last gate opened.
+ back: bool = false,
+ /// The next or the previous slide (`Frame.slide`), at rest: held at
+ /// its first gate, every gate before it opened (at once, a choice with
+ /// 0) or undone.
+ next_slide: bool = false,
+ back_slide: bool = false,
+ /// A seek: the gates opened after it have not happened yet.
+ to: ?f32 = null,
+ /// The end: every gate opened where it is reached.
+ end: bool = false,
+};
+
+/// A talk's playhead: plain data for a sketch's State, so hot reload,
+/// snapshots, replay and the console see it like any field. The talk is
+/// `frame(s: *Frame, ctx...)`, a live scene's frame with more arguments,
+/// run from the top every frame: in `update`, given `ctx` as it is, so it
+/// may change the app (`mutable`), and in `shot`, given it read-only.
+pub const Deck = struct {
+ /// Talk time, in seconds: it runs on through gates.
+ t: f32 = 0,
+ playing: bool = true,
+ speed: f32 = 1,
+ /// Exported, each gate holds this long, then opens itself.
+ hold: f32 = 1,
+ /// The gates opened, in order: with `t`, all the talk depends on.
+ log: Log = .{},
+ /// When the last gate in `log` opened, as of the last update: an edit
+ /// that moves it moves `t` with it, so a reload keeps the same step, as
+ /// far into it.
+ anchor: f32 = 0,
+ /// The talk as the last update laid it, for a HUD and for scripts: its
+ /// end (a closed gate lays what follows it just past `t`), the gates
+ /// laid, opened or not, whether it waits at one, the slides begun by
+ /// `t`, and all the slides.
+ duration: f32 = 0,
+ gates: u32 = 0,
+ waiting: bool = false,
+ slide: u32 = 0,
+ slides: u32 = 0,
+
+ /// In `update`: time from the ticks, `ask` applied, and the talk run
+ /// once (more when asked to move), opening the gate it waits at.
+ /// Exported (`in.exporting`), it opens every gate `hold` after it is
+ /// reached, in the first frame's run, and runs at the export's pace.
+ pub fn update(d: *Deck, in: *const sk.Input, ask: Ask, comptime frame: anytype, ctx: anytype) void {
+ var arena_state: std.heap.ArenaAllocator = .init(std.heap.page_allocator);
+ defer arena_state.deinit();
+ const arena = arena_state.allocator();
+ for (in.events) |e| if (e.kind == .tick) {
+ if (in.exporting) {
+ d.t += e.x;
+ } else if (d.playing) d.t += e.x * d.speed;
+ };
+ if (ask.next) d.playing = true;
+ const events = arena.dupe(sk.Event, in.events) catch return;
+ for (events) |*e| switch (e.kind) {
+ .mouse_move, .mouse_down, .mouse_up, .wheel, .wheel_horizontal => {
+ const p = pointer(in, e.x, e.y);
+ e.x = p[0];
+ e.y = p[1];
+ },
+ else => {},
+ };
+ const all: Frame.Lay = .{ .hold = 0, .slides = std.math.maxInt(usize) };
+
+ // Elsewhere: against the talk as it is laid now.
+ const moves = ask.back or ask.to != null or ask.end or ask.next_slide or ask.back_slide;
+ if (moves) {
+ const m = d.run(arena, in, frame, readOnly(ctx), &.{}, false, false, null);
+ d.log.len = @min(d.log.count(), m.stops.items.len);
+ const n = d.log.count();
+ var on: u32 = 0;
+ for (m.slides.items) |sl| on += @intFromBool(sl.at <= d.t);
+ if (ask.back) {
+ d.t = if (n > 0) m.stops.items[n - 1] + d.log.buffer[n - 1].wait else 0;
+ d.log.len = n -| 1;
+ } else if (ask.to) |to| {
+ d.t = to;
+ while (d.log.count() > 0 and m.stops.items[d.log.count() - 1] + d.log.buffer[d.log.count() - 1].wait > to) d.log.len -= 1;
+ } else if (ask.back_slide) {
+ if (on < 2) {
+ d.t = 0;
+ d.log.len = 0;
+ } else {
+ d.log.len = m.slides.items[on - 2].gates;
+ d.t = m.rest(on - 2);
+ }
+ } else {
+ // Gates open up to the next slide's first, or all of them:
+ // a choice may be what lays the slides after it.
+ const l = d.run(arena, in, frame, readOnly(ctx), &.{}, true, false, if (ask.next_slide) .{ .hold = 0, .slides = on + 1 } else all);
+ d.t = if (ask.next_slide and on < l.slides.items.len) l.rest(on) else l.cursor;
+ }
+ }
+
+ const before = d.log.count();
+ var s = d.run(arena, in, frame, ctx, events, true, ask.next and !moves, if (in.exporting) .{ .hold = d.hold, .slides = all.slides } else null);
+ if (s.stops.items.len < before) {
+ // An edit took gates out: the ones it left are the talk's.
+ d.log.len = @intCast(s.stops.items.len);
+ } else if (!moves and before > 0) {
+ // An edit moved the last opened gate: so does `t`. That run's
+ // input is not taken again.
+ const now = s.stops.items[before - 1] + d.log.buffer[before - 1].wait;
+ if (now != d.anchor) {
+ d.log.len = before;
+ d.t += now - d.anchor;
+ s = d.run(arena, in, frame, readOnly(ctx), &.{}, false, false, null);
+ }
+ }
+ // A step under way, finished: the playhead to where it waits next.
+ if (ask.next and s.next and !s.opened and !moves) d.t = @max(d.t, s.closed orelse s.cursor);
+
+ const n = d.log.count();
+ d.anchor = if (n > 0) s.stops.items[n - 1] + d.log.buffer[n - 1].wait else 0;
+ d.duration = s.cursor;
+ d.gates = @intCast(s.stops.items.len);
+ d.waiting = if (s.closed) |c| d.t >= c else false;
+ d.slides = @intCast(s.slides.items.len);
+ d.slide = 0;
+ for (s.slides.items) |sl| d.slide += @intFromBool(sl.at <= d.t);
+ }
+
+ /// In `draw`: the talk now, for `Painter.paint`; `ctx` read-only and
+ /// the log too, so drawing changes nothing.
+ pub fn shot(d: *const Deck, arena: std.mem.Allocator, in: *const sk.Input, mouse: [2]f32, comptime frame: anytype, ctx: anytype) !Shot {
+ var s: Frame = .{ .t = d.t, .in = in, .pointer = mouse, .arena = arena, .gates = d.log.constSlice() };
+ @call(.auto, frame, .{&s} ++ readOnly(ctx));
+ return s.shot();
+ }
+
+ /// Window pixels to scene units from the center: the scene's frame
+ /// (`width` by `height`) fitted into the window, as `Painter` draws it.
+ pub fn pointer(in: *const sk.Input, x: f32, y: f32) [2]f32 {
+ const w = @max(@floor(in.window_width), 1);
+ const h = @max(@floor(in.window_height), 1);
+ const k = @min(w / width, h / height);
+ return .{ (x - w / 2) / k, (y - h / 2) / k };
+ }
+
+ /// One run of the talk at `t`, as the log stands.
+ fn run(d: *Deck, arena: std.mem.Allocator, in: *const sk.Input, comptime frame: anytype, ctx: anytype, events: []const sk.Event, logs: bool, next: bool, lay: ?Frame.Lay) Frame {
+ var s: Frame = .{
+ .t = d.t,
+ .in = in,
+ .pointer = pointer(in, in.mouse_x, in.mouse_y),
+ .arena = arena,
+ .gates = d.log.constSlice(),
+ .log = if (logs) &d.log else null,
+ .next = next,
+ .events = events,
+ .lay = lay,
+ };
+ @call(.auto, frame, .{&s} ++ ctx);
+ return s;
+ }
+};
+
+/// `app`, to change: a talk is given the app as `*App` in the deck's
+/// `update` run and as `*const App` when drawn, where this is null, so
+/// drawing cannot write to it. `if (anim.mutable(app)) |a| a.n += 1`.
+pub fn mutable(app: anytype) ?*@typeInfo(@TypeOf(app)).pointer.child {
+ return if (@typeInfo(@TypeOf(app)).pointer.attrs.@"const") null else app;
+}
+
+/// `ctx` with every pointer in it to const: what the runs that only look
+/// are given.
+fn readOnly(ctx: anytype) ReadOnly(@TypeOf(ctx)) {
+ var out: ReadOnly(@TypeOf(ctx)) = undefined;
+ inline for (0..ctx.len) |i| out[i] = ctx[i];
+ return out;
+}
+
+fn ReadOnly(comptime Ctx: type) type {
+ const types = @typeInfo(Ctx).@"struct".field_types;
+ var out: [types.len]type = undefined;
+ for (&out, types) |*o, T| o.* = switch (@typeInfo(T)) {
+ .pointer => |p| if (p.size == .one) *const p.child else T,
+ else => T,
+ };
+ return @Tuple(&out);
+}
+
+/// The scene's frame, in scene units: what shows at camera zoom 1.
+pub const width = 1280;
+pub const height = 720;
+
+// ---------------------------------------------------------------------------
// Both kinds, to the player
/// What a scene is asked for, each frame.
pub const Instant = struct {
/// Scene time, in seconds.
t: f32,
- clock: f32 = 0,
in: *const sk.Input = &no_input,
pointer: [2]f32 = .{ 0, 0 },
@@ -972,6 +1303,7 @@ pub const Instant = struct {
/// A scene at one instant: what the player draws.
pub const Shot = struct {
+ t: f32,
objects: []const Object,
poses: []const Pose,
/// For each object morphing (`pose.into`): the pose its morph started
@@ -983,7 +1315,7 @@ pub const Shot = struct {
duration: f32,
/// Start times of every play, for chapter-style seeking.
marks: []const f32,
- /// Where the player holds until a click (`pause`).
+ /// Where each gate is laid (`gate`, `pause`).
stops: []const f32,
};
@@ -1053,3 +1385,418 @@ test "a live scene shows what the compiled one does, at every instant" {
try std.testing.expectEqualSlices(f32, a.marks, b.marks);
}
}
+
+test "Typst sources come from a namespace or a tuple of them" {
+ const a = struct {
+ pub const title = "= A";
+ };
+ const b = struct {
+ pub const law = "$ x $";
+ pub const end = "= B";
+ };
+ try std.testing.expectEqual(@as(usize, 1), Live(liveScene, a).typst_sources.len);
+ try std.testing.expectEqualStrings("$ x $", Live(liveScene, .{ a, b }).typst_sources[1]);
+ try std.testing.expectEqual(@as(usize, 3), sources(.{ a, b }).len);
+ try std.testing.expect(Live(liveScene, a).frame == liveScene);
+}
+
+// ---------------------------------------------------------------------------
+// Talks: the semantics of the model in .scratch/sketch/anim/gates_model.zig
+// (pardes-code), on the real types, then the presenter's rulings.
+
+/// `d.update` with `before` and then a tick of `seconds`, in a window the
+/// size of the scene's frame (its center the scene's origin).
+fn step(d: *Deck, before: []const sk.Event, seconds: f32, ask: Ask, comptime frame: anytype, ctx: anytype) void {
+ var events: [8]sk.Event = undefined;
+ @memcpy(events[0..before.len], before);
+ events[before.len] = .{ .kind = .tick, .x = seconds };
+ d.update(&.{ .events = events[0 .. before.len + 1], .window_width = width, .window_height = height }, ask, frame, ctx);
+}
+
+/// Value 0 of the talk drawn now.
+fn shown(d: *const Deck, arena: std.mem.Allocator, comptime frame: anytype, ctx: anytype) !f32 {
+ return (try d.shot(arena, &Instant.no_input, .{ 0, 0 }, frame, ctx)).values[0];
+}
+
+/// Round 1's slide 2: a phase that runs from `spin`, through the hold at
+/// the second gate, until half a second after it opens; -1 otherwise.
+fn orbit(s: *Frame) void {
+ const phase = s.value(-1);
+ s.wait(2); // the title, written
+ s.pause();
+ s.wait(2.5); // out, and the equation in
+ const spin = s.cursor;
+ s.pause();
+ const leave = s.cursor;
+ s.wait(0.5);
+ if (s.t >= spin and s.t < leave + 0.5) s.values.items[@backingInt(phase)].shown = s.t - spin;
+}
+
+test "a loop runs on through the hold, and its phase is continuous across the click" {
+ var arena: std.heap.ArenaAllocator = .init(std.testing.allocator);
+ defer arena.deinit();
+ var d: Deck = .{};
+ step(&d, &.{}, 10, .{}, orbit, .{});
+ try std.testing.expect(d.waiting and d.log.count() == 0 and d.gates == 2);
+ step(&d, &.{}, 0, .{ .next = true }, orbit, .{});
+ try std.testing.expectEqual(@as(f32, 8), d.log.buffer[0].wait);
+ // Slide 2 is in at 12.5; at 15 the deck waits, the phase running.
+ step(&d, &.{}, 5, .{}, orbit, .{});
+ try std.testing.expect(d.waiting);
+ const before = try shown(&d, arena.allocator(), orbit, .{});
+ step(&d, &.{}, 0, .{ .next = true }, orbit, .{});
+ try std.testing.expect(!d.waiting and d.log.count() == 2);
+ try std.testing.expectEqual(before, try shown(&d, arena.allocator(), orbit, .{}));
+ try std.testing.expectApproxEqAbs(@as(f32, 2.5), before, 1e-4);
+ // Half a second after the click it has gone.
+ step(&d, &.{}, 0.6, .{}, orbit, .{});
+ try std.testing.expectEqual(@as(f32, -1), try shown(&d, arena.allocator(), orbit, .{}));
+}
+
+/// Round 1's equation, stepped: written to 1, then each step morphs it one
+/// further, to 4.
+fn equations(s: *Frame) void {
+ const form = s.value(0);
+ s.play(.{form.to(1)}, .{ .seconds = 2, .ease = ease.linear });
+ for (2..5) |i| {
+ s.pause();
+ s.play(.{form.to(@floatFromInt(i))}, .{ .seconds = 1.2, .ease = ease.linear });
+ }
+}
+
+test "back cuts to the picture held before the last click" {
+ var arena: std.heap.ArenaAllocator = .init(std.testing.allocator);
+ defer arena.deinit();
+ var d: Deck = .{};
+ // Clicks at 5, 9 and 20.
+ step(&d, &.{}, 5, .{ .next = true }, equations, .{});
+ step(&d, &.{}, 4, .{ .next = true }, equations, .{});
+ step(&d, &.{}, 11, .{ .next = true }, equations, .{});
+ try std.testing.expectEqual(@as(u32, 3), d.log.count());
+ step(&d, &.{}, 0.6, .{}, equations, .{});
+ try std.testing.expectApproxEqAbs(@as(f32, 3.5), try shown(&d, arena.allocator(), equations, .{}), 1e-3);
+ // Back, mid-morph: the third form at rest, held where the click was.
+ step(&d, &.{}, 0, .{ .back = true }, equations, .{});
+ try std.testing.expect(d.t == 20 and d.log.count() == 2 and d.waiting);
+ try std.testing.expectEqual(@as(f32, 3), try shown(&d, arena.allocator(), equations, .{}));
+ // Time runs on while held; nothing moves.
+ step(&d, &.{}, 40, .{}, equations, .{});
+ try std.testing.expectEqual(@as(f32, 3), try shown(&d, arena.allocator(), equations, .{}));
+ // Back again: the second form, at 9; then the first, at 5; then the start.
+ step(&d, &.{}, 0, .{ .back = true }, equations, .{});
+ try std.testing.expect(d.t == 9 and d.log.count() == 1);
+ try std.testing.expectEqual(@as(f32, 2), try shown(&d, arena.allocator(), equations, .{}));
+ step(&d, &.{}, 0, .{ .back = true }, equations, .{});
+ try std.testing.expect(d.t == 5 and d.log.count() == 0 and d.waiting);
+ step(&d, &.{}, 0, .{ .back = true }, equations, .{});
+ try std.testing.expect(d.t == 0 and !d.waiting);
+ // Forward after back plays the step again.
+ step(&d, &.{}, 3, .{ .next = true }, equations, .{});
+ step(&d, &.{}, 0.6, .{}, equations, .{});
+ try std.testing.expectApproxEqAbs(@as(f32, 1.5), try shown(&d, arena.allocator(), equations, .{}), 1e-3);
+}
+
+test "exported, each gate opens a fixed hold after it is reached: the same frames every run" {
+ var arena: std.heap.ArenaAllocator = .init(std.testing.allocator);
+ defer arena.deinit();
+ var runs: [2]Deck = .{ .{ .hold = 1 }, .{ .hold = 1 } };
+ var seen: [2][4]f32 = undefined;
+ for (&runs, &seen) |*d, *values| for (0..10 * 30) |frame| {
+ const tick = [_]sk.Event{.{ .kind = .tick, .x = 1.0 / 30.0 }};
+ d.update(&.{ .events = &tick, .exporting = true, .window_width = width, .window_height = height }, .{}, equations, .{});
+ if (frame % 75 == 0) values[frame / 75] = try shown(d, arena.allocator(), equations, .{});
+ };
+ for (runs) |d| {
+ try std.testing.expectEqual(@as(u32, 3), d.log.count());
+ for (d.log.constSlice()) |g| try std.testing.expectEqual(@as(f32, 1), g.wait);
+ try std.testing.expectApproxEqAbs(@as(f32, 2 + 3 * 2.2), d.duration, 1e-4);
+ }
+ try std.testing.expectEqualSlices(Gate, runs[0].log.constSlice(), runs[1].log.constSlice());
+ try std.testing.expectEqual(seen[0], seen[1]);
+}
+
+/// A talk that branches on the app's choice: proof (0) is two steps with a
+/// pause between, skip (1) one; both end on the same slide. Each part shows
+/// a circle: proof one, proof two, skipped, the end.
+fn branching(s: *Frame, app: anytype) void {
+ var parts: [4]Obj = undefined;
+ for (&parts) |*p| p.* = s.circle(.{ .r = 1 });
+ s.wait(2);
+ const pick = s.gate(app.pick) orelse return; // closed: nothing after it shows
+ switch (pick) {
+ 0 => {
+ s.play(.{parts[0].fadeIn()}, .{});
+ s.pause();
+ s.play(.{parts[1].fadeIn()}, .{});
+ },
+ else => s.play(.{parts[2].fadeIn()}, .{}),
+ }
+ s.play(.{parts[3].fadeIn()}, .{});
+}
+
+const Choice = struct { pick: ?u16 = null };
+
+fn showing(d: *const Deck, arena: std.mem.Allocator, app: *const Choice) ![4]bool {
+ const shot = try d.shot(arena, &Instant.no_input, .{ 0, 0 }, branching, .{app});
+ var out: [4]bool = undefined;
+ for (&out, shot.poses) |*o, p| o.* = p.visible;
+ return out;
+}
+
+test "a choice is logged in update, branched on, and replays from the log alone" {
+ var arena: std.heap.ArenaAllocator = .init(std.testing.allocator);
+ defer arena.deinit();
+ var app: Choice = .{};
+ var d: Deck = .{};
+ step(&d, &.{}, 3, .{}, branching, .{&app});
+ try std.testing.expect(d.waiting and d.log.count() == 0);
+ // A click is no choice.
+ step(&d, &.{}, 0, .{ .next = true }, branching, .{&app});
+ try std.testing.expect(d.waiting and d.log.count() == 0 and d.t == 3);
+ // The app says "skip": the gate opens with 1.
+ app.pick = 1;
+ step(&d, &.{}, 0, .{}, branching, .{&app});
+ try std.testing.expectEqual(Gate{ .wait = 1, .value = 1 }, d.log.buffer[0]);
+ // From the log alone, whatever the app says now: skipped, then the end.
+ app.pick = null;
+ d.t = 3.5;
+ try std.testing.expectEqual([4]bool{ false, false, true, false }, try showing(&d, arena.allocator(), &app));
+ d.t = 4.5;
+ try std.testing.expectEqual([4]bool{ false, false, true, true }, try showing(&d, arena.allocator(), &app));
+ // Another log takes the proof, whose pause is the second gate.
+ var proof: Deck = .{ .t = 4.5 };
+ try proof.log.appendBounded(.{ .wait = 1, .value = 0 });
+ try std.testing.expectEqual([4]bool{ true, false, false, false }, try showing(&proof, arena.allocator(), &app));
+ try proof.log.appendBounded(.{ .wait = 2 });
+ proof.t = 6.5;
+ try std.testing.expectEqual([4]bool{ true, true, false, false }, try showing(&proof, arena.allocator(), &app));
+}
+
+fn twoPauses(s: *Frame) void {
+ s.wait(2);
+ s.pause();
+ s.pause();
+}
+
+test "one click opens one gate, even when two are back to back" {
+ var d: Deck = .{};
+ step(&d, &.{}, 5, .{ .next = true }, twoPauses, .{});
+ try std.testing.expect(d.log.count() == 1 and d.waiting);
+ step(&d, &.{}, 0, .{ .next = true }, twoPauses, .{});
+ try std.testing.expect(d.log.count() == 2 and !d.waiting);
+}
+
+/// A swing of value `v` from 0 to 1 and back, in 1.5 s.
+fn swing(s: *Frame, v: Value) void {
+ s.play(.{v.to(1)}, .{ .seconds = 0.75, .ease = ease.linear });
+ s.play(.{v.to(0)}, .{ .seconds = 0.75, .ease = ease.linear });
+}
+
+fn swinging(s: *Frame) void {
+ const v = s.value(0);
+ s.wait(2);
+ s.loop(swing, .{v});
+ s.pause();
+}
+
+test "a loop repeats until the next gate opens, then finishes its cycle" {
+ var arena: std.heap.ArenaAllocator = .init(std.testing.allocator);
+ defer arena.deinit();
+ // Laid at 2: at 5.3 the third cycle is 0.3 s in.
+ var f: Frame = .{ .t = 5.3, .in = &Instant.no_input, .pointer = .{ 0, 0 }, .arena = arena.allocator() };
+ swinging(&f);
+ try std.testing.expectApproxEqAbs(@as(f32, 0.4), f.get(@fromBackingInt(0)), 1e-4);
+ // The gate opened at 6, in the third cycle (from 5): at 6.4 it is
+ // still swinging back, at 6.6 done, with no fourth.
+ const gates = [_]Gate{.{ .wait = 4 }};
+ var g: Frame = .{ .t = 6.4, .in = &Instant.no_input, .pointer = .{ 0, 0 }, .arena = arena.allocator(), .gates = &gates };
+ swinging(&g);
+ try std.testing.expectApproxEqAbs(@as(f32, 1 - 0.65 / 0.75), g.get(@fromBackingInt(0)), 1e-4);
+ var h: Frame = .{ .t = 6.6, .in = &Instant.no_input, .pointer = .{ 0, 0 }, .arena = arena.allocator(), .gates = &gates };
+ swinging(&h);
+ try std.testing.expectEqual(@as(f32, 0), h.get(@fromBackingInt(0)));
+}
+
+/// A three-step talk whose first step lasts `tempo.first`: value 0 is ten
+/// times the step shown plus how far into it.
+fn retimed(s: *Frame, tempo: anytype) void {
+ const at = s.value(0);
+ s.wait(tempo.first);
+ s.pause();
+ const one = s.cursor;
+ s.wait(1);
+ s.pause();
+ const two = s.cursor;
+ s.wait(1);
+ const v = &s.values.items[@backingInt(at)].shown;
+ if (s.t >= two) v.* = 20 + s.t - two else if (s.t >= one) v.* = 10 + s.t - one else v.* = s.t;
+}
+
+test "retiming a step above: waits plus re-anchoring keep the presenter where they were" {
+ var arena: std.heap.ArenaAllocator = .init(std.testing.allocator);
+ defer arena.deinit();
+ var tempo: struct { first: f32 } = .{ .first = 2 };
+ var d: Deck = .{};
+ // Opened after 3 s of waiting, then 4: half a second into step 2.
+ step(&d, &.{}, 5, .{ .next = true }, retimed, .{&tempo});
+ step(&d, &.{}, 5, .{ .next = true }, retimed, .{&tempo});
+ step(&d, &.{}, 0.5, .{}, retimed, .{&tempo});
+ try std.testing.expectApproxEqAbs(@as(f32, 20.5), try shown(&d, arena.allocator(), retimed, .{&tempo}), 1e-4);
+ // The first step is retimed to 5 s, and the library reloads: the same
+ // step, as far in, the log as it was.
+ tempo.first = 5;
+ step(&d, &.{}, 0, .{}, retimed, .{&tempo});
+ try std.testing.expectApproxEqAbs(@as(f32, 13.5), d.t, 1e-4);
+ try std.testing.expectApproxEqAbs(@as(f32, 20.5), try shown(&d, arena.allocator(), retimed, .{&tempo}), 1e-4);
+ try std.testing.expect(d.log.count() == 2 and d.log.buffer[0].wait == 3 and d.log.buffer[1].wait == 4);
+}
+
+/// Written in 2 s, a pause, then one more second.
+fn written(s: *Frame) void {
+ const v = s.value(0);
+ s.play(.{v.to(1)}, .{ .seconds = 2 });
+ s.pause();
+ s.play(.{v.to(2)}, .{ .seconds = 1 });
+}
+
+test "a click during a step finishes it, and the next click opens the gate (Keynote)" {
+ var arena: std.heap.ArenaAllocator = .init(std.testing.allocator);
+ defer arena.deinit();
+ var d: Deck = .{};
+ step(&d, &.{}, 1, .{}, written, .{});
+ try std.testing.expect(!d.waiting);
+ step(&d, &.{}, 0, .{ .next = true }, written, .{});
+ try std.testing.expect(d.t == 2 and d.waiting and d.log.count() == 0);
+ try std.testing.expectEqual(@as(f32, 1), try shown(&d, arena.allocator(), written, .{}));
+ // A paused deck plays on when asked for the next step.
+ d.playing = false;
+ step(&d, &.{}, 0, .{ .next = true }, written, .{});
+ try std.testing.expect(d.playing and d.log.count() == 1 and d.log.buffer[0].wait == 0);
+ // The last step, finished: the end.
+ step(&d, &.{}, 0.2, .{ .next = true }, written, .{});
+ try std.testing.expectEqual(@as(f32, 3), d.t);
+ try std.testing.expectEqual(@as(f32, 2), try shown(&d, arena.allocator(), written, .{}));
+}
+
+/// Three slides: the first holds one pause, the second two, the third none.
+fn slides(s: *Frame) void {
+ const v = s.value(0);
+ s.slide();
+ s.play(.{v.to(1)}, .{ .ease = ease.linear });
+ s.pause();
+ s.play(.{v.to(2)}, .{ .ease = ease.linear });
+ s.slide();
+ s.play(.{v.to(3)}, .{ .ease = ease.linear });
+ s.pause();
+ s.play(.{v.to(4)}, .{ .ease = ease.linear });
+ s.pause();
+ s.play(.{v.to(5)}, .{ .ease = ease.linear });
+ s.slide();
+ s.play(.{v.to(6)}, .{ .ease = ease.linear });
+}
+
+test "slides: next and previous go to each one's resting picture" {
+ var arena: std.heap.ArenaAllocator = .init(std.testing.allocator);
+ defer arena.deinit();
+ var d: Deck = .{};
+ step(&d, &.{}, 0.5, .{}, slides, .{});
+ try std.testing.expect(d.slide == 1 and d.slides == 3 and !d.waiting);
+ // Slide 2 at rest: slide 1's step done at once, held at slide 2's first pause.
+ step(&d, &.{}, 0, .{ .next_slide = true }, slides, .{});
+ try std.testing.expect(d.slide == 2 and d.t == 3 and d.log.count() == 1 and d.waiting);
+ try std.testing.expectEqual(@as(f32, 3), try shown(&d, arena.allocator(), slides, .{}));
+ // A step within it, then slide 3, which holds no pause: its end.
+ step(&d, &.{}, 0, .{ .next = true }, slides, .{});
+ try std.testing.expectEqual(@as(u32, 2), d.log.count());
+ step(&d, &.{}, 0.5, .{ .next_slide = true }, slides, .{});
+ try std.testing.expect(d.slide == 3 and d.log.count() == 3 and d.t == 6);
+ try std.testing.expectEqual(@as(f32, 6), try shown(&d, arena.allocator(), slides, .{}));
+ // Back to slide 2 at rest (its steps undone), then slide 1, then the start.
+ step(&d, &.{}, 0, .{ .back_slide = true }, slides, .{});
+ try std.testing.expect(d.slide == 2 and d.t == 3 and d.log.count() == 1 and d.waiting);
+ step(&d, &.{}, 0, .{ .back_slide = true }, slides, .{});
+ try std.testing.expect(d.slide == 1 and d.t == 1 and d.log.count() == 0 and d.waiting);
+ try std.testing.expectEqual(@as(f32, 1), try shown(&d, arena.allocator(), slides, .{}));
+ step(&d, &.{}, 0, .{ .back_slide = true }, slides, .{});
+ try std.testing.expect(d.t == 0 and d.log.count() == 0);
+ // Past the last slide: the end.
+ step(&d, &.{}, 0, .{ .end = true }, slides, .{});
+ try std.testing.expect(d.t == 6 and d.log.count() == 3 and d.slide == 3);
+}
+
+/// Slide 2 lies after a choice: it is laid once the choice is made.
+fn choosing(s: *Frame) void {
+ s.slide();
+ s.wait(1);
+ _ = s.gate(null) orelse return;
+ s.wait(1);
+ s.slide();
+ s.wait(1);
+ s.pause();
+}
+
+test "the next slide past a choice not made makes it, with 0" {
+ var d: Deck = .{};
+ step(&d, &.{}, 0, .{}, choosing, .{});
+ try std.testing.expect(d.slide == 1 and d.slides == 1);
+ step(&d, &.{}, 0, .{ .next_slide = true }, choosing, .{});
+ try std.testing.expect(d.slide == 2 and d.slides == 2 and d.t == 3 and d.waiting);
+ try std.testing.expect(d.log.count() == 1 and d.log.buffer[0].value == 0);
+}
+
+/// A button laid out before the pause it waits at, taking clicks on it.
+fn counting(s: *Frame, app: anytype) void {
+ s.wait(1);
+ const button: sk.Rect = .{ .x = -50, .y = -50, .w = 100, .h = 100 };
+ if (mutable(app)) |a| for (s.events) |e| if (e.kind == .mouse_up and button.contains(e.x, e.y)) {
+ a.n += 1;
+ s.next = false;
+ };
+ s.pause();
+}
+
+test "a click a widget takes is not the presenter's next as well" {
+ var app: struct { n: u32 = 0 } = .{};
+ var d: Deck = .{};
+ step(&d, &.{}, 2, .{}, counting, .{&app});
+ try std.testing.expect(d.waiting);
+ // On the button, at the window's center (the scene's origin): the
+ // button's. The sketch made it `next`, as it makes every click.
+ const on: sk.Event = .{ .kind = .mouse_up, .x = width / 2, .y = height / 2, .code = 1 };
+ step(&d, &.{on}, 0, .{ .next = true }, counting, .{&app});
+ try std.testing.expect(app.n == 1 and d.log.count() == 0 and d.waiting);
+ // Elsewhere: the presenter's.
+ const off: sk.Event = .{ .kind = .mouse_up, .x = 100, .y = 100, .code = 1 };
+ step(&d, &.{off}, 0, .{ .next = true }, counting, .{&app});
+ try std.testing.expect(app.n == 1 and d.log.count() == 1);
+ // Drawn, the talk gets the app read-only: nothing to write through.
+ const app_const: *const @TypeOf(app) = &app;
+ try std.testing.expect(mutable(app_const) == null);
+ try std.testing.expect(mutable(&app).? == &app);
+}
+
+fn fadeIn(s: *Frame, o: Obj) void {
+ s.play(.{o.fadeIn()}, .{ .seconds = 1 });
+}
+
+fn besideAndClear(s: *Frame) void {
+ const a = s.circle(.{ .r = 1 });
+ const b = s.circle(.{ .r = 1 });
+ s.beside(fadeIn, .{a});
+ s.play(.{b.fadeIn()}, .{ .seconds = 1 });
+ s.clear(.{ .seconds = 1 });
+}
+
+test "beside runs alongside the main line; clear fades out what shows" {
+ var arena: std.heap.ArenaAllocator = .init(std.testing.allocator);
+ defer arena.deinit();
+ const live = Live(besideAndClear, struct {});
+ const mid = try live.shot(arena.allocator(), .{ .t = 0.5 });
+ try std.testing.expectEqual(mid.poses[0], mid.poses[1]);
+ try std.testing.expect(mid.poses[0].visible and mid.poses[0].opacity > 0 and mid.poses[0].opacity < 1);
+ const out = try live.shot(arena.allocator(), .{ .t = 1.5 });
+ try std.testing.expectEqual(out.poses[0], out.poses[1]);
+ try std.testing.expect(out.poses[0].opacity < 1);
+ const gone = try live.shot(arena.allocator(), .{ .t = 2 });
+ try std.testing.expect(!gone.poses[0].visible and !gone.poses[1].visible and gone.duration == 2);
+}