From 7e8f87dc575b8a725b74cefdcd2ba677f5445969 Mon Sep 17 00:00:00 2001 From: Homero Thompson Date: Wed, 28 Oct 2026 14:13:45 +0000 Subject: [PATCH] Extrude: a face shared by two bodies is resolved in the active occurrence (#419) (#6469) * claim: #419 * fix(#419): a face shared by two bodies is resolved in the active occurrence --- crates/engine/src/cmd/face.rs | 17 +++++- crates/engine/src/cmd/face_join_tests.rs | 38 ++++++++++++ crates/engine/src/frames.rs | 74 ++++++++++++++++++++---- crates/engine/src/lib.rs | 7 ++- 4 files changed, 123 insertions(+), 13 deletions(-) diff --git a/crates/engine/src/cmd/face.rs b/crates/engine/src/cmd/face.rs index 090374362..5571f43ca 100644 --- a/crates/engine/src/cmd/face.rs +++ b/crates/engine/src/cmd/face.rs @@ -181,9 +181,24 @@ type FacePick = (std::sync::Arc, u32, f64, String); /// The face under a point of `only` (any body when `None`). Where faces of several bodies are /// equally near (bodies touching flush), the pick is ambiguous: `Err` names those bodies. +/// A pick of the running command was resolved against the placed model, so the body under it +/// wins: a body that only shares its place in the model is not in the way (#419). A named +/// body still wins over that. fn face_at_in(s: &Session, p: Vec3, only: Option<&str>) -> std::result::Result, Vec> { let st = s.model.state(); - face_at_state(&st, p, only) + match (crate::frames::picked(p), only) { + (Some(names), None) if names.len() > 1 => Err(model_names(&st, &names)), + (Some(names), None) => { + let under = names.first().and_then(|n| st.bodies.iter().find(|b| b.definition_name() == n.as_str()).map(|b| b.name.clone())); + face_at_state(&st, p, under.as_deref()) + } + (_, only) => face_at_state(&st, p, only), + } +} + +/// The names the model gives the bodies a pick met. +fn model_names(st: &solidcraft_doc::ModelState, names: &[String]) -> Vec { + names.iter().map(|n| st.bodies.iter().find(|b| b.definition_name() == n.as_str()).map(|b| b.name.clone()).unwrap_or_else(|| n.clone())).collect() } pub(super) fn face_at_state(st: &solidcraft_doc::ModelState, p: Vec3, only: Option<&str>) -> std::result::Result, Vec> { diff --git a/crates/engine/src/cmd/face_join_tests.rs b/crates/engine/src/cmd/face_join_tests.rs index 7ebd9a7a1..ca5f61430 100644 --- a/crates/engine/src/cmd/face_join_tests.rs +++ b/crates/engine/src/cmd/face_join_tests.rs @@ -126,6 +126,44 @@ fn face_join_of_a_step_import_keeps_all_32_neighbours_unchanged() { assert_eq!(targets, &["Wall"]); } +/// #419: a face pick is resolved against the placed state: a leaf of an assembly that its +/// joint swung away does not make the pick ambiguous, even though both leaves are built at +/// the same local place. The pick lands on the leaf that is shown there. +#[test] +fn a_face_pick_on_an_assembly_leaf_is_resolved_where_the_leaf_is_shown() { + let mut s = Session::default(); + for leaf in ["Leaf A", "Leaf B"] { + run(&mut s, "component.activate", json!({"component": "root"})); + run(&mut s, "component.create", json!({"name": leaf})); + run(&mut s, "solid.box", json!({"length": 40, "width": 30, "height": 3, "corner": [0, 0, 0]})); + run(&mut s, "solid.cylinder", json!({"base": [0, 33, 4], "axis": [1, 0, 0], "radius": 4, "height": 40, "operation": "new"})); + } + run(&mut s, "component.activate", json!({"component": "root"})); + run(&mut s, "occurrence.ground", json!({"occurrence": "Leaf A:1", "grounded": true})); + run( + &mut s, + "joint.create", + json!({ + "type": "revolute", + "name": "Hinge", + "a": {"occurrence": "Leaf A:1", "circle": [1, 37, 4]}, + "b": {"occurrence": "Leaf B:1", "circle": [1, 37, 4]}, + "limits": [["0 deg", "180 deg"]] + }), + ); + run(&mut s, "joint.drive", json!({"joint": "Hinge", "value": 60})); + // Leaf B is swung 60° away, so the pick is on Leaf A's top face, where it is shown. + let result = run( + &mut s, + "solid.extrude", + json!({"face": [13.002403831300967, 9.849781594495369, 3.0], "distance": "10 mm", "direction": "positive", "operation": "join"}), + ); + assert_eq!(result["changed_bodies"], json!(["Body1"])); + let state = s.model.state(); + let volume = solidcraft_kernel::measure(&state.body("Body1").unwrap().body).unwrap().volume; + assert!((volume - 15_600.0).abs() < 1e-6, "{volume}"); +} + /// #1349: a profile sketched on a body's face joins that body, and leaves alone a neighbour /// whose face it lies on too: a rib on the side of a bracket, drawn down over the motor the /// bracket sits on, welded the motor in (a join that ran for minutes on the imported motor and diff --git a/crates/engine/src/frames.rs b/crates/engine/src/frames.rs index e55b6eaca..64fb163bd 100644 --- a/crates/engine/src/frames.rs +++ b/crates/engine/src/frames.rs @@ -142,17 +142,19 @@ fn pt(p: Vec3) -> Value { serde_json::json!([p.x, p.y, p.z]) } -/// The frame of the body a world point lies on (the nearest), or of the named body. -fn frame_at(s: &Session, f: &Frames, p: Vec3, body: Option<&str>) -> Option { +/// The frame of the body a world point lies on (the nearest), or of the named body, with the +/// bodies whose faces meet there: the first is the body under the point, and more than one +/// means the pick is ambiguous. +fn frame_at(s: &Session, f: &Frames, p: Vec3, body: Option<&str>) -> Option<(Mat, Vec)> { if let Some(b) = body - && let Some((_, _, m)) = f.bodies(s).iter().find(|(w, _, _)| w == b) + && let Some((_, own, m)) = f.bodies(s).iter().find(|(w, _, _)| w == b) { - return Some(*m); + return Some((*m, vec![own.clone()])); } let world = s.world_state(); - let mut best: Option<(f64, Mat)> = None; + let mut best: Option<(f64, Mat, Vec)> = None; for wb in &world.bodies { - let Some((_, _, m)) = f.bodies(s).iter().find(|(w, _, _)| *w == wb.name) else { continue }; + let Some((_, own, m)) = f.bodies(s).iter().find(|(w, _, _)| *w == wb.name) else { continue }; let mesh = wb.mesh(); let bb = mesh.bounds(); let tol = (bb.diagonal() * 1e-3).max(1e-3); @@ -166,11 +168,23 @@ fn frame_at(s: &Session, f: &Frames, p: Vec3, body: Option<&str>) -> Option continue; } let d = mesh.triangles.iter().filter_map(|t| mesh.tri(t)).map(|[a, b, c]| tri_dist(p, a, b, c)).fold(f64::INFINITY, f64::min); - if d <= tol && best.as_ref().is_none_or(|(bd, _)| d < *bd) { - best = Some((d, *m)); + if d > tol { + continue; + } + // Bodies whose faces are as near the point as the nearest one meet there: two of them + // make the pick ambiguous. The same body placed twice is one body, not a tie. + let as_near = best.as_ref().is_some_and(|(bd, _, _)| (d - *bd).abs() <= 1e-8); + if as_near { + if let Some((_, _, names)) = &mut best + && !names.contains(own) + { + names.push(own.clone()); + } + } else if best.as_ref().is_none_or(|(bd, _, _)| d < *bd) { + best = Some((d, *m, vec![own.clone()])); } } - best.map(|(_, m)| m) + best.map(|(_, m, names)| (m, names)) } fn tri_dist(p: Vec3, a: Vec3, b: Vec3, c: Vec3) -> f64 { @@ -195,9 +209,17 @@ struct Mapper<'a> { impl Mapper<'_> { fn pick(&mut self, v: &Value, body: Option<&str>) -> Option { let p = vec3(v)?; - let m = if self.here { self.f.sketch } else { frame_at(self.s, &self.f, p, body).unwrap_or(self.f.active) }; + let under = if self.here { None } else { frame_at(self.s, &self.f, p, body) }; + let m = if self.here { self.f.sketch } else { under.as_ref().map(|(m, _)| *m).unwrap_or(self.f.active) }; self.first.get_or_insert(m); - self.local_point(&m, p) + let out = self.local_point(&m, p); + // The command sees the pick in the frame of the body under it. Remember the bodies + // whose faces meet there, so a face of that body is found and a body that only + // shares its place in the model does not make the pick ambiguous (#419). + if let Some((_, names)) = &under { + remember(out.as_ref().and_then(vec3).unwrap_or(p), names.clone()); + } + out } fn local_point(&mut self, m: &Mat, p: Vec3) -> Option { @@ -315,6 +337,36 @@ thread_local! { static DEPTH: std::cell::Cell = const { std::cell::Cell::new(0) }; /// The outermost command's coordinates were mapped here (its table lists them). static MAPPED: std::cell::Cell = const { std::cell::Cell::new(false) }; + /// The picks of the running command: the point it sees and the bodies whose faces meet + /// there (the first is the body under it; more than one means the pick is ambiguous). + static PICKS: std::cell::RefCell)>> = const { std::cell::RefCell::new(Vec::new()) }; +} + +/// How many picks of one command are remembered (a command takes few). +const MAX_PICKS: usize = 4096; +/// How many bodies may meet at one pick (an ambiguous pick names them). +const MAX_PICK_BODIES: usize = 64; + +/// Remember the bodies whose faces meet at a pick, against the point the command sees. +fn remember(point: Vec3, names: Vec) { + let names: Vec = names.into_iter().take(MAX_PICK_BODIES).collect(); + PICKS.with(|picks| { + let mut picks = picks.borrow_mut(); + if picks.len() < MAX_PICKS { + picks.push((point, names)); + } + }); +} + +/// The bodies whose faces meet at `point`, when the running command picked it: the first is +/// the body under the pick, and more than one means the pick is ambiguous. +pub(crate) fn picked(point: Vec3) -> Option> { + PICKS.with(|picks| picks.borrow().iter().find(|(p, _)| *p == point).map(|(_, names)| names.clone())) +} + +/// Forget the picks of the last command: a new one starts with none. +pub(crate) fn forget_picks() { + PICKS.with(|picks| picks.borrow_mut().clear()); } /// Did this module map the running command's coordinates? (Otherwise a new feature's geometry diff --git a/crates/engine/src/lib.rs b/crates/engine/src/lib.rs index 4f7207088..e48da6756 100644 --- a/crates/engine/src/lib.rs +++ b/crates/engine/src/lib.rs @@ -1160,7 +1160,12 @@ impl Session { // Picks in the world go into their component's frame (once: commands run by commands // already have them there). let (_nested, outermost) = frames::Nested::enter(spec.id); - let mapped = if outermost { frames::to_local(self, spec.id, params) } else { None }; + let mapped = if outermost { + frames::forget_picks(); + frames::to_local(self, spec.id, params) + } else { + None + }; let params = mapped.as_ref().unwrap_or(params); if outermost { crash::command_begin(self, spec.id, given);