Skip to content

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

Keep a zoomed-in profile's hover fill: count the slabs each edge crosses (#336)

Vitali M.b2fc6d1fac3a
diff --git a/crates/geom/src/profile.rs b/crates/geom/src/profile.rs
index 80fe248ed0..4145c5853c 100644
--- a/crates/geom/src/profile.rs
+++ b/crates/geom/src/profile.rs
@@ -527,11 +527,23 @@ impl Region2 {
ys.sort_by(f64::total_cmp);
ys.dedup_by(|a, b| (*a - *b).abs() < 1e-12);
let x_at = |e: &(Vec2, Vec2), y: f64| e.0.x + (y - e.0.y) / (e.1.y - e.0.y) * (e.1.x - e.0.x);
+ // Sweep upward: an edge joins the slabs once its lower end is passed and leaves after
+ // its upper end, so each slab sorts only the edges crossing it (a finely sampled ring
+ // has hundreds of slabs and edges, but four edges in each slab).
+ edges.sort_by(|a, b| a.0.y.total_cmp(&b.0.y));
+ let mut next = 0;
+ let mut span: Vec<&(Vec2, Vec2)> = Vec::new();
let mut out = Vec::new();
for w in ys.windows(2) {
let (y0, y1) = (w[0], w[1]);
let ym = (y0 + y1) * 0.5;
- let mut span: Vec<&(Vec2, Vec2)> = edges.iter().filter(|e| e.0.y <= ym && e.1.y >= ym).collect();
+ while let Some(e) = edges.get(next)
+ && e.0.y <= ym
+ {
+ span.push(e);
+ next += 1;
+ }
+ span.retain(|e| e.1.y >= ym);
span.sort_by(|a, b| x_at(a, ym).total_cmp(&x_at(b, ym)));
for pair in span.chunks(2) {
let [l, r] = pair else { continue };
@@ -630,6 +642,57 @@ mod tests {
}
}
+ /// The sweep visits only the edges crossing each slab; it must give the triangles that
+ /// testing every edge against every slab gives, for a finely sampled ring too (#164).
+ #[test]
+ fn triangulation_sweep_matches_every_edge_against_every_slab() {
+ fn every_edge(r: &Region2, tol: f64) -> Vec<[Vec2; 3]> {
+ let mut edges = Vec::new();
+ for l in std::iter::once(&r.outer).chain(&r.holes) {
+ let pl = l.polyline(tol);
+ for i in 0..pl.len() {
+ let (a, b) = (pl[i], pl[(i + 1) % pl.len()]);
+ if (a.y - b.y).abs() > 1e-12 {
+ edges.push(if a.y < b.y { (a, b) } else { (b, a) });
+ }
+ }
+ }
+ let mut ys: Vec<f64> = edges.iter().flat_map(|(a, b): &(Vec2, Vec2)| [a.y, b.y]).collect();
+ ys.sort_by(f64::total_cmp);
+ ys.dedup_by(|a, b| (*a - *b).abs() < 1e-12);
+ let x_at = |e: &(Vec2, Vec2), y: f64| e.0.x + (y - e.0.y) / (e.1.y - e.0.y) * (e.1.x - e.0.x);
+ let mut out = Vec::new();
+ for w in ys.windows(2) {
+ let ym = (w[0] + w[1]) * 0.5;
+ let mut span: Vec<_> = edges.iter().filter(|e| e.0.y <= ym && e.1.y >= ym).collect();
+ span.sort_by(|a, b| x_at(a, ym).total_cmp(&x_at(b, ym)));
+ for pair in span.chunks(2) {
+ let [l, r] = pair else { continue };
+ let (a, b) = (Vec2::new(x_at(l, w[0]), w[0]), Vec2::new(x_at(r, w[0]), w[0]));
+ let (c, d) = (Vec2::new(x_at(r, w[1]), w[1]), Vec2::new(x_at(l, w[1]), w[1]));
+ out.extend([[a, b, c], [a, c, d]]);
+ }
+ }
+ out
+ }
+ let comb = Loop2::polygon(&[
+ Vec2::new(0.0, 0.0),
+ Vec2::new(9.0, 0.0),
+ Vec2::new(9.0, 6.0),
+ Vec2::new(7.0, 2.0),
+ Vec2::new(5.0, 7.0),
+ Vec2::new(3.0, 2.5),
+ Vec2::new(1.0, 6.0),
+ ]);
+ let ring = Region2 { outer: Loop2::circle(Vec2::ZERO, 45.0), holes: vec![Loop2::circle(Vec2::ZERO, 40.0).reversed()] };
+ let regions = [Region2 { outer: comb, holes: vec![Loop2::circle(Vec2::new(4.5, 1.2), 0.6).reversed()] }, ring];
+ for (r, tol) in regions.iter().zip([1e-3, 1e-4]) {
+ let tris = r.triangulate(tol);
+ assert!(tris.len() > 100);
+ assert_eq!(tris, every_edge(r, tol));
+ }
+ }
+
#[test]
fn triangulated_area() {
let sq = Loop2::polygon(&[Vec2::new(0.0, 0.0), Vec2::new(10.0, 0.0), Vec2::new(10.0, 8.0), Vec2::new(5.0, 3.0), Vec2::new(0.0, 8.0)]);
diff --git a/crates/ui-egui/src/sketch_display.rs b/crates/ui-egui/src/sketch_display.rs
index 981c819307..b9eae2246e 100644
--- a/crates/ui-egui/src/sketch_display.rs
+++ b/crates/ui-egui/src/sketch_display.rs
@@ -114,23 +114,26 @@ pub fn region_triangles(region: &Region2, plane: &Plane, proj: &Proj, ppp: f32)
display_region(region, plane, proj, ppp).map_or_else(Vec::new, |display| fill_triangles(&display, &mut 65_536))
}
-/// Bound the slab triangulator's allocation before calling it. Every slab can emit
-/// at most one triangle per edge; complex fills are omitted rather than cut into holes.
+/// Bound the slab triangulator's allocation before calling it. Every slab emits one
+/// triangle per edge crossing it; complex fills are omitted rather than cut into holes.
pub fn fill_triangles(display: &Region2, budget: &mut usize) -> Vec<[Vec2; 3]> {
- let mut heights = Vec::new();
- let mut edges = 0usize;
+ let mut spans = Vec::new();
for loop_ in std::iter::once(&display.outer).chain(&display.holes) {
for segment in &loop_.segs {
let (a, b) = (segment.start(), segment.end());
if (a.y - b.y).abs() > 1e-12 {
- edges += 1;
- heights.extend([a.y, b.y]);
+ spans.push((a.y.min(b.y), a.y.max(b.y)));
}
}
}
+ let mut heights: Vec<f64> = spans.iter().flat_map(|&(lo, hi)| [lo, hi]).collect();
heights.sort_by(f64::total_cmp);
heights.dedup_by(|a, b| (*a - *b).abs() < 1e-12);
- if edges.saturating_mul(heights.len().saturating_sub(1)) > *budget {
+ // An edge crosses the slabs between its end heights. Counting every edge in every slab
+ // overestimated a zoomed-in ring a hundredfold and dropped its hover fill (#164).
+ let slab = |y: f64| heights.partition_point(|h| *h < y - 1e-12);
+ let crossings = spans.iter().fold(0usize, |n, &(lo, hi)| n.saturating_add(slab(hi).saturating_sub(slab(lo))));
+ if crossings > *budget {
return Vec::new();
}
let triangles = display.triangulate(1.0);
diff --git a/crates/ui-egui/src/sketch_display_ui_tests.rs b/crates/ui-egui/src/sketch_display_ui_tests.rs
index f20f57276f..a654a44817 100644
--- a/crates/ui-egui/src/sketch_display_ui_tests.rs
+++ b/crates/ui-egui/src/sketch_display_ui_tests.rs
@@ -289,3 +289,37 @@ fn pixel_frame_budget_does_not_cache_unbounded_empty_curve_results() {
assert!(h.app.viewport.display.lock().unwrap().len() <= 4096);
assert_eq!(h.app.session.doc.to_json(), baseline);
}
+
+/// 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]
+fn zoomed_in_ring_fill_fits_the_hover_highlight_budget() {
+ let mut h = Harness::new();
+ h.app.ui.show_origin = false;
+ h.app.ui.perspective = true;
+ h.app.run("sketch.create", json!({"plane":"XY","name":"Ring"})).unwrap();
+ h.app.run("sketch.circle.center", json!({"center":[0,0],"radius":40})).unwrap();
+ h.app.run("sketch.circle.center", json!({"center":[0,0],"radius":45})).unwrap();
+ h.settle();
+ h.step(&json!({"call":"ui.view","params":{"view":"iso"}})).unwrap();
+ h.step(&json!({"call":"ui.view","params":{"view":"fit"}})).unwrap();
+ h.app.cam.zoom_at(0.15, Some(Vec3::new(42.5, 0.0, 0.0)));
+ h.settle();
+ let baseline = h.app.session.doc.to_json();
+ let sid = h.app.session.active_sketch.unwrap();
+ let state = h.app.session.world_state();
+ let ss = state.sketch(sid).unwrap();
+ let proj = projection(&h.app, h.app.viewport.rect.unwrap());
+ let ppp = h.app.viewport.pixels_per_point();
+ let ring = ss.profiles.iter().find(|p| p.region.holes.len() == 1).unwrap();
+ let display = crate::sketch_display::display_region(&ring.region, &ss.plane, &proj, ppp).unwrap();
+ let edges = std::iter::once(&display.outer).chain(&display.holes).map(|l| l.segs.len()).sum::<usize>();
+ assert!(edges * edges / 2 > 65_536, "fixture must sample the ring finely enough to exceed the old estimate: {edges} edges");
+ let triangles = crate::sketch_display::region_triangles(&ring.region, &ss.plane, &proj, ppp);
+ assert!(!triangles.is_empty(), "the ring's fill was dropped at this zoom");
+ for t in &triangles {
+ let r = ((t[0] + t[1] + t[2]) / 3.0).len();
+ assert!((39.9..=45.1).contains(&r), "fill triangle outside the ring: r = {r}");
+ }
+ assert_eq!(h.app.session.doc.to_json(), baseline);
+}