summaryrefslogtreecommitdiff
path: root/anim/src/theme.zig
diff options
context:
space:
mode:
Diffstat (limited to 'anim/src/theme.zig')
-rw-r--r--anim/src/theme.zig90
1 files changed, 90 insertions, 0 deletions
diff --git a/anim/src/theme.zig b/anim/src/theme.zig
index cb52287..7d505d7 100644
--- a/anim/src/theme.zig
+++ b/anim/src/theme.zig
@@ -134,6 +134,17 @@ pub const layout = struct {
/// its view 200 (a dump of seven); ten lines over nine
/// instructions; the registers over six words, a small frame whole.
pub const subject: Split = shared(296, 200, 10, 9, 6, 7);
+ /// The `blocks` lens: its drawing (the graph as shapes) 296 high
+ /// over the program column, which then holds the source alone
+ /// (twenty lines); its view the disassembly itself, seven rows over
+ /// the state column; the registers over six words.
+ pub const blocks: Split = blk: {
+ var s = subject;
+ s.disasm = .{ .x = state.x, .y = canvas.stage.y, .w = state.w, .h = panelH(7) };
+ s.view = .{ .x = state.x, .y = canvas.stage.y, .w = state.w, .h = 0 };
+ s.source.h = panelH(20);
+ break :blk s;
+ };
fn shared(drawing_h: f32, view_h: f32, source_rows: f32, disasm_rows: f32, slots: f32, dump_rows: u32) Split {
const band: Rect = .{ .x = program.x, .y = canvas.stage.y, .w = program.w, .h = drawing_h };
@@ -675,6 +686,66 @@ pub const metric = struct {
pub const bottom_lane = 8;
};
+ /// `graph` (design/README.md, "graph"): on the map a block is a head of
+ /// 24 and its rows: the offset ranged right at 72, the line at 116, the
+ /// mnemonic at 128, the operands at 212; 300 wide at least; over 16
+ /// rows, where the graph is too tall, its first four, `more` and its
+ /// last four. Layers 48 apart, blocks 56; lanes 16 apart from 24 in, the
+ /// blocks 24 right of the last; the first layer 36 under the tag; a back
+ /// edge down 14; ports 40 in; arrivals 48 apart; the right channel 32
+ /// out; corners 8; the way out's stub 14 and bar 28; a call's hook 14
+ /// out and back a row down. A fold of blocks never reached: 520 wide.
+ /// Columns are as far apart as the pc's block is wide with its annotation.
+ /// The `blocks` lens at half measure: boxes 24 high, 60 and 10 a row
+ /// wide, 132 at least, columns 300 apart; layers 12 apart, lanes 10.
+ pub const graph = struct {
+ pub const offset = 72;
+ pub const line = 116;
+ pub const mnemonic = 128;
+ pub const operands = 212;
+ pub const least = 300;
+ pub const long = 16;
+ pub const keep = 4;
+ pub const layer_gap = 48;
+ pub const block_gap = 56;
+ pub const lane = 16;
+ pub const lane_in = 24;
+ pub const top = 36;
+ pub const back_down = 14;
+ pub const port = 40;
+ pub const arrivals = 48;
+ pub const channel = 32;
+ pub const corner = 8;
+ pub const exit_stub = 14;
+ pub const exit_bar = 28;
+ pub const hook = 14;
+ pub const fold_w = 520;
+ pub const head = [2]f32{ 10, 10 };
+ /// The rows are `insn`'s, `shift` left (its address column given to
+ /// the offset); the pc's block widens to its column for the
+ /// annotation, 30 characters from where `insn` puts it.
+ pub const shift = 52;
+ pub const note = 360;
+ pub const lens = struct {
+ pub const box = 24;
+ pub const lead = 60;
+ pub const per_row = 10;
+ pub const least = 132;
+ pub const pitch = 300;
+ pub const layer_gap = 12;
+ pub const lane = 10;
+ pub const blocks_in = 76;
+ pub const top = 14;
+ pub const port = 16;
+ pub const channel = 20;
+ pub const back_down = 8;
+ pub const corner = 4;
+ pub const head = [2]f32{ 7, 8 };
+ /// The pc's box: framed gold this wide.
+ pub const gold = 3;
+ };
+ };
+
/// The ties' channels: the thread in the left margin, the gutter's two
/// lanes (a link comes up the left, a projection down the right).
pub const tie = struct {
@@ -932,6 +1003,25 @@ pub const time = struct {
pub const out = 0.20;
pub const names = 0.20;
};
+ /// `leave` (and `turn`, along a loop's lane): the jump fires; the
+ /// compare's chips framed as read from `chips` (the CPU's slot); the
+ /// edge it takes drawn gold over `edge`, ending as the mark sets off at
+ /// `sets_off`; the mark along it `mark` and `per_100` a 100 units,
+ /// `mark_most` at most (`run` at a run); the target's count struck
+ /// `count` after it lands; the oldest trail edge cooled over `trail`;
+ /// `rest` from the landing to the step's end.
+ pub const leave = struct {
+ pub const chips = 0.30;
+ pub const edge = 0.30;
+ pub const sets_off = 0.70;
+ pub const mark = 0.20;
+ pub const per_100 = 2.0 / 60.0;
+ pub const mark_most = 0.50;
+ pub const count = 0.10;
+ pub const trail = 0.30;
+ pub const rest = 0.70;
+ pub const run = 8.0 / 60.0;
+ };
/// A return in the calls tree: its frame leaves the backtrace as the
/// idea strikes, and the result on the node's shoulder this long after.
pub const badge_after = 0.20;