SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Extrude dialog: keep the taper limits while the profile is unchanged (#10503)
kaltenbrunnermarkusea63eec845bc
diff --git a/crates/ui-egui/src/canvas.rs b/crates/ui-egui/src/canvas.rsindex bb336aafc0..760a23dce2 100644--- a/crates/ui-egui/src/canvas.rs+++ b/crates/ui-egui/src/canvas.rs@@ -614,7 +614,7 @@ fn draw(app: &SolveApp, ui: &mut egui::Ui, painter: &egui::Painter, proj: &Proj,let mut dir = dir;// Extrude taper: a handle beside the arrow tip; dragging it sideways tilts the walls.let cam_right = app.cam.basis().0;- if let (Kind::Extrude { direction: 0 | 1, distance, taper, taper_present, to_offset, .. }, Some(n)) = (&mut d.kind, dir) {+ if let (Kind::Extrude { direction: 0 | 1, distance, taper, taper_present, to_offset, smart, .. }, Some(n)) = (&mut d.kind, dir) {let n = n * sign;let span =to_span.map(|span| span.abs() + crate::length_input::eval(&app.session.doc, to_offset, ValueKind::Length).unwrap_or(0.0)).or(all_span);@@ -638,7 +638,7 @@ fn draw(app: &SolveApp, ui: &mut egui::Ui, painter: &egui::Painter, proj: &Proj,_ => None,}).collect();- let limits = taper_limits(®ions, l.abs());+ let limits = taper_limits(taper_radii_kept(&mut smart.taper_radii, ®ions), l.abs());taper_handle(ui, painter, proj, base - e * (40.0 * px), n * l, -e, ang, limits, taper);if *taper != before {*taper_present = true;@@ -1511,19 +1511,57 @@ fn measure_components(}}-/// The tapers (degrees, least and most) a drag of the taper handle may reach for `regions`-/// extruded `height` (#1602): going in, the sides close the material where they have moved its-/// inradius; going out, they close the smallest hole. Each stops just short, so the drag ends at-/// the largest taper that builds instead of one that fails. A typed angle is not limited.-pub(crate) fn taper_limits(regions: &[&solidcraft_engine::geom::Region2], height: f64) -> (f64, f64) {+/// The tapers (degrees, least and most) a drag of the taper handle may reach for profiles of+/// `radii` ([`taper_radii`]) extruded `height` (#1602): going in, the sides close the material+/// where they have moved its inradius; going out, they close the smallest hole. Each stops just+/// short, so the drag ends at the largest taper that builds instead of one that fails. A typed+/// angle is not limited.+pub(crate) fn taper_limits((inward, outward): (f64, f64), height: f64) -> (f64, f64) {const MAX: f64 = 89.0;- if !(height > 1e-9) || regions.is_empty() {+ if !(height > 1e-9) {return (-MAX, MAX);}let at = |r: f64| (0.99 * r / height).atan().to_degrees().min(MAX);+ (if inward.is_finite() { -at(inward) } else { -MAX }, if outward.is_finite() { at(outward) } else { MAX })+}++/// The smallest inradius of `regions` and of their holes (infinite for none), which+/// [`taper_limits`] turns into angles. A grid search over every side of every loop, so the+/// extrude window keeps it while its profiles stay the same ([`taper_radii_kept`]).+pub(crate) fn taper_radii(regions: &[&solidcraft_engine::geom::Region2]) -> (f64, f64) {+ #[cfg(test)]+ TAPER_RADII_WORKED_OUT.with(|n| n.set(n.get() + 1));let inward = regions.iter().map(|r| r.inradius(1e-3)).fold(f64::INFINITY, f64::min);let outward = regions.iter().flat_map(|r| &r.holes).map(|h| h.inradius(1e-3)).fold(f64::INFINITY, f64::min);- (if inward.is_finite() { -at(inward) } else { -MAX }, if outward.is_finite() { at(outward) } else { MAX })+ (inward, outward)+}++/// [`taper_radii`] of `regions`, worked out again only when they differ from the ones `kept`+/// holds: the extrude window draws its taper handle every frame, and only the height changes.+fn taper_radii_kept(+ kept: &mut Option<(Vec<solidcraft_engine::geom::Region2>, (f64, f64))>,+ regions: &[&solidcraft_engine::geom::Region2],+) -> (f64, f64) {+ if let Some((was, radii)) = kept+ && was.len() == regions.len()+ && was.iter().zip(regions).all(|(a, b)| a == *b)+ {+ return *radii;+ }+ let radii = taper_radii(regions);+ *kept = Some((regions.iter().map(|r| (*r).clone()).collect(), radii));+ radii+}++#[cfg(test)]+thread_local! {+ static TAPER_RADII_WORKED_OUT: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };+}++/// How often the taper handle's radii were worked out on this thread.+#[cfg(test)]+pub(crate) fn taper_radii_worked_out() -> usize {+ TAPER_RADII_WORKED_OUT.with(std::cell::Cell::get)}/// The taper handle: a line from `foot` along the extrude (`span`) leaning by `angle` towards@@ -2071,7 +2109,7 @@ mod tests {#[cfg(test)]mod taper_limit_tests {- use super::taper_limits;+ use super::{taper_limits, taper_radii};use solidcraft_engine::geom::{Loop2, Region2, Vec2};/// #1602: a drag stops just short of the taper that closes the profile, either way.@@ -2084,16 +2122,16 @@ mod taper_limit_tests {outer: Loop2::polygon(&[Vec2::new(0.0, 0.0), Vec2::new(10.0, 0.0), Vec2::new(10.0, 4.0), Vec2::new(0.0, 4.0)]),holes: Vec::new(),};- let (lo, hi) = taper_limits(&[&rect], 26.0);+ let (lo, hi) = taper_limits(taper_radii(&[&rect]), 26.0);assert!(close(lo, -deg(2.0, 26.0)) && hi == 89.0, "{lo} {hi}");// A ring 10 to 6, 10 high: in, its 4 mm wall; out, its hole of radius 6.let ring = Region2 { outer: Loop2::circle(Vec2::ZERO, 10.0), holes: vec![Loop2::circle(Vec2::ZERO, 6.0).reversed()] };- let (lo, hi) = taper_limits(&[&ring], 10.0);+ let (lo, hi) = taper_limits(taper_radii(&[&ring]), 10.0);assert!(close(lo, -deg(2.0, 10.0)) && close(hi, deg(6.0, 10.0)), "{lo} {hi}");// The tightest of several profiles; no profile or no height, no limit.- let (lo, _) = taper_limits(&[&ring, &rect], 10.0);+ let (lo, _) = taper_limits(taper_radii(&[&ring, &rect]), 10.0);assert!(close(lo, -deg(2.0, 10.0)));- assert_eq!(taper_limits(&[], 10.0), (-89.0, 89.0));- assert_eq!(taper_limits(&[&rect], 0.0), (-89.0, 89.0));+ assert_eq!(taper_limits(taper_radii(&[]), 10.0), (-89.0, 89.0));+ assert_eq!(taper_limits(taper_radii(&[&rect]), 0.0), (-89.0, 89.0));}}diff --git a/crates/ui-egui/src/smart_extrude.rs b/crates/ui-egui/src/smart_extrude.rsindex a5615b70ae..677142f450 100644--- a/crates/ui-egui/src/smart_extrude.rs+++ b/crates/ui-egui/src/smart_extrude.rs@@ -31,6 +31,9 @@ pub struct Smart {pub latch: Option<(usize, i8)>,/// The To Object target the distance was last set from.pub target: Option<Sel>,+ /// The profiles the taper handle's limits were last worked out for, and their radii+ /// (`canvas::taper_radii`): too slow to work out every frame on a profile with many holes.+ pub taper_radii: Option<(Vec<solidcraft_engine::geom::Region2>, (f64, f64))>,/// Where the extrude starts (its From Object and start offset) when the latch was decided.pub start: serde_json::Value,/// The bodies shown when the latch was decided (None: every one), as `shown_scope` gives them.diff --git a/crates/ui-egui/src/viewport_overlays_tests.rs b/crates/ui-egui/src/viewport_overlays_tests.rsindex 09412ffa3d..7f9583dff4 100644--- a/crates/ui-egui/src/viewport_overlays_tests.rs+++ b/crates/ui-egui/src/viewport_overlays_tests.rs@@ -1543,6 +1543,37 @@ fn a_huge_extrude_distance_draws_its_handles_at_once() {assert!(started.elapsed().as_secs_f64() < 10.0, "{:?}", started.elapsed());}+/// The taper handle's limits come from the profiles' inradii, a grid search over every side:+/// an open extrude works them out once for its profiles, not every frame, and again when the+/// profiles change.+#[test]+fn an_open_extrude_keeps_its_taper_limits_while_the_profiles_stay() {+ let mut h = Harness::new();+ h.app.run("sketch.create", json!({"plane":"XY"})).unwrap();+ h.app.run("sketch.rectangle.two_point", json!({"p0":[-20,-20],"p1":[20,20]})).unwrap();+ h.app.run("sketch.circle.center", json!({"center":[0,0],"radius":6})).unwrap();+ h.app.run("sketch.finish", json!({})).unwrap();+ h.app.run("select.clear", json!({})).unwrap();+ h.step(&json!({"call":"ui.view","params":{"view":"home"}})).unwrap();+ h.step(&json!({"call":"ui.view","params":{"view":"fit"}})).unwrap();+ h.settle();+ h.step(&json!({"start":"solid.extrude"})).unwrap();+ h.step(&json!({"click":{"world":[15,15,0]}})).unwrap();+ h.frames(2);+ assert!(crate::scenario::handle_at("taper").is_some(), "the taper handle is drawn");+ let once = crate::canvas::taper_radii_worked_out();+ h.frames(20);+ assert_eq!(crate::canvas::taper_radii_worked_out(), once, "the same profile: not worked out again");+ h.step(&json!({"text":"25"})).unwrap();+ h.frames(4);+ assert_eq!(crate::canvas::taper_radii_worked_out(), once, "only the height changed");+ // The disc in the hole joins the extrude: other profiles, other limits.+ h.step(&json!({"click":{"world":[-3,-3,0]}})).unwrap();+ h.frames(2);+ assert_eq!(h.app.dialog.as_ref().map(|d| d.inputs[0].items.len()), Some(2), "{:?}", h.app.dialog.as_ref().map(|d| &d.inputs[0].items));+ assert!(crate::canvas::taper_radii_worked_out() > once, "new profiles are worked out");+}+fn point_overlays(app: &SolveApp) -> Vec<Shape> {let ctx = egui::Context::default();let proj = display_proj(app);