SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Open: show a design as its bodies are meshed (#3053) (#3178)
bherbruck47108fa0632c
diff --git a/crates/doc/src/eval.rs b/crates/doc/src/eval.rsindex e9832fdb73..8fa1512eef 100644--- a/crates/doc/src/eval.rs+++ b/crates/doc/src/eval.rs@@ -57,6 +57,9 @@ pub struct ModelBody {bytes: usize,/// In a world state: the [`ModelBody::geometry_key`] of the model body this one places (0: none).source_key: u64,+ /// [`Body::outline_bounds`] of `body` (with the body it was measured on), worked out once+ /// and shared by clones.+ outline: Arc<OnceLock<(Body, solidcraft_geom::Aabb3)>>,}impl ModelBody {@@ -79,6 +82,16 @@ impl ModelBody {imported: None,bytes: 0,source_key: 0,+ outline: Arc::new(OnceLock::new()),+ }+ }++ /// A box around the body without meshing it ([`Body::outline_bounds`]), worked out once.+ pub fn outline_bounds(&self) -> solidcraft_geom::Aabb3 {+ match self.outline.get_or_init(|| (self.body.clone(), self.body.outline_bounds())) {+ (measured, b) if measured.same(&self.body) => *b,+ // The body was replaced in this cell's holder since: measure it again.+ _ => self.body.outline_bounds(),}}diff --git a/crates/engine/src/view.rs b/crates/engine/src/view.rsindex 5e3c19a281..4ce7ec792e 100644--- a/crates/engine/src/view.rs+++ b/crates/engine/src/view.rs@@ -110,10 +110,21 @@ pub fn bounds(s: &Session) -> Aabb3 {/// [`bounds`], with the browser's Sketches folder shown (`sketches`) or hidden.pub fn visible_bounds(s: &Session, sketches: bool) -> Aabb3 {+ bounds_by(s, sketches, |body| body.mesh().bounds())+}++/// [`visible_bounds`] without meshing anything: a body not meshed yet counts with its outline+/// ([`solidcraft_kernel::Body::outline_bounds`]), which a face curving out past all of its edges+/// can exceed. Frames a design whose bodies are still being meshed.+pub fn unmeshed_bounds(s: &Session, sketches: bool) -> Aabb3 {+ bounds_by(s, sketches, |body| body.cached_mesh().map(|m| m.bounds()).unwrap_or_else(|| body.outline_bounds()))+}++fn bounds_by(s: &Session, sketches: bool, of: impl Fn(&solidcraft_doc::ModelBody) -> Aabb3) -> Aabb3 {let st = s.world_state();let mut b = Aabb3::EMPTY;for body in st.bodies.iter().filter(|x| s.body_visible(&x.name)) {- b = b.union(&body.mesh().bounds());+ b = b.union(&of(body));}for ss in st.sketches.iter().filter(|x| sketch_drawn(s, x.feature, sketches)) {// All four corners: on a tilted plane two opposite ones don't span the rectangle.diff --git a/crates/kernel/src/body.rs b/crates/kernel/src/body.rsindex 33db86eebe..5b082e649a 100644--- a/crates/kernel/src/body.rs+++ b/crates/kernel/src/body.rs@@ -1077,6 +1077,52 @@ impl Body {if d.is_finite() && d > 0.0 { d } else { 1.0 }}+ /// A box around the body worked out without meshing it: its vertices and its edges' control+ /// points (a spline lies in the hull of its controls; a face's surface does not count, as an+ /// imported face is often trimmed from a far larger one). A face curving out beyond all of+ /// its edges (a dome on a circle) can reach past it, so it frames a view while the body is+ /// still being meshed; [`Mesh::bounds`] is the exact one.+ /// A mesh body's box is its triangles'.+ pub fn outline_bounds(&self) -> solidcraft_geom::Aabb3 {+ crate::guard("outline bounds", || Ok(self.outline_bounds_unguarded())).unwrap_or(solidcraft_geom::Aabb3::EMPTY)+ }++ fn outline_bounds_unguarded(&self) -> solidcraft_geom::Aabb3 {+ use mt::BoundedCurve;+ let mut b = solidcraft_geom::Aabb3::EMPTY;+ if let Some(m) = &self.mesh {+ for p in &m.positions {+ b.add(*p);+ }+ return b;+ }+ let homogeneous = |b: &mut solidcraft_geom::Aabb3, v: mt::Vector4| {+ if v.w > 0.0 {+ b.add(Vec3::new(v.x / v.w, v.y / v.w, v.z / v.w));+ }+ };+ for v in self.solid.vertex_iter() {+ b.add(from_p3(v.point()));+ }+ for e in self.solid.edge_iter() {+ match e.curve() {+ mt::Curve::Line(l) => {+ b.add(from_p3(l.0));+ b.add(from_p3(l.1));+ }+ mt::Curve::BSplineCurve(c) => c.control_points().iter().for_each(|p| b.add(from_p3(*p))),+ mt::Curve::NurbsCurve(c) => c.control_points().iter().for_each(|p| homogeneous(&mut b, *p)),+ mt::Curve::IntersectionCurve(c) => {+ let (t0, t1) = c.range_tuple();+ for i in 0..=8 {+ b.add(from_p3(mt::ParametricCurve::subs(&e.curve(), t0 + (t1 - t0) * f64::from(i) / 8.0)));+ }+ }+ }+ }+ b+ }+/// The body's volume from a mesh at `tol`, measured once per (solid, tolerance): clones of/// a body share the measurement, so an operand a later boolean takes again is not meshed/// twice for the same number. `None` when the body cannot be meshed.diff --git a/crates/kernel/src/display_mesh_tests.rs b/crates/kernel/src/display_mesh_tests.rsindex ca5d94a415..c1cf7d45a7 100644--- a/crates/kernel/src/display_mesh_tests.rs+++ b/crates/kernel/src/display_mesh_tests.rs@@ -389,3 +389,24 @@ fn a_cylinder_wall_split_along_its_seam_meshes_round() {}}}++/// A body's outline box, made without meshing, holds its display mesh and is not much larger.+#[test]+fn outline_bounds_hold_the_display_mesh() {+ let cube = crate::box_solid(Vec3::ZERO, Vec3::new(40., 30., 10.)).unwrap();+ let rounded = crate::fillet(&cube, &[Vec3::new(20., 0., 10.)], 3.).unwrap();+ let rod = crate::cylinder(Vec3::new(5., 5., 0.), Vec3::Z, 4., 25.).unwrap();+ for body in [cube, rounded, rod] {+ let outline = body.outline_bounds();+ let mesh = body.reference_display_mesh_angular(body.size() * 1e-3, crate::DISPLAY_ANGLE).unwrap().bounds();+ let slack = body.size() * 1e-6;+ for (lo, hi, m_lo, m_hi) in [+ (outline.min.x, outline.max.x, mesh.min.x, mesh.max.x),+ (outline.min.y, outline.max.y, mesh.min.y, mesh.max.y),+ (outline.min.z, outline.max.z, mesh.min.z, mesh.max.z),+ ] {+ assert!(lo <= m_lo + slack && hi >= m_hi - slack, "outline {outline:?} holds the mesh {mesh:?}");+ }+ assert!(outline.diagonal() <= mesh.diagonal() * 1.5, "and is not much larger");+ }+}diff --git a/crates/ui-egui/src/file_load.rs b/crates/ui-egui/src/file_load.rsindex a664722301..bff9b92c60 100644--- a/crates/ui-egui/src/file_load.rs+++ b/crates/ui-egui/src/file_load.rs@@ -737,13 +737,14 @@ fn compute(phase.store(1, Ordering::Relaxed);let world = session.world_state();let placement_ms = view_began.elapsed().as_secs_f64() * 1000.0;- let mesh_began = std::time::Instant::now();- // Fit, picking and the first viewport frame must not trigger cold tessellation on the UI.- world.warm_meshes(|| !progress.is_cancelled());- if progress.is_cancelled() {- return cancelled();- }- let tessellation_ms = mesh_began.elapsed().as_secs_f64() * 1000.0;+ // The display meshes are made once the design is in the window, which shows its bodies as+ // they come ([`crate::open_meshing`]): framing, picking and drawing never mesh on the UI.+ // Its outlines frame it in the window until it is meshed: measured here, not there.+ solidcraft_engine::kernel::for_each_on_threads(&world.bodies, 16, |b| {+ let _ = b.outline_bounds();+ });+ drop(world);+ let tessellation_ms = 0.0;phase.store(2, Ordering::Relaxed);let view_ms = view_began.elapsed().as_secs_f64() * 1000.0;if profile {@@ -794,6 +795,9 @@ pub fn tick(app: &mut SolveApp, ctx: &egui::Context) {}_ if running.cancelled() => request.answer(Err("file operation cancelled".into())),Ok(made) if running.matches(&app.session) => {+ // Not meshed yet: framing it while it goes in must not mesh it here.+ app.open_meshing_next = true;+ crate::frame_watch::step(app, "before the open");if request.insert() {app.session.accept_computed(made.session);app.big_operation = true;@@ -801,17 +805,19 @@ pub fn tick(app: &mut SolveApp, ctx: &egui::Context) {crate::documents::adopt(app, made.session);if request.kind == Kind::Open {app.home.add_recent(&request.path);- if made.thumbnail {- crate::home::remember_source(&mut app.home, &app.session, &request.path);- }}}app.home.open = false;- app.fit_view();+ crate::frame_watch::step(app, "adopt the design");+ // Shown as its bodies are meshed, framed from their outlines meanwhile; its Home+ // picture is drawn once they all are.+ crate::open_meshing::start(app, (request.kind == Kind::Open && made.thumbnail).then(|| request.path.clone()));+ crate::frame_watch::step(app, "start meshing and frame");// A caller that said which way is up has been answered: no offer to stand the part up.if (request.kind == Kind::Open || request.insert()) && !request.options.contains_key("up") {crate::stand_up::offer(app, &request.path, &running.before, Some(&made.result));}+ crate::frame_watch::step(app, "stand-up offer");let warnings = made.result.get("warnings").and_then(Value::as_array);if let Kind::Recover { .. } = request.kind {recovered(app, request);@@ -855,6 +861,17 @@ pub fn tick(app: &mut SolveApp, ctx: &egui::Context) {/// The light overlay over everything under the title bar while a file loads. The title bar,/// its window buttons and the window's resize edges stay live; the design underneath takes no/// pointer input until the file is in.+/// What a file operation under way is doing (for the frame watch), if one is.+pub(crate) fn phase(app: &SolveApp) -> Option<&'static str> {+ let r = app.file_load.running.as_ref()?;+ Some(match (r.staged.is_some(), r.phase.load(Ordering::Relaxed)) {+ (true, 0) => "reading the file (staged)",+ (_, 0) => "reading the file",+ (_, 1) => "preparing the view",+ _ => "finishing the open",+ })+}+pub fn show(app: &mut SolveApp, ctx: &egui::Context) {let Some(r) = &app.file_load.running else { return };let cancelled = r.cancelled();diff --git a/crates/ui-egui/src/file_load_ui_tests.rs b/crates/ui-egui/src/file_load_ui_tests.rsindex c2d7635f5e..d6aa945f0c 100644--- a/crates/ui-egui/src/file_load_ui_tests.rs+++ b/crates/ui-egui/src/file_load_ui_tests.rs@@ -211,7 +211,10 @@ fn a_control_open_answers_after_loading_without_freezing_the_window() {assert_eq!(reply["ok"], true, "{reply}");assert_eq!(reply["result"], expected);assert!(count_rx.try_recv().is_ok(), "inspection answered while the file loaded");- // Its Home picture is drawn after it opened, not before.+ // Its bodies are meshed after it opened, and its Home picture drawn then, off the UI thread.+ while crate::open_meshing::active(&w.app) {+ w.frame(vec![]);+ }assert!(crate::home::remembering(&w.app.home), "the Home picture is drawn off the UI thread");for _ in 0..3 {w.frame(vec![]);@@ -267,3 +270,153 @@ fn a_control_import_passes_up_and_names_on() {assert!(size[1] > 39.9 && !offered, "{size:?} {offered}");let _ = std::fs::remove_dir_all(&dir);}++/// An opened design is in the window before its bodies are meshed: the view draws the bodies+/// meshed so far (never meshing one itself), framed from their outlines, until all are.+#[test]+fn an_opened_design_shows_its_bodies_as_they_are_meshed() {+ let dir = scratch("progressive");+ let path = large_design(&dir, 24);+ let mut w = Win::new();+ let (tx, rx) = std::sync::mpsc::channel();+ w.app.control_rx = Some(rx);+ let (open, open_rx) = crate::control::ControlRequest::new("engine.execute", json!({"command": "doc.open", "params": {"path": path}}));+ tx.send(open).unwrap();+ let deadline = std::time::Instant::now() + std::time::Duration::from_secs(120);+ while open_rx.try_recv().is_err() {+ w.frame(vec![]);+ std::thread::sleep(std::time::Duration::from_millis(1));+ assert!(std::time::Instant::now() < deadline, "the open answers");+ }+ let mut seen = Vec::new();+ while crate::open_meshing::active(&w.app) {+ let shown = crate::open_meshing::shown_world(&w.app);+ assert!(shown.bodies.iter().all(|b| b.cached_mesh().is_some()), "only meshed bodies are drawn");+ let (done, total) = crate::open_meshing::progress(&w.app).unwrap();+ assert!(done <= total && total == w.app.session.world_state().bodies.len(), "Loading parts {done}/{total}");+ seen.push(shown.bodies.len());+ w.frame(vec![]);+ }+ assert!(seen.windows(2).all(|p| p[0] <= p[1]), "the picture only grows: {seen:?}");+ let world = w.app.session.world_state();+ // Then the whole design (in the order its bodies came, kept until the design changes).+ let names = |st: &solidcraft_engine::doc::ModelState| {+ let mut n: Vec<String> = st.bodies.iter().map(|b| b.name.clone()).collect();+ n.sort();+ n+ };+ assert_eq!(names(&crate::open_meshing::shown_world(&w.app)), names(&world), "then the whole design");+ assert!(world.bodies.iter().all(|b| b.cached_mesh().is_some()));+ // Framed from the meshes now, as a synchronous open frames it.+ let framed = w.app.cam;+ w.app.fit_view();+ assert_eq!(w.app.cam, framed);+ // An edit after that: the viewport draws the session's world again.+ w.app.session.execute("solid.box", &json!({"length": 5, "width": 5, "height": 5, "operation": "new"})).unwrap();+ w.frame(vec![]);+ assert!(std::sync::Arc::ptr_eq(&crate::open_meshing::shown_world(&w.app), &w.app.session.world_state()));+ let _ = std::fs::remove_dir_all(&dir);+}++/// A screenshot asked for right after an open shows the whole design: it waits for the meshing,+/// and what was asked after it waits for it.+#[test]+fn a_screenshot_after_an_open_waits_for_the_whole_design() {+ let dir = scratch("progressive-shot");+ let path = large_design(&dir, 24);+ let mut w = Win::new();+ let (tx, rx) = std::sync::mpsc::channel();+ w.app.control_rx = Some(rx);+ let (open, open_rx) = crate::control::ControlRequest::new("engine.execute", json!({"command": "doc.open", "params": {"path": path}}));+ tx.send(open).unwrap();+ let deadline = std::time::Instant::now() + std::time::Duration::from_secs(120);+ while open_rx.try_recv().is_err() {+ w.frame(vec![]);+ std::thread::sleep(std::time::Duration::from_millis(1));+ assert!(std::time::Instant::now() < deadline, "the open answers");+ }+ if !crate::open_meshing::active(&w.app) {+ return; // Meshed already: nothing to wait for on this machine.+ }+ let (shot, _shot_rx) = crate::control::ControlRequest::new("ui.screenshot", json!({}));+ let (count, count_rx) = crate::control::ControlRequest::new("document.inspect", json!({}));+ tx.send(shot).unwrap();+ tx.send(count).unwrap();+ w.frame(vec![]);+ if crate::open_meshing::active(&w.app) {+ assert!(count_rx.try_recv().is_err(), "a request after the screenshot waits for it");+ }+ while crate::open_meshing::active(&w.app) {+ w.frame(vec![]);+ }+ for _ in 0..3 {+ w.frame(vec![]);+ }+ assert!(count_rx.try_recv().is_ok(), "answered once the design is meshed");+ let _ = std::fs::remove_dir_all(&dir);+}++/// An assembly of a few rounded parts placed many times, as a STEP file: an import that takes a+/// while to read, place and mesh.+fn step_assembly(dir: &std::path::Path) -> String {+ let mut s = Session::default();+ // Distinct parts (each meshed on its own), each placed a few times (placed copies share it).+ for k in 0..40 {+ let len = 30.0 + k as f64;+ let part = s.execute("component.create", &json!({"name": format!("Bracket {k}")})).unwrap()["component"].as_u64().unwrap();+ s.execute("solid.box", &json!({"length": len, "width": 20, "height": 8, "operation": "new"})).unwrap();+ s.execute("solid.cylinder", &json!({"radius": 6, "height": 20, "base": [10, 10, 0], "operation": "join"})).unwrap();+ s.execute("solid.cylinder", &json!({"radius": 2.5, "height": 40, "base": [len - 10.0, 10, -10], "operation": "cut"})).unwrap();+ s.execute("solid.fillet", &json!({"edges": [[len / 2.0, 0, 8]], "radius": 3})).unwrap();+ s.execute("solid.sphere", &json!({"radius": 4, "center": [10, 10, 24], "operation": "join"})).unwrap();+ s.execute("component.activate", &json!({"component": 0})).unwrap();+ for i in 1..5 {+ s.execute("occurrence.copy", &json!({"component": part, "translate": [i as f64 * 80.0, k as f64 * 40.0, 0]})).unwrap();+ }+ }+ let path = dir.join("assembly.step").to_string_lossy().to_string();+ s.execute("file.export", &json!({"path": path})).unwrap();+ path+}++/// Open `path` through the window as a person would, every frame timed, until it is in and meshed.+/// The slowest frame: ms and the phase it was in.+fn open_timed(path: &str) -> (Win, (f64, &'static str)) {+ let mut w = Win::new();+ w.app.frame_watch.slowest = (0.0, "idle");+ let (tx, rx) = std::sync::mpsc::channel();+ w.app.control_rx = Some(rx);+ let (open, open_rx) = crate::control::ControlRequest::new("engine.execute", json!({"command": "doc.open", "params": {"path": path}}));+ tx.send(open).unwrap();+ let deadline = std::time::Instant::now() + std::time::Duration::from_secs(300);+ let mut answered = false;+ while !answered || crate::open_meshing::active(&w.app) || !w.app.file_load.idle() {+ w.frame(vec![]);+ answered |= open_rx.try_recv().is_ok();+ std::thread::sleep(std::time::Duration::from_millis(1));+ assert!(std::time::Instant::now() < deadline, "{path} opens");+ }+ let slowest = w.app.frame_watch.slowest;+ eprintln!("{path}: slowest frame {:.1} ms while {}, {} bodies", slowest.0, slowest.1, w.app.session.world_state().bodies.len());+ (w, slowest)+}++/// The window stays responsive through every phase of opening a design: a STEP assembly imported,+/// the design saved with its model and opened again, and saved without it and opened again. No+/// frame on the window thread takes longer than 250 ms (the test names the phase that did).+#[test]+fn opening_a_large_design_never_stalls_the_window() {+ const BUDGET_MS: f64 = 250.0;+ let dir = scratch("watchdog");+ let step = step_assembly(&dir);+ let (mut w, (ms, phase)) = open_timed(&step);+ assert!(ms < BUDGET_MS, "STEP import: a {ms:.0} ms frame while {phase}");+ assert!(w.app.session.world_state().bodies.len() >= 200);+ for (name, cache) in [("cached.solidcraft", true), ("plain.solidcraft", false)] {+ let path = dir.join(name).to_string_lossy().to_string();+ w.app.session.execute("file.save_as", &json!({"path": path, "cache": cache})).unwrap();+ let (_, (ms, phase)) = open_timed(&path);+ assert!(ms < BUDGET_MS, "{name}: a {ms:.0} ms frame while {phase}");+ }+ let _ = std::fs::remove_dir_all(&dir);+}diff --git a/crates/ui-egui/src/frame_watch.rs b/crates/ui-egui/src/frame_watch.rsnew file mode 100644index 0000000000..0c3e742316--- /dev/null+++ b/crates/ui-egui/src/frame_watch.rs@@ -0,0 +1,62 @@+//! How long the window thread spends on each frame, by what the app is doing (#3053): the window+//! must stay responsive through every phase of opening a design. `SOLIDCRAFT_PROFILE_FRAMES=1`+//! logs every frame slower than [`SLOW_MS`] with its phase; tests read [`Watch::slowest`].++use crate::SolveApp;++/// A frame slower than this is logged (ms).+pub(crate) const SLOW_MS: f64 = 50.0;++#[derive(Default)]+pub(crate) struct Watch {+ began: Option<f64>,+ phase: &'static str,+ /// This frame's named steps so far, and when the last one ended (ms).+ steps: Vec<(&'static str, f64)>,+ last: f64,+ /// The slowest frame so far: ms, and the phase it was in.+ pub slowest: (f64, &'static str),+}++/// What the app is doing this frame, as far as opening a design goes.+pub(crate) fn phase(app: &SolveApp) -> &'static str {+ if let Some(p) = crate::file_load::phase(app) {+ return p;+ }+ if crate::open_meshing::active(app) { "loading parts" } else { "idle" }+}++/// The frame starts (before any of its work).+pub(crate) fn begin(app: &mut SolveApp) {+ let now = crate::now_ms();+ app.frame_watch.began = Some(now);+ app.frame_watch.last = now;+ app.frame_watch.steps.clear();+ app.frame_watch.phase = phase(app);+}++/// A named step of this frame's work ended: a slow frame is logged with them.+pub(crate) fn step(app: &mut SolveApp, name: &'static str) {+ let now = crate::now_ms();+ let w = &mut app.frame_watch;+ if w.began.is_some() && w.steps.len() < 32 {+ w.steps.push((name, now - w.last));+ }+ w.last = now;+}++/// The frame's work is done.+pub(crate) fn end(app: &mut SolveApp) {+ step(app, "the rest of the frame");+ let Some(began) = app.frame_watch.began.take() else { return };+ let ms = crate::now_ms() - began;+ // The phase the frame started in names it (a frame that finishes an open did that work).+ let phase = app.frame_watch.phase;+ if ms > app.frame_watch.slowest.0 {+ app.frame_watch.slowest = (ms, phase);+ }+ if ms > SLOW_MS && solidcraft_engine::geom::env::var_os("PROFILE_FRAMES").is_some() {+ let steps: Vec<String> = app.frame_watch.steps.iter().filter(|(_, t)| *t >= 1.0).map(|(n, t)| format!("{n} {t:.0}")).collect();+ eprintln!("SolidCraft slow frame: {ms:.0} ms ({phase}) [{}]", steps.join(", "));+ }+}diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rsindex 60870c71f8..5fbbe848ad 100644--- a/crates/ui-egui/src/lib.rs+++ b/crates/ui-egui/src/lib.rs@@ -115,6 +115,7 @@ mod extrude_edit_tests;mod extrude_preview;mod file_load;mod file_picker;+pub(crate) mod frame_watch;#[cfg(test)]mod history_off_thread_tests;pub use file_picker::FilePickerFuture;@@ -130,6 +131,7 @@ mod file_load_ui_tests;#[cfg(test)]mod fillet_spline_handle_tests;pub(crate) mod navigation;+pub(crate) mod open_meshing;pub mod palette;pub mod params_dialog;pub(crate) mod pick_buffer;@@ -437,6 +439,12 @@ pub struct SolveApp {/// The 3D mouse: which device, its reading, and the calibration window.pub space_mouse: space_mouse::Input,pub file_load: file_load::FileLoad,+ /// An opened design's bodies still being meshed, off the UI thread.+ pub(crate) open_meshing: Option<open_meshing::Meshing>,+ /// A design is being put in the window and will be meshed after it: framing it uses outlines.+ pub(crate) open_meshing_next: bool,+ /// How long each frame takes on the window thread, by phase.+ pub(crate) frame_watch: frame_watch::Watch,/// The other open designs (tabs).pub docs: documents::Documents,/// The language the installed font fallback chain is ordered for (`fonts::fallback_order`);@@ -533,6 +541,9 @@ impl SolveApp {home: home::HomeState::default(),space_mouse: Default::default(),file_load: file_load::FileLoad::default(),+ open_meshing: None,+ open_meshing_next: false,+ frame_watch: Default::default(),docs: documents::Documents::default(),applied_fonts_language: "en".into(),applied_ui_font: String::new(),@@ -1314,6 +1325,7 @@ impl SolveApp {/// Per-frame logic before layout.pub fn logic(&mut self, ctx: &egui::Context) {+ frame_watch::begin(self);file_picker::tick(self, ctx);render_workspace::sync_backend(self);render_workspace::tick(self, ctx);@@ -1322,6 +1334,8 @@ impl SolveApp {if self.saving.is_some() {ctx.request_repaint_after(std::time::Duration::from_millis(16));}+ open_meshing::tick(self, ctx);+ open_meshing::refresh(self, ctx.input(|i| i.time));self.esc_handled = false;prefs::apply(self, ctx);if !self.styled || theme::is_dark() != self.ui.dark || theme::vision() != self.preferences.color_vision {@@ -1431,6 +1445,7 @@ impl SolveApp {ui.ctx().request_repaint_after(std::time::Duration::from_millis(50));}self.frame_ms = now_ms() - t0;+ frame_watch::end(self);}fn cad_ui(&mut self, ui: &mut egui::Ui, report_input: &mut Option<issue_report::CadInput>) {@@ -1440,6 +1455,7 @@ impl SolveApp {toolbar::app_bar(self, ui);issue_report::CadInput::block(self, ui, report_input);file_load::show(self, ui.ctx());+ open_meshing::show(self, ui.ctx());documents::prompt(self, ui.ctx());update::show(self, ui.ctx());install::show(self, ui.ctx());@@ -1524,13 +1540,25 @@ impl SolveApp {break;}// Held requests go first, in order, once the file is in.- let held = if self.file_load.busy() || self.file_picker.is_some() { None } else { self.control_held.pop_front() };+ // A screenshot waiting for an opened design to be meshed holds what came after it.+ let shot_waits = open_meshing::active(self) && self.control_held.front().is_some_and(|r| r.method == "ui.screenshot");+ let held = if self.file_load.busy() || self.file_picker.is_some() || shot_waits { None } else { self.control_held.pop_front() };let Some(req) = held.or_else(|| rx.as_ref().and_then(|rx| rx.try_recv().ok())) else { break };+ if shot_waits {+ if self.control_held.len() < MAX_HELD {+ self.control_held.push_back(req);+ } else {+ let _ = req.reply.send(json!({"ok": false, "error": "a file operation is in progress"}));+ }+ continue;+ }// A file is loading: commands that change the design wait for it (the window,// inspection and screenshots still answer).if ((self.file_load.busy() || self.file_picker.is_some())&& matches!(req.method.as_str(), "engine.execute" | "command" | "engine.script" | "engine.batch"))|| (self.file_picker_busy() && matches!(req.method.as_str(), "ui.file" | "ui.home"))+ // A screenshot shows the whole design: it waits until an opened one is meshed.+ || (open_meshing::active(self) && req.method == "ui.screenshot"){if self.control_held.len() < MAX_HELD {self.control_held.push_back(req);diff --git a/crates/ui-egui/src/open_meshing.rs b/crates/ui-egui/src/open_meshing.rsnew file mode 100644index 0000000000..7843ceef89--- /dev/null+++ b/crates/ui-egui/src/open_meshing.rs@@ -0,0 +1,249 @@+//! A design that has just opened shows its parts as they are meshed (#3053).+//!+//! Opening hands the design to the window once its timeline is evaluated (or taken from its+//! file) and placed; the display meshes are made afterwards, off the UI thread. Until they all+//! are, the viewport draws the bodies already meshed ([`shown_world`]), so the first parts show+//! within moments and the window stays responsive while the rest come in. The first placement of+//! every part is meshed first: its other placements only move that mesh. The view is framed from+//! the bodies' outlines meanwhile, and framed again from the meshes when they are all made, unless+//! the camera was moved in between. Editing the design meanwhile meshes the new world instead.+//!+//! The picture lists the bodies in the order they were meshed, and is kept once complete until+//! the design changes: the viewport's scene keeps the blocks it built for the bodies already+//! shown and builds only the new ones, and finishing does not build the whole scene again. It is+//! remade at most every [`REFRESH`] seconds, and less often while a remake takes longer.+//!+//! Display only: commands, picking of what is drawn and exports read the session's world as ever.++use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};+use std::sync::{Arc, Mutex};++use solidcraft_engine::doc::ModelState;++use crate::SolveApp;++/// How often a growing picture is remade at most (s).+const REFRESH: f64 = 0.25;+/// A remake waits this many times as long as the last scene build took, so remakes take at most+/// a small share of the window thread.+const REFRESH_SHARE: f64 = 6.0;++pub(crate) struct Meshing {+ /// The world being meshed (the session's when it started).+ world: Arc<ModelState>,+ /// The bodies of `world` whose display (mesh, and plans when drawn from them) is made, in+ /// the order they were made.+ ready: Arc<Mutex<Vec<usize>>>,+ done: Arc<AtomicUsize>,+ /// All are meshed and framed: the picture is kept until the design changes.+ complete: bool,+ stop: Arc<AtomicBool>,+ /// The picture so far: the bodies shown, and how many were ready when it was made.+ shown: Option<(usize, Arc<ModelState>)>,+ shown_at: f64,+ /// The camera the outline framing left (a refit at the end only replaces that one).+ framed: Option<crate::Camera>,+ /// Draw the design's Home picture when all is meshed.+ remember: Option<String>,+ /// When it started, and whether the first bodies have been shown (`SOLIDCRAFT_PROFILE_OPEN`).+ began: Option<f64>,+ first_shown: bool,+}++impl Meshing {+ fn start(world: Arc<ModelState>, plans: bool) -> Meshing {+ let n = world.bodies.len();+ let ready = Arc::new(Mutex::new(Vec::with_capacity(n)));+ let (done, stop) = (Arc::new(AtomicUsize::new(0)), Arc::new(AtomicBool::new(false)));+ // The first placement of each part first: the others only move its mesh.+ let mut seen = std::collections::HashSet::new();+ let (mut first, mut rest) = (Vec::new(), Vec::new());+ for (i, b) in world.bodies.iter().enumerate() {+ if seen.insert(b.definition_name().to_string()) { first.push(i) } else { rest.push(i) }+ }+ first.extend(rest);+ let job = (world.clone(), ready.clone(), done.clone(), stop.clone());+ let spawned = std::thread::Builder::new().name("open-meshing".into()).spawn(move || {+ let (world, ready, done, stop) = job;+ solidcraft_engine::kernel::for_each_on_threads(&first, 16, |&i| {+ if stop.load(Ordering::Relaxed) {+ return;+ }+ if let Some(b) = world.bodies.get(i) {+ let _ = b.mesh();+ if plans {+ let _ = b.display_plan();+ let _ = b.plan_mesh();+ }+ }+ if let Ok(mut r) = ready.lock() {+ r.push(i);+ }+ done.fetch_add(1, Ordering::Release);+ });+ });+ if spawned.is_err() {+ // No thread: the viewport meshes as it draws, as before.+ done.store(n, Ordering::Release);+ }+ Meshing {+ world,+ ready,+ done,+ stop,+ complete: false,+ shown: None,+ shown_at: f64::NEG_INFINITY,+ framed: None,+ remember: None,+ began: None,+ first_shown: false,+ }+ }++ fn finished(&self) -> bool {+ self.done.load(Ordering::Acquire) >= self.world.bodies.len()+ }+}++impl Drop for Meshing {+ fn drop(&mut self) {+ self.stop.store(true, Ordering::Relaxed);+ }+}++/// Start meshing the session's world off the UI thread (an opened design), framing the view from+/// the bodies' outlines; `remember`: then draw the Home picture of that file.+pub(crate) fn start(app: &mut SolveApp, remember: Option<String>) {+ app.open_meshing_next = false;+ let plans = app.viewport.gpu.is_some_and(|g| g.tess);+ let mut meshing = Meshing::start(app.session.world_state(), plans);+ meshing.remember = remember;+ app.open_meshing = Some(meshing);+ app.fit_view();+ if let Some(m) = app.open_meshing.as_mut() {+ m.framed = Some(app.cam);+ }+}++/// How far the meshing is: bodies done, and of how many.+pub(crate) fn progress(app: &SolveApp) -> Option<(usize, usize)> {+ app.open_meshing.as_ref().filter(|m| !m.complete).map(|m| (m.done.load(Ordering::Acquire).min(m.world.bodies.len()), m.world.bodies.len()))+}++/// A small "Loading parts n/N" note at the foot of the viewport while bodies are being meshed:+/// a part not drawn yet can't be picked yet either, and this says why.+pub(crate) fn show(app: &SolveApp, ctx: &egui::Context) {+ let (Some((done, total)), Some(view)) = (progress(app), app.viewport.rect) else { return };+ let t = crate::theme::Tokens::get();+ let at = egui::pos2(view.left() + 12.0, view.bottom() - 12.0);+ egui::Area::new(egui::Id::new("open_meshing"))+ .order(egui::Order::Foreground)+ .pivot(egui::Align2::LEFT_BOTTOM)+ .fixed_pos(at)+ .interactable(false)+ .show(ctx, |ui| {+ egui::Frame::popup(ui.style()).fill(t.panel).show(ui, |ui| {+ ui.horizontal(|ui| {+ ui.spinner();+ ui.label(egui::RichText::new(format!("Loading parts {done}/{total}")).color(t.text));+ });+ });+ });+}++/// Whether bodies are still being meshed after an open.+pub(crate) fn active(app: &SolveApp) -> bool {+ app.open_meshing.as_ref().is_some_and(|m| !m.complete)+}++/// Whether the view is framed from outlines: bodies being meshed, or about to be.+pub(crate) fn framing(app: &SolveApp) -> bool {+ active(app) || app.open_meshing_next+}++/// Per frame: follow the session's world, show more as it is meshed, and frame the finished+/// picture.+pub(crate) fn tick(app: &mut SolveApp, ctx: &egui::Context) {+ let Some(m) = app.open_meshing.as_ref() else { return };+ let world = app.session.world_state();+ if !Arc::ptr_eq(&world, &m.world) {+ if m.complete {+ // The design changed after its open: the viewport draws it as ever.+ app.open_meshing = None;+ return;+ }+ // The design changed (an edit, an undo): mesh the new world; what is made is kept.+ let (framed, remember) = (m.framed, m.remember.clone());+ let plans = app.viewport.gpu.is_some_and(|g| g.tess);+ let mut next = Meshing::start(world.clone(), plans);+ (next.framed, next.remember) = (framed, remember);+ app.open_meshing = Some(next);+ }+ let Some(m) = app.open_meshing.as_ref().filter(|m| !m.complete) else { return };+ if m.finished() && m.shown.as_ref().is_some_and(|(n, _)| *n >= m.world.bodies.len()) {+ let (framed, remember, began) = (m.framed, m.remember.clone(), m.began);+ if let Some(m) = app.open_meshing.as_mut() {+ m.complete = true;+ }+ if profiling() {+ let ms = began.map_or(0.0, |t| (ctx.input(|i| i.time) - t) * 1000.0);+ eprintln!("SolidCraft open meshing: all {} bodies shown after {ms:.0} ms", world.bodies.len());+ }+ // Framed from outlines and not moved since: frame the meshes.+ if framed == Some(app.cam) {+ app.fit_view();+ }+ crate::frame_watch::step(app, "frame the meshes");+ if let Some(key) = remember {+ crate::home::remember_source(&mut app.home, &app.session, &key);+ }+ crate::frame_watch::step(app, "home picture");+ return;+ }+ ctx.request_repaint();+}++/// The world the viewport draws: while an opened design is being meshed, the bodies meshed so+/// far (the picture grows a few times a second), then all of them, in the order they came, until+/// the design changes; otherwise the session's.+pub(crate) fn shown_world(app: &SolveApp) -> Arc<ModelState> {+ let Some(m) = app.open_meshing.as_ref() else { return app.session.world_state() };+ if !Arc::ptr_eq(&app.session.world_state(), &m.world) {+ return app.session.world_state();+ }+ m.shown.as_ref().map(|(_, st)| st.clone()).unwrap_or_else(|| Arc::new(ModelState::default()))+}++/// Remake the picture so far, at most every [`REFRESH`] seconds and no sooner than+/// [`REFRESH_SHARE`] times the last scene build (the bodies shown before keep their place, so the+/// viewport builds only the new ones).+pub(crate) fn refresh(app: &mut SolveApp, now: f64) {+ let build_s = app.viewport.build_ms / 1000.0;+ let Some(m) = app.open_meshing.as_mut().filter(|m| !m.complete) else { return };+ let order: Vec<usize> = match m.ready.lock() {+ Ok(r) => r.clone(),+ Err(_) => return,+ };+ let done = order.len();+ let all = done >= m.world.bodies.len();+ let wait = REFRESH.max(build_s * REFRESH_SHARE);+ if m.shown.as_ref().is_some_and(|(n, _)| *n == done) || (now - m.shown_at < wait && !all) {+ return;+ }+ let began = *m.began.get_or_insert(now);+ let mut st = (*m.world).clone();+ st.bodies = order.iter().filter_map(|&i| m.world.bodies.get(i).cloned()).collect();+ if !m.first_shown && !st.bodies.is_empty() {+ m.first_shown = true;+ if profiling() {+ eprintln!("SolidCraft open meshing: first {} bodies shown after {:.0} ms", st.bodies.len(), (now - began) * 1000.0);+ }+ }+ m.shown = Some((done, Arc::new(st)));+ m.shown_at = now;+}++fn profiling() -> bool {+ solidcraft_engine::geom::env::var_os("PROFILE_OPEN").is_some()+}diff --git a/crates/ui-egui/src/scenario.rs b/crates/ui-egui/src/scenario.rsindex 04a56dac00..6a002fa820 100644--- a/crates/ui-egui/src/scenario.rs+++ b/crates/ui-egui/src/scenario.rs@@ -256,7 +256,9 @@ impl Harness {}// A file opening, recovering or saving in the background: wait for it (as a person would).let began = std::time::Instant::now();- while (!self.app.file_load.idle() || self.app.saving.is_some()) && began.elapsed() < std::time::Duration::from_secs(120) {+ while (!self.app.file_load.idle() || self.app.saving.is_some() || crate::open_meshing::active(&self.app))+ && began.elapsed() < std::time::Duration::from_secs(120)+ {self.frame();std::thread::sleep(std::time::Duration::from_millis(1));}diff --git a/crates/ui-egui/src/viewport.rs b/crates/ui-egui/src/viewport.rsindex 1686c59ce4..c23cbbb75e 100644--- a/crates/ui-egui/src/viewport.rs+++ b/crates/ui-egui/src/viewport.rs@@ -284,20 +284,24 @@ pub fn projection(app: &SolveApp, rect: Rect) -> Proj {/// Sketches drawn in the viewport: the active one, and finished ones not yet used by a feature.pub(crate) fn visible_sketches(app: &SolveApp) -> Vec<u64> {- let st = app.session.world_state();+ let st = crate::open_meshing::shown_world(app);st.sketches.iter().filter(|s| solidcraft_engine::view::sketch_drawn(&app.session, s.feature, app.ui.show_sketches)).map(|s| s.feature).collect()}/// What Home, Fit and the orbit pivot frame: the bodies and sketches shown now, where they are/// now (see [`solidcraft_engine::view::visible_bounds`]).pub fn view_bounds(app: &SolveApp) -> solidcraft_engine::geom::Aabb3 {+ // Bodies still being meshed after an open frame the view by their outlines.+ if crate::open_meshing::framing(app) {+ return solidcraft_engine::view::unmeshed_bounds(&app.session, app.ui.show_sketches);+ }solidcraft_engine::view::visible_bounds(&app.session, app.ui.show_sketches)}fn scene_key(app: &SolveApp) -> u64 {let mut h = std::collections::hash_map::DefaultHasher::new();app.session.revision.hash(&mut h);- (std::sync::Arc::as_ptr(&app.session.world_state()) as usize).hash(&mut h);+ (std::sync::Arc::as_ptr(&crate::open_meshing::shown_world(app)) as usize).hash(&mut h);app.ui.show_grid.hash(&mut h);app.ui.visual_style.hash(&mut h);app.ui.ground_shadow.hash(&mut h);@@ -331,7 +335,7 @@ fn sketch_scene_key(app: &SolveApp, proj: &Proj) -> u64 {// The grid this scene draws follows the view when the preference says so (#1470): turning it// on or off redraws even while the camera holds still.app.preferences.grid_follows_view.hash(&mut h);- (std::sync::Arc::as_ptr(&app.session.world_state()) as usize).hash(&mut h);+ (std::sync::Arc::as_ptr(&crate::open_meshing::shown_world(app)) as usize).hash(&mut h);crate::sketch_display::projection_key(proj, app.viewport.pixels_per_point()).hash(&mut h);h.finish()}@@ -499,7 +503,7 @@ fn update_refinement(app: &mut SolveApp, ctx: &egui::Context, proj: &Proj) {}let t0 = crate::now_ms();app.viewport.lod_view = view;- let st = app.session.world_state();+ let st = crate::open_meshing::shown_world(app);let ppp = f64::from(app.viewport.pixels_per_point());let lens = crate::display_lod::Lens::new(&proj.cam, f64::from(proj.rect.height()) * ppp);let bounds = body_bounds(app, &st);@@ -642,7 +646,7 @@ fn build_scene(app: &SolveApp) -> GpuScene {let mut sc = GpuScene::default();let s = &app.session;// Bodies where their occurrences place them.- let st = s.world_state();+ let st = crate::open_meshing::shown_world(app);let active_bodies = s.active_occurrence_path.as_ref().and_then(|p| s.occurrence_bodies(p, true).ok());let (shaded, edges) = match app.ui.visual_style {1 => (true, false),@@ -744,7 +748,7 @@ fn build_sketch_scene(app: &SolveApp, proj: &Proj) -> GpuScene {let tk = Tokens::get();let mut sc = GpuScene::default();let s = &app.session;- let st = s.world_state();+ let st = crate::open_meshing::shown_world(app);let mut fill_budget = 131_072;let sketch_plane = solidcraft_engine::view::open_sketch_plane(s);if sketch_plane.is_some() || (app.ui.show_grid && !active_view(app).hide_grid) {@@ -1065,7 +1069,7 @@ 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 = app.session.world_state();+ 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));for ss in &st.sketches {if let Some((lo, hi)) = ss.sketch.bounds() {@@ -1139,7 +1143,7 @@ pub(crate) fn pick_cached(app: &mut SolveApp, proj: &Proj, pos: Pos2) -> Vec<Hitv.to_bits().hash(&mut h);}app.session.revision.hash(&mut h);- (std::sync::Arc::as_ptr(&app.session.world_state()) as usize).hash(&mut h);+ (std::sync::Arc::as_ptr(&crate::open_meshing::shown_world(app)) as usize).hash(&mut h);app.session.active_sketch.hash(&mut h);crate::sketch3d::drawing(app).hash(&mut h);app.dialog.as_ref().and_then(|d| d.active_input()).map(|i| i.accept).hash(&mut h);@@ -1236,7 +1240,7 @@ impl<T: PartialOrd + Copy> Near<T> {fn pick_hits(app: &SolveApp, proj: &Proj, pos: Pos2, other_sketch_points: bool, all: bool) -> Vec<Hit> {let s = &app.session;- let st = s.world_state();+ let st = crate::open_meshing::shown_world(app);let bounds = body_bounds(app, &st);let mut hits = Vec::new();let (o, d) = proj.ray(pos);@@ -1466,7 +1470,7 @@ fn pick_hits(app: &SolveApp, proj: &Proj, pos: Pos2, other_sketch_points: bool,/// The section cut shown now: the open Section Analysis dialog's plane, else the session's./// The active sketch's display options (defaults when not sketching).pub fn active_view(app: &SolveApp) -> solidcraft_engine::sketch::SketchView {- let st = app.session.world_state();+ let st = crate::open_meshing::shown_world(app);app.session.active_sketch.and_then(|s| st.sketch(s)).map(|ss| ss.sketch.view.clone()).unwrap_or_default()}@@ -1480,7 +1484,7 @@ pub fn section_plane(app: &SolveApp) -> Option<(Vec3, Vec3)> {}// Slice (Sketch Palette): cut the model at the plane of the sketch being edited.if app.session.section.is_none() {- let st = app.session.world_state();+ let st = crate::open_meshing::shown_world(app);if let Some(ss) = app.session.active_sketch.and_then(|s| st.sketch(s)).filter(|ss| ss.sketch.view.slice) {return Some((ss.plane.origin, ss.plane.normal()));}@@ -1496,7 +1500,7 @@ fn feature_geometry(app: &SolveApp, id: u64) -> Vec<Sel> {if !app.session.model.result(id).is_some_and(|r| !r.skipped && r.error.is_none()) {return Vec::new();}- let st = app.session.world_state();+ let st = crate::open_meshing::shown_world(app);let prefix = format!("F{id}:");let mut out = Vec::new();for b in &st.bodies {@@ -1541,7 +1545,7 @@ fn displayed_selection(app: &SolveApp, item: &Sel) -> Vec<Sel> {/// The box around what is selected (bodies, faces, edges, vertices, sketch curves and the/// bodies of selected features), where it is shown.pub fn selection_bounds(app: &SolveApp) -> Option<solidcraft_engine::geom::Aabb3> {- let st = app.session.world_state();+ let st = crate::open_meshing::shown_world(app);let mut b = solidcraft_engine::geom::Aabb3::EMPTY;for s in app.session.selection.iter().flat_map(|item| displayed_selection(app, item)) {match &s {@@ -1851,7 +1855,7 @@ fn hidden_face_outline(sc: &mut GpuScene, m: &solidcraft_engine::geom::Mesh, fac}pub(crate) fn profile_fill(sc: &mut GpuScene, app: &SolveApp, sketch: u64, index: usize, fill: Color32, edge: Color32) {- let st = app.session.world_state();+ let st = crate::open_meshing::shown_world(app);let Some(ss) = st.sketch(sketch) else { return };let Some(p) = ss.profiles.get(index) else { return };let plane = match crate::dialogs::emboss_profile_plane(app, sketch) {@@ -1908,7 +1912,7 @@ fn highlight_geometry_key(app: &SolveApp) -> u64 {let mut h = std::collections::hash_map::DefaultHasher::new();let selected = app.highlighted();app.session.revision.hash(&mut h);- (std::sync::Arc::as_ptr(&app.session.world_state()) as usize).hash(&mut h);+ (std::sync::Arc::as_ptr(&crate::open_meshing::shown_world(app)) as usize).hash(&mut h);serde_json::to_string(&selected).unwrap_or_default().hash(&mut h);format!("{:?}", app.viewport.hover).hash(&mut h);app.viewport.hover_feature.hash(&mut h);@@ -1960,7 +1964,7 @@ struct HoverBlock {fn build_highlight(app: &SolveApp) -> GpuScene {let t = Tokens::get();let mut sc = GpuScene::default();- let st = app.session.world_state();+ let st = crate::open_meshing::shown_world(app);let s = &app.session;let active_bodies = s.active_occurrence_path.as_ref().and_then(|p| s.occurrence_bodies(p, true).ok());// Faces lit over the model use the triangles the model shows them with.@@ -2250,7 +2254,7 @@ fn body_color(doc: &solidcraft_engine::doc::Document, b: &solidcraft_engine::doc/// A body's display colour (else the theme's) as RGB.fn body_rgb(app: &SolveApp, name: &str) -> (u8, u8, u8) {- let st = app.session.world_state();+ let st = crate::open_meshing::shown_world(app);let c = st.body(name).and_then(|b| body_color(&app.session.doc, b)).unwrap_or(Tokens::get().body);(c.r(), c.g(), c.b())}@@ -2280,7 +2284,7 @@ fn seg_dist(p: Pos2, a: Pos2, b: Pos2) -> f32 {/// id of the sketch point it snapped to.pub fn sketch_point_at(app: &SolveApp, proj: &Proj, pos: Pos2) -> Option<(Vec2, Option<String>)> {let sid = app.session.active_sketch?;- let st = app.session.world_state();+ let st = crate::open_meshing::shown_world(app);let ss = st.sketch(sid)?;for h in pick(app, proj, pos) {if let Hit::SketchPoint { sketch, id, at } = h@@ -2372,7 +2376,7 @@ pub fn show(app: &mut SolveApp, ui: &mut egui::Ui) {}let proj = projection(app, rect);if let Ok(mut cache) = app.viewport.display.lock() {- cache.prepare(app.session.world_state(), &proj, app.viewport.pixels_per_point());+ cache.prepare(crate::open_meshing::shown_world(app), &proj, app.viewport.pixels_per_point());}// Suppress hover for the whole navigation gesture, including frames between pointer// events. Testing delta made the highlight reappear whenever a held drag paused.@@ -2420,7 +2424,9 @@ pub fn show(app: &mut SolveApp, ui: &mut egui::Ui) {painter.add(Shape::mesh(mesh));// ---- model ----+ crate::frame_watch::step(app, "viewport before the model");update_refinement(app, ui.ctx(), &proj);+ crate::frame_watch::step(app, "display refinement");let key = scene_key(app);let t0 = crate::now_ms();// Drawn on the GPU; without one (the headless harness, tests) the model is not drawn.@@ -2432,6 +2438,7 @@ pub fn show(app: &mut SolveApp, ui: &mut egui::Ui) {}app.viewport.key = key;app.viewport.build_ms = crate::now_ms() - t0;+ crate::frame_watch::step(app, "model scene");}let sk = sketch_scene_key(app, &proj);if sk != app.viewport.sketch_key {@@ -2562,7 +2569,7 @@ pub fn show(app: &mut SolveApp, ui: &mut egui::Ui) {if let Some((hit, Some(sel))) = cand {dialog_pick(app, &hit, sel);} else if let Some(mut dialog) = app.dialog.take() {- let state = app.session.world_state();+ let state = crate::open_meshing::shown_world(app);if let Some(sketch) = app.session.active_sketch.and_then(|id| state.sketch(id)) {let (origin, direction) = proj.ray(p);if let Some(point) = sketch.plane.intersect_ray(origin, direction) {@@ -2637,7 +2644,7 @@ pub fn show(app: &mut SolveApp, ui: &mut egui::Ui) {&& app.tool.is_none()&& app.dialog.is_none()&& let Some(Hit::Edge { body, index, .. }) = app.viewport.hover.clone()- && let Some(b) = app.session.world_state().body(&body).cloned()+ && let Some(b) = crate::open_meshing::shown_world(app).body(&body).cloned(){let m = b.mesh();let items: Vec<Sel> = m@@ -2658,7 +2665,7 @@ pub fn show(app: &mut SolveApp, ui: &mut egui::Ui) {// Dragging a sketch point of the active sketch moves it; the solver keeps the constraints.if app.tool.is_none() && app.dialog.is_none() && primary_nav.is_none() && mode.is_none() && app.session.active_sketch.is_some() && !held {let on_plane = |app: &SolveApp, p: Pos2| {- let ss = app.session.active_sketch.and_then(|sid| app.session.world_state().sketch(sid).cloned())?;+ let ss = app.session.active_sketch.and_then(|sid| crate::open_meshing::shown_world(app).sketch(sid).cloned())?;let (o, d) = proj.ray(p);ss.plane.intersect_ray(o, d).map(|w| ss.plane.to_local(w))};@@ -2745,7 +2752,7 @@ pub fn show(app: &mut SolveApp, ui: &mut egui::Ui) {let with = dragged_with(app, &id);// Snap the dragged point (or the line's ends) to other geometry, like drawing.let snap = {- let st = app.session.world_state();+ let st = crate::open_meshing::shown_world(app);app.session.active_sketch.and_then(|s| st.sketch(s)).and_then(|ss| {let sk = &ss.sketch;let (mut own, mut exclude) = crate::drag_snap::moving_points(sk, &id);@@ -3083,7 +3090,7 @@ fn box_select(app: &mut SolveApp, proj: &Proj, bx: BoxSel, add: bool) {if app.applying.is_some() {return;}- let st = app.session.world_state();+ let st = crate::open_meshing::shown_world(app);let mut out: Vec<Sel> = Vec::new();let to2 = |pts: &[Vec3]| -> Vec<Pos2> { pts.iter().filter_map(|p| proj.to_screen(*p)).collect() };let sketch_dialog = app.dialog.as_ref().is_some_and(|d| matches!(d.kind, crate::dialogs::Kind::SketchModify(_)));@@ -3271,7 +3278,7 @@ fn grid_centre(tf: Vec3, back: Vec3, n: Vec3, ext: f64) -> Vec3 {/// Hover feedback for the active sketch's points and curves (drawn on top of everything).fn hover_highlight(app: &SolveApp, painter: &egui::Painter, proj: &Proj) {let col = Tokens::get().hover_profile_edge;- let st = app.session.world_state();+ let st = crate::open_meshing::shown_world(app);match &app.viewport.hover {// Trim shows the piece it would take away instead (`sketch_tools::preview`, #3052).Some(Hit::SketchCurve { sketch, id, .. }) if crate::sketch_tools::trim_hover_piece(app, *sketch, id).is_some() => {}@@ -3326,7 +3333,7 @@ pub(crate) fn standalone_points(app: &SolveApp) -> Vec<Vec3> {/// Sketch points and the status of the active sketch (constraint glyphs: `sketch_tools`).fn overlays(app: &SolveApp, painter: &egui::Painter, proj: &Proj) {let t = Tokens::get();- let st = app.session.world_state();+ let st = crate::open_meshing::shown_world(app);for item in &app.session.selection {if let Sel::ExternalSketchPoint { sketch, id } = item&& let Some(ss) = st.sketch(*sketch)