summaryrefslogtreecommitdiff
path: root/design/mock/map.py
diff options
context:
space:
mode:
authorGabriel Schneider <[email protected]>2026-11-10 22:43:41 -0300
committerGabriel Schneider <[email protected]>2026-11-10 22:43:41 -0300
commitf0180748b19eac5fe99124142aea60eac78cf4bd (patch)
treef2c09f539000938bf29b6d286a334ec2587f5990 /design/mock/map.py
parent423e3817a106e5f926f1690943a1300d1f088676 (diff)
downloadcomputeranim-f0180748b19eac5fe99124142aea60eac78cf4bd.tar.gz
computeranim-f0180748b19eac5fe99124142aea60eac78cf4bd.zip
design: the dense stage is a map; the frame keeps its layout and gains a minimap
From the user, on the 4K mocks: the space was not well used, and the dense view is better as where a scene starts or as a minimap than as the frame it works in. The map is the same moment with every panel at full length on 3840 by 2160, packed by content. The working frame is the 1920 stage again, each panel a window on its column of the map, with the map at a twentieth in the caption band: windows outlined, marks no window shows flashing there. dive and surface carry a scene between the two, each window travelling to its panel's place. The loupe hangs from its pointer in the working frame. Mocks 16 to 18 are withdrawn; 19 is the map, 20 the dive in four instants, 21 a loupe with the minimap. Co-Authored-By: Claude Fable 5.2 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNCKgYCGiANnEwcEQxa
Diffstat (limited to 'design/mock/map.py')
-rw-r--r--design/mock/map.py393
1 files changed, 393 insertions, 0 deletions
diff --git a/design/mock/map.py b/design/mock/map.py
new file mode 100644
index 0000000..84e42fa
--- /dev/null
+++ b/design/mock/map.py
@@ -0,0 +1,393 @@
+#!/usr/bin/env python3
+"""The map, the minimap, and the working frame they belong to, from one fresh recording of targets/list.
+
+ python3 -B map.py # 09, 10, 11 (the working frame), 19 (the map), 20 (the dive), 21 (a loupe open)
+
+The working frame is the 1920 stage (context.py's blocks, as mocks 9 to 14 always drew them). The map is the same
+moment unfolded on 3840 by 2160: every panel at its full length, packed into four columns by content. The minimap
+is the map at a twentieth, drawn from the map itself: every run of text a stroke, the marks, the windows. The data
+is `list-dbg.txt` (registers, the stack from 128 bytes under rsp, the heap) and `list.dis`, as dense.py reads them.
+"""
+import subprocess
+
+from PIL import Image, ImageDraw, ImageFont
+
+import gen
+import dense as D
+import context as C
+from context import (PAGE, RAISED, RULE, VELLUM, BRIGHT, DIM, FAINT, GOLD, VERM, READ, HEAP, STACK, A, S, ROW, TAG,
+ PAD, MONO, b, ph, tw, mix, Svg, H_)
+
+MINI = (1664, 912, 192, 108) # the minimap's place in the working frame: x, y, w, h
+K = 1 / 20 # map units to the minimap's
+RSP, UNDER = D.RSP, 16 # the map's stack starts 16 words above rsp
+ROLES = {0: "saved rbp", 3: "saved rbx", 4: "saved rbp", 26: "saved rbp", 38: "saved rbp", 42: "argc",
+ 43: "argv[0]", 44: "argv end", 45: "envp end", 46: "auxv"}
+FRAMES = [("reverse", 0, 1), ("main", 2, 5), ("libc+27781", 6, 27), ("__libc_start_main", 28, 39), ("_start", 40, 999)]
+
+
+def stage(map_):
+ """Set the blocks' globals for the map (3840) or the working frame (1920)."""
+ gen.W, gen.H = (3840, 2160) if map_ else (1920, 1080)
+ C.W = gen.W
+ C.TOP, C.BOTTOM = (96, 1784) if map_ else (48, 888)
+ C.LANE_LINK, C.LANE_VIEW = (1912, 1924) if map_ else (950, 962)
+
+
+class Rec(Svg):
+ """An Svg that keeps what it drew, so the minimap can be drawn from it."""
+ def __init__(self):
+ super().__init__()
+ self.log = []
+
+ def t(self, x, y, s, size=30, fill=VELLUM, font="mono", anchor="start"):
+ super().t(x, y, s, size, fill, font, anchor)
+ w = len(s) * 0.6 * size if font.startswith("mono") else tw(s, size, font)
+ x0 = x - w if anchor == "end" else x - w / 2 if anchor == "middle" else x
+ self.log.append(("t", x0, y, w, size, fill))
+
+ def rect(self, x, y, w, h, fill="none", stroke=None, sw=2, dash=None):
+ super().rect(x, y, w, h, fill, stroke, sw, dash)
+ self.log.append(("r", x, y, w, h, fill, stroke))
+
+
+# ---- the map --------------------------------------------------------------------------------------------
+def slot_rows(first, n, step_free=True):
+ """Stack rows from slot `first` (0 is 16 words above rsp): the free ones above rsp, then the stack."""
+ rows = []
+ for i in range(first, first + n):
+ a = RSP + 8 * (i - UNDER)
+ w = D.word(a)
+ if i < UNDER:
+ rows.append((a, [], [], ("int", w), {"free": True}))
+ continue
+ links, end = D.value(w)
+ rows.append((a, ["rbp", "rsp"] if a == RSP else [], links, end))
+ return rows
+
+
+def roles_from(first, n):
+ return {i - first: (t, DIM) for j, t in ROLES.items() for i in [j + UNDER] if first <= i < first + n}
+
+
+def frames_from(first, n):
+ out = []
+ for name, a, z in FRAMES:
+ a, z = a + UNDER - first, z + UNDER - first
+ if z >= 0 and a < n:
+ out.append((name, a if a >= 0 else -1, z))
+ return out
+
+
+def node_marks(step):
+ return {"tick": [0x10040b8]} | ({"read": 0x1004098} if step else {})
+
+
+def pins(step):
+ return {0x10040b0: ["rcx"], 0x1004090: ["rax"] + ([] if step else ["rdi"]), 0x1004070: ["rdi"] if step else []}
+
+
+def draw_map(g, step, loupe, subject=False):
+ """The map at one moment. Returns the outlines of the working frame's windows, in map units."""
+ stage(True)
+ sp = C.SUBJECT if subject else C.BESIDE
+ col = D.COL
+ win = {}
+ # A: the lens's drawing at its subject size, the file whole, the backtrace whole, the key
+ D.put(col[0])
+ C.RX = col[2]
+ C.lens(g, 96, 296, 0, D.NODES, pins(step), node_marks(step), 0x1004000, 0, subject=True, view_rows={}, ties=False)
+ win["drawing"] = (col[0], 96, D.CW, 296)
+ ys = C.source(g, 404, 42, D.SRC, 1, 21, [], "list.c", 42)
+ first = 18 if subject else 19
+ win["source"] = (col[0], 404 + TAG + PAD + (first - 1) * ROW, D.CW, sp["src"] * ROW)
+ D.put(col[0])
+ C.backtrace(g, 1456, ph(5), D.BT, x=col[0], note="newest on top")
+ key(g, col[0], 1620, step)
+ # B: 69 instructions, the function and its neighbours
+ D.put(col[1])
+ rows = D.window(69, step)
+ at = C.disasm(g, 96, rows, "reverse", 21)
+ D.thread_across(g, ys, [(at[0x1001926], at[0x1001926] + ROW)])
+ wn = [r[0] for r in D.window(sp["dis"], step)]
+ win["disasm"] = (col[1], at[wn[0]], D.CW, sp["dis"] * ROW)
+ # C: memory, the registers, a loupe, the stack continued
+ D.put(col[2])
+ mem = C.fields(g, 96, ph(14), "the heap, round what the step reads", 0x1004000, 512,
+ D.heap_fields(0x1004000, 512, 0x1004098), D.MEM, HEAP, D.region, marks=(9,) if step else (),
+ title="memory")
+ win["view"] = (col[2], mem[0x1004050 if subject else 0x1004070], D.CW, (7 if subject else 5) * ROW)
+ C.registers(g, 476, D.regs(step), D.FLAGS, {"rax": {0: "tick"}, "rcx": {0: "tick"},
+ "rdi": {0: "strike" if step else "tick"}})
+ win["registers"] = (col[2], 476, D.CW, ph(17))
+ y = 476 + ph(17) + 12
+ if loupe:
+ lys = D.loupe(g, col[2], y, [("rdi", DIM), (" → ", FAINT), ("1004070", HEAP)], "heap · struct node, 16 bytes",
+ 0x1004030, D.heap_fields(0x1004030, 144), [(0x1004070 - 0x1004030, 16)], 0)
+ win["loupe"] = (col[2], lys[0x1004050], D.CW, 5 * ROW)
+ y += ph(9) + 12
+ n_c = (1784 - y - TAG - 2 * PAD) // ROW
+ # D: the stack, 16 words above rsp and on; what does not fit continues at C's foot, then `more`
+ D.put(col[3])
+ C.stack(g, 96, slot_rows(0, 69), frames_from(0, 69), note="from rsp-80", rsp=RSP, roles=roles_from(0, 69))
+ win["stack"] = (col[3], 96 + TAG + PAD + UNDER * ROW, D.CW, sp["words"] * ROW)
+ D.put(col[2])
+ C.stack(g, y, slot_rows(69, n_c - 1), frames_from(69, n_c - 1), note="continued", rsp=RSP,
+ roles=roles_from(69, n_c - 1))
+ left = (0x7ffffffff000 - (RSP + 8 * (69 + n_c - 1 - UNDER))) // 8
+ g.rect(col[2] + 2, y + ph(n_c - 1) - 2, D.CW - 4, 2, PAGE) # one row longer: the `more` row is the panel's
+ g.frame(col[2], y, D.CW, ph(n_c), RULE, 2)
+ yy = y + TAG + PAD + (n_c - 1) * ROW
+ C.more(g, col[2] + 184 - 6, yy)
+ g.t(col[2] + 184 + 66, b(yy), "%d words, to the stack's top" % left, S, FAINT, MONO)
+ # the windows the working frame shows: an outline round each, 4 out
+ for x, y0, w, h in win.values():
+ g.frame(x - 4, y0 - 4, w + 8, h + 8, DIM, 2)
+ return win
+
+
+def key(g, x, y, step):
+ """The map's key, at the foot of a column it leaves: what this is, and its marks."""
+ y0 = C.panel(g, x, y, D.CW, 5, "the map", note="targets/list · moment %d of 4" % (3 if step else 2))
+ g.t(x + 12, b(y0), "every panel whole; the working frame's windows outlined", 18, DIM, "sans")
+ items = [("current", lambda xx, yy: C.current_row(g, xx, yy, 120, 24)), ("struck", lambda xx, yy: C.struck(g, xx, yy, 60)),
+ ("read", lambda xx, yy: g.frame(xx, yy, 60, ROW, READ, 2)), ("held", lambda xx, yy: C.held(g, xx + 8, yy, 40)),
+ ("window", lambda xx, yy: g.frame(xx, yy, 60, ROW, DIM, 2))]
+ for i, (name, draw) in enumerate(items):
+ xx, yy = x + 12 + (i % 3) * 290, y0 + (1 + i // 3) * ROW + 8
+ draw(xx, yy)
+ g.t(xx + 136, b(yy), name, 18, DIM, "sans")
+
+
+# ---- the minimap -------------------------------------------------------------------------------------------
+INKED = {GOLD, C.SOFT, VERM, C.WASH, RAISED, D.LIFT, D.LIFT_TAG, READ}
+
+
+def minimap(g, log, windows, x0, y0, k=K, focus="drawing"):
+ """The map at k: every run of text a stroke 1 high in its ink at 45% toward the page; tags, paper and the
+ lift as blocks; the marks over them; the working frame's windows outlined, the one in focus 2."""
+ W, H = 3840 * k, 2160 * k
+ g.rect(x0, y0, W, H, PAGE)
+ marks = []
+ for e in log:
+ if e[0] == "r":
+ _, x, y, w, h, fill, stroke = e
+ if fill in (GOLD, C.SOFT, VERM) or stroke in (READ, VERM, BRIGHT):
+ marks.append(e)
+ elif fill in INKED and w * k >= 1:
+ g.rect(x0 + x * k, y0 + y * k, max(w * k, 1), max(h * k, 1), mix(fill, PAGE, 0.7 if fill == RAISED else 0.6))
+ elif stroke in (RULE, DIM) and w > 200:
+ g.frame(x0 + x * k, y0 + y * k, w * k, h * k, mix(RULE, PAGE, 0.8), 1)
+ elif e[2] < 2100 and e[5] not in (None, "none"):
+ _, x, y, w, size, fill = e
+ g.rect(x0 + x * k, y0 + (y - size * 0.62) * k, max(w * k, 0.8), max(size * 0.05, 0.9), mix(fill, PAGE, 0.55))
+ for _, x, y, w, h, fill, stroke in marks: # the marks: gold, a strike, a read; at least a pixel and a half
+ ink = fill if fill in (GOLD, C.SOFT, VERM) else stroke
+ if ink == C.SOFT:
+ ink = VERM
+ if ink == BRIGHT:
+ continue
+ g.rect(x0 + x * k, y0 + y * k, max(w * k, 1.5), max(h * k, 1.5), ink)
+ for name, (x, y, w, h) in windows.items():
+ g.frame(x0 + (x - 4) * k, y0 + (y - 4) * k, (w + 8) * k, (h + 8) * k, BRIGHT if name == focus else VELLUM,
+ 1.5 if name == focus else 1)
+ g.frame(x0, y0, W, H, RULE, 1)
+
+
+def map_log(step, loupe, subject=False):
+ stage(True)
+ m = Rec()
+ win = draw_map(m, step, loupe, subject)
+ return m, win
+
+
+# ---- the working frame -------------------------------------------------------------------------------------
+BESIDE_VIEW = [7, 8, 9, 10, 11] # the view's rows (of the heap's 32): 1004070 to 10040b0
+SUBJECT_VIEW = [5, 6, 7, 8, 9, 10, 11]
+
+
+def clock(g, moment, total):
+ g.rect(64, 899, 1792, 2, RULE)
+ g.rect(64, 898, 1792 * moment / total, 4, GOLD)
+ g.t(MINI[0] - 16, 934, "moment %d of %d" % (moment, total), S, FAINT, MONO, "end")
+
+
+def working_panels(g, step, subject, wrap=lambda name: ("", "")):
+ """The working frame's panels, each between the strings wrap(name) gives (a transform, for the dive)."""
+ stage(False)
+ sp = C.SUBJECT if subject else C.BESIDE
+ out = {}
+
+ def open_(name):
+ o, c = wrap(name)
+ g.o.append(o) if o else None
+ return c
+
+ y = 48 + sp["band"] + 12
+ c = open_("source")
+ D.put(64)
+ ys = C.source(g, y, sp["src"], D.SRC, 18 if subject else 19, 21, [], "list.c", 42)
+ g.o.append(c) if c else None
+ c = open_("disasm")
+ at = C.disasm(g, y + ph(sp["src"]) + 12, D.window(sp["dis"], step), "reverse", 21)
+ g.o.append(c) if c else None
+ out["thread"] = (ys, at[0x1001926])
+ yr = 48 + sp["view"] + 12
+ c = open_("registers")
+ D.put(976)
+ out["regs"] = C.registers(g, yr, D.regs(step), D.FLAGS, {"rax": {0: "tick"}, "rcx": {0: "tick"},
+ "rdi": {0: "strike" if step else "tick"}})
+ g.o.append(c) if c else None
+ c = open_("stack")
+ n = sp["words"]
+ C.stack(g, yr + ph(17) + 12, slot_rows(UNDER, n), frames_from(UNDER, n), rsp=RSP, roles=roles_from(UNDER, n))
+ g.o.append(c) if c else None
+ c = open_("view")
+ view = C.fields(g, 48, sp["view"], "the heap, %x to %x" % (0x1004000 + 16 * (SUBJECT_VIEW if subject else BESIDE_VIEW)[0],
+ 0x10040bf), 0x1004000, 512, D.heap_fields(0x1004000, 512, 0x1004098), D.MEM, HEAP, D.region,
+ marks=(9,) if step else (), rows_shown=SUBJECT_VIEW if subject else BESIDE_VIEW, more_rows=False)
+ g.o.append(c) if c else None
+ out["view"] = view
+ return out, sp
+
+
+def working(name, step, subject=False, loupe=False, caption=None):
+ """A working frame at 1920 by 1080, with its minimap."""
+ m, win = map_log(step, loupe, subject)
+ stage(False)
+ g = Svg()
+ out, sp = working_panels(g, step, subject)
+ D.put(64)
+ C.thread(g, out["thread"][0], [(out["thread"][1], out["thread"][1] + ROW)])
+ D.put(64)
+ C.RX = 976
+ C.lens(g, 48, sp["band"], sp["view"], D.NODES, pins(step), node_marks(step), 0x1004000, 32,
+ link_from=(out["regs"]["rdi"], "rdi") if step and not loupe else None, subject=subject, view_rows=out["view"],
+ ties=not loupe)
+ if loupe: # opened under its pointer, rdi's new value: the heap round 1004070
+ ry = out["regs"]["rdi"]
+ hop = 976 + 72
+ lx, ly = 956, ry + ROW - 1 # it hangs from its pointer: its tag on the row's foot, the rows under rdi covered whole
+ D.loupe(g, lx, ly, [("rdi", DIM), (" → ", FAINT), ("1004070", HEAP)], "heap · struct node, 16 bytes",
+ 0x1004050, D.heap_fields(0x1004050, 80), [(0x1004070 - 0x1004050, 16)], 1, rows=5)
+ g.rect(hop - 2, ry + ROW - 3, 7 * A + 4, 4, HEAP) # the stem, short: a bracket under the pointer's digits, on the tag
+ minimap(g, m.log, win, *MINI[:2], focus="loupe" if loupe else "drawing")
+ clock(g, 3 if step else 2, 4)
+ gen.caption(g, caption)
+ g.save(name)
+
+
+# ---- the dive: the map coming in to the working frame, four instants -------------------------------------
+def glide(t):
+ """The glide curve (0.45, 0, 0.55, 1), solved for t."""
+ lo, hi = 0.0, 1.0
+ for _ in range(40):
+ s = (lo + hi) / 2
+ x = 3 * (1 - s) ** 2 * s * 0.45 + 3 * (1 - s) * s * s * 0.55 + s ** 3
+ lo, hi = (s, hi) if x < t else (lo, s)
+ return 3 * (1 - s) * s * s + s ** 3
+
+
+FRAME_RECT = {"source": (64, 212, 880, ph(8)), "disasm": (64, 448, 880, ph(17)), "registers": (976, 212, 880, ph(17)),
+ "stack": (976, 664, 880, ph(8)), "view": (976, 48, 880, 152), "drawing": (64, 48, 880, 152)}
+
+
+def dive(name, e, veil, outline, fade_frame):
+ """One instant of `dive`: e, the move's progress (glide applied), veil on the map, the windows' outline, how
+ far the working frame's own tags and minimap have come in."""
+ m, win = map_log(False, False)
+ body = m.o[1:] # the map's drawing, its page and all, without its svg head
+ stage(False)
+ g = Svg()
+ sm = 0.5 ** (1 - e) * K ** e # the map: from filling the frame to the minimap, on the log of its scale
+ tx, ty = MINI[0] * e, MINI[1] * e
+ g.o.append('<g transform="translate(%.2f,%.2f) scale(%.4f)">' % (tx, ty, sm))
+ g.o += body
+ if veil:
+ g.o.append('<rect width="3840" height="2160" fill="%s" opacity="%.2f"/>' % (PAGE, veil))
+ for x, y, w, h in win.values():
+ if outline:
+ g.o.append('<rect x="%.1f" y="%.1f" width="%.1f" height="%.1f" fill="none" stroke="%s" stroke-width="%.1f"/>'
+ % (x - 4, y - 4, w + 8, h + 8, BRIGHT, 2 + outline * 2))
+ g.o.append("</g>")
+ # each window: the working panel, from its place on the map to its own, its scale on a logarithm
+ map_rect = {"source": win["source"], "disasm": win["disasm"], "registers": win["registers"], "stack": win["stack"],
+ "view": win["view"], "drawing": win["drawing"]}
+
+ def wrap(nm):
+ if nm not in FRAME_RECT:
+ return "", ""
+ fx, fy, fw, fh = FRAME_RECT[nm]
+ mx, my, mw, mh = map_rect[nm]
+ # at e = 0 the panel's first row lies on its window's first row on the map, both at half size; at e = 1
+ # the panel is at its own place and size. Scale on its logarithm, the offset with the move.
+ row0 = fy if nm in ("registers", "drawing") else fy + TAG + PAD
+ sw = 0.5 ** (1 - e)
+ ox, oy = (mx - fx) * 0.5 * (1 - e), (my - row0) * 0.5 * (1 - e)
+ return '<g transform="translate(%.2f,%.2f) scale(%.4f)">' % (ox, oy, sw), "</g>"
+
+ if e > 0:
+ working_panels(g, False, False, wrap)
+ o, c = wrap("drawing")
+ g.o.append(o)
+ D.put(64)
+ C.RX = 976
+ C.lens(g, 48, 152, 152, D.NODES, pins(False), node_marks(False), 0x1004000, 32, view_rows={0x1004090: 0},
+ ties=False)
+ g.o.append(c)
+ if fade_frame > 0:
+ g.o.append('<g opacity="%.2f">' % fade_frame)
+ minimap(g, m.log, win, *MINI[:2])
+ clock(g, 2, 4)
+ g.o.append("</g>")
+ gen.caption(g, [[("Stopped in ",), ("reverse", "mono"), (", about to load ",), ("head->next", "mono"), (".",)],
+ [("rdi", "mono"), (" points at a node; the word after its value is the next node.",)]])
+ g.save(name)
+
+
+def sheet(names, out, labels):
+ """Four 1920 by 1080 instants on one 3840 by 2160 sheet, each at its own size."""
+ tiles = []
+ for n in names:
+ subprocess.run(["resvg", n + ".svg", n + ".png"], check=True)
+ tiles.append(Image.open(n + ".png").convert("RGB"))
+ s = Image.new("RGB", (3840, 2160), "#000000")
+ font = ImageFont.truetype("/usr/share/fonts/TTF/JetBrainsMonoNL-Medium.ttf", 28)
+ d = ImageDraw.Draw(s)
+ for i, (t, lab) in enumerate(zip(tiles, labels)):
+ x, y = (i % 2) * 1920, (i // 2) * 1080
+ s.paste(t, (x, y))
+ d.rectangle((x + 8, y + 8, x + 8 + 18 * len(lab), y + 48), fill="#000000")
+ d.text((x + 16, y + 12), lab, font=font, fill="#fff8e8")
+ s.save(out)
+
+
+if __name__ == "__main__":
+ import os
+ stage(True)
+ g = Rec()
+ draw_map(g, True, True)
+ D.clock4(g, 3, 4)
+ D.caption4(g, [[("The map: this moment of ",), ("targets/list", "mono"), (", every panel whole.",)],
+ [("The working frame's windows are outlined; a scene comes in from here.",)]])
+ g.save("19-map")
+ cap9 = [[("Stopped in ",), ("reverse", "mono"), (", about to load ",), ("head->next", "mono"), (".",)],
+ [("rdi", "mono"), (" points at a node; the word after its value is the next node.",)]]
+ cap10 = [[("The load read the word at ",), ("1004098", "mono"), (": the address of the next node.",)],
+ [("rdi", "mono"), (" holds it now, and points at the node whose value is 9.",)]]
+ working("09-context", False, caption=cap9)
+ working("10-context-step", True, caption=cap10)
+ working("11-context-lens", True, subject=True, caption=cap10)
+ working("21-loupe", True, loupe=True,
+ caption=[[("rdi", "mono"), (" holds ",), ("1004070", "mono"), ("; under it opens the heap round that node.",)],
+ [("The minimap shows the same loupe at its place on the map.",)]])
+ names = ["20a", "20b", "20c", "20d"]
+ dive("20a", 0, 0, 0, 0)
+ dive("20b", 0, 0.5, 1, 0)
+ dive("20c", glide(0.5), 0.5, 1, 0)
+ dive("20d", 1, 0.5, 0, 1)
+ sheet(names, "20-dive.png", ["frame 0: the map", "frame 24: windows bright, the rest veiled",
+ "frame 60: halfway", "frame 96: the working frame"])
+ for n in names:
+ os.remove(n + ".svg")
+ os.remove(n + ".png")