Viewport: keep the sketches' box per world state, not every frame (#5223)

projection() reads the model's box for the scene's depth, several times a
frame, and model_bounds() sampled every sketch's curves for it each time,
hidden sketches too. A 533-feature design with 445 sketches spent about 45 ms
of every frame there (stack samples: model_bounds -> Sketch::bounds -> segs ->
spline polylines), so orbiting ran near 16 fps. The sketches' box is now kept
for the world state it was made from, as the bodies' boxes already are.

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
dudedagger42
2026-10-24 21:39:33 +00:00
committed by GitHub
parent 2fd7b6f08d
commit 9e065aa0d5
2 changed files with 47 additions and 3 deletions
+24
View File
@@ -2367,3 +2367,27 @@ fn combine_takes_bodies_clicked_in_the_browser_in(layout: &str, control: bool) {
assert_eq!(d.inputs[0].items, vec![Sel::Body { name: "Block".into() }], "{layout} control={control} target: {:?}", d.inputs);
assert_eq!(d.inputs[1].items, vec![Sel::Body { name: "Cutter".into() }], "{layout} control={control} tools: {:?}", d.inputs);
}
/// The model's box (what every `projection` reads for the scene's depth) is kept per world state,
/// so a design with hundreds of sketches no longer samples them all again each frame, and it still
/// follows the model: a sketch added far away grows it.
#[test]
fn model_bounds_are_kept_until_the_model_changes() {
let mut app = app_with(json!([
{"command": "sketch.create", "params": {"plane": "XY", "name": "Near"}},
{"command": "sketch.circle.center", "params": {"center": [0, 0], "radius": 10}},
{"command": "sketch.finish", "params": {}},
]));
let near = crate::viewport::model_bounds(&app);
assert!((near.max.x - 10.0).abs() < 1e-6, "{near:?}");
assert_eq!(crate::viewport::model_bounds(&app), near, "the same state gives the same box");
for (cmd, p) in [
("sketch.create", json!({"plane": "XY", "name": "Far"})),
("sketch.circle.center", json!({"center": [500, 0], "radius": 5})),
("sketch.finish", json!({})),
] {
app.run(cmd, p).unwrap();
}
let far = crate::viewport::model_bounds(&app);
assert!((far.max.x - 505.0).abs() < 1e-6, "a new sketch grows the box: {far:?}");
}
+23 -3
View File
@@ -61,6 +61,9 @@ pub struct ViewportState {
/// Per-body boxes of one world state, held (not just its address, which a later state can
/// reuse once the old one is freed, so stale boxes would come back).
pick_bounds: std::sync::Mutex<Option<BodyBounds>>,
/// The sketches' box in the world of one world state (held, as `pick_bounds` is). Every
/// `projection` reads it, several times a frame, and each sketch's box samples its curves.
sketch_bounds: std::sync::Mutex<Option<(std::sync::Arc<solidcraft_engine::doc::ModelState>, solidcraft_engine::geom::Aabb3)>>,
/// The model scene's blocks of bodies by key, from the last scene built.
pub(crate) blocks: std::sync::Mutex<std::collections::HashMap<u64, CachedBlock>>,
/// The triangles of each mesh the last scene drew as instances, by the mesh's address (the
@@ -1352,7 +1355,24 @@ type BodyBounds = (std::sync::Arc<solidcraft_engine::doc::ModelState>, std::sync
/// The model's extent: bodies (from the cached boxes) and sketches.
pub fn model_bounds(app: &SolveApp) -> solidcraft_engine::geom::Aabb3 {
let st = crate::open_meshing::shown_world(app);
let mut b = body_bounds(app, &st).iter().fold(solidcraft_engine::geom::Aabb3::EMPTY, |a, (_, x)| a.union(x));
let bodies = body_bounds(app, &st).iter().fold(solidcraft_engine::geom::Aabb3::EMPTY, |a, (_, x)| a.union(x));
let mut b = bodies.union(&sketch_bounds(app, &st));
for point in crate::sketch_attachment_ui::guide_lines(app).into_iter().flatten() {
b.add(point);
}
b
}
/// The box of every sketch of `st` in the world, kept for that state: a design with hundreds of
/// sketches spent most of each frame sampling their splines again for `projection`.
fn sketch_bounds(app: &SolveApp, st: &std::sync::Arc<solidcraft_engine::doc::ModelState>) -> solidcraft_engine::geom::Aabb3 {
if let Ok(g) = app.viewport.sketch_bounds.lock()
&& let Some((k, b)) = g.as_ref()
&& std::sync::Arc::ptr_eq(k, st)
{
return *b;
}
let mut b = solidcraft_engine::geom::Aabb3::EMPTY;
for ss in &st.sketches {
if let Some((lo, hi)) = ss.sketch.bounds() {
for p in [lo, hi] {
@@ -1360,8 +1380,8 @@ pub fn model_bounds(app: &SolveApp) -> solidcraft_engine::geom::Aabb3 {
}
}
}
for point in crate::sketch_attachment_ui::guide_lines(app).into_iter().flatten() {
b.add(point);
if let Ok(mut g) = app.viewport.sketch_bounds.lock() {
*g = Some((std::sync::Arc::clone(st), b));
}
b
}