summaryrefslogtreecommitdiff
path: root/examples/talk.zig
blob: 2ad3d704ed2683b5260fe6ee5cfd3e18e7e91648 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
//! A talk in a sketch of its own: the sketch keeps an `anim.Deck` in its
//! State beside its own data, decides which keys and clicks step the talk,
//! and paints with an `anim.Painter`. The talk is a function run from the
//! top every frame; it may change the app in `update` (`anim.mutable`),
//! so the slider below is laid out, drawn and hit-tested in one place.
//!
//!   click, space, right, page down  next step     left, page up  back
//!   ] / [                           next / previous slide
const std = @import("std");
const sk = @import("sketch");
const anim = @import("anim");
/// This file's Typst, compiled at build time (`sb.addTypst`).
const svgs = @import("typst");

pub const name = "talk";
pub const width = anim.width;
pub const height = anim.height;

pub const typst_preamble =
    \\#set page(width: auto, height: auto, margin: 3pt, fill: none)
    \\#set text(fill: rgb("#ece6e2"), size: 28pt)
;
pub const typst = struct {
    pub const title = "#text(size: 40pt, weight: \"bold\")[Damping]";
    pub const law = "$ x'' + 2 zeta x' + x = 0 $";
    pub const hint = "#text(size: 18pt, fill: rgb(\"#58c4dd\"))[drag $zeta$, then go on]";
    pub const rings = "#text(size: 24pt)[$zeta < 1$: it rings]";
    pub const creeps = "#text(size: 24pt)[$zeta >= 1$: it creeps back]";
    pub const end = "#text(size: 32pt)[$zeta = 1$: home fastest, no overshoot]";
};
/// What the build compiles.
pub const scene = struct {
    pub const typst_sources = anim.sources(.{typst});
};

const App = struct {
    zeta: f32 = 0.2,
    /// The slider is held.
    dragging: bool = false,
};

pub const State = struct {
    deck: anim.Deck = .{ .hold = 2 },
    app: App = .{},
};

pub const Session = struct {
    painter: anim.Painter = .{},
};

pub fn update(s: *State, in: *const sk.Input) void {
    var ask: anim.Ask = .{};
    for (in.events) |e| switch (e.kind) {
        // Every click is the presenter's, unless the talk takes it.
        .mouse_up => ask.next = true,
        .key_down => switch (e.key()) {
            .space, .right, .page_down => ask.next = true,
            .left, .page_up => ask.back = true,
            .right_bracket => ask.next_slide = true,
            .left_bracket => ask.back_slide = true,
            else => {},
        },
        else => {},
    };
    s.deck.update(in, ask, talk, .{&s.app});
}

pub fn draw(s: *const State, ss: *Session, f: *sk.Frame) void {
    const mouse = anim.Deck.pointer(f.in, f.in.mouse_x, f.in.mouse_y);
    const shot = s.deck.shot(f.scratch, f.in, mouse, talk, .{&s.app}) catch |err| return f.host.print("talk: {t}", .{err});
    ss.painter.paint(f, shot, svgs, .{}) catch |err| f.host.print("paint: {t}", .{err});
    if (f.in.exporting and s.deck.t >= shot.duration) f.quit();
}

