//! manim-style animation, written as code. A scene is one file, of one of //! two kinds, drawn by the same player. //! //! **Compiled** (`Scene`): `construct` runs once, at comptime, recording //! objects and plays, which become keyframes per object (a `from` pose, a //! `to` pose, a time span and an easing). The whole timeline is data before //! the first frame, and drawing an instant is a lookup and a `tween.lerp`. //! Updaters (`always`) add motion on top. //! //! pub const scene = anim.Scene(construct); //! //! fn construct(s: *anim.Builder) void { //! const title = s.typst("= Hello", .{ .y = -200 }); //! s.play(.{title.write()}, .{}); //! s.always(title, bob, .{20}); //! s.play(.{anim.camera(.{ .zoom = 1.5 })}, .{ .ease = anim.ease.outBack }); //! } //! //! fn bob(now: anim.Now, height: f32) anim.Pose { //! var p = now.pose; //! p.y += height * @sin(now.t * 3); //! return p; //! } //! //! **Live** (`Live`): `frame` runs every frame, at runtime, with the time //! and the input. The same calls add objects and play animations, but each //! `play` takes effect at once, against `s.t`, so the code after it can read //! and change what shows: updaters are plain code, and a scene can follow //! the mouse or any runtime data. Its Typst sources sit in a namespace, for //! the build to find. //! //! pub const typst = struct { //! pub const title = "= Hello"; //! }; //! pub const scene = anim.Live(frame, typst); //! //! fn frame(s: *anim.Frame) void { //! const title = s.typst(typst.title, .{ .y = -200 }); //! s.play(.{title.write()}, .{}); //! s.pause(); //! s.pose(title).x = s.pointer[0]; //! } //! //! 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` //! 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 //! the others: same camera, same pose, same animations (see `Placed`). const std = @import("std"); const sk = @import("sketch"); const vector = @import("vector"); 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; pub const teal: u32 = 0x5cd0b3; pub const green: u32 = 0x83c167; pub const yellow: u32 = 0xf7d96f; pub const gold: u32 = 0xf0ac5f; pub const red: u32 = 0xfc6255; pub const maroon: u32 = 0xc55f73; pub const purple: u32 = 0x9a72ac; pub const white: u32 = 0xece6e2; pub const background: u32 = 0x1c1c1f; /// Where an object is and how much of it shows. Every field interpolates. pub const Pose = struct { x: f32 = 0, y: f32 = 0, scale: f32 = 1, rotation: f32 = 0, opacity: f32 = 1, visible: bool = false, /// Write/create progress: 0 nothing, 1 complete. drawn: f32 = 1, reveal: Reveal = .write, /// Morph progress into `into`. morph: f32 = 0, into: u16 = none, /// Indicate's glow. highlight: f32 = 0, pub const none = std.math.maxInt(u16); pub const Reveal = enum { write, create }; }; pub const Camera = struct { x: f32 = 0, y: f32 = 0, zoom: f32 = 1, rotation: f32 = 0, }; pub const Ease = *const fn (f32) f32; pub fn Key(comptime P: type) type { return struct { start: f32, end: f32, ease: Ease, lag: f32 = 0, from: P, to: P, pub fn at(k: @This(), t: f32) P { return tween.lerp(k.from, k.to, k.ease(tween.progress(t, k.start, k.end))); } }; } // --------------------------------------------------------------------------- // Objects pub const Source = union(enum) { svg: []const u8, /// Typst source, compiled to SVG at build time. typst: []const u8, rect: struct { w: f32, h: f32, radius: f32 = 0 }, circle: struct { r: f32 }, line: struct { dx: f32, dy: f32, arrow: bool = false }, polygon: []const [2]f32, /// Drawn by the scene's own code (`custom`). custom: Custom, }; /// An object the scene draws itself with 2D commands (`f.fill`, `sk.draw`, /// `f.text`): runtime data as a table, a memory grid, a code panel. It is /// an object like the others: posed, animated and ordered among them. /// `draw` runs while the frame is painted, when the object shows /// (`visible`, `opacity` above 0); `ctx` must live until then (a live /// scene's `s.arena` does). pub const Custom = struct { draw: *const fn (ctx: *const anyopaque, f: *sk.Frame, at: Placed) void, ctx: *const anyopaque, }; /// What a custom object's `draw` gets: where it stands at this instant. pub const Placed = struct { /// Scene time, in seconds. t: f32, /// The object's pose now. `x`, `y`, `scale` and `rotation` are in `xf` /// already; `opacity` is for `draw` to honour (`pen` and `text` do), /// and so are `drawn` (0 to 1 as a `write` or `create` plays: reveal /// what you like by it) and `highlight` (`indicate`). pose: Pose, /// The object's units (its origin where the pose puts it, y down) to /// canvas pixels: the camera, then the pose. xf: sk.math.Affine, /// Canvas pixels per unit of the object: for text sizes. scale: f32, /// Scene units to canvas pixels: the camera alone. stage: sk.math.Affine, /// Every `Value` of the scene, now. values: []const f32, pub fn value(p: Placed, v: Value) f32 { return p.values[@backingInt(v)]; } /// `base` in the object's units and at its opacity, for `sk.draw`: /// `sk.draw.rect(f, r, at.pen(.{ .fill = .white }))`. pub fn pen(p: Placed, base: sk.draw.Pen) sk.draw.Pen { var out = base.transformed(p.xf); if (out.fill) |c| out.fill = p.faded(c); if (out.stroke) |c| out.stroke = p.faded(c); return out; } /// `f.text` in the object's units and at its opacity: `x, y` is the /// line's top left, scale 1 a 13-unit font. Text does not turn: a /// rotated object's text moves with it and stays level. pub fn text(p: Placed, f: *sk.Frame, x: f32, y: f32, scale: f32, bytes: []const u8, ink: sk.Color) void { const at = p.xf.apply(.{ x, y }); f.text(at[0], at[1], scale * p.scale, bytes, p.faded(ink)); } /// `text` in another face (`sk.Face`: bold or italic mono, the sans). pub fn textIn(p: Placed, f: *sk.Frame, face: sk.Face, x: f32, y: f32, scale: f32, bytes: []const u8, ink: sk.Color) void { const at = p.xf.apply(.{ x, y }); f.textIn(face, at[0], at[1], scale * p.scale, bytes, p.faded(ink)); } /// The width and line height `textIn` covers, in the object's units. pub fn textSizeIn(p: Placed, f: *sk.Frame, face: sk.Face, scale: f32, bytes: []const u8) [2]f32 { const size = f.host.textSizeIn(face, scale * p.scale, bytes); return .{ size[0] / p.scale, size[1] / p.scale }; } /// The width and line height `text` covers, in the object's units. pub fn textSize(p: Placed, f: *sk.Frame, scale: f32, bytes: []const u8) [2]f32 { const size = f.host.textSize(scale * p.scale, bytes); return .{ size[0] / p.scale, size[1] / p.scale }; } /// `ink` at the pose's opacity. pub fn faded(p: Placed, ink: sk.Color) sk.Color { return ink.alphaFloat(@as(f32, @floatFromInt(ink.a)) / 255 * p.pose.opacity); } }; pub const Object = struct { source: Source, pose: Pose, /// Styling for primitives; SVGs keep their own. fill: ?u32 = null, stroke: ?u32 = null, width: f32 = 4, /// Identifies what the object looks like (not where it is), to cache /// its drawing by. pub fn id(o: Object) u64 { var h: std.hash.Wyhash = .init(0); h.update(@tagName(o.source)); switch (o.source) { .svg, .typst => |text| h.update(text), .polygon => |points| h.update(std.mem.sliceAsBytes(points)), .rect => |r| h.update(std.mem.asBytes(&[_]f32{ r.w, r.h, r.radius })), .circle => |c| h.update(std.mem.asBytes(&c.r)), .line => |l| h.update(std.mem.asBytes(&[_]f32{ l.dx, l.dy, @floatFromInt(@intFromBool(l.arrow)) })), .custom => |c| h.update(std.mem.asBytes(&[_]usize{ @intFromPtr(c.draw), @intFromPtr(c.ctx) })), } h.update(std.mem.asBytes(&[_]u64{ o.fill orelse 1 << 32, o.stroke orelse 1 << 32 })); h.update(std.mem.asBytes(&o.width)); return h.final(); } }; /// Pose fields to animate towards; the others stay as they are. pub const Target = struct { x: ?f32 = null, y: ?f32 = null, scale: ?f32 = null, rotation: ?f32 = null, opacity: ?f32 = null, fn of(fields: anytype) Target { var t: Target = .{}; inline for (@typeInfo(@TypeOf(fields)).@"struct".field_names) |name| @field(t, name) = @field(fields, name); return t; } fn apply(t: Target, p: *Pose) void { inline for (@typeInfo(Target).@"struct".field_names) |name| if (@field(t, name)) |v| { @field(p, name) = v; }; } }; pub const CameraTarget = struct { x: ?f32 = null, y: ?f32 = null, zoom: ?f32 = null, rotation: ?f32 = null, }; /// A handle to an object added to a scene. pub const Obj = enum(u16) { _, pub fn write(o: Obj) Animation { return .{ .write = o }; } pub fn create(o: Obj) Animation { return .{ .create = o }; } pub fn fadeIn(o: Obj) Animation { return .{ .fade_in = o }; } pub fn fadeOut(o: Obj) Animation { return .{ .fade_out = o }; } /// Morphs into `other`, which takes over when done. pub fn transformInto(o: Obj, other: Obj) Animation { return .{ .transform = .{ .from = o, .to = other } }; } /// Towards any of `x`, `y`, `scale`, `rotation`, `opacity`. pub fn move(o: Obj, to: anytype) Animation { return .{ .move = .{ .obj = o, .to = .of(to) } }; } pub fn scaleTo(o: Obj, scale: f32) Animation { return .{ .move = .{ .obj = o, .to = .{ .scale = scale } } }; } /// By `radians`, from wherever it is. pub fn rotate(o: Obj, radians: f32) Animation { return .{ .rotate = .{ .obj = o, .by = radians } }; } pub fn indicate(o: Obj) Animation { return .{ .indicate = o }; } }; /// A number animated along the timeline, for updaters (or live code) to read. pub const Value = enum(u16) { _, pub fn to(v: Value, target: f32) Animation { return .{ .value = .{ .value = v, .to = target } }; } }; /// Moves the camera towards any of `x`, `y`, `zoom`, `rotation`. pub fn camera(to: anytype) Animation { var t: CameraTarget = .{}; inline for (@typeInfo(@TypeOf(to)).@"struct".field_names) |name| @field(t, name) = @field(to, name); return .{ .camera = t }; } pub const Animation = union(enum) { write: Obj, create: Obj, fade_in: Obj, fade_out: Obj, transform: struct { from: Obj, to: Obj }, move: struct { obj: Obj, to: Target }, rotate: struct { obj: Obj, by: f32 }, indicate: Obj, camera: CameraTarget, value: struct { value: Value, to: f32 }, }; /// What an updater sees each frame. pub const Now = struct { /// Scene time, in seconds. t: f32, /// The object's pose from the timeline (and earlier updaters). pose: Pose, values: []const f32, pub fn value(n: Now, v: Value) f32 { return n.values[@backingInt(v)]; } }; pub const Updater = struct { obj: Obj, /// From this time on. since: f32, update: *const fn (Now) Pose, }; // --------------------------------------------------------------------------- // Playing animations, the same for both kinds of scene const Play = struct { start: f32, seconds: f32, ease: Ease, lag: f32, animations: []const Animation, /// `play`'s options: `.seconds` (1, or 2 with a write in it), `.ease` /// (`ease.smooth`) and `.lag` (0.08). fn of(start: f32, animations: []const Animation, options: anytype) Play { const O = @TypeOf(options); var seconds: f32 = 1; for (animations) |a| if (a == .write) { seconds = 2; }; if (@hasField(O, "seconds")) seconds = options.seconds; return .{ .start = start, .seconds = seconds, .ease = if (@hasField(O, "ease")) options.ease else ease.smooth, .lag = if (@hasField(O, "lag")) options.lag else 0.08, .animations = animations, }; } fn key(p: Play, comptime P: type, from: P, to: P, with: ?Ease) Key(P) { return .{ .start = p.start, .end = p.start + p.seconds, .ease = with orelse p.ease, .lag = p.lag, .from = from, .to = to }; } }; /// Animations as an array, from a tuple or an array. fn list(animations: anytype) [count(@TypeOf(animations))]Animation { var out: [count(@TypeOf(animations))]Animation = undefined; inline for (animations, 0..) |a, i| out[i] = a; return out; } fn count(comptime T: type) usize { return switch (@typeInfo(T)) { .array => |a| a.len, else => @typeInfo(T).@"struct".field_names.len, }; } /// What a play does to one object: the pose it starts from and ends on. const Change = struct { obj: u16, from: Pose, to: Pose, ease: ?Ease = null }; /// The changes `animations`, played together, make to objects standing in /// their `settled` poses. `buf` needs two per animation. fn changes(buf: []Change, settled: []const Pose, animations: []const Animation) []Change { var n: usize = 0; for (animations) |a| switch (a) { .write, .create => |o| { const c = touch(buf, &n, settled, o); c.from.visible = true; c.from.drawn = 0; if (c.from.opacity <= 0) c.from.opacity = 1; c.from.reveal = if (a == .write) .write else .create; c.to = c.from; c.to.drawn = 1; }, .fade_in => |o| { const c = touch(buf, &n, settled, o); c.from.visible = true; c.from.drawn = 1; c.from.opacity = 0; c.to = c.from; c.to.opacity = 1; }, .fade_out => |o| { const c = touch(buf, &n, settled, o); c.to.opacity = 0; c.to.visible = false; }, .transform => |t| { const c = touch(buf, &n, settled, t.from); c.from.into = @backingInt(t.to); c.from.morph = 0; c.to = c.from; c.to.morph = 1; c.to.visible = false; const d = touch(buf, &n, settled, t.to); d.from.visible = false; d.to = d.from; d.to.visible = true; d.to.drawn = 1; d.to.opacity = 1; }, .move => |m| m.to.apply(&touch(buf, &n, settled, m.obj).to), .rotate => |r| touch(buf, &n, settled, r.obj).to.rotation += r.by, .indicate => |o| { const c = touch(buf, &n, settled, o); c.to.scale *= 1.2; c.to.highlight = 1; c.ease = ease.thereAndBack; }, .camera, .value => {}, }; return buf[0..n]; } fn touch(buf: []Change, n: *usize, settled: []const Pose, o: Obj) *Change { const i = @backingInt(o); for (buf[0..n.*]) |*c| if (c.obj == i) return c; buf[n.*] = .{ .obj = i, .from = settled[i], .to = settled[i] }; n.* += 1; return &buf[n.* - 1]; } /// Where `animations` leave a camera standing at `view`, if they move it. fn aim(view: Camera, animations: []const Animation) ?Camera { var out: ?Camera = null; for (animations) |a| if (a == .camera) { var c = out orelse view; inline for (@typeInfo(CameraTarget).@"struct".field_names) |name| if (@field(a.camera, name)) |v| { @field(c, name) = v; }; out = c; }; return out; } /// Adding objects, the same for both kinds of scene (anything with `add`). const adding = struct { /// An SVG document, placed by `at`'s fields: `x`, `y`, `scale`, /// `rotation`, `opacity`, `visible`. fn svg(s: anytype, bytes: []const u8, at: anytype) Obj { return s.add(.{ .source = .{ .svg = bytes }, .pose = tween.toward(Pose{}, at, 1) }); } /// Typst markup (after the scene's `typst_preamble`), placed like `svg`. fn typst(s: anytype, source: []const u8, at: anytype) Obj { return s.add(.{ .source = .{ .typst = source }, .pose = tween.toward(Pose{}, at, 1) }); } /// Primitives take their size, `fill`, `stroke`, `width`, and the pose /// fields, in one literal. fn rect(s: anytype, spec: anytype) Obj { return s.add(primitive(.{ .rect = .{ .w = spec.w, .h = spec.h, .radius = number(spec, "radius", 0) } }, spec)); } fn circle(s: anytype, spec: anytype) Obj { return s.add(primitive(.{ .circle = .{ .r = spec.r } }, spec)); } fn line(s: anytype, spec: anytype) Obj { return s.add(primitive(.{ .line = .{ .dx = spec.dx, .dy = spec.dy } }, spec)); } fn arrow(s: anytype, spec: anytype) Obj { return s.add(primitive(.{ .line = .{ .dx = spec.dx, .dy = spec.dy, .arrow = true } }, spec)); } /// `.points` is a slice of `[2]f32`, kept by reference. fn polygon(s: anytype, spec: anytype) Obj { return s.add(primitive(.{ .polygon = spec.points }, spec)); } /// An object drawn by `data.draw(f, placed)` (`f: *sk.Frame`, `placed: /// Placed`), placed like `svg`. `data` is a pointer, kept: in a live /// scene to something in `s.arena`, which the code after the plays may /// still change; in a compiled one to a constant. fn custom(s: anytype, data: anytype, at: anytype) Obj { const T = @typeInfo(@TypeOf(data)).pointer.child; const erased = struct { fn draw(ctx: *const anyopaque, f: *sk.Frame, placed: Placed) void { @as(*const T, @ptrCast(@alignCast(ctx))).draw(f, placed); } }; return s.add(.{ .source = .{ .custom = .{ .draw = erased.draw, .ctx = data } }, .pose = tween.toward(Pose{}, at, 1) }); } }; fn primitive(source: Source, spec: anytype) Object { var pose: Pose = .{}; inline for (.{ "x", "y", "scale", "rotation", "opacity", "visible" }) |name| { if (@hasField(@TypeOf(spec), name)) @field(pose, name) = @field(spec, name); } return .{ .source = source, .pose = pose, .fill = if (@hasField(@TypeOf(spec), "fill")) spec.fill else null, .stroke = if (@hasField(@TypeOf(spec), "stroke")) spec.stroke else null, .width = number(spec, "width", 4), }; } fn number(spec: anytype, comptime name: []const u8, default: f32) f32 { return if (@hasField(@TypeOf(spec), name)) @field(spec, name) else default; } // --------------------------------------------------------------------------- // Compiled scenes /// What `construct` receives. Every method runs at comptime. pub const Builder = struct { objects: []const Object = &.{}, values: []const f32 = &.{}, plays: []const Play = &.{}, updaters: []const Updater = &.{}, /// Where the next play starts. cursor: f32 = 0, pub fn add(b: *Builder, o: Object) Obj { b.objects = b.objects ++ .{o}; return @fromBackingInt(@intCast(b.objects.len - 1)); } pub const svg = adding.svg; pub const typst = adding.typst; pub const rect = adding.rect; pub const circle = adding.circle; pub const line = adding.line; pub const arrow = adding.arrow; pub const polygon = adding.polygon; pub const custom = adding.custom; pub fn value(b: *Builder, initial: f32) Value { b.values = b.values ++ .{initial}; return @fromBackingInt(@intCast(b.values.len - 1)); } /// Runs `animations` (a tuple or an array) together, then moves time /// past them. pub fn play(b: *Builder, animations: anytype, options: anytype) void { const all = list(animations); const p = Play.of(b.cursor, &all, options); b.plays = b.plays ++ .{p}; b.cursor += p.seconds; } pub fn wait(b: *Builder, seconds: f32) void { b.cursor += seconds; } /// 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. pub fn always(b: *Builder, o: Obj, comptime update: anytype, comptime args: anytype) void { const bound = struct { fn call(now: Now) Pose { return @call(.auto, update, .{now} ++ args); } }; b.updaters = b.updaters ++ .{Updater{ .obj = o, .since = b.cursor, .update = bound.call }}; } }; /// Runs `construct` at comptime and compiles what it recorded. pub fn Scene(comptime construct: fn (*Builder) void) type { @setEvalBranchQuota(10_000_000); const recorded = comptime blk: { var b: Builder = .{}; construct(&b); break :blk b; }; const n = recorded.objects.len; // Play the timeline once, at comptime, recording keyframes. const compiled = comptime blk: { var poses: [n]Pose = undefined; for (&poses, recorded.objects) |*p, o| p.* = o.pose; var values: [recorded.values.len]f32 = recorded.values[0..recorded.values.len].*; var view: Camera = .{}; var keys: [n][]const Key(Pose) = @splat(&.{}); var value_keys: [recorded.values.len][]const Key(f32) = @splat(&.{}); var camera_keys: []const Key(Camera) = &.{}; var marks: []const f32 = &.{}; for (recorded.plays) |play| { var buf: [2 * play.animations.len]Change = undefined; for (changes(&buf, &poses, play.animations)) |c| { const k = play.key(Pose, c.from, c.to, c.ease); keys[c.obj] = keys[c.obj] ++ .{k}; poses[c.obj] = k.at(k.end); } for (play.animations) |a| if (a == .value) { const i = @backingInt(a.value.value); value_keys[i] = value_keys[i] ++ .{play.key(f32, values[i], a.value.to, null)}; values[i] = a.value.to; }; if (aim(view, play.animations)) |to| { camera_keys = camera_keys ++ .{play.key(Camera, view, to, null)}; view = to; } marks = marks ++ .{play.start}; } break :blk .{ .keys = keys, .value_keys = value_keys, .camera_keys = camera_keys, .marks = marks }; }; 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_keys = compiled.keys; const frozen_value_keys = compiled.value_keys; const frozen_camera_keys = compiled.camera_keys[0..compiled.camera_keys.len].*; const frozen_marks = compiled.marks[0..compiled.marks.len].*; const typst_list = comptime blk: { var out: []const []const u8 = &.{}; for (recorded.objects) |o| if (o.source == .typst) { out = out ++ .{o.source.typst}; }; break :blk out[0..out.len].*; }; return struct { pub const objects: []const Object = &frozen_objects; pub const initial_values: []const f32 = &frozen_values; pub const updaters: []const Updater = &frozen_updaters; pub const keys: [n][]const Key(Pose) = frozen_keys; pub const value_keys = frozen_value_keys; 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 duration: f32 = recorded.cursor; /// Every Typst source, for the build step that compiles them. pub const typst_sources: []const []const u8 = &typst_list; /// The scene at `now`, for the player. pub fn shot(arena: std.mem.Allocator, now: Instant) !Shot { const poses = try arena.alloc(Pose, n); const morphs = try arena.alloc(Morph, n); for (poses, morphs, 0..) |*p, *m, i| { p.* = pose(i, now.t); if (p.into != Pose.none) if (key(i, now.t)) |k| { m.* = .{ .from = k.from, .to = pose(p.into, k.end) }; }; } 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. pub fn key(i: usize, t: f32) ?Key(Pose) { return latest(Pose, keys[i], t); } /// Every value at `t`. pub fn values(t: f32) [frozen_values.len]f32 { var out = frozen_values; for (&out, value_keys) |*v, own| if (latest(f32, own, t)) |k| { v.* = k.at(t); }; return out; } /// Where object `i` is at `t`: the timeline, then its updaters. pub fn pose(i: usize, t: f32) Pose { var p = if (key(i, t)) |k| k.at(t) else objects[i].pose; if (updaters.len > 0) { const now_values = values(t); for (updaters) |u| if (@backingInt(u.obj) == i and t >= u.since) { p = u.update(.{ .t = t, .pose = p, .values = &now_values }); }; } return p; } /// The camera at `t`. pub fn view(t: f32) Camera { return if (latest(Camera, camera_keys, t)) |k| k.at(t) else .{}; } }; } fn latest(comptime P: type, keys: []const Key(P), t: f32) ?Key(P) { var found: ?Key(P) = null; for (keys) |k| { if (k.start > t) break; found = k; } return found; } /// The drawing of an object, centered on its origin, in pixels at scale 1. /// `compiled` has `find(source) ?[]const u8` for Typst objects' SVGs. pub fn build(arena: std.mem.Allocator, o: Object, compiled: anytype) !Drawing { const document: ?[]const u8 = switch (o.source) { .svg => |bytes| bytes, .typst => |source| compiled.find(source) orelse return error.TypstNotCompiled, .custom => return error.CustomHasNoDrawing, else => null, }; if (document) |bytes| { { const d = try vector.svg.parse(arena, bytes); // Keep the SVG's pixel size (Typst's points are 4/3 px), centered. const s = if (d.view.w > 0) d.width / d.view.w else 1; const c = d.view.center(); const shapes = try arena.dupe(Drawing.Shape, d.shapes); for (shapes) |*shape| shape.transform = vector.geom.Affine.scale(s, s).mul(.translate(-c[0], -c[1])).mul(shape.transform); var out = d; out.shapes = shapes; out.view = .{ .x = -d.view.w * s / 2, .y = -d.view.h * s / 2, .w = d.view.w * s, .h = d.view.h * s }; return out; } } var b: Drawing.Builder = .init(arena); var style: Drawing.Style = .{ .fill = if (o.fill) |c| .{ .color = color(c) } else .none, .stroke = if (o.stroke) |c| .{ .color = color(c) } else .none, .stroke_width = o.width, .cap = .round, .join = .round, }; switch (o.source) { .rect => |r| try b.rect(.{ .x = -r.w / 2, .y = -r.h / 2, .w = r.w, .h = r.h }, r.radius), .circle => |c| try b.ellipse(.{ 0, 0 }, c.r, c.r), .polygon => |pts| { var points: [64]vector.geom.Vec = undefined; for (pts[0..@min(pts.len, 64)], 0..) |p, i| points[i] = p; try b.polyline(points[0..@min(pts.len, 64)], true); }, .line => |l| { const a: vector.geom.Vec = .{ -l.dx / 2, -l.dy / 2 }; const z: vector.geom.Vec = .{ l.dx / 2, l.dy / 2 }; try b.lineTo(a, z); try b.closeSubpath(false); if (l.arrow) { try b.endShape(.identity, style); // The head, filled in the stroke color. const dir = vector.geom.normalize(z - a); const n = vector.geom.perp(dir); const head = @max(o.width * 3, 12); const back = z - dir * vector.geom.splat(head); try b.polyline(&.{ z + dir * vector.geom.splat(o.width), back + n * vector.geom.splat(head / 2), back - n * vector.geom.splat(head / 2) }, true); style.fill = style.stroke; style.stroke = .none; } }, .svg, .typst, .custom => unreachable, } try b.endShape(.identity, style); const r = @max(extent(o.source), 1); return b.finish(.{ .x = -r, .y = -r, .w = 2 * r, .h = 2 * r }, 2 * r, 2 * r); } fn extent(s: Source) f32 { return switch (s) { .rect => |r| @max(r.w, r.h) / 2, .circle => |c| c.r, .line => |l| @max(@abs(l.dx), @abs(l.dy)) / 2, .polygon => |pts| blk: { var m: f32 = 0; for (pts) |p| m = @max(m, @max(@abs(p[0]), @abs(p[1]))); break :blk m; }, .svg, .typst, .custom => 0, }; } /// `0xRRGGBB`, or `0xRRGGBBAA` when above 24 bits. pub fn color(c: u32) Drawing.Color { const rgba: u32 = if (c > 0xffffff) c else (c << 8) | 0xff; return .{ @as(f32, @floatFromInt(rgba >> 24)) / 255, @as(f32, @floatFromInt((rgba >> 16) & 0xff)) / 255, @as(f32, @floatFromInt((rgba >> 8) & 0xff)) / 255, @as(f32, @floatFromInt(rgba & 0xff)) / 255, }; } // --------------------------------------------------------------------------- // Live scenes /// 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, 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 frame = frame_fn; pub const typst_sources: []const []const u8 = sources(typst); /// 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, .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. In a talk it runs on through gates. t: 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, /// Each object's pose after every play so far, and as it shows at `t`. settled: std.ArrayList(Pose) = .empty, shown: std.ArrayList(Pose) = .empty, morphs: std.ArrayList(Morph) = .empty, values: std.ArrayList(struct { settled: f32, shown: f32 }) = .empty, 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); s.push(&s.settled, o.pose); s.push(&s.shown, o.pose); s.push(&s.morphs, undefined); return @fromBackingInt(@intCast(s.objects.items.len - 1)); } pub const svg = adding.svg; pub const typst = adding.typst; pub const rect = adding.rect; pub const circle = adding.circle; pub const line = adding.line; pub const arrow = adding.arrow; pub const polygon = adding.polygon; pub const custom = adding.custom; pub fn value(s: *Frame, initial: f32) Value { s.push(&s.values, .{ .settled = initial, .shown = initial }); return @fromBackingInt(@intCast(s.values.items.len - 1)); } /// Value `v` at `t`. pub fn get(s: *const Frame, v: Value) f32 { return s.values.items[@backingInt(v)].shown; } /// How `o` shows at `t`, to change in place. Code runs in order: a later /// play that has started by `t` sets it again. pub fn pose(s: *Frame, o: Obj) *Pose { return &s.shown.items[@backingInt(o)]; } /// The camera at `t`, to change in place, like `pose`. pub fn camera(s: *Frame) *Camera { return &s.view; } /// Runs `animations` (a tuple or an array) together from the cursor, as /// they stand at `t`, then moves the cursor past them. pub fn play(s: *Frame, animations: anytype, options: anytype) void { const all = list(animations); var buf: [2 * all.len]Change = undefined; 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); if (started) s.shown.items[c.obj] = k.at(s.t); } // A morph ends where its target settles. if (started) for (touched) |c| if (c.from.into != Pose.none) { s.morphs.items[c.obj] = .{ .from = c.from, .to = s.settled.items[c.from.into] }; }; for (all) |a| if (a == .value) { const v = &s.values.items[@backingInt(a.value.value)]; const k = p.key(f32, v.settled, a.value.to, null); v.settled = a.value.to; if (started) v.shown = k.at(s.t); }; 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); } s.push(&s.marks, p.start); s.cursor += p.seconds; } pub fn wait(s: *Frame, seconds: f32) void { s.cursor += seconds; } /// 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 /// object draws. pub fn new(s: *Frame, data: anytype) *@TypeOf(data) { const kept = s.arena.create(@TypeOf(data)) catch @panic("anim: out of memory"); kept.* = data; 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 { items.append(s.arena, item) catch @panic("anim: out of memory"); } }; // --------------------------------------------------------------------------- // 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, in: *const sk.Input = &no_input, pointer: [2]f32 = .{ 0, 0 }, const no_input: sk.Input = .{}; }; /// 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 /// from, and where its target ends up. morphs: []const Morph, /// Every `Value`, by handle. values: []const f32, camera: Camera, duration: f32, /// Start times of every play, for chapter-style seeking. marks: []const f32, /// Where each gate is laid (`gate`, `pause`). stops: []const f32, }; pub const Morph = struct { from: Pose, to: Pose }; // --------------------------------------------------------------------------- fn testScene(s: *Builder) void { const a = s.circle(.{ .r = 10, .fill = blue }); const b = s.rect(.{ .w = 20, .h = 20, .x = 100 }); const k = s.value(0); s.play(.{a.create()}, .{}); s.wait(0.5); s.play(.{ a.move(.{ .x = 50 }), camera(.{ .zoom = 2 }), k.to(10) }, .{ .seconds = 2 }); s.always(b, follow, .{k}); s.play(.{a.transformInto(b)}, .{}); } fn follow(now: Now, k: Value) Pose { var p = now.pose; p.y = now.value(k); return p; } test "construct records a timeline that compiles to settling keyframes" { const S = Scene(testScene); try std.testing.expectEqual(@as(f32, 4.5), S.duration); try std.testing.expectEqual(@as(f32, 1), S.pose(0, 1).drawn); try std.testing.expectApproxEqAbs(@as(f32, 25), S.pose(0, 2.5).x, 1e-3); try std.testing.expectEqual(@as(f32, 2), S.view(10).zoom); try std.testing.expectApproxEqAbs(@as(f32, 5), S.values(2.5)[0], 1e-3); // The updater only runs from where it was added. try std.testing.expectEqual(@as(f32, 0), S.pose(1, 1).y); try std.testing.expectEqual(@as(f32, 10), S.pose(1, 4).y); const mid = S.pose(0, 4.0); try std.testing.expect(mid.visible and mid.morph > 0 and mid.into == 1); try std.testing.expect(!S.pose(0, 4.5).visible); try std.testing.expect(S.pose(1, 4.5).visible); try std.testing.expectEqual(@as(usize, 3), S.marks.len); } /// `testScene`, live: the updater is a line of code after the plays. fn liveScene(s: *Frame) void { const a = s.circle(.{ .r = 10, .fill = blue }); const b = s.rect(.{ .w = 20, .h = 20, .x = 100 }); const k = s.value(0); s.play(.{a.create()}, .{}); s.wait(0.5); s.play(.{ a.move(.{ .x = 50 }), camera(.{ .zoom = 2 }), k.to(10) }, .{ .seconds = 2 }); const since = s.cursor; s.play(.{a.transformInto(b)}, .{}); if (s.t >= since) s.pose(b).y = s.get(k); } test "a live scene shows what the compiled one does, at every instant" { var arena: std.heap.ArenaAllocator = .init(std.testing.allocator); defer arena.deinit(); const compiled = Scene(testScene); const live = Live(liveScene, struct {}); for ([_]f32{ 0, 0.5, 1, 1.7, 2.5, 3.5, 4, 4.5, 9 }) |t| { const a = try compiled.shot(arena.allocator(), .{ .t = t }); const b = try live.shot(arena.allocator(), .{ .t = t }); try std.testing.expectEqualSlices(Pose, a.poses, b.poses); try std.testing.expectEqualSlices(f32, a.values, b.values); try std.testing.expectEqual(a.camera, b.camera); try std.testing.expectEqual(a.duration, b.duration); 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); }