summaryrefslogtreecommitdiff
path: root/anim/scenes/intro_code.zig
blob: b50c971fcafe50330c14754e06e68012a016cd01 (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
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
//! The introduction, chapter III: code and meaning (design/motion.md, "A
//! scene: the introduction", III1 to III5; mocks 32, 33, 36). On the
//! `intro` recording at the load in `reverse` (line 21, `node *next =
//! cur->next;`, the instruction that reads `cur->next`): the code's bytes
//! as a dump row, that instruction's four framed; `decode`d into its row
//! of `aligned` (`interleaved`), its neighbours at a run, each line level
//! with its run; then `align` to `columns`; then the working frame with the
//! nodes drawn from the heap's bytes, each pane's minimap drawing itself
//! last; then the map (`surface`). The texts `above` the aligned panel,
//! then below the working frame, and the last one on the map.
const std = @import("std");
const anim = @import("anim");
const sk = @import("sketch");
const canim = @import("canim");
const recordings = @import("recordings");

pub const background = canim.background;
pub const scene = anim.Live(frame, struct {});

const t = canim.theme.time;

fn f(frames: f32) f32 {
    return frames / 60;
}

fn run(s: *anim.Frame, v: anim.Value, frames: f32) void {
    s.play(.{v.to(0)}, .{ .seconds = 0 });
    s.play(.{v.to(frames)}, .{ .seconds = f(frames), .ease = anim.ease.linear });
}

fn on(rec: *canim.Recording, from: u64, text: []const u8) u64 {
    var buf: [256]u8 = undefined;
    var i = from;
    while (i < rec.end()) : (i += 1) if (rec.instruction(i, rec.register(i, "rip"), &buf)) |here| if (std.mem.indexOf(u8, here.text, text) != null) return i;
    return from;
}

/// The page over a part not drawn yet (a pane's minimap until III4).
const Page = struct {
    box: canim.Rect,
    pub fn draw(c: *const Page, fr: *sk.Frame, placed: anim.Placed) void {
        (canim.ui.Ui{ .f = fr, .at = placed }).fill(c.box, canim.theme.color.page);
    }
};

/// Chapter II's last picture (scenes/intro_stack.zig, its layout and texts
/// as there): its registers and stack, a context of their own at II's last
/// moment; main's rows, faint; II3's text dimmed and II4's.
fn lastOfTwo(s: *anim.Frame, rec: *canim.Recording) struct { panels: [3]anim.Obj, texts: [2]anim.Obj } {
    const enter = rec.call("reverse", 0).enter;
    const last = enter + 3;
    const row = canim.theme.metric.context.row;
    const head = canim.theme.metric.context.tag + canim.theme.metric.context.pad;
    var at = canim.cursor(s, rec, enter);
    at.journey(.moment, last);
    at.levels = .{ .fire = .disasm, .source_rows = 14 };
    at.jump(s, last);
    var split = canim.layout.split.none;
    split.backtrace.h = 0;
    const ctx = canim.context(s, at, .{ .split = split });
    const rb = ctx.stage.first.registers;
    ctx.stage.first.stack.h = canim.layout.panelH(18);
    ctx.stage.first.stack.y = rb.y + rb.h + canim.theme.canvas.row_gap;
    const top = ctx.stage.first.stack.y + head;
    const rsp = rec.register(enter, "rsp");
    const window = rec.register(last, "rsp") - 16;
    const rowY = struct {
        fn y(t0: f32, from: u64, addr: u64) f32 {
            return t0 + row * @as(f32, @floatFromInt(@as(i64, @bitCast(addr -% from)) >> 3));
        }
    }.y;
    const stack = canim.add(s, canim.Stack{ .cursor = ctx.cursor, .stage = ctx.stage });
    const back_y = rowY(top, rsp - 8 - 16, rsp);
    // (Placed at the origin: it draws at its own box.)
    const caller = s.custom(s.new(canim.descent.Caller{ .rec = rec, .at = enter, .call = rec.register(enter - 1, "rip"), .box = .{ .x = canim.theme.layout.program.x, .y = back_y + row / 2 + 176, .w = canim.theme.layout.program.w, .h = 4 * row }, .in = s.value(999), .faint = s.value(1) }), .{ .x = -640, .y = -360, .scale = canim.ui.scale });
    const left = canim.theme.canvas.margin_x;
    const said = [2]canim.Aside{
        .{ .text = "A function's words are its frame: the saved rbp, its locals, the way back.", .x = left, .level = (rowY(top, window, window + 16) + rowY(top, window, rsp + 8)) / 2, .dim = s.value(1) },
        .{ .text = "The registers are the other place values live: seventeen of them.", .x = left, .level = rb.y + head + row * 2.5, .dim = s.value(0) },
    };
    var texts: [2]anim.Obj = undefined;
    for (said, &texts) |a, *o| o.* = s.custom(s.new(a), .{ .x = -640, .y = -360, .scale = canim.ui.scale });
    for ([_]anim.Obj{ ctx.registers, stack, caller, texts[0], texts[1] }) |o| s.play(.{o.fadeIn()}, .{ .seconds = 0 });
    return .{ .panels = .{ ctx.registers, stack, caller }, .texts = texts };
}

/// The variables whose tags the nodes carry, as the list scene's.
const tracked = [_][]const u8{ "prev", "cur", "next", "head" };

fn frame(s: *anim.Frame) void {
    const rec = canim.open(recordings.intro);
    const reverse = rec.call("reverse", 0);
    // The load: `cur->next` read, line 21's second instruction.
    const moment = on(rec, rec.lineMoment(21, reverse.enter), "[rax + 8]");
    const pc = rec.register(moment, "rip");
    var buf: [256]u8 = undefined;
    const insn = rec.instruction(moment, pc, &buf).?;
    // Its bytes and its text as canim writes it (the size word dropped), from the recording.
    var code: [16]u8 = undefined;
    var known: [16]bool = undefined;
    rec.moment(moment).read(pc, code[0..insn.len], known[0..insn.len]) catch {};
    var hex: std.ArrayList(u8) = .empty;
    for (code[0..insn.len], 0..) |b, k| hex.print(s.arena, "{s}{x:0>2}", .{ if (k > 0) " " else "", b }) catch {};
    const text = std.mem.replaceOwned(u8, s.arena, insn.text, "qword ptr ", "") catch insn.text;

    // Chapter II's last picture, which this chapter opens on (II's own
    // context at II's last moment, laid out as II has it, under this one's).
    const opening = lastOfTwo(s, rec);

    var at = canim.cursor(s, rec, moment);
    at.journey(.moment, moment + 1);
    at.levels = .{ .idea = .data, .follow = t.move, .source_rows = 8 };
    const ctx = canim.context(s, at, .{ .split = canim.layout.split.subject });
    const list = canim.nodes(s, .{ .cursor = at, .stage = ctx.stage, .root = "head", .track = &tracked });
    ctx.map.add(s, canim.Nodes{ .cursor = at, .stage = ctx.map.stage, .root = "head", .track = &tracked });
    const joins = ctx.ties(s);

    // Each pane's minimap under the page until III4, where they draw themselves last, top down
    // (over the panels, under the aligned rows landing on them; on from the panels' first frame).
    const first = ctx.stage.first;
    var strips: [4]anim.Obj = undefined;
    for ([_]canim.Rect{ first.view, first.source, first.stack, first.disasm }, &strips) |b, *o|
        o.* = s.custom(s.new(Page{ .box = .{ .x = b.x + b.w - canim.theme.strip.cost, .y = b.y + canim.theme.metric.context.tag, .w = canim.theme.strip.cost - canim.theme.stroke.rule, .h = b.h - canim.theme.metric.context.tag - canim.theme.stroke.rule } }), .{ .x = -640, .y = -360, .scale = canim.ui.scale });

    const al = s.new(canim.Aligned.init(s, rec, moment));
    const panel = s.custom(al, .{ .x = -640, .y = -360, .scale = canim.ui.scale });
    s.play(.{panel.fadeIn()}, .{ .seconds = 0 });
    var asides: canim.Asides = .{};
    const left = canim.theme.canvas.margin_x;
    const above = canim.theme.canvas.stage.y + 40;

    // From II's last picture: it gives way (its texts 12 f, the rest 18 f), the stage clear for the code.
    s.wait(t.beat);
    s.play(.{ opening.texts[0].fadeOut(), opening.texts[1].fadeOut() }, .{ .seconds = t.caption_out, .ease = canim.ease.exit });
    s.cursor -= t.caption_out;
    s.play(.{ opening.panels[0].fadeOut(), opening.panels[1].fadeOut(), opening.panels[2].fadeOut() }, .{ .seconds = f(18), .ease = anim.ease.linear });
    s.wait(t.beat);

    // III1: the code's bytes, one instruction's framed.
    asides.say(s, std.fmt.allocPrint(s.arena, "Code is bytes too: `{s}` is one instruction.", .{hex.items}) catch "", left, above);
    s.wait(t.caption_lead);
    run(s, al.bytes, 12 + 2 * 15 + 12 + 6);
    s.wait(t.beat);

    // III2: decoded into its row, its neighbours at a run, each line level with its run.
    asides.say(s, std.fmt.allocPrint(s.arena, "Decoded: `{s}`, from line {d}. Each line sits level with its code.", .{ text, insn.line orelse 0 }) catch "", left, above);
    run(s, al.decode, 60);
    run(s, al.rows_in, 2 * 32 + 8);
    run(s, al.chrome, 24);
    s.wait(t.beat);

    // III2, the other form: two columns, each line level with the first of its instructions.
    asides.say(s, "Two columns: each line level with its first instruction.", left, above);
    run(s, al.form, 80);
    s.wait(t.beat);

    // Into the working frame: the texts above leave; `stack`: the lines glide to
    // the source panel's rows, the instructions to the disassembly's (60 f); those
    // panels come in under them as the aligned rows go (12 f): the same rows; then
    // the band and the state column (`establish`).
    asides.leave(s);
    al.to = .{ .source = ctx.stage.first.source, .disasm = ctx.stage.first.disasm };
    run(s, al.stack, 60);
    s.play(.{ strips[0].fadeIn(), strips[1].fadeIn(), strips[2].fadeIn(), strips[3].fadeIn() }, .{ .seconds = 0 });
    s.play(.{ ctx.source.fadeIn(), ctx.disasm.fadeIn(), panel.fadeOut() }, .{ .seconds = f(12), .ease = anim.ease.linear });
    var says: canim.Narrator = .{};
    canim.establish(s, .{ ctx.clock, ctx.registers, ctx.stack, joins });
    // III3: the node it reads, as bytes and drawn: the band comes in, its
    // elements rising from their bytes. No camera: at x1.5 the drawing's
    // nodes and its bytes do not both fit the frame, and the band is whole at x1.
    says.line(s, "`rax` points at a list node on the heap:\nits bytes, and drawn, the node.");
    // The heap's dump first, in the band's right half (18 f); then the nodes drawn from it, rising (`establish`).
    s.play(.{ctx.stage.drawing.to(0)}, .{ .seconds = 0 });
    s.play(.{list.fadeIn()}, .{ .seconds = f(18), .ease = anim.ease.linear });
    s.wait(f(30));
    s.play(.{ctx.stage.drawing.to(1)}, .{ .seconds = f(12), .ease = anim.ease.linear });
    s.cursor -= f(12);
    ctx.establish(s, .{}, 3);
    s.wait(t.beat);
    // III4: the whole frame; each pane's minimap draws itself, last, top down (24 f, 48 f apart).
    says.line(s, "This is the whole frame.\nEvery view in it is these same bytes.");
    const strips_from = s.cursor;
    for (strips, 0..) |o, k| {
        s.cursor = strips_from + f(48 * @as(f32, @floatFromInt(k)));
        s.play(.{o.fadeOut()}, .{ .seconds = f(24), .ease = anim.ease.linear });
    }
    s.wait(t.beat);
    // III5: the map, and its text on it, in the key's corner (the middle column's foot, empty on this map).
    s.wait(@max(says.read_by - s.cursor, 0));
    s.play(.{says.current.?.fadeOut()}, .{ .seconds = t.caption_out, .ease = canim.ease.exit });
    s.wait(t.caption_gap);
    ctx.map.surface(s);
    asides.say(s, "And all of it at once:\nthe map.", 528, 720);
    s.wait(@max(asides.read_by - s.cursor, 0));
    s.wait(t.before_cut);
}