summaryrefslogtreecommitdiff
path: root/anim/src/map.zig
diff options
context:
space:
mode:
Diffstat (limited to 'anim/src/map.zig')
-rw-r--r--anim/src/map.zig59
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).