summaryrefslogtreecommitdiff
path: root/anim/scenes/intro_code.zig
diff options
context:
space:
mode:
Diffstat (limited to 'anim/scenes/intro_code.zig')
-rw-r--r--anim/scenes/intro_code.zig124
1 files changed, 105 insertions, 19 deletions
diff --git a/anim/scenes/intro_code.zig b/anim/scenes/intro_code.zig
index a5660ed..b50c971 100644
--- a/anim/scenes/intro_code.zig
+++ b/anim/scenes/intro_code.zig
@@ -1,14 +1,16 @@
//! The introduction, chapter III: code and meaning (design/motion.md, "A
//! scene: the introduction", III1 to III5; mocks 32, 33, 36). On the
-//! `list` recording at the load in `reverse` (line 21, `node *next =
+//! `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; then the map (`surface`). The texts
-//! `above` the aligned panel, then below the working frame.
+//! 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");
@@ -33,11 +35,60 @@ fn on(rec: *canim.Recording, from: u64, text: []const u8) u64 {
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.list);
+ 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]");
@@ -52,6 +103,10 @@ fn frame(s: *anim.Frame) void {
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 };
@@ -60,6 +115,13 @@ fn frame(s: *anim.Frame) void {
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 });
@@ -67,8 +129,14 @@ fn frame(s: *anim.Frame) void {
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.
- s.wait(1.0);
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);
@@ -83,28 +151,46 @@ fn frame(s: *anim.Frame) void {
// 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, 72);
+ run(s, al.form, 80);
s.wait(t.beat);
- // Into the working frame: the texts above leave, the panel goes, the frame comes in.
+ // 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);
- s.play(.{panel.fadeOut()}, .{ .seconds = f(12), .ease = anim.ease.linear });
+ 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 = .{};
- var cam: canim.Camera = .{};
- canim.establish(s, .{ ctx.clock, ctx.registers, ctx.stack, ctx.source, ctx.disasm, joins });
+ 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, and the camera nearer on it (x1.5).
+ // 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.");
- ctx.establish(s, .{list}, 3);
- cam.go(s, .{ .x = 512, .y = 48, .w = 896, .h = 296 }, 1.5, .{});
+ // 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: the camera back to x1.
+ // 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.");
- cam.back(s, .{});
+ 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.
- says.line(s, "And all of it at once: the map.");
+ // 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);
- says.close(s);
- cam.apply(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);
}