/// Run in `update` with `app: *App`, and drawn with `app: *const App`.
fn talk(s: *anim.Frame, app: anytype) void {
    // Slide 1: the law, and a mass on a spring that bobs while we talk.
    s.slide();
    const title = s.typst(typst.title, .{ .y = -270 });
    const law = s.typst(typst.law, .{ .y = -180 });
    const mass = s.rect(.{ .w = 60, .h = 60, .fill = anim.blue });
    s.play(.{ title.write(), law.write() }, .{});
    s.play(.{mass.fadeIn()}, .{ .seconds = 0.5 });
    s.loop(bob, .{mass});
    s.pause();

    // The slider, laid out before the gate it waits at: a click on it is
    // its own, not the presenter's.
    const plot = s.custom(s.new(Plot{ .zeta = app.zeta }), .{});
    const hint = s.typst(typst.hint, .{ .y = 290 });
    s.play(.{ mass.fadeOut(), plot.fadeIn(), hint.fadeIn() }, .{ .seconds = 0.6 });
    if (anim.mutable(app)) |a| if (s.pose(plot).visible) drag(s, a);
    // A choice: the regime the slider is in when the presenter goes on.
    const regime = s.gate(if (s.next) @intFromBool(app.zeta >= 1) else null) orelse return;
    const verdict = s.typst(if (regime == 0) typst.rings else typst.creeps, .{ .y = 290 });
    s.play(.{ hint.fadeOut(), verdict.write() }, .{ .seconds = 1 });
    s.pause();

    // Slide 2, written while slide 1 goes.
    s.beside(anim.Frame.clear, .{.{ .seconds = 0.8 }});
    s.slide();
    s.play(.{s.typst(typst.end, .{}).write()}, .{});
}

/// Down and up again, in a second.
fn bob(s: *anim.Frame, mass: anim.Obj) void {
    s.play(.{mass.move(.{ .y = 80 })}, .{ .seconds = 0.5 });
    s.play(.{mass.move(.{ .y = 0 })}, .{ .seconds = 0.5 });
}

/// The slider's track, in scene units: zeta from 0 to 2 along it.
const track: sk.Rect = .{ .x = -300, .y = 200, .w = 600, .h = 40 };

/// The slider follows a press on it to where it is let go, and takes that
/// click: it is not the presenter's next.
fn drag(s: *anim.Frame, app: *App) void {
    for (s.events) |e| {
        if (e.kind != .mouse_down and e.kind != .mouse_move and e.kind != .mouse_up) continue;
        if (e.kind == .mouse_down) app.dragging = track.contains(e.x, e.y);
        if (!app.dragging) continue;
        app.zeta = std.math.clamp((e.x - track.x) / track.w * 2, 0, 2);
        if (e.kind == .mouse_up) {
            app.dragging = false;
            s.next = false;
        }
    }
}

/// The motion zeta makes, x(t) from x = 1 at rest, over the slider: a
/// custom object at the scene's origin, so its units are scene units.
const Plot = struct {
    zeta: f32,

    pub fn draw(p: *const Plot, f: *sk.Frame, at: anim.Placed) void {
        var points: [121]sk.math.Vec = undefined;
        for (&points, 0..) |*q, i| {
            const t: f32 = @as(f32, @floatFromInt(i)) / 10;
            q.* = .{ -300 + 50 * t, 60 - 120 * response(p.zeta, t) };
        }
        sk.draw.line(f, .{ -300, 60 }, .{ 300, 60 }, at.pen(.{ .stroke = .hex(0x8c8c8c), .width = 1 }));
        sk.draw.polyline(f, &points, at.pen(.{ .stroke = .hex(anim.yellow), .width = 3 }));
        sk.draw.rect(f, .{ .x = track.x, .y = track.y + 18, .w = track.w, .h = 4 }, at.pen(.{ .fill = .hex(0x8c8c8c) }));
        sk.draw.circle(f, .{ track.x + p.zeta / 2 * track.w, track.y + 20 }, 14, at.pen(.{ .fill = .hex(anim.blue) }));
        var label: [16]u8 = undefined;
        at.text(f, track.x + p.zeta / 2 * track.w - 30, track.y - 22, 1.5, std.fmt.bufPrint(&label, "{d:.2}", .{p.zeta}) catch "", .white);
    }
};

/// x(t) of x'' + 2 zeta x' + x = 0 from x = 1, x' = 0.
fn response(zeta: f32, t: f32) f32 {
    if (zeta < 1) {
        const w = @sqrt(1 - zeta * zeta);
        return @exp(-zeta * t) * (@cos(w * t) + zeta / w * @sin(w * t));
    }
    if (zeta == 1) return @exp(-t) * (1 + t);
    const r = @sqrt(zeta * zeta - 1);
    const a = -zeta + r;
    const b = -zeta - r;
    return (b * @exp(a * t) - a * @exp(b * t)) / (b - a);
}