diff options
| author | Gabriel Schneider <[email protected]> | 2026-11-10 11:27:39 -0300 |
|---|---|---|
| committer | Gabriel Schneider <[email protected]> | 2026-11-12 13:22:02 -0300 |
| commit | 71e534631bf68f33f802d64794340870374b9f69 (patch) | |
| tree | 2a45229ce238a4e2ce355683f0e75a7725d4851a /src/anim/root.zig | |
| parent | 00605f7a109845a99f16621b267305a8b995dddc (diff) | |
| download | sketchbook-71e534631bf68f33f802d64794340870374b9f69.tar.gz sketchbook-71e534631bf68f33f802d64794340870374b9f69.zip | |
sketchbook: anim, manim-style scenes as a module (from the game's vecanim), with objects a scene draws itself
The player takes its canvas from the room it has and fits the scene's
frame into it, plays through and quits when exported, and draws vector
objects in runs around custom ones. The renderers' resvg comparison and
the timings come along as `zig build diff` and `zig build bench`; the
comparison's reference is padded to whole blocks rather than squeezed,
which had put Typst text over the limit.
Co-Authored-By: Claude Fable 5.2 <[email protected]>
Diffstat (limited to 'src/anim/root.zig')
| -rw-r--r-- | src/anim/root.zig | 1043 |
1 files changed, 1043 insertions, 0 deletions
diff --git a/src/anim/root.zig b/src/anim/root.zig new file mode 100644 index 0000000..00e9362 --- /dev/null +++ b/src/anim/root.zig @@ -0,0 +1,1043 @@ +//! 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. +//! +//! 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`. +//! +//! **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; + +// 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)); + } + + /// 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 = &.{}, + stops: []const f32 = &.{}, + /// 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; + } + + /// 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. + 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_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].*; + 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 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; + + /// 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 .{ .objects = objects, .poses = poses, .morphs = morphs, .values = try arena.dupe(f32, &values(now.t)), .camera = view(now.t), .duration = duration, .marks = marks, .stops = 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, 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; + return struct { + pub const typst_sources: []const []const u8 = &frozen_sources; + + /// The scene at `now`, for the player: `frame`, run once. + 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 }; + } + }; +} + +/// 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. + 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, + /// 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, + stops: std.ArrayList(f32) = .empty, + + 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); + 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); + 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; + } + + /// The player holds here until a click, like a slide. + pub fn pause(s: *Frame) void { + s.push(&s.stops, s.cursor); + } + + /// `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; + } + + /// 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"); + } +}; + +// --------------------------------------------------------------------------- +// 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 }, + + const no_input: sk.Input = .{}; +}; + +/// A scene at one instant: what the player draws. +pub const Shot = struct { + 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 the player holds until a click (`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); + } +} |
