SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Move to Component: a sketch on a face inside the moved part goes along (#11063) (#11072)
semmelrindeac9d4e8a1d8e
diff --git a/crates/engine/src/cmd/component_reparent.rs b/crates/engine/src/cmd/component_reparent.rsindex 35edd2d0b6..c2563d1972 100644--- a/crates/engine/src/cmd/component_reparent.rs+++ b/crates/engine/src/cmd/component_reparent.rs@@ -3,8 +3,8 @@//! once is one definition: what goes in it goes in every instance, placed by the one instance//! named (`parent_path`, else the active placement) and in the same place in the others. Paths//! through the placement change: the session's paths (selection, active and hidden placements,-//! hidden folders) follow it, and a move that would leave a feature failing that worked before-//! (a face attachment found through the old path) is refused.+//! hidden folders) and the design's face attachments found through it follow it, and a move that+//! would still leave a feature failing that worked before is refused.use super::placing::{parent_path, placement_of};use super::*;@@ -71,6 +71,37 @@ pub(super) fn reparent(s: &mut Session, p: &Value) -> Result<Value> {{c.parent = to;}+ // Face attachments found through it follow it too (#11063): a sketch on a face of a body+ // inside it kept the old path, which no longer starts at the design, and the move was refused.+ // A path through it by way of any placement of its old parent (a parent placed more than once+ // is one definition) now runs through its one new place. A path that would grow past the 64+ // placements a design keeps is refused here rather than saved where it can't be read back.+ let mut too_deep = false;+ let mut rebase = |path: &mut Vec<u64>| {+ if let Some(at) = path.iter().position(|x| *x == id) {+ let moved: Vec<u64> = new_path.iter().chain(&path[at + 1..]).copied().collect();+ too_deep |= moved.len() > 64;+ *path = moved;+ }+ };+ for f in &mut scratch.doc_mut().features {+ match &mut f.kind {+ FeatureKind::Emboss { face: Some(face), .. } => {+ rebase(&mut face.path);+ rebase(&mut face.author_path);+ }+ FeatureKind::Sketch { plane, .. } | FeatureKind::ConstructionPlane { plane } => {+ if let Some(anchor) = crate::cmd::sketch::face::anchor_mut(plane) {+ rebase(&mut anchor.path);+ rebase(&mut anchor.author_path);+ }+ }+ _ => {}+ }+ }+ if too_deep {+ return Err(bad(cmd, format!("moving {} would nest a face attachment more than 64 placements deep", o.name)));+ }// The paths through it follow it before the model is worked out again: that drops a selected// or active placement whose path no longer leads anywhere.for sel in &mut scratch.selection {diff --git a/crates/engine/src/cmd/occurrence_tests.rs b/crates/engine/src/cmd/occurrence_tests.rsindex 18dc2bff43..48182507bd 100644--- a/crates/engine/src/cmd/occurrence_tests.rs+++ b/crates/engine/src/cmd/occurrence_tests.rs@@ -1303,6 +1303,54 @@ fn reparent_keeps_the_world_position_and_follows_paths() {/// A component can't go inside itself or what it holds. Out of a parent placed more than once it/// moves from the placement named, keeping that one's place in the world.+/// #11063: a part with a hole cut from a sketch on its disc's top face moves into another+/// component. The sketch's face attachment was found through the part's old placement path,+/// which no longer starts at the design once the part is inside the other component, and the+/// move was refused ("would break Sketch2"). The attachment follows the move, and the hole stays.+#[test]+fn reparent_carries_a_sketch_on_a_face_inside_the_moved_part() {+ let mut s = Session::default();+ run(&mut s, "component.create", json!({"name": "Component1", "activate": false}));+ run(&mut s, "component.create", json!({"name": "Component2"}));+ run(&mut s, "sketch.create", json!({"plane": "XY", "name": "Sketch1"}));+ run(&mut s, "sketch.circle.center", json!({"center": [0, 0], "radius": 10}));+ run(&mut s, "sketch.finish", json!({}));+ run(&mut s, "solid.extrude", json!({"sketch": "Sketch1", "distance": 3, "operation": "new"}));+ run(&mut s, "sketch.create", json!({"plane": {"face": [0, 5, 3]}, "name": "Sketch2"}));+ run(&mut s, "sketch.circle.center", json!({"center": [0, 0], "radius": 3}));+ run(&mut s, "sketch.finish", json!({}));+ run(&mut s, "solid.extrude", json!({"sketch": "Sketch2", "distance": -3, "operation": "cut"}));+ let volume = |s: &Session| s.world_state().bodies.iter().map(|b| b.mesh().measure().volume.abs()).sum::<f64>();+ let before = volume(&s);+ let r = run(&mut s, "occurrence.reparent", json!({"occurrence": "Component2:1", "parent": "Component1"}));+ assert_eq!(r["path"].as_array().map(Vec::len), Some(2), "{r}");+ assert!(s.model.results.iter().all(|r| r.error.is_none()), "every feature still builds");+ assert!((volume(&s) - before).abs() < 1e-6, "the disc keeps its hole: {} vs {before}", volume(&s));+ let reopened = Session::new(crate::doc::Document::from_json(&s.doc.to_json()).unwrap());+ assert!(reopened.model.results.iter().all(|r| r.error.is_none()), "and after reopening");+}++/// A parent placed twice is one definition: a sketch on the child's face made through the+/// second placement moves along when the child is moved out through the first one, to the+/// child's one new place.+#[test]+fn reparent_carries_a_face_sketch_made_through_another_placement_of_the_parent() {+ let mut s = Session::default();+ let (parent, first_parent) = created(&mut s, "Assembly");+ let (_, child) = created(&mut s, "Knob");+ run(&mut s, "solid.box", json!({"length": 10, "width": 10, "height": 10, "corner": [0, 0, 0], "body_name": "Knob"}));+ let second_parent = run(&mut s, "occurrence.copy", json!({"component": parent, "translate": [20, 0, 0]}))["occurrence"].as_u64().unwrap();+ run(&mut s, "sketch.create", json!({"plane": {"face": [25, 5, 10], "path": [second_parent, child]}, "name": "OnTop"}));+ run(&mut s, "sketch.finish", json!({}));+ let out = run(&mut s, "occurrence.reparent", json!({"occurrence": child, "parent": "root", "path": [first_parent, child]}));+ assert_eq!(out["path"], json!([child]));+ assert!(s.model.results.iter().all(|r| r.error.is_none()), "the sketch still finds its face");+ let sketch = s.doc.features.iter().find(|f| f.name == "OnTop").unwrap();+ let solidcraft_doc::FeatureKind::Sketch { plane, .. } = &sketch.kind else { panic!("OnTop is no sketch") };+ let anchor = crate::cmd::sketch::face::anchor(plane).unwrap();+ assert_eq!(anchor.path, vec![child], "{anchor:?}");+}+#[test]fn reparent_refuses_cycles_and_moves_out_of_a_named_instance() {let mut s = Session::default();