summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
authorGabriel Schneider <[email protected]>2026-11-16 22:53:41 -0300
committerGabriel Schneider <[email protected]>2026-11-17 12:15:01 -0300
commit0c10f9668b3ef67ce1eb83db435aaa94b35df012 (patch)
treeeec8d966b75a3fcd6b7972b1a7b81b2163034cc1 /src
parent64a816dbe194c05e089729ac1fdc15061afdd903 (diff)
downloadsketchbook-0c10f9668b3ef67ce1eb83db435aaa94b35df012.tar.gz
sketchbook-0c10f9668b3ef67ce1eb83db435aaa94b35df012.zip
anim: the player's render path moves into anim.Painter
render, paint, reveal, built, stage, guides and labels move verbatim from player.zig into src/anim/Painter.zig, with the viewer's settings and the Typst module as parameters, so a sketch that runs a Deck itself paints its shot the same way: a Painter in its Session and paint() once a frame. The scene's frame size is anim.width/height and a Shot carries its t. Pixels unchanged: the scene tests' screenshots and all 92 exported frames match the previous build's.
Diffstat (limited to 'src')
-rw-r--r--src/anim/Painter.zig256
-rw-r--r--src/anim/player.zig242
-rw-r--r--src/anim/root.zig1
3 files changed, 264 insertions, 235 deletions
diff --git a/src/anim/Painter.zig b/src/anim/Painter.zig
new file mode 100644
index 0000000..b5d492f
--- /dev/null
+++ b/src/anim/Painter.zig
@@ -0,0 +1,256 @@
+//! Draws a scene's `Shot` with the vector library, on the GPU (or the CPU),
+//! the scene's frame fitted into the canvas, and the canvas the room the
+//! host has: the window, or an export's `--size`. The player paints with
+//! one, and so does a sketch that runs a `Deck` itself: a `Painter` in its
+//! Session, and `paint` once a frame.
+const std = @import("std");
+const sk = @import("sketch");
+const vector = @import("vector");
+const anim = @import("root.zig");
+const geom = vector.geom;
+
+const Painter = @This();
+
+/// A renderer per run of vector objects between custom ones (`paint`).
+gpu: std.ArrayList(vector.Renderer(.gpu)) = .empty,
+cpu: std.ArrayList(vector.Renderer(.cpu)) = .empty,
+/// Drawings by what they look like (`Object.id`), built on first use and
+/// dropped on reload, since the code that builds them may have changed.
+/// Their memory is the host's, kept across reloads.
+arena: ?std.heap.ArenaAllocator = null,
+drawings: std.AutoHashMapUnmanaged(u64, Built) = .empty,
+/// Shapes drawn in the last frame.
+shapes: usize = 0,
+
+pub const Options = struct {
+ /// The viewer's own pan and zoom, on top of the scene's camera.
+ view: sk.Camera = .{},
+ backend: vector.Backend = .gpu,
+ /// Boxes, origins and axes, in scene units, with their numbers.
+ guides: bool = false,
+ /// The page (0xRRGGBB).
+ background: u32 = anim.background,
+};
+
+const Built = struct { drawing: vector.Drawing, bounds: geom.Rect };
+
+/// Sets the canvas to the window and draws `shot` on it. `svgs` has
+/// `find(source) ?[]const u8` for its Typst objects (`sb.addTypst`).
+pub fn paint(p: *Painter, f: *sk.Frame, shot: anim.Shot, svgs: anytype, options: Options) !void {
+ // All the room there is: the window, or the size an export asks for.
+ const canvas: sk.Rect = .{ .w = @max(@floor(f.in.window_width), 1), .h = @max(@floor(f.in.window_height), 1) };
+ f.canvas(@intFromFloat(canvas.w), @intFromFloat(canvas.h));
+ if (p.arena == null) p.arena = .init(f.session);
+ // A live scene may make new drawings every frame: start over now and then.
+ if (f.in.reloaded or p.drawings.count() > 1024) {
+ _ = p.arena.?.reset(.retain_capacity);
+ p.drawings = .empty;
+ }
+ // Use the host's GPU when it has one.
+ if (options.backend == .gpu and f.host.gpu()) try p.paintLayers(&p.gpu, f, shot, svgs, canvas, options) else try p.paintLayers(&p.cpu, f, shot, svgs, canvas, options);
+}
+
+/// Canvas pixels per scene unit: the scene's frame, fitted into `canvas`.
+pub fn fit(canvas: sk.Rect) f32 {
+ return @min(canvas.w / anim.width, canvas.h / anim.height);
+}
+
+/// Object `o`'s drawing, centered on its origin, and its bounds.
+fn built(p: *Painter, o: anim.Object, svgs: anytype) !Built {
+ const id = o.id();
+ if (p.drawings.get(id)) |b| return b;
+ const arena = p.arena.?.allocator();
+ const d = try anim.build(arena, o, svgs);
+ const b: Built = .{ .drawing = d, .bounds = d.bounds().rect() };
+ try p.drawings.put(arena, id, b);
+ return b;
+}
+
+/// Scene units to canvas pixels: the scene's camera, then the viewer's.
+/// The scene's origin is the canvas center.
+fn stage(view: sk.Camera, cam: anim.Camera, canvas: sk.Rect) geom.Affine {
+ const k = fit(canvas) * cam.zoom;
+ return geom.Affine.translate(view.x, view.y)
+ .mul(.scale(view.zoom, view.zoom))
+ .mul(.translate(canvas.w / 2, canvas.h / 2))
+ .mul(.scale(k, k))
+ .mul(.rotate(-cam.rotation))
+ .mul(.translate(-cam.x, -cam.y));
+}
+
+/// The next of `layers`, begun: a renderer the size of the canvas.
+fn begun(layers: anytype, used: *usize, f: *sk.Frame, canvas: sk.Rect, clear: vector.Drawing.Color) !*@TypeOf(layers.items[0]) {
+ if (used.* == layers.items.len) try layers.append(f.session, try .init(f.session, f.host, @intFromFloat(canvas.w), @intFromFloat(canvas.h)));
+ const r = &layers.items[used.*];
+ used.* += 1;
+ r.begin(f, clear);
+ return r;
+}
+
+/// Draws `shot` with the renderers in `layers` (either backend), objects
+/// in the order they were added. Vector objects go into a renderer's image,
+/// which is then drawn on the canvas; a custom object draws on the canvas
+/// itself. So the vector objects before a custom one and those after it
+/// are separate images, one renderer each: every GPU pass of a frame runs
+/// before its first 2D command, and one image could only show the last.
+fn paintLayers(p: *Painter, layers: anytype, f: *sk.Frame, shot: anim.Shot, svgs: anytype, canvas: sk.Rect, options: Options) !void {
+ if (layers.items.len > 0 and (layers.items[0].width() != @as(u32, @intFromFloat(canvas.w)) or layers.items[0].height() != @as(u32, @intFromFloat(canvas.h)))) {
+ for (layers.items) |*r| r.deinit(f.host);
+ layers.clearRetainingCapacity();
+ }
+ const world = stage(options.view, shot.camera, canvas);
+ var used: usize = 0;
+ // The first layer is the background too.
+ var open: ?*@TypeOf(layers.items[0]) = try begun(layers, &used, f, canvas, anim.color(options.background));
+ var shapes: usize = 0;
+ for (shot.objects, shot.poses, 0..) |o, pose, i| {
+ if (!pose.visible or pose.opacity <= 0) continue;
+ const m = world.mul(model(pose));
+ if (o.source == .custom) {
+ if (open) |r| r.present(f, canvas);
+ open = null;
+ o.source.custom.draw(o.source.custom.ctx, f, .{ .t = shot.t, .pose = pose, .xf = m, .scale = m.scaleFactor(), .stage = world, .values = shot.values });
+ // It leaves no target, clip or blend behind.
+ f.target(.none);
+ f.blend(.alpha);
+ continue;
+ }
+ const r = open orelse try begun(layers, &used, f, canvas, .{ 0, 0, 0, 0 });
+ open = r;
+ const d = (try p.built(o, svgs)).drawing;
+ if (pose.into != anim.Pose.none and pose.morph > 0 and pose.morph < 1 and shot.objects[pose.into].source != .custom) {
+ // Morphing: from where this object began the transform to where
+ // its target will stand.
+ const morph = shot.morphs[i];
+ const target = (try p.built(shot.objects[pose.into], svgs)).drawing;
+ const between = try vector.morph.between(f.scratch, d, world.mul(model(morph.from)), target, world.mul(model(morph.to)), pose.morph);
+ try r.draw(between, .identity, pose.opacity);
+ shapes += between.shapes.len;
+ continue;
+ }
+ try reveal(r, d, m, pose, fit(canvas));
+ shapes += d.shapes.len;
+ }
+ if (options.guides) {
+ const r = open orelse try begun(layers, &used, f, canvas, .{ 0, 0, 0, 0 });
+ open = r;
+ try r.draw(try p.guides(f.scratch, shot, svgs, world, canvas), .identity, 1);
+ }
+ if (open) |r| r.present(f, canvas);
+ p.shapes = shapes;
+ if (options.guides) try p.labels(f, shot, svgs, world);
+}
+
+fn model(p: anim.Pose) geom.Affine {
+ return geom.Affine.translate(p.x, p.y).mul(.rotate(p.rotation)).mul(.scale(p.scale, p.scale));
+}
+
+/// manim's reveals, shape by shape with a stagger: Write traces each outline
+/// then fills it; Create draws strokes along their length, then fills.
+/// Outlines are `k` canvas pixels to the scene unit wide.
+fn reveal(r: anytype, d: vector.Drawing, m: geom.Affine, pose: anim.Pose, k: f32) !void {
+ const n: f32 = @floatFromInt(d.shapes.len);
+ const lag: f32 = if (pose.drawn >= 1) 0 else 0.08;
+ const window = 1 / (1 + lag * @max(n - 1, 0));
+ const glow = pose.highlight;
+ for (d.shapes, 0..) |shape, i| {
+ const local = std.math.clamp((pose.drawn - @as(f32, @floatFromInt(i)) * lag * window) / window, 0, 1);
+ if (local <= 0) continue;
+ var o: vector.Options = .{ .alpha = pose.opacity };
+ switch (pose.reveal) {
+ .write => if (local < 1) {
+ o.trim = @min(local * 2, 1);
+ o.outline = .{ .width = 1.5 * k, .alpha = 1 - std.math.clamp(local * 2 - 1, 0, 1) };
+ o.stroke = false;
+ // Fill arrives in the second half.
+ var fill = o;
+ fill.outline = null;
+ fill.alpha = pose.opacity * std.math.clamp(local * 2 - 1, 0, 1);
+ try r.drawShape(d, shape, m, fill);
+ o.fill = false;
+ },
+ .create => if (local < 1) {
+ o.trim = local;
+ if (shape.style.stroke == .none) o.outline = .{ .width = 2 * k };
+ var fill = o;
+ fill.stroke = false;
+ fill.outline = null;
+ fill.alpha = pose.opacity * std.math.clamp(local * 3 - 2, 0, 1);
+ try r.drawShape(d, shape, m, fill);
+ o.fill = false;
+ },
+ }
+ try r.drawShape(d, shape, m, o);
+ if (glow > 0) {
+ // Indicate: a yellow glow over the shape.
+ var hot = shape;
+ hot.style.fill = if (shape.style.fill != .none) .{ .color = anim.color(anim.yellow) } else .none;
+ hot.style.stroke = if (shape.style.stroke != .none) .{ .color = anim.color(anim.yellow) } else .none;
+ try r.drawShape(d, hot, m, .{ .alpha = pose.opacity * glow });
+ }
+ }
+}
+
+/// Spacing of the guides' ticks, in scene units.
+const tick = 100;
+
+fn guideStyle(c: u32, w: f32) vector.Drawing.Style {
+ return .{ .fill = .none, .stroke = .{ .color = anim.color(c) }, .stroke_width = w };
+}
+
+/// The scene's axes with ticks, and each visible object's bounding box (a
+/// custom object has none) and origin, in canvas pixels.
+fn guides(p: *Painter, arena: std.mem.Allocator, shot: anim.Shot, svgs: anytype, world: geom.Affine, canvas: sk.Rect) !vector.Drawing {
+ var b: vector.Drawing.Builder = .init(arena);
+ const far = 100 * tick;
+ try b.lineTo(world.apply(.{ -far, 0 }), world.apply(.{ far, 0 }));
+ try b.closeSubpath(false);
+ try b.endShape(.identity, guideStyle(anim.red, 1.5));
+ try b.lineTo(world.apply(.{ 0, -far }), world.apply(.{ 0, far }));
+ try b.closeSubpath(false);
+ try b.endShape(.identity, guideStyle(anim.green, 1.5));
+ var i: f32 = -20;
+ while (i <= 20) : (i += 1) {
+ const x = world.apply(.{ i * tick, 0 });
+ const y = world.apply(.{ 0, i * tick });
+ try b.lineTo(x - geom.Vec{ 0, 5 }, x + geom.Vec{ 0, 5 });
+ try b.closeSubpath(false);
+ try b.lineTo(y - geom.Vec{ 5, 0 }, y + geom.Vec{ 5, 0 });
+ try b.closeSubpath(false);
+ }
+ try b.endShape(.identity, guideStyle(0x8c8c8c, 1));
+
+ for (shot.objects, shot.poses) |o, pose| {
+ if (!pose.visible or pose.opacity <= 0) continue;
+ const m = world.mul(model(pose));
+ if (o.source != .custom) {
+ const r = (try p.built(o, svgs)).bounds;
+ try b.polyline(&.{ m.apply(.{ r.x, r.y }), m.apply(.{ r.x + r.w, r.y }), m.apply(.{ r.x + r.w, r.y + r.h }), m.apply(.{ r.x, r.y + r.h }) }, true);
+ }
+ // The object's origin: where its pose puts it.
+ const c = m.apply(.{ 0, 0 });
+ try b.lineTo(c - geom.Vec{ 6, 0 }, c + geom.Vec{ 6, 0 });
+ try b.closeSubpath(false);
+ try b.lineTo(c - geom.Vec{ 0, 6 }, c + geom.Vec{ 0, 6 });
+ try b.closeSubpath(false);
+ }
+ try b.endShape(.identity, guideStyle(anim.yellow, 1));
+ return b.finish(.{ .w = canvas.w, .h = canvas.h }, canvas.w, canvas.h);
+}
+
+/// The guides' numbers: tick values, and each object's index and position.
+fn labels(p: *Painter, f: *sk.Frame, shot: anim.Shot, svgs: anytype, world: geom.Affine) !void {
+ var i: f32 = -20;
+ while (i <= 20) : (i += 2) {
+ const x = world.apply(.{ i * tick, 0 });
+ const y = world.apply(.{ 0, i * tick });
+ f.print(x[0] + 3, x[1] + 8, 1, 0x8c8c8c, "{d}", .{i * tick});
+ if (i != 0) f.print(y[0] + 8, y[1] - 3, 1, 0x8c8c8c, "{d}", .{i * tick});
+ }
+ for (shot.objects, shot.poses, 0..) |o, pose, n| {
+ if (!pose.visible or pose.opacity <= 0) continue;
+ const r: geom.Rect = if (o.source == .custom) .{} else (try p.built(o, svgs)).bounds;
+ const corner = world.mul(model(pose)).apply(.{ r.x, r.y });
+ f.print(corner[0], corner[1] - 11, 1, anim.yellow, "#{d} {d:.0},{d:.0}", .{ n, pose.x, pose.y });
+ }
+}
diff --git a/src/anim/player.zig b/src/anim/player.zig
index 9d29e95..c9f2169 100644
--- a/src/anim/player.zig
+++ b/src/anim/player.zig
@@ -23,14 +23,13 @@ const scene_file = @import("scene");
const scene = scene_file.scene;
/// The scene's Typst sources, compiled at build time.
const typst = @import("typst");
-const geom = vector.geom;
pub const name = if (@hasDecl(scene_file, "name")) scene_file.name else "anim";
/// The page: the scene file's `background` (0xRRGGBB), or manim's.
const background: u32 = if (@hasDecl(scene_file, "background")) scene_file.background else anim.background;
/// The scene's frame, in scene units: what shows at camera zoom 1.
-pub const width = 1280;
-pub const height = 720;
+pub const width = anim.width;
+pub const height = anim.height;
pub const State = struct {
t: f32 = 0,
@@ -47,21 +46,11 @@ pub const State = struct {
};
pub const Session = struct {
- /// A renderer per run of vector objects between custom ones (`paint`).
- gpu: std.ArrayList(vector.Renderer(.gpu)) = .empty,
- cpu: std.ArrayList(vector.Renderer(.cpu)) = .empty,
- /// Drawings by what they look like (`Object.id`), built on first use and
- /// dropped on reload, since the code that builds them may have changed.
- /// Their memory is the host's, kept across reloads.
- arena: ?std.heap.ArenaAllocator = null,
- drawings: std.AutoHashMapUnmanaged(u64, Built) = .empty,
- /// Smoothed time to record a frame, and its shape count.
+ painter: anim.Painter = .{},
+ /// Smoothed time to record a frame.
render_ns: f32 = 0,
- shapes: usize = 0,
};
-const Built = struct { drawing: vector.Drawing, bounds: geom.Rect };
-
pub fn update(s: *State, in: *const sk.Input) void {
// The timeline as it stands: a live scene builds it as it runs.
var arena: std.heap.ArenaAllocator = .init(std.heap.page_allocator);
@@ -145,29 +134,23 @@ fn nextMark(t: f32, shot: anim.Shot) f32 {
return shot.duration;
}
-/// Canvas pixels per scene unit: the scene's frame, fitted into `canvas`.
-fn fit(canvas: sk.Rect) f32 {
- return @min(canvas.w / width, canvas.h / height);
-}
-
/// The mouse in scene units from the canvas center, before the scene's
/// camera: the viewer's pan and zoom undone.
fn pointer(s: *const State, in: *const sk.Input, canvas: sk.Rect) [2]f32 {
- const k = fit(canvas);
+ const k = anim.Painter.fit(canvas);
return .{ ((in.mouse_x - s.view.x) / s.view.zoom - canvas.w / 2) / k, ((in.mouse_y - s.view.y) / s.view.zoom - canvas.h / 2) / k };
}
pub fn draw(s: *const State, ss: *Session, f: *sk.Frame) void {
// All the room there is: the window, or the size an export asks for.
const canvas: sk.Rect = .{ .w = @max(@floor(f.in.window_width), 1), .h = @max(@floor(f.in.window_height), 1) };
- f.canvas(@intFromFloat(canvas.w), @intFromFloat(canvas.h));
const started = f.host.clock();
const shot = scene.shot(f.scratch, .{
.t = s.t,
.in = f.in,
.pointer = pointer(s, f.in, canvas),
}) catch |err| return f.host.print("scene: {t}", .{err});
- render(s, ss, f, shot, canvas) catch |err| f.host.print("render: {t}", .{err});
+ ss.painter.paint(f, shot, typst, .{ .view = s.view, .backend = s.backend, .guides = s.guides, .background = background }) catch |err| f.host.print("render: {t}", .{err});
if (f.in.exporting) {
// The frame that shows the end is the last.
if (s.t >= shot.duration) f.quit();
@@ -178,217 +161,6 @@ pub fn draw(s: *const State, ss: *Session, f: *sk.Frame) void {
hud(s, ss, f, shot, canvas);
}
-fn render(s: *const State, ss: *Session, f: *sk.Frame, shot: anim.Shot, canvas: sk.Rect) !void {
- if (ss.arena == null) ss.arena = .init(f.session);
- // A live scene may make new drawings every frame: start over now and then.
- if (f.in.reloaded or ss.drawings.count() > 1024) {
- _ = ss.arena.?.reset(.retain_capacity);
- ss.drawings = .empty;
- }
- // Use the host's GPU when it has one.
- if (s.backend == .gpu and f.host.gpu()) try paint(s, ss, &ss.gpu, f, shot, canvas) else try paint(s, ss, &ss.cpu, f, shot, canvas);
-}
-
-/// Object `o`'s drawing, centered on its origin, and its bounds.
-fn built(ss: *Session, o: anim.Object) !Built {
- const id = o.id();
- if (ss.drawings.get(id)) |b| return b;
- const arena = ss.arena.?.allocator();
- const d = try anim.build(arena, o, typst);
- const b: Built = .{ .drawing = d, .bounds = d.bounds().rect() };
- try ss.drawings.put(arena, id, b);
- return b;
-}
-
-/// Scene units to canvas pixels: the scene's camera, then the viewer's.
-/// The scene's origin is the canvas center.
-fn stage(s: *const State, cam: anim.Camera, canvas: sk.Rect) geom.Affine {
- const k = fit(canvas) * cam.zoom;
- return geom.Affine.translate(s.view.x, s.view.y)
- .mul(.scale(s.view.zoom, s.view.zoom))
- .mul(.translate(canvas.w / 2, canvas.h / 2))
- .mul(.scale(k, k))
- .mul(.rotate(-cam.rotation))
- .mul(.translate(-cam.x, -cam.y));
-}
-
-/// The next of `layers`, begun: a renderer the size of the canvas.
-fn begun(layers: anytype, used: *usize, f: *sk.Frame, canvas: sk.Rect, clear: vector.Drawing.Color) !*@TypeOf(layers.items[0]) {
- if (used.* == layers.items.len) try layers.append(f.session, try .init(f.session, f.host, @intFromFloat(canvas.w), @intFromFloat(canvas.h)));
- const r = &layers.items[used.*];
- used.* += 1;
- r.begin(f, clear);
- return r;
-}
-
-/// Draws `shot` with the renderers in `layers` (either backend), objects
-/// in the order they were added. Vector objects go into a renderer's image,
-/// which is then drawn on the canvas; a custom object draws on the canvas
-/// itself. So the vector objects before a custom one and those after it
-/// are separate images, one renderer each: every GPU pass of a frame runs
-/// before its first 2D command, and one image could only show the last.
-fn paint(s: *const State, ss: *Session, layers: anytype, f: *sk.Frame, shot: anim.Shot, canvas: sk.Rect) !void {
- if (layers.items.len > 0 and (layers.items[0].width() != @as(u32, @intFromFloat(canvas.w)) or layers.items[0].height() != @as(u32, @intFromFloat(canvas.h)))) {
- for (layers.items) |*r| r.deinit(f.host);
- layers.clearRetainingCapacity();
- }
- const world = stage(s, shot.camera, canvas);
- var used: usize = 0;
- // The first layer is the background too.
- var open: ?*@TypeOf(layers.items[0]) = try begun(layers, &used, f, canvas, anim.color(background));
- var shapes: usize = 0;
- for (shot.objects, shot.poses, 0..) |o, pose, i| {
- if (!pose.visible or pose.opacity <= 0) continue;
- const m = world.mul(model(pose));
- if (o.source == .custom) {
- if (open) |r| r.present(f, canvas);
- open = null;
- o.source.custom.draw(o.source.custom.ctx, f, .{ .t = s.t, .pose = pose, .xf = m, .scale = m.scaleFactor(), .stage = world, .values = shot.values });
- // It leaves no target, clip or blend behind.
- f.target(.none);
- f.blend(.alpha);
- continue;
- }
- const r = open orelse try begun(layers, &used, f, canvas, .{ 0, 0, 0, 0 });
- open = r;
- const d = (try built(ss, o)).drawing;
- if (pose.into != anim.Pose.none and pose.morph > 0 and pose.morph < 1 and shot.objects[pose.into].source != .custom) {
- // Morphing: from where this object began the transform to where
- // its target will stand.
- const morph = shot.morphs[i];
- const target = (try built(ss, shot.objects[pose.into])).drawing;
- const between = try vector.morph.between(f.scratch, d, world.mul(model(morph.from)), target, world.mul(model(morph.to)), pose.morph);
- try r.draw(between, .identity, pose.opacity);
- shapes += between.shapes.len;
- continue;
- }
- try reveal(r, d, m, pose, fit(canvas));
- shapes += d.shapes.len;
- }
- if (s.guides) {
- const r = open orelse try begun(layers, &used, f, canvas, .{ 0, 0, 0, 0 });
- open = r;
- try r.draw(try guides(ss, f.scratch, shot, world, canvas), .identity, 1);
- }
- if (open) |r| r.present(f, canvas);
- ss.shapes = shapes;
- if (s.guides) try labels(ss, f, shot, world);
-}
-
-fn model(p: anim.Pose) geom.Affine {
- return geom.Affine.translate(p.x, p.y).mul(.rotate(p.rotation)).mul(.scale(p.scale, p.scale));
-}
-
-/// manim's reveals, shape by shape with a stagger: Write traces each outline
-/// then fills it; Create draws strokes along their length, then fills.
-/// Outlines are `k` canvas pixels to the scene unit wide.
-fn reveal(r: anytype, d: vector.Drawing, m: geom.Affine, pose: anim.Pose, k: f32) !void {
- const n: f32 = @floatFromInt(d.shapes.len);
- const lag: f32 = if (pose.drawn >= 1) 0 else 0.08;
- const window = 1 / (1 + lag * @max(n - 1, 0));
- const glow = pose.highlight;
- for (d.shapes, 0..) |shape, i| {
- const local = std.math.clamp((pose.drawn - @as(f32, @floatFromInt(i)) * lag * window) / window, 0, 1);
- if (local <= 0) continue;
- var o: vector.Options = .{ .alpha = pose.opacity };
- switch (pose.reveal) {
- .write => if (local < 1) {
- o.trim = @min(local * 2, 1);
- o.outline = .{ .width = 1.5 * k, .alpha = 1 - std.math.clamp(local * 2 - 1, 0, 1) };
- o.stroke = false;
- // Fill arrives in the second half.
- var fill = o;
- fill.outline = null;
- fill.alpha = pose.opacity * std.math.clamp(local * 2 - 1, 0, 1);
- try r.drawShape(d, shape, m, fill);
- o.fill = false;
- },
- .create => if (local < 1) {
- o.trim = local;
- if (shape.style.stroke == .none) o.outline = .{ .width = 2 * k };
- var fill = o;
- fill.stroke = false;
- fill.outline = null;
- fill.alpha = pose.opacity * std.math.clamp(local * 3 - 2, 0, 1);
- try r.drawShape(d, shape, m, fill);
- o.fill = false;
- },
- }
- try r.drawShape(d, shape, m, o);
- if (glow > 0) {
- // Indicate: a yellow glow over the shape.
- var hot = shape;
- hot.style.fill = if (shape.style.fill != .none) .{ .color = anim.color(anim.yellow) } else .none;
- hot.style.stroke = if (shape.style.stroke != .none) .{ .color = anim.color(anim.yellow) } else .none;
- try r.drawShape(d, hot, m, .{ .alpha = pose.opacity * glow });
- }
- }
-}
-
-/// Spacing of the guides' ticks, in scene units.
-const tick = 100;
-
-fn guideStyle(c: u32, w: f32) vector.Drawing.Style {
- return .{ .fill = .none, .stroke = .{ .color = anim.color(c) }, .stroke_width = w };
-}
-
-/// The scene's axes with ticks, and each visible object's bounding box (a
-/// custom object has none) and origin, in canvas pixels.
-fn guides(ss: *Session, arena: std.mem.Allocator, shot: anim.Shot, world: geom.Affine, canvas: sk.Rect) !vector.Drawing {
- var b: vector.Drawing.Builder = .init(arena);
- const far = 100 * tick;
- try b.lineTo(world.apply(.{ -far, 0 }), world.apply(.{ far, 0 }));
- try b.closeSubpath(false);
- try b.endShape(.identity, guideStyle(anim.red, 1.5));
- try b.lineTo(world.apply(.{ 0, -far }), world.apply(.{ 0, far }));
- try b.closeSubpath(false);
- try b.endShape(.identity, guideStyle(anim.green, 1.5));
- var i: f32 = -20;
- while (i <= 20) : (i += 1) {
- const x = world.apply(.{ i * tick, 0 });
- const y = world.apply(.{ 0, i * tick });
- try b.lineTo(x - geom.Vec{ 0, 5 }, x + geom.Vec{ 0, 5 });
- try b.closeSubpath(false);
- try b.lineTo(y - geom.Vec{ 5, 0 }, y + geom.Vec{ 5, 0 });
- try b.closeSubpath(false);
- }
- try b.endShape(.identity, guideStyle(0x8c8c8c, 1));
-
- for (shot.objects, shot.poses) |o, pose| {
- if (!pose.visible or pose.opacity <= 0) continue;
- const m = world.mul(model(pose));
- if (o.source != .custom) {
- const r = (try built(ss, o)).bounds;
- try b.polyline(&.{ m.apply(.{ r.x, r.y }), m.apply(.{ r.x + r.w, r.y }), m.apply(.{ r.x + r.w, r.y + r.h }), m.apply(.{ r.x, r.y + r.h }) }, true);
- }
- // The object's origin: where its pose puts it.
- const c = m.apply(.{ 0, 0 });
- try b.lineTo(c - geom.Vec{ 6, 0 }, c + geom.Vec{ 6, 0 });
- try b.closeSubpath(false);
- try b.lineTo(c - geom.Vec{ 0, 6 }, c + geom.Vec{ 0, 6 });
- try b.closeSubpath(false);
- }
- try b.endShape(.identity, guideStyle(anim.yellow, 1));
- return b.finish(.{ .w = canvas.w, .h = canvas.h }, canvas.w, canvas.h);
-}
-
-/// The guides' numbers: tick values, and each object's index and position.
-fn labels(ss: *Session, f: *sk.Frame, shot: anim.Shot, world: geom.Affine) !void {
- var i: f32 = -20;
- while (i <= 20) : (i += 2) {
- const x = world.apply(.{ i * tick, 0 });
- const y = world.apply(.{ 0, i * tick });
- f.print(x[0] + 3, x[1] + 8, 1, 0x8c8c8c, "{d}", .{i * tick});
- if (i != 0) f.print(y[0] + 8, y[1] - 3, 1, 0x8c8c8c, "{d}", .{i * tick});
- }
- for (shot.objects, shot.poses, 0..) |o, pose, n| {
- if (!pose.visible or pose.opacity <= 0) continue;
- const r: geom.Rect = if (o.source == .custom) .{} else (try built(ss, o)).bounds;
- const corner = world.mul(model(pose)).apply(.{ r.x, r.y });
- f.print(corner[0], corner[1] - 11, 1, anim.yellow, "#{d} {d:.0},{d:.0}", .{ n, pose.x, pose.y });
- }
-}
-
fn hud(s: *const State, ss: *const Session, f: *sk.Frame, shot: anim.Shot, canvas: sk.Rect) void {
const w = canvas.w;
const h = canvas.h;
@@ -400,7 +172,7 @@ fn hud(s: *const State, ss: *const Session, f: *sk.Frame, shot: anim.Shot, canva
const status = if (!s.playing) " paused" else if (held(s.t, shot)) " click to continue" else "";
f.fill(sk.Rect{ .y = h - 28, .w = w, .h = 28 }, sk.Color{ .r = 0, .g = 0, .b = 0, .a = 150 });
f.print(12, h - 19, 1, 0xece6e2, "{d:5.2}s / {d:.2}s play {d}/{d} {s} record {d:.3}ms {d} shapes speed x{d}{s}", .{
- s.t, shot.duration, play, shot.marks.len, backend, ss.render_ns / 1e6, ss.shapes, s.speed, status,
+ s.t, shot.duration, play, shot.marks.len, backend, ss.render_ns / 1e6, ss.painter.shapes, s.speed, status,
});
if (s.guides) {
const p = pointer(s, f.in, canvas);
diff --git a/src/anim/root.zig b/src/anim/root.zig
index ea57ed2..4acecb3 100644
--- a/src/anim/root.zig
+++ b/src/anim/root.zig
@@ -69,6 +69,7 @@ const tween = sk.tween;
const Drawing = vector.Drawing;
pub const ease = tween.ease;
+pub const Painter = @import("Painter.zig");
// manim's palette.
pub const blue: u32 = 0x58c4dd;