SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Fillet/chamfer: point the drag arrow into the corner on inside edges (#1394)
bherbruck6eaf7458aba0
diff --git a/crates/ui-egui/src/blend_arrow_tests.rs b/crates/ui-egui/src/blend_arrow_tests.rsnew file mode 100644index 0000000000..a2dbfeec9b--- /dev/null+++ b/crates/ui-egui/src/blend_arrow_tests.rs@@ -0,0 +1,103 @@+//! Fillet and chamfer drag arrows on outside and inside edges (#1384): the arrow points where+//! the value grows (into the body on an outside edge, into the open corner on an inside one),+//! and dragging out along it increases the value.++use crate::canvas::{anchor, blend_grow_dir};+use crate::dialogs::Kind;+use crate::scenario::Harness;+use serde_json::json;+use solidcraft_engine::Sel;+use solidcraft_engine::geom::Vec3;++/// A 40 x 30 x 20 block with a 20 x 30 x 10 step on its left half: the edge along y at x 20,+/// z 20 is inside (concave); the block's right top edge (x 40, z 20) and the step's top right+/// edge (x 20, z 30) are outside (convex).+fn l_step() -> Harness {+ let mut h = Harness::new();+ h.app.run("solid.box", json!({"length": 40, "width": 30, "height": 20})).unwrap();+ h.app.run("solid.box", json!({"length": 20, "width": 30, "height": 10, "corner": [0, 0, 20], "operation": "join"})).unwrap();+ h.frames(2);+ h+}++fn edge(h: &Harness, p: Vec3) -> Sel {+ let st = h.app.session.world_state();+ let m = st.body("Body1").unwrap().mesh();+ let i = m.edges.iter().position(|e| e.windows(2).any(|w| p.dist_to_segment(w[0], w[1]) < 1e-9)).expect("an edge there");+ Sel::Edge { body: "Body1".into(), index: i, point: p }+}++fn grow(h: &Harness, s: &Sel) -> Vec3 {+ let Sel::Edge { body, index, point } = s else { panic!("an edge") };+ blend_grow_dir(&h.app.session.world_state().body(body).unwrap().mesh(), *index, *point).unwrap()+}++fn close(a: Vec3, b: Vec3) -> bool {+ a.dist(b) < 1e-6+}++const INSIDE: Vec3 = Vec3::new(20.0, 15.0, 20.0);+const OUTSIDE: Vec3 = Vec3::new(40.0, 15.0, 20.0);+const STEP_TOP: Vec3 = Vec3::new(20.0, 15.0, 30.0);++/// The direction function on its own: the corner's open side on the inside edge, into the+/// material on the outside ones, each edge of a mixed chain on its own.+#[test]+fn grow_direction_follows_each_edges_convexity() {+ let h = l_step();+ let s = std::f64::consts::FRAC_1_SQRT_2;+ let open = Vec3::new(s, 0.0, s);+ assert!(close(grow(&h, &edge(&h, INSIDE)), open), "inside: {:?}", grow(&h, &edge(&h, INSIDE)));+ assert!(close(grow(&h, &edge(&h, OUTSIDE)), Vec3::new(-s, 0.0, -s)), "outside: {:?}", grow(&h, &edge(&h, OUTSIDE)));+ // Same face normals as the inside edge, but outside: the opposite way.+ assert!(close(grow(&h, &edge(&h, STEP_TOP)), -open), "step top: {:?}", grow(&h, &edge(&h, STEP_TOP)));+}++/// A plain box's outside edge keeps its arrow into the body.+#[test]+fn box_edge_arrow_still_points_into_the_body() {+ let mut h = Harness::new();+ h.app.run("solid.box", json!({"length": 40, "width": 30, "height": 20})).unwrap();+ let e = edge(&h, Vec3::new(20.0, 0.0, 20.0));+ for id in ["solid.fillet", "solid.chamfer"] {+ h.app.session.selection = vec![e.clone()];+ h.app.start(id);+ let dir = anchor(&h.app, h.app.dialog.as_ref().unwrap()).unwrap().1.unwrap();+ assert!(dir.y > 0.5 && dir.z < -0.5, "{id}: {dir:?}");+ h.app.dialog = None;+ }+}++/// The value of the open fillet or chamfer window.+fn value(h: &Harness) -> f64 {+ let Some(Kind::Fillet { radius, .. }) = h.app.dialog.as_ref().map(|d| &d.kind) else { panic!("a fillet window") };+ h.app.session.doc.eval(radius, solidcraft_engine::doc::expr::Kind::Length).unwrap()+}++/// On an inside edge (and on an outside one, a mixed chain's first edge either way), the arrow+/// points along the edge's own grow direction and dragging outward along it increases the value.+#[test]+fn dragging_out_along_the_arrow_grows_fillet_and_chamfer_on_both_kinds_of_edge() {+ for first in [INSIDE, OUTSIDE] {+ for id in ["solid.fillet", "solid.chamfer"] {+ let mut h = l_step();+ h.step(&json!({"call": "ui.view", "params": {"view": "iso"}})).unwrap();+ h.step(&json!({"call": "ui.view", "params": {"view": "fit"}})).unwrap();+ let chain = if first == INSIDE { vec![edge(&h, INSIDE), edge(&h, OUTSIDE)] } else { vec![edge(&h, OUTSIDE), edge(&h, INSIDE)] };+ h.app.session.selection = chain;+ h.app.start(id);+ h.frames(3);+ let shown = h.app.dialog.as_ref().unwrap().inputs[0].items[0].clone();+ assert_eq!(h.app.dialog.as_ref().unwrap().inputs[0].items.len(), 2);+ let want = grow(&h, &shown);+ assert!(close(want, grow(&h, &edge(&h, first))) || matches!(&shown, Sel::Edge { point, .. } if *point != first));+ let (at, dir) = anchor(&h.app, h.app.dialog.as_ref().unwrap()).unwrap();+ assert!(close(dir.unwrap(), want), "{id} at {first:?}: {dir:?} vs {want:?}");+ let before = value(&h);+ let to = at + want * 6.0;+ h.step(&json!({"drag": [{"handle": "arrow"}, {"world": [to.x, to.y, to.z]}], "ctrl": true})).unwrap();+ let after = value(&h);+ assert!(after > before && (after - 6.0).abs() < 0.3, "{id} at {first:?}: {before} -> {after}");+ }+ }+}diff --git a/crates/ui-egui/src/canvas.rs b/crates/ui-egui/src/canvas.rsindex 93cc4f54dd..2cc38d3f58 100644--- a/crates/ui-egui/src/canvas.rs+++ b/crates/ui-egui/src/canvas.rs@@ -116,7 +116,13 @@ pub fn anchor(app: &SolveApp, d: &Dialog) -> Option<(Vec3, Option<Vec3>)> {(at, normal.or(dir.map(|d| -d)))}Kind::Section { .. } | Kind::OffsetPlane { .. } | Kind::OffsetFaces { .. } => (at, normal),- // Fillet radii, chamfer distances and shell thickness grow into the body.+ // Fillet radii and chamfer distances grow the way `blend_grow_dir` gives (into the body+ // on an outside edge, into the open corner on an inside one); shell thickness grows into+ // the body.+ Kind::Fillet { .. } if matches!(first, Sel::Edge { .. }) => {+ let Sel::Edge { body, index, .. } = first else { return None };+ (at, st.body(body).and_then(|b| blend_grow_dir(&b.mesh(), *index, at)))+ }Kind::Fillet { .. } | Kind::Shell { .. } => (at, normal.map(|n| -n)),Kind::Sheet(_) => (at, crate::dialogs_sheet::arrow(app, d).or(normal)),Kind::Plastic(_) => (at, normal),@@ -178,23 +184,46 @@ fn reference_height(app: &SolveApp, d: &Dialog, label: &str, plane: &solidcraft_Some(solidcraft_engine::doc::object_height(&app.session.world_state(), plane, centre, p))}-/// The outward direction between the two faces at an edge (a fillet's radius arrow points the-/// other way, into the body).-fn edge_bisector(m: &Mesh, index: usize, p: Vec3) -> Option<Vec3> {+/// The two faces at an edge, near `p`: for each, the normal and centroid of its triangle nearest+/// `p`.+fn edge_sides(m: &Mesh, index: usize, p: Vec3) -> Option<Vec<(Vec3, Vec3)>> {let faces = m.edge_faces.get(index)?;- let mut sum = Vec3::ZERO;- for f in faces {- let n = m- .triangles- .iter()- .zip(&m.tri_face)- .filter(|(_, tf)| *tf == f)- .filter_map(|(t, _)| m.tri(t))- .min_by(|a, b| ((a[0] + a[1] + a[2]) / 3.0).dist(p).total_cmp(&((b[0] + b[1] + b[2]) / 3.0).dist(p)))- .and_then(|[a, b, c]| (b - a).cross(c - a).normalized())?;- sum += n;- }- sum.normalized()+ faces+ .iter()+ .map(|f| {+ m.triangles+ .iter()+ .zip(&m.tri_face)+ .filter(|(_, tf)| *tf == f)+ .filter_map(|(t, _)| m.tri(t))+ .min_by(|a, b| ((a[0] + a[1] + a[2]) / 3.0).dist(p).total_cmp(&((b[0] + b[1] + b[2]) / 3.0).dist(p)))+ .and_then(|[a, b, c]| Some(((b - a).cross(c - a).normalized()?, (a + b + c) / 3.0)))+ })+ .collect()+}++/// The outward direction between the two faces at an edge: the mean of their normals.+fn edge_bisector(m: &Mesh, index: usize, p: Vec3) -> Option<Vec3> {+ edge_sides(m, index, p)?.iter().fold(Vec3::ZERO, |sum, (n, _)| sum + *n).normalized()+}++/// Whether the edge is an inside (concave) one: each face near it lies in front of the other's+/// plane, where on an outside edge it lies behind. Only the offset across the edge counts, since+/// each normal is square to the edge.+fn edge_concave(m: &Mesh, index: usize, p: Vec3) -> Option<bool> {+ let sides = edge_sides(m, index, p)?;+ let [(n1, c1), (n2, c2)] = sides.as_slice() else { return None };+ let s = (*c1 - p).dot(*n2) + (*c2 - p).dot(*n1);+ Some(s > 0.0)+}++/// The direction a fillet's radius or a chamfer's distance grows from an edge, along the bisector+/// of its faces: into the body on an outside edge, where the blend takes material away, and out+/// into the open corner on an inside edge, where it adds material (#1384). Dragging along it+/// increases the value either way.+pub(crate) fn blend_grow_dir(m: &Mesh, index: usize, p: Vec3) -> Option<Vec3> {+ let n = edge_bisector(m, index, p)?;+ Some(if edge_concave(m, index, p).unwrap_or(false) { n } else { -n })}/// Whether a dynamically registered canvas handle owns this point before navigation.@@ -609,8 +638,9 @@ fn radius_spline_handles(app: &SolveApp, ui: &mut egui::Ui, painter: &egui::Painlet (spline, start) = law.as_ref()?;let other = if start.dist(*a) <= start.dist(*b) { *b } else { *a };let mid = *start + (other - *start) * 0.5;- // Into the body, between the two faces (the edge is straight between planar faces).- let n = -edge_bisector(mesh, *index, mid)?;+ // Between the two faces, the way this edge's radius grows: into the body on an outside+ // edge, into the corner on an inside one (the edge is straight between planar faces).+ let n = blend_grow_dir(mesh, *index, mid)?;let curve = (0..=48).filter_map(|k| {let u = f64::from(k) / 48.0;diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rsindex d3a73d9c5f..6cea2e4d2f 100644--- a/crates/ui-egui/src/lib.rs+++ b/crates/ui-egui/src/lib.rs@@ -89,6 +89,8 @@ mod file_load;mod file_picker;pub use file_picker::FilePickerFuture;#[cfg(test)]+mod blend_arrow_tests;+#[cfg(test)]mod file_load_ui_tests;#[cfg(test)]mod fillet_spline_handle_tests;