perf: hovering a large body never waits for its pick index or plan mesh (#3745) (#3766)

The first hover over a large body made two things in the frame: the body's
pick index (its triangles and edges in hierarchies; about 0.3 s for a long
modelled thread, a quarter of a million triangles) and, with the GPU viewport,
the plan mesh a highlighted face is drawn from (about 0.7 s for the same
thread). The window froze for the sum.

A large mesh's pick index is now made on a worker, and picks scan the mesh
until it is there (a few milliseconds); a body's plan mesh is made on a worker
too (`ModelBody::plan_mesh_soon`), and until it is there the hovered face is
lit on the mesh the viewport already has. Small meshes, and the browser build,
make both at once as before.

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
bherbruckandClaude Opus 5.5 authored and GitHub committed 2026-10-20 16:28:11 -04:00
1 parent 9d04e28b51
commit 754eb56e5b
5 files changed
+154 -18

No files matched your search

+34
View File
@@ -163,6 +163,40 @@ impl ModelBody {
.clone()
}
/// [`ModelBody::plan_mesh`] if it is made already; otherwise it is made on a worker thread
/// (once, however often this is asked) and `None` comes back meanwhile, so a caller drawing a
/// frame (a face highlighted under the pointer) is not held up by a large body's plan
/// (#3745): the plan mesh of a long modelled thread takes most of a second. The browser
/// build has no threads: there it is made now.
pub fn plan_mesh_soon(&self) -> Option<Arc<Mesh>> {
let q = crate::display_quality::current();
let cell = self.plan_mesh.get(q.index())?;
if let Some(mesh) = cell.get() {
return mesh.clone();
}
#[cfg(not(target_arch = "wasm32"))]
{
static WARMING: std::sync::Mutex<Vec<usize>> = std::sync::Mutex::new(Vec::new());
let key = Arc::as_ptr(&self.plan_mesh) as usize + q.index();
let Ok(mut warming) = WARMING.lock() else { return None };
if warming.contains(&key) {
return None;
}
let body = self.clone();
let started = std::thread::Builder::new().name("plan-mesh".into()).spawn(move || {
let _ = body.plan_mesh_at(q);
if let Ok(mut warming) = WARMING.lock() {
warming.retain(|k| *k != key);
}
});
if started.is_ok() {
warming.push(key);
return None;
}
}
self.plan_mesh_at(q)
}
/// The display plan and its mesh `k` steps finer than `q` (view-dependent refinement, #1320;
/// see [`crate::display_quality::refinement_for`]). Step 0 is the cached plan at `q`; finer
/// steps are made on each call and kept by the viewport, which evicts them when it runs over
+17
View File
@@ -201,6 +201,23 @@ mod tests {
}
}
/// #3745: a highlight never waits for a body's plan mesh: the first ask starts it on a
/// worker and answers `None`, and once made it is the plan mesh, in the body's own cell.
#[test]
fn plan_mesh_soon_makes_it_on_a_worker() {
let body = ModelBody::new("Pin".into(), kernel::cylinder(Vec3::ZERO, Vec3::Z, 2., 8.).unwrap(), 1);
assert!(body.plan_mesh_soon().is_none(), "not made in the asking frame");
let began = std::time::Instant::now();
let soon = loop {
if let Some(mesh) = body.plan_mesh_soon() {
break mesh;
}
assert!(began.elapsed() < std::time::Duration::from_secs(30), "the worker made it");
std::thread::sleep(std::time::Duration::from_millis(2));
};
assert!(Arc::ptr_eq(&soon, &body.plan_mesh().unwrap()), "the same mesh, in the body's cell");
}
#[test]
fn world_instances_warm_one_definition_and_an_edit_replaces_it() {
let mut doc = crate::Document::new("instances");
+43 -15
View File
@@ -2,7 +2,9 @@
//! triangles and edge segments in hierarchies), made the first time a pick reaches the body and
//! kept while the mesh is. The viewport's picker asks it for the nearest triangle along the
//! cursor's ray and for the edge segments near that ray, then runs its exact screen tests on
//! those alone.
//! those alone. A large mesh's index takes a while to make (a third of a second for a long
//! modelled thread, #3745), so it is made on a worker thread, and picks scan the mesh until it
//! is there: a scan takes a few milliseconds, the index a frame never waits for.
use std::collections::HashMap;
use std::sync::{Arc, Mutex};
@@ -12,21 +14,47 @@ use solidcraft_engine::geom::{Mesh, MeshIndex, Vec3};
use crate::viewport::Proj;
/// Indexes by mesh address, each with its mesh held (so the address stays its own).
/// Indexes by mesh address, each with its mesh held (so the address stays its own); `None`
/// while a worker is still making it.
#[derive(Default)]
pub(crate) struct PickIndexes(Mutex<HashMap<usize, (Arc<Mesh>, Arc<MeshIndex>)>>);
pub(crate) struct PickIndexes(Arc<Mutex<Indexes>>);
type Indexes = HashMap<usize, (Arc<Mesh>, Option<Arc<MeshIndex>>)>;
/// Meshes up to this many triangles and edge points get their index at once (it takes well under
/// a millisecond); larger ones on a worker.
#[cfg_attr(target_arch = "wasm32", allow(dead_code))]
const AT_ONCE: usize = 20_000;
impl PickIndexes {
/// The index of `mesh`, made now when there is none yet.
pub(crate) fn of(&self, mesh: &Arc<Mesh>) -> Arc<MeshIndex> {
/// The index of `mesh`, or `None` while it is being made (the caller scans the mesh).
pub(crate) fn of(&self, mesh: &Arc<Mesh>) -> Option<Arc<MeshIndex>> {
let key = Arc::as_ptr(mesh) as usize;
let Ok(mut map) = self.0.lock() else { return Arc::new(MeshIndex::new(mesh)) };
let Ok(mut map) = self.0.lock() else { return Some(Arc::new(MeshIndex::new(mesh))) };
if let Some((_, index)) = map.get(&key) {
return index.clone();
}
let size = mesh.triangles.len() + mesh.edges.iter().map(Vec::len).sum::<usize>();
#[cfg(not(target_arch = "wasm32"))]
if size > AT_ONCE {
map.insert(key, (mesh.clone(), None));
let (indexes, source) = (self.0.clone(), mesh.clone());
let started = std::thread::Builder::new().name("pick-index".into()).spawn(move || {
let index = Arc::new(MeshIndex::new(&source));
if let Ok(mut map) = indexes.lock()
&& let Some(slot) = map.get_mut(&key)
{
slot.1 = Some(index);
}
});
if started.is_ok() {
return None;
}
}
let _ = size;
let index = Arc::new(MeshIndex::new(mesh));
map.insert(key, (mesh.clone(), index.clone()));
index
map.insert(key, (mesh.clone(), Some(index.clone())));
Some(index)
}
/// Drops the indexes of meshes `keep` no longer names (a new model state).
@@ -59,25 +87,25 @@ pub(crate) fn reach(proj: &Proj, pos: Pos2, px: f32) -> (f64, f64) {
/// The edge segments of `index` that may come within reach of the ray, as (edge, first point),
/// in edge order and then along each edge: the order a scan of every edge would meet them in.
pub(crate) fn segments_near(index: &MeshIndex, mesh: &Mesh, o: Vec3, d: Vec3, (a, b): (f64, f64)) -> Vec<(usize, usize)> {
pub(crate) fn segments_near(index: Option<&MeshIndex>, mesh: &Mesh, o: Vec3, d: Vec3, (a, b): (f64, f64)) -> Vec<(usize, usize)> {
let mut v = Vec::new();
if scanning() {
let Some(index) = index.filter(|_| !scanning()) else {
for (ei, e) in mesh.edges.iter().enumerate() {
v.extend((0..e.len().max(2) - 1).map(|si| (ei, si)));
}
return v;
}
};
index.segments_near(o, d, a, b, |e, s| v.push((e, s)));
v.sort_unstable();
v
}
/// The nearest triangle of `mesh` along the ray, through its index.
pub(crate) fn raycast(index: &MeshIndex, mesh: &Mesh, o: Vec3, d: Vec3) -> Option<(f64, usize)> {
if scanning() {
return mesh.raycast(o, d);
pub(crate) fn raycast(index: Option<&MeshIndex>, mesh: &Mesh, o: Vec3, d: Vec3) -> Option<(f64, usize)> {
match index.filter(|_| !scanning()) {
Some(index) => index.raycast(mesh, o, d),
None => mesh.raycast(o, d),
}
index.raycast(mesh, o, d)
}
#[cfg(test)]
+55
View File
@@ -2118,3 +2118,58 @@ fn convert_mesh_asks_for_the_body_and_converts_the_selected_one() {
let state = h.app.session.model.state();
assert!(!state.body("Mesh").unwrap().body.is_mesh(), "rebuilt as faces");
}
/// #3745: hovering a large body never waits for its pick index. A long modelled thread's mesh
/// has a quarter of a million triangles and its index took a third of a second to make, on the
/// first hover, in the frame. Now the index is made on a worker and the first hovers scan the
/// mesh: the first hover takes a small part of what making the index takes, and still finds
/// the face under the pointer.
#[test]
fn hovering_a_large_body_does_not_wait_for_its_pick_index() {
// A closed ball of 300 000 triangles, inserted as a mesh body.
let (rings, segments) = (500usize, 300usize);
let at = |i: usize, j: usize| {
let (theta, phi) = (std::f64::consts::PI * i as f64 / rings as f64, std::f64::consts::TAU * j as f64 / segments as f64);
[20.0 * theta.sin() * phi.cos(), 20.0 * theta.sin() * phi.sin(), 20.0 * theta.cos()]
};
let mut stl = vec![0u8; 80];
let mut tris: Vec<[[f64; 3]; 3]> = Vec::new();
for i in 0..rings {
for j in 0..segments {
let (a, b, c, d) = (at(i, j), at(i + 1, j), at(i + 1, j + 1), at(i, j + 1));
if i > 0 {
tris.push([a, b, d]);
}
if i + 1 < rings {
tris.push([b, c, d]);
}
}
}
stl.extend((tris.len() as u32).to_le_bytes());
for t in &tris {
stl.extend([0u8; 12]);
for p in t {
for c in p {
stl.extend((*c as f32).to_le_bytes());
}
}
stl.extend([0u8; 2]);
}
let mut h = crate::scenario::Harness::new();
let path = h.dir.join("ball.stl");
std::fs::write(&path, stl).unwrap();
h.app.run("file.insert_mesh", json!({"path": path.to_string_lossy()})).unwrap();
let mesh = h.app.session.world_state().bodies[0].mesh();
assert!(mesh.triangles.len() > 250_000, "{}", mesh.triangles.len());
let t = std::time::Instant::now();
let _ = solidcraft_engine::geom::MeshIndex::new(&mesh);
let index_ms = t.elapsed().as_secs_f64() * 1000.0;
h.app.fit_view();
h.frames(3);
let at = h.at(&json!({"world": [0.0, -20.0, 0.0]})).unwrap();
let t = std::time::Instant::now();
h.step(&json!({"move": at})).unwrap();
let hover_ms = t.elapsed().as_secs_f64() * 1000.0;
assert!(matches!(h.app.viewport.hover, Some(crate::viewport::Hit::Face { .. })), "{:?}", h.app.viewport.hover);
assert!(hover_ms < index_ms / 3.0, "the first hover took {hover_ms:.1} ms; making the index takes {index_ms:.1} ms");
}
+5 -3
View File
@@ -468,7 +468,9 @@ fn shown_mesh(
(app.viewport.gpu.is_some_and(|g| g.tess) && opaque())
.then(|| drawn_plan(app, b, true))
.flatten()
.and_then(|_| b.plan_mesh())
// A large body's plan mesh is made on a worker: until then its faces are lit on the
// mesh drawn here (#3745).
.and_then(|_| b.plan_mesh_soon())
.unwrap_or_else(|| drawn_mesh(app, b))
}
@@ -1343,7 +1345,7 @@ fn pick_hits(app: &SolveApp, proj: &Proj, pos: Pos2, other_sketch_points: bool,
}
}
let m = b.mesh();
if let Some((t, ti)) = crate::pick_index::raycast(&app.viewport.pick_index.of(&m), &m, o, d) {
if let Some((t, ti)) = crate::pick_index::raycast(app.viewport.pick_index.of(&m).as_deref(), &m, o, d) {
let fi = m.tri_face.get(ti).copied().unwrap_or(0) as usize;
let hit = Hit::Face { body: b.name.clone(), index: fi, point: o + d * t };
if bestf.as_ref().is_none_or(|(bt, _)| t < *bt) {
@@ -1381,7 +1383,7 @@ fn pick_hits(app: &SolveApp, proj: &Proj, pos: Pos2, other_sketch_points: bool,
// them, so ties go the same way.
let near = match &seen {
Some(seen) => seen.segments(i, &m),
None => crate::pick_index::segments_near(&app.viewport.pick_index.of(&m), &m, o, d, reach),
None => crate::pick_index::segments_near(app.viewport.pick_index.of(&m).as_deref(), &m, o, d, reach),
};
let mut last_edge = None;
for (ei, si) in near {