fc398bd1f9
- 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>
147 lines
5.3 KiB
Rust
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());
|
|
}
|