Files
Marcos Paulo fc398bd1f9 feat: screens, packed pages, per-layer change log and canvas perf
- Screens: frames can be declared screens or overlays (set_screens, inspector toggles,
  "Declare N screens"). Agent edits to layers hidden behind a drawer/modal in a screen
  are refused unless allowHidden; partly covered ones are reported. get_basic_info lists
  screens, get_node_info reports visibility, lint skips hidden layers, On click lists
  screens, nested screens get canvas labels. Spec in specs/screens.
- Pages and versions are stored as zstd-compressed compact JSON (.json.zst, format v3);
  legacy .json still reads and is replaced on save.
- Editor keeps a per-layer change log; the scene cache re-tessellates only changed layers
  and no longer keeps a copy of every node (less RAM).
- Canvas perf: zoom settle and LOD, 24-byte vertices, vsync-paced redraws, idle hover
  skip, malloc relief when idle, off-screen frame labels skipped, layer-panel heights
  memoized across frames, run recount on a background thread.
- Frame labels: no label on tiny frames, overlapping labels dropped, ellipsis.
- Selects: menu sizes to content (capped), path labels keep the name, scroll, tooltips.
- Settings: performance monitor page, agent logos, chat page scroll fix.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-27 22:55:43 -03:00

147 lines
5.3 KiB
Rust

//! Performance guards: 10k elements stay smooth because unchanged nodes are never
//! re-tessellated and panning never re-uploads geometry.
mod common;
use common::*;
use papercraft::editor::Editor;
use papercraft::geom::{Rect, V2, v2};
use papercraft::model::{Color, Node, NodeId, NodeKind};
use papercraft::render::gpu::{CanvasRenderer, OFFSCREEN_FORMAT};
use papercraft::render::scene::{self, SceneCache};
use std::time::Instant;
pub fn ten_thousand() -> Editor {
let mut e = editor(1600.0, 1000.0);
let mut tx_nodes = Vec::new();
for i in 0..10_000u64 {
let (x, y) = ((i % 100) as f64 * 60.0, (i / 100) as f64 * 60.0);
let kind = match i % 4 {
0 => NodeKind::Rect,
1 => NodeKind::Ellipse,
2 => NodeKind::Star {
points: 5,
inner: 0.5,
},
_ => NodeKind::Text {
text: format!("#{i}"),
font_size: 12.0,
auto_width: true,
align: papercraft::model::TextAlign::Left,
},
};
let mut n = Node::new(NodeId(0), kind, Rect::new(x, y, 40.0, 40.0));
n.style
.set_fill(Some(Color::rgb((i * 7 % 255) as u8, 120, 200)));
tx_nodes.push(n);
}
e.begin("Bulk");
{
let mut tx = e.tx();
for mut n in tx_nodes {
n.id = tx.alloc_id();
tx.insert(n, None, None);
}
}
e.commit();
e
}
#[test]
fn ten_thousand_elements_cache_and_pan_without_rework() {
let mut e = ten_thousand();
assert_eq!(e.doc.nodes.len(), 10_000);
// Whole board in view (worst case: everything visible).
e.zoom_to_fit();
let mut cache = SceneCache::default();
let t0 = Instant::now();
let f1 = scene::canvas(&e, &mut cache, V2::ZERO, true);
let first = t0.elapsed();
assert_eq!(cache.last_misses, 10_000);
let t1 = Instant::now();
let f2 = scene::canvas(&e, &mut cache, V2::ZERO, true);
let second = t1.elapsed();
assert_eq!(
cache.last_misses, 0,
"an unchanged frame tessellates nothing"
);
assert_eq!(f1.items.len(), f2.items.len());
eprintln!("10k nodes: first frame {first:?}, cached frame {second:?}");
// The cached frame is far cheaper than the first and well under a 60 fps budget even
// in an unoptimized test build.
assert!(second * 4 < first, "{second:?} vs {first:?}");
// Editing one node re-tessellates just that node.
let id = e.doc.root[5000];
e.edit("Move", |tx| tx.node_mut(id).unwrap().rect.x += 5.0);
scene::canvas(&e, &mut cache, V2::ZERO, true);
assert_eq!(cache.last_misses, 1);
// A change that keeps the position (a fill), its undo and a scroll come from the
// editor's change log, not from comparing nodes.
e.edit("Fill", |tx| tx.node_mut(id).unwrap().style.fills = vec![papercraft::model::Paint::solid(Color::rgb(1, 2, 3))]);
scene::canvas(&e, &mut cache, V2::ZERO, true);
assert_eq!(cache.last_misses, 1, "fill change");
e.undo();
scene::canvas(&e, &mut cache, V2::ZERO, true);
assert_eq!(cache.last_misses, 1, "undo");
// A cache further behind than the log redoes everything.
for _ in 0..70 {
e.edit("Move", |tx| tx.node_mut(id).unwrap().rect.x += 1.0);
}
scene::canvas(&e, &mut cache, V2::ZERO, true);
assert_eq!(cache.last_misses, 10_000, "log overflow");
// Panning: same items, so the GPU world buffers are reused (no upload).
let Some(g) = gpu() else { return };
let mut r = CanvasRenderer::new(&g.device, OFFSCREEN_FORMAT);
let tex = g.target([800, 500]);
let view = tex.create_view(&Default::default());
let mut draw = |e: &Editor, cache: &mut SceneCache| {
let f = scene::canvas(e, cache, V2::ZERO, true);
let mut enc = g.device.create_command_encoder(&Default::default());
r.render(
&g.device,
&g.queue,
&mut enc,
&view,
[800, 500],
1.0,
&f,
[1.0; 4],
);
g.queue.submit([enc.finish()]);
};
draw(&e, &mut cache);
for i in 0..5 {
e.camera.pan = e.camera.pan + v2(3.0 * i as f64, 1.0);
draw(&e, &mut cache);
}
drop(draw);
assert_eq!(r.uploads, 1, "panning reuses the uploaded geometry");
}
/// Selecting a layer scrolls the layers panel to it without building every row: the panel
/// stays virtual, so a selection change on a large page costs about one frame.
#[test]
fn revealing_a_layer_builds_only_the_rows_on_screen() {
let mut e = ten_thousand();
let ctx = egui::Context::default();
papercraft::ui::setup_style(&ctx);
let mut st = papercraft::ui::UiState::default();
let input = || egui::RawInput {
screen_rect: Some(egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(1600.0, 1000.0))),
..Default::default()
};
let mut frame = |e: &mut Editor, st: &mut papercraft::ui::UiState| {
papercraft::render::frame::layout(&ctx, input(), e, st).output.textures_delta.clear();
};
frame(&mut e, &mut st);
let target = e.doc.root[9000];
e.selection = vec![target];
st.reveal = Some(target);
frame(&mut e, &mut st);
assert!(st.layer_rows.iter().any(|(id, ..)| *id == target), "the target row is built");
assert!(st.layer_rows.len() < 500, "{} rows built", st.layer_rows.len());
}