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
197
198
199
200
201
202
203
204
|
//! 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`). It opens on chapter II's last picture,
//! its state column staying veiled until the decoded code spans it. The
//! texts `above` the aligned panel, then below the working frame, the
//! last landing before the map surfaces under it.
const std = @import("std");
const anim = @import("anim");
const sk = @import("sketch");
const canim = @import("canim");
const recordings = @import("recordings");
const two = @import("intro_stack.zig");
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, the window held as II holds it; main's rows, faint, and reverse's
/// first rows under them; II4's text dimmed and II5's.
fn lastOfTwo(s: *anim.Frame, rec: *canim.Recording) struct { state: [2]anim.Obj, code: [2]anim.Obj, texts: [2]anim.Obj } {
const enter = rec.call("reverse", 0).enter;
const last = enter + 3;
var at = canim.cursor(s, rec, enter);
at.journey(.moment, last);
at.levels = .{ .fire = .disasm, .source_rows = 14, .introduction = true };
// As II walked it: its push, `mov` and `sub` the steps behind its last moment.
at.jumpWalked(s, enter, last);
var split = canim.layout.split.none;
split.backtrace.h = 0;
const ctx = canim.context(s, at, .{ .split = split });
const g = two.layout(ctx.stage, rec, enter);
two.hold(s, ctx.stage, enter);
const stack = canim.add(s, canim.Stack{ .cursor = ctx.cursor, .stage = ctx.stage });
// (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 = g.caller, .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 = two.texts[two.texts.len - 2], .x = left, .level = g.span_y, .dim = s.value(1) },
.{ .text = two.texts[two.texts.len - 1], .x = left, .level = g.registers_y, .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, ctx.disasm, texts[0], texts[1] }) |o| s.play(.{o.fadeIn()}, .{ .seconds = 0 });
return .{ .state = .{ ctx.registers, stack }, .code = .{ caller, ctx.disasm }, .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);
// list.c's types as the pass would tell them: the recording is of the
// plain build, which tells none (its locals are the debug info's).
rec.declare("head", "*`struct node`");
rec.declare("`struct node`", "struct(16){value@0:i64;next@8:*`struct node`;}");
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, .introduction = true };
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, .named = true });
ctx.map.add(s, canim.Nodes{ .cursor = at, .stage = ctx.map.stage, .root = "head", .track = &tracked, .named = true });
// The relations, and rax's link to the node as III3 names it.
const joins, const rax_link = ctx.tiesWith(s, "rax", 1.0);
// 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 });
// Texts above the panel that spans both columns: twice a beside's line (two lines in the band of 120).
var asides: canim.Asides = .{ .wrap = 2 * 40 };
const left = canim.theme.canvas.margin_x;
const above = canim.theme.canvas.stage.y + 40;
// From II's last picture: its texts and code give way (12 f, 18 f); its
// state column stays, veiled at 50%, until the decoded code takes both columns.
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.code[0].fadeOut(), opening.code[1].fadeOut(), opening.state[0].move(.{ .opacity = 0.5 }), opening.state[1].move(.{ .opacity = 0.5 }) }, .{ .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 heading its run.
asides.say(s, std.fmt.allocPrint(s.arena, "Decoded: `{s}`, from line {d}. Each line heads the instructions it compiled to.", .{ text, insn.line orelse 0 }) catch "", left, above);
// II's state column goes as the decoded rows come to span it (12 f).
s.play(.{ opening.state[0].fadeOut(), opening.state[1].fadeOut() }, .{ .seconds = f(12), .ease = anim.ease.linear });
s.cursor -= f(12);
run(s, al.decode, 60);
// The neighbours at half the run's pace (rows 4 f apart): they come while the text is read.
s.play(.{al.rows_in.to(0)}, .{ .seconds = 0 });
s.play(.{al.rows_in.to(2 * 32 + 8)}, .{ .seconds = 2 * f(2 * 32 + 8), .ease = anim.ease.linear });
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 by its first instruction. A square after `]`: a byte it touches.", left, above);
// `align` at two thirds of its pace (120 f for 80): the two columns come while the text is read.
s.play(.{al.form.to(0)}, .{ .seconds = 0 });
s.play(.{al.form.to(80)}, .{ .seconds = f(120), .ease = anim.ease.linear });
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, "Later, at line 21, `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);
// rax framed as read, its link up to the node it points at, held, drawn back.
rax_link.play(s);
s.wait(rax_link.total());
s.wait(t.beat);
// III4: the whole frame; each pane's minimap draws itself, last, top down (24 f, 72 f apart: while the text is read).
says.line(s, "This is the whole frame. Every view in it is these same bytes;\neach strip, the whole of its pane.");
const strips_from = s.cursor;
for (strips, 0..) |o, k| {
s.cursor = strips_from + f(72 * @as(f32, @floatFromInt(k)));
s.play(.{o.fadeOut()}, .{ .seconds = f(24), .ease = anim.ease.linear });
}
s.wait(t.beat);
// III5: its text lands before the move, under the map as under the frame; then `surface`.
says.line(s, "And all of it at once: the map.");
ctx.map.surface(s);
s.wait(@max(says.read_by - s.cursor, 0));
s.wait(t.before_cut);
}
|