diff options
Diffstat (limited to 'anim/src/map.zig')
| -rw-r--r-- | anim/src/map.zig | 59 |
1 files changed, 48 insertions, 11 deletions
diff --git a/anim/src/map.zig b/anim/src/map.zig index c870d60..108bafd 100644 --- a/anim/src/map.zig +++ b/anim/src/map.zig @@ -96,7 +96,7 @@ pub fn row(panel: Panel, key: u64, u: ui.Ui, r: Rect) void { /// lens's view, the registers, and in the rest the stack going on /// (`continued`), in the third; the stack in the fourth, whole. // shortcut: a column's rest after the disassembly is page: the 5-row dumps round what the registers point at, the open loupes and the key are not built. -pub fn split(rec: *const Recording, lens: bool, way: [2]u64) Split { +pub fn split(rec: *const Recording, lens: bool, way: [2]u64, graph: bool) Split { const st = theme.map.stage; const c = theme.map.columns; const w = theme.map.column; @@ -136,6 +136,25 @@ pub fn split(rec: *const Recording, lens: bool, way: [2]u64) Split { return .{ .x = r.x, .y = y, .w = r.w, .h = @max(bottom - y, 0) }; } }.under; + // The disassembly as its graph (`graph.Map`): two columns wide beside the + // source, the drawing it is (no band); the registers over the stack in the last. + if (graph) { + const regs: Rect = .{ .x = c[3], .y = st.y, .w = w, .h = panelH(17) }; + const nothing: Rect = .{ .x = c[3], .y = st.y, .w = w, .h = 0 }; + const src: Rect = .{ .x = c[0], .y = st.y, .w = w, .h = panelH(@floatFromInt(@min(rec.line_count, theme.layout.rowsIn(foot - st.y - gap - panelH(bt_rows))))) }; + const bt: Rect = .{ .x = c[0], .y = src.y + src.h + gap, .w = w, .h = @min(panelH(bt_rows), foot - (src.y + src.h + gap)) }; + return .{ + .band = .{ .x = c[0], .y = st.y, .w = w, .h = 0 }, + .view = nothing, + .source = src, + .disasm = .{ .x = c[1], .y = st.y, .w = c[2] + w - c[1], .h = st.h }, + .registers = regs, + .stack = rest(regs, foot), + .backtrace = bt, + .dump_rows = theme.map.memory_rows, + .spare = .{ rest(bt, foot), .{ .x = c[1], .y = foot, .w = w, .h = 0 } }, + }; + } return .{ .band = band, .view = view, @@ -322,6 +341,10 @@ pub const Map = struct { cursor: ?@import("cursor.zig").Cursor = null, /// The scene's loupes: open, each is a panel of its own on the map (`Spare`). loupes: [2]?*const @import("loupe.zig").Loupe = .{ null, null }, + /// The disassembly is its graph (`graph.Map`): the thread is its digits, + /// no line crosses the lanes; the band's window is the whole graph; the + /// disassembly's, the rows it shows. + graph: bool = false, const Part = struct { ctx: *const anyopaque, draw: *const fn (*const anyopaque, *sk.Frame, anim.Placed) void }; @@ -340,7 +363,7 @@ pub const Map = struct { /// Puts a drawing on the map, in a band of its own over the source, /// for a scene whose working frame has none (its map is split anew). pub fn drawing(m: *Map, s: *anim.Frame, rec: *const Recording, component: anytype) void { - m.stage.first = split(rec, true, if (m.cursor) |c| .{ c.first, c.last } else .{ 0, 0 }); + m.stage.first = split(rec, true, if (m.cursor) |c| .{ c.first, c.last } else .{ 0, 0 }, m.graph); m.add(s, component); } @@ -371,7 +394,8 @@ pub const Map = struct { /// `surface`: the dive backwards, a little quicker; then the map is /// still before anything plays on it. pub fn surface(m: *const Map, s: *anim.Frame) void { - s.play(.{m.t.to(diving.land)}, .{ .seconds = 0 }); + // A scene that did not open on it has not shown it yet: under the panels until it rises. + s.play(.{ m.t.to(diving.land), m.obj.fadeIn() }, .{ .seconds = 0 }); s.play(.{m.t.to(0)}, .{ .seconds = @as(f32, diving.surface) / 60.0, .ease = anim.ease.linear }); s.wait(@as(f32, diving.still) / 60.0); } @@ -414,7 +438,9 @@ pub const Map = struct { const y = std.math.lerp(from.y, box.y, p); // The tags, rules and lanes come in as the map lands. const chrome = std.math.clamp((t - diving.lift) / 12, 0, 1); - context.zoomed[i] = .{ .box = box, .to = .{ .x = x, .y = y, .w = box.w * scale, .h = box.h * scale }, .chrome = chrome }; + // Out of a graph the rows and the lens are another form of what the map shows there: they come in on their way. + const other = m.graph and (i == @intFromEnum(Panel.disasm) or i == @intFromEnum(Panel.band)); + context.zoomed[i] = .{ .box = box, .to = .{ .x = x, .y = y, .w = box.w * scale, .h = box.h * scale }, .chrome = chrome, .shows = if (other) p else 1 }; }; } } @@ -505,7 +531,7 @@ pub const Map = struct { ui.strokes = mini; counts = @splat(0); for (m.parts[0..m.n]) |p| p.draw(p.ctx, f, at); - if (m.cursor) |c| m.thread(f, at, c.now(at), mini); + if (m.cursor) |c| if (!m.graph) m.thread(f, at, c.now(at), mini); ui.mapping = false; ui.strokes = false; } @@ -559,13 +585,17 @@ pub const Map = struct { /// The top and bottom of the map's rows of panel `i` with keys from `keys[0]` to `keys[1]`, in canvas pixels. fn spanOf(i: usize, keys: [2]u64) ?[2]f32 { - var top: f32 = std.math.inf(f32); - var bottom: f32 = -std.math.inf(f32); + const r = boxOf(i, keys) orelse return null; + return .{ r[1], r[3] }; + } + + /// The box round the map's rows of panel `i` with keys from `keys[0]` to `keys[1]`, in canvas pixels. + fn boxOf(i: usize, keys: [2]u64) ?[4]f32 { + var r: [4]f32 = .{ std.math.inf(f32), std.math.inf(f32), -std.math.inf(f32), -std.math.inf(f32) }; for (rows[i][0..counts[i]]) |rw| if (rw.key >= keys[0] and rw.key <= keys[1]) { - top = @min(top, rw.box[1]); - bottom = @max(bottom, rw.box[3]); + r = .{ @min(r[0], rw.box[0]), @min(r[1], rw.box[1]), @max(r[2], rw.box[2]), @max(r[3], rw.box[3]) }; }; - return if (top < bottom) .{ top, bottom } else null; + return if (r[1] < r[3]) r else null; } /// Where the map's row of key `key` in `panel` is this frame, in canvas pixels. @@ -585,7 +615,8 @@ pub const Map = struct { inline for (.{ "band", "view", "source", "disasm", "registers", "stack", "backtrace" }) |name| { const panel = @field(Panel, name); const i = @intFromEnum(panel); - const box = @field(split_, name); + // The lens drawing the graph is: its window is the graph whole. + const box = if (m.graph and panel == .band) split_.disasm else @field(split_, name); if (box.h > 0) { const a = at.xf.apply(.{ box.x, box.y }); const b = at.xf.apply(.{ box.x + box.w, box.y + box.h }); @@ -606,6 +637,12 @@ pub const Map = struct { r[1] = std.math.lerp(snap(from[0], mini), snap(to[0], mini), win.p); r[3] = std.math.lerp(snap(from[1], mini), snap(to[1], mini), win.p); shown = true; + // In a graph the rows a window shows are in blocks: round them, not the panel's width. + if (m.graph and panel == .disasm) if (boxOf(i, win.now)) |round| { + const was_box = boxOf(i, win.was) orelse round; + r[0] = std.math.lerp(snap(was_box[0], mini), snap(round[0], mini), win.p); + r[2] = std.math.lerp(snap(was_box[2], mini), snap(round[2], mini), win.p); + }; } } // On the minimap on whole pixels (a window's ends already are, at rest). |
