//! The `anim` module's player: plays the scene file it is built around //! (`sb.addScene`), compiled or live, as a manim-style animation drawn by //! the vector library on the GPU (or the CPU, with B). Its state is an //! `anim.Deck`, the playhead and the gates opened, and the viewer's own //! settings; the picture is a function of them (and, for a live scene, of //! the input). A scene that pauses is a talk, and steps: //! //! click, space, page down next step: open the pause the talk waits at, //! or finish the step under way (in a scene with //! no pause, space plays or pauses) //! page up, backspace back a step: the picture before the last click //! ] / [ next / previous slide (`s.slide()`), at rest //! P play / pause left/right previous / next play //! ,/. step back / ahead home/end start / end //! up/down speed B GPU or CPU renderer //! L loop (not a talk) G guides: boxes, origins, axes //! drag, wheel: look around R reset the view //! //! The scene's frame, 1280x720 scene units around its origin, is fitted //! into the canvas, and the canvas is the room the host has: the window, or //! an export's `--size`. Exported (`in.exporting`), the scene plays through //! once without controls, each pause held for the scene file's `hold` //! seconds (1 without one), and the player quits at the end. const std = @import("std"); const sk = @import("sketch"); const vector = @import("vector"); const anim = @import("anim"); const scene_file = @import("scene"); const scene = scene_file.scene; /// The scene's Typst sources, compiled at build time. const typst = @import("typst"); pub const name = if (@hasDecl(scene_file, "name")) scene_file.name else "anim"; /// The page: the scene file's `background` (0xRRGGBB), or manim's. const background: u32 = if (@hasDecl(scene_file, "background")) scene_file.background else anim.background; /// Exported, how long each pause holds. const hold: f32 = if (@hasDecl(scene_file, "hold")) scene_file.hold else 1; /// The scene's frame, in scene units: what shows at camera zoom 1. pub const width = anim.width; pub const height = anim.height; pub const State = struct { deck: anim.Deck = .{ .hold = hold }, looping: bool = true, backend: vector.Backend = .gpu, /// The viewer's own pan and zoom, on top of the scene's camera. view: sk.Camera = .{}, dragging: bool = false, /// Where the left button went down: a click, not a drag, steps. press: [2]f32 = .{ 0, 0 }, guides: bool = false, }; pub const Session = struct { painter: anim.Painter = .{}, /// Smoothed time to record a frame. render_ns: f32 = 0, }; /// A live scene's frame, or a compiled scene as a talk without gates. const talk = if (@hasDecl(scene, "frame")) scene.frame else struct { fn frame(s: *anim.Frame) void { s.cursor = scene.duration; } }.frame; pub fn update(s: *State, in: *const sk.Input) void { const d = &s.deck; // A scene that waits somewhere is a talk: clicks and space step it. const talking = d.gates > 0; var ask: anim.Ask = .{}; var mark: enum { none, previous, next } = .none; for (in.events) |e| switch (e.kind) { .key_down => if (e.flags & sk.Event.repeat == 0 or e.key() == .left or e.key() == .right or e.key() == .comma or e.key() == .period) switch (e.key()) { .space => if (talking) { ask.next = true; } else { d.playing = !d.playing; }, .page_down => ask.next = true, .page_up, .backspace => ask.back = true, .right_bracket => ask.next_slide = true, .left_bracket => ask.back_slide = true, .p => d.playing = !d.playing, .home => ask.to = 0, .end => ask.end = true, .left => mark = .previous, .right => mark = .next, .comma => ask.to = @max((ask.to orelse d.t) - 1.0 / 30.0, 0), .period => ask.to = @min((ask.to orelse d.t) + 1.0 / 30.0, d.duration), .up => d.speed = @min(d.speed * 2, 8), .down => d.speed = @max(d.speed / 2, 0.125), .b => s.backend = if (s.backend == .gpu) .cpu else .gpu, .g => s.guides = !s.guides, .l => s.looping = !s.looping, .r => s.view = .{}, else => {}, }, .mouse_down => if (e.code == 1) { s.dragging = true; s.press = .{ e.x, e.y }; }, .mouse_up => { const click = @abs(e.x - s.press[0]) + @abs(e.y - s.press[1]) < 4; if (s.dragging and click and talking) ask.next = true; s.dragging = false; }, .cancel => s.dragging = false, .mouse_move => if (s.dragging) s.view.pan(.{ .x = e.x - in.mouse_x, .y = e.y - in.mouse_y }), .wheel => s.view.zoomAt(e, e.wheel(), .{ .min = 0.2, .max = 20 }), else => {}, }; if (mark != .none) { // The plays as the scene lays them now. var arena: std.heap.ArenaAllocator = .init(std.heap.page_allocator); defer arena.deinit(); if (shotNow(s, arena.allocator(), in, .{ 0, 0 })) |shot| { ask.to = if (mark == .previous) previousMark(d.t, shot) else nextMark(d.t, shot); } else |_| {} } // Played past the end: from the start again, or held there (a talk // holds its last picture). if (!in.exporting and d.t > d.duration + 1) { if (s.looping and !talking) ask.to = 0 else d.t = d.duration; } d.update(in, ask, talk, .{}); } /// The scene at the deck's `t`: a live one through the deck, with its gates. fn shotNow(s: *const State, arena: std.mem.Allocator, in: *const sk.Input, mouse: [2]f32) !anim.Shot { if (@hasDecl(scene, "frame")) return s.deck.shot(arena, in, mouse, scene.frame, .{}); return scene.shot(arena, .{ .t = s.deck.t, .in = in, .pointer = mouse }); } fn previousMark(t: f32, shot: anim.Shot) f32 { var best: f32 = 0; for (shot.marks) |m| if (m < t - 0.25) { best = m; }; return best; } fn nextMark(t: f32, shot: anim.Shot) f32 { for (shot.marks) |m| if (m > t + 0.01) return m; return shot.duration; } /// 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 = 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) }; const started = f.host.clock(); const shot = shotNow(s, f.scratch, f.in, pointer(s, f.in, canvas)) catch |err| return f.host.print("scene: {t}", .{err}); ss.painter.paint(f, shot, typst, .{ .view = s.view, .backend = s.backend, .guides = s.guides, .background = background }) catch |err| f.host.print("render: {t}", .{err}); if (f.in.exporting) { // The frame that shows the end is the last. if (s.deck.t >= shot.duration) f.quit(); return; } const elapsed: f32 = @floatFromInt(f.host.clock() -| started); ss.render_ns = if (ss.render_ns == 0) elapsed else ss.render_ns * 0.9 + elapsed * 0.1; hud(s, ss, f, shot, canvas); } fn hud(s: *const State, ss: *const Session, f: *sk.Frame, shot: anim.Shot, canvas: sk.Rect) void { const w = canvas.w; const h = canvas.h; const d = &s.deck; var play: usize = 0; for (shot.marks, 1..) |m, i| if (m <= d.t) { play = i; }; var buf: [64]u8 = undefined; const steps = (if (d.slides > 0) std.fmt.bufPrint(&buf, " slide {d}/{d} step {d}/{d}", .{ d.slide, d.slides, d.log.count(), d.gates }) else if (d.gates > 0) std.fmt.bufPrint(&buf, " step {d}/{d}", .{ d.log.count(), d.gates }) else std.fmt.bufPrint(&buf, "", .{})) catch ""; const backend = if (s.backend == .gpu and f.host.gpu()) "GPU" else "CPU"; const status = if (!d.playing) " paused" else if (d.waiting) " click to continue" else ""; f.fill(sk.Rect{ .y = h - 28, .w = w, .h = 28 }, sk.Color{ .r = 0, .g = 0, .b = 0, .a = 150 }); f.print(12, h - 19, 1, 0xece6e2, "{d:5.2}s / {d:.2}s play {d}/{d}{s} {s} record {d:.3}ms {d} shapes speed x{d}{s}", .{ d.t, shot.duration, play, shot.marks.len, steps, backend, ss.render_ns / 1e6, ss.painter.shapes, d.speed, status, }); if (s.guides) { const p = pointer(s, f.in, canvas); f.print(w - 540, h - 19, 1, anim.yellow, "pointer {d:.0},{d:.0}", .{ p[0], p[1] }); } f.text(w - 400, h - 19, 1, "click space pgup [ ] P <- -> , . B G drag", 0x8c8c8c); f.cursor(.arrow); }