Skip to content

SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.

Sketch display: each sketch samples within its own budget (#6524) (#6838)

sascha21017ae17e6dd54c
diff --git a/crates/ui-egui/src/sketch_display.rs b/crates/ui-egui/src/sketch_display.rs
index a1178b609c..15959bece2 100644
--- a/crates/ui-egui/src/sketch_display.rs
+++ b/crates/ui-egui/src/sketch_display.rs
@@ -173,18 +173,37 @@ pub fn boundary_parts(loop_: &Loop2, plane: &Plane, proj: &Proj, ppp: f32) -> Ve
loop_.segs.iter().flat_map(|segment| sample_segment(segment, plane, &pixel_view(proj, ppp), &mut budget).parts).collect()
}
+/// What one sketch may sample per model state and view: its curves and profiles cached, and the
+/// vertices and nodes they take. Each sketch has its own (#6524): one shared by every sketch
+/// let a large one drawn first (an imported drawing) use it all, so a later sketch's curves came
+/// back empty, neither drawn nor pickable, while their points still showed.
+struct SketchBudget {
+ sampling: SamplingBudget,
+ curves: usize,
+ profiles: usize,
+}
+
+impl Default for SketchBudget {
+ fn default() -> Self {
+ Self { sampling: SamplingBudget::new(131_072, 1_048_576), curves: 0, profiles: 0 }
+ }
+}
+
+/// The most curves and profiles one sketch caches per model state and view.
+const SKETCH_CURVES: usize = 4096;
+const SKETCH_PROFILES: usize = 1024;
+/// The most curves (and profiles) cached for every sketch together: a bound on memory however
+/// many sketches are shown.
+const CACHED_CURVES: usize = 65_536;
+const CACHED_PROFILES: usize = 16_384;
+
+#[derive(Default)]
pub struct DisplayCache {
state: Option<Arc<ModelState>>,
view: u64,
curves: HashMap<(u64, usize, [u64; 9]), Arc<SampledPath>>,
profiles: HashMap<(u64, usize, [u64; 9]), Arc<Option<Region2>>>,
- budget: SamplingBudget,
-}
-
-impl Default for DisplayCache {
- fn default() -> Self {
- Self { state: None, view: 0, curves: HashMap::new(), profiles: HashMap::new(), budget: SamplingBudget::new(131_072, 1_048_576) }
- }
+ budgets: HashMap<u64, SketchBudget>,
}
impl DisplayCache {
@@ -202,7 +221,7 @@ impl DisplayCache {
if view != self.view || self.state.as_ref().is_none_or(|old| !Arc::ptr_eq(old, state)) {
self.curves.clear();
self.profiles.clear();
- self.budget = SamplingBudget::new(131_072, 1_048_576);
+ self.budgets.clear();
self.view = view;
self.state = Some(Arc::clone(state));
}
@@ -213,18 +232,24 @@ impl DisplayCache {
let plane_key =
[plane.origin.x, plane.origin.y, plane.origin.z, plane.x.x, plane.x.y, plane.x.z, plane.y.x, plane.y.y, plane.y.z].map(f64::to_bits);
let key = (sketch, index, plane_key);
- if !self.curves.contains_key(&key) && (self.curves.len() >= 4096 || self.budget.remaining_vertices == 0 || self.budget.remaining_nodes == 0) {
+ if let Some(path) = self.curves.get(&key) {
+ return path.clone();
+ }
+ let budget = self.budgets.entry(sketch).or_default();
+ if budget.curves >= SKETCH_CURVES
+ || self.curves.len() >= CACHED_CURVES
+ || budget.sampling.remaining_vertices == 0
+ || budget.sampling.remaining_nodes == 0
+ {
return Arc::new(SampledPath { parts: Vec::new(), quality: SamplingQuality::BudgetLimited, vertex_count: 0 });
}
- self.curves
- .entry(key)
- .or_insert_with(|| {
- Arc::new(state.sketch(sketch).map_or_else(
- || SampledPath { parts: Vec::new(), quality: SamplingQuality::Invalid, vertex_count: 0 },
- |ss| curve_with_budget(&ss.sketch, index, plane, proj, ppp, &mut self.budget),
- ))
- })
- .clone()
+ let path = Arc::new(state.sketch(sketch).map_or_else(
+ || SampledPath { parts: Vec::new(), quality: SamplingQuality::Invalid, vertex_count: 0 },
+ |ss| curve_with_budget(&ss.sketch, index, plane, proj, ppp, &mut budget.sampling),
+ ));
+ budget.curves += 1;
+ self.curves.insert(key, path.clone());
+ path
}
fn profile(&mut self, state: Arc<ModelState>, sketch: u64, index: usize, plane: &Plane, proj: &Proj, ppp: f32) -> Arc<Option<Region2>> {
@@ -232,22 +257,26 @@ impl DisplayCache {
let plane_key =
[plane.origin.x, plane.origin.y, plane.origin.z, plane.x.x, plane.x.y, plane.x.z, plane.y.x, plane.y.y, plane.y.z].map(f64::to_bits);
let key = (sketch, index, plane_key);
- if !self.profiles.contains_key(&key)
- && (self.profiles.len() >= 1024 || self.budget.remaining_vertices == 0 || self.budget.remaining_nodes == 0)
+ if let Some(region) = self.profiles.get(&key) {
+ return region.clone();
+ }
+ let budget = self.budgets.entry(sketch).or_default();
+ if budget.profiles >= SKETCH_PROFILES
+ || self.profiles.len() >= CACHED_PROFILES
+ || budget.sampling.remaining_vertices == 0
+ || budget.sampling.remaining_nodes == 0
{
return Arc::new(None);
}
- self.profiles
- .entry(key)
- .or_insert_with(|| {
- Arc::new(
- state
- .sketch(sketch)
- .and_then(|ss| ss.profiles.get(index))
- .and_then(|profile| display_region_with_budget(&profile.region, plane, proj, ppp, &mut self.budget)),
- )
- })
- .clone()
+ let region = Arc::new(
+ state
+ .sketch(sketch)
+ .and_then(|ss| ss.profiles.get(index))
+ .and_then(|profile| display_region_with_budget(&profile.region, plane, proj, ppp, &mut budget.sampling)),
+ );
+ budget.profiles += 1;
+ self.profiles.insert(key, region.clone());
+ region
}
}
diff --git a/crates/ui-egui/src/sketch_display_ui_tests.rs b/crates/ui-egui/src/sketch_display_ui_tests.rs
index 22f04d8f65..9aab5d151e 100644
--- a/crates/ui-egui/src/sketch_display_ui_tests.rs
+++ b/crates/ui-egui/src/sketch_display_ui_tests.rs
@@ -290,6 +290,42 @@ fn pixel_frame_budget_does_not_cache_unbounded_empty_curve_results() {
assert_eq!(h.app.session.doc.to_json(), baseline);
}
+/// #6524: an imported drawing of 5000 lines, shown and sampled first (sketches are drawn in
+/// timeline order), uses up its own sketch's budget only. A line drawn in a later sketch is still
+/// sampled, so drawn and pickable, instead of coming back empty while its end points show.
+#[test]
+fn a_large_sketch_drawn_first_leaves_a_later_sketch_its_curves() {
+ let mut h = Harness::new();
+ h.app.set_origin_shown(false);
+ let mut dxf = String::from("0\nSECTION\n2\nENTITIES\n");
+ for i in 0..5000 {
+ let (x, y) = (f64::from(i % 100) * 2.0, f64::from(i / 100) * 2.0);
+ dxf.push_str(&format!("0\nLINE\n8\n0\n10\n{x}\n20\n{y}\n11\n{}\n21\n{y}\n", x + 1.5));
+ }
+ dxf.push_str("0\nENDSEC\n0\nEOF\n");
+ h.app.run("sketch.insert_dxf", json!({"text": dxf, "plane": "XY", "name": "Drawing"})).unwrap();
+ h.app.run("sketch.finish", json!({})).unwrap();
+ h.app.run("sketch.create", json!({"plane":"XY","name":"After"})).unwrap();
+ h.app.run("sketch.line", json!({"points":[[-30,-30],[-10,-20]],"ids":["new"]})).unwrap();
+ h.settle();
+ let proj = projection(&h.app, h.app.viewport.rect.unwrap());
+ let state = h.app.session.world_state();
+ let drawing = state.sketches.iter().find(|s| s.name == "Drawing").unwrap().clone();
+ let after = state.sketches.iter().find(|s| s.name == "After").unwrap().clone();
+ drop(state);
+ assert_eq!(drawing.sketch.curves.len(), 5000);
+ // A fresh frame that samples the drawing first, as the viewport does.
+ *h.app.viewport.display.lock().unwrap() = Default::default();
+ let limited = (0..drawing.sketch.curves.len())
+ .filter(|&i| curve_sample(&h.app, drawing.feature, i, &drawing.plane, &proj).quality == SamplingQuality::BudgetLimited)
+ .count();
+ assert!(limited > 0, "the drawing must exceed one sketch's budget for this to test anything");
+ let line = after.sketch.curve_index("new").unwrap();
+ let path = curve_sample(&h.app, after.feature, line, &after.plane, &proj);
+ assert_eq!((path.quality, path.vertex_count), (SamplingQuality::Complete, 2), "{path:?}");
+ assert_eq!(path.parts.len(), 1);
+}
+
/// A zoomed-in ring is sampled finely, but each slab of the fill still crosses only its
/// four boundary edges: its fill must fit the hover highlight's budget (#164).
#[test]