SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Move: placements of one part moved together each go the way asked (#4768) (#4849)
dudedagger42f512d4a0047a
diff --git a/crates/engine/src/cmd/features.rs b/crates/engine/src/cmd/features.rsindex c1ea4a5a74..2b00a1a4d4 100644--- a/crates/engine/src/cmd/features.rs+++ b/crates/engine/src/cmd/features.rs@@ -1481,6 +1481,57 @@ fn combine(s: &mut Session, p: &Value) -> Result<Value> {}fn move_bodies(s: &mut Session, p: &Value) -> Result<Value> {+ if let Some(plan) = crate::frames::placements_moved(s, p) {+ return move_placements(s, p, plan);+ }+ move_body_feature(s, p)+}++/// A move of several placements of one part (`frames::placements_moved`, #4768): each placement+/// moved in the world by the move's translation and turn (about the world origin, as the Move+/// feature turns bodies), and the root component's bodies listed moved as bodies, in one step.+fn move_placements(s: &mut Session, p: &Value, plan: crate::frames::PlacementMove) -> Result<Value> {+ let cmd = "solid.move";+ let length = |v: &Value| -> Result<f64> {+ match v {+ Value::Number(n) => n.as_f64().ok_or_else(|| bad(cmd, "translate entries must be numbers or expressions")),+ Value::String(e) => s.doc.eval(e, Kind::Length).map_err(|e| bad(cmd, format!("translate: {e}"))),+ _ => Err(bad(cmd, "translate entries must be numbers or expressions")),+ }+ };+ let translate = match p.get("translate") {+ Some(Value::Array(a)) if a.len() == 3 => a.iter().map(length).collect::<Result<Vec<f64>>>()?,+ None => vec![0.0; 3],+ _ => return Err(bad(cmd, "`translate` must be [x, y, z]")),+ };+ let angle = match expr(p, "angle") {+ Some(a) => Some(s.doc.eval(&a, Kind::Angle).map_err(|e| bad(cmd, format!("angle: {e}")))?),+ None => None,+ };+ let spec = super::find_command("occurrence.move").ok_or_else(|| EngineError::UnknownCommand("occurrence.move".into()))?;+ let mut moved = Vec::new();+ for path in &plan.paths {+ let Some(&occurrence) = path.last() else { continue };+ let mut q = json!({"occurrence": occurrence, "path": path, "space": "world", "translate": translate});+ if let Some(axis) = p.get("axis") {+ q["axis"] = axis.clone();+ }+ if let Some(angle) = angle {+ q["angle"] = json!(angle);+ }+ spec.run_nested(s, &q)?;+ moved.push(occurrence);+ }+ let mut out = json!({"placements": moved});+ if !plan.bodies.is_empty() {+ let mut rest = p.clone();+ rest["bodies"] = json!(plan.bodies);+ out["bodies"] = move_body_feature(s, &rest)?;+ }+ Ok(out)+}++fn move_body_feature(s: &mut Session, p: &Value) -> Result<Value> {let cmd = "solid.move";let bodies = string_list(p, "bodies");if bodies.is_empty() {diff --git a/crates/engine/src/cmd/features_more_tests.rs b/crates/engine/src/cmd/features_more_tests.rsindex 5620ff88e6..a4120c9bf6 100644--- a/crates/engine/src/cmd/features_more_tests.rs+++ b/crates/engine/src/cmd/features_more_tests.rs@@ -1953,3 +1953,96 @@ fn a_sketch_coil_never_panics_on_hostile_parameters() {assert!(!matches!(result, Err(crate::EngineError::Internal(..))), "profiles {profiles} panicked: {result:?}");}}++fn placed_bounds(s: &Session, name: &str) -> solidcraft_geom::Aabb3 {+ s.world_state().body(name).unwrap_or_else(|| panic!("no {name}")).mesh().bounds()+}++fn about(a: f64, b: f64) -> bool {+ (a - b).abs() < 1e-6+}++/// Frees every grounded placement (a design's first part starts grounded), so a move can take it.+fn unground_all(s: &mut Session) {+ let grounded: Vec<u64> = s.doc.occurrences.iter().filter(|o| o.grounded).map(|o| o.id).collect();+ for occurrence in grounded {+ run(s, "occurrence.ground", json!({"occurrence": occurrence, "grounded": false}));+ }+}++/// A part placed twice, the copy turned a quarter about X and set at x = 100: `Blade` at+/// x 0…20, y 0…8, z 0…30 and its copy at x 100…120, y −30…0, z 0…8.+fn twice_placed_blade(s: &mut Session) -> (String, String) {+ let made = run(s, "component.create", json!({"name": "Blade"}));+ run(s, "solid.box", json!({"length": 20, "width": 8, "height": 30, "body_name": "Blade"}));+ run(s, "component.activate", json!({"component": 0}));+ let copy = run(s, "occurrence.copy", json!({"occurrence": made["occurrence"]}));+ run(s, "occurrence.move", json!({"occurrence": copy["occurrence"], "axis": [1, 0, 0], "angle": "90 deg"}));+ run(s, "occurrence.move", json!({"occurrence": copy["occurrence"], "translate": [100, 0, 0], "space": "world"}));+ let names: Vec<String> = s.world_state().bodies.iter().map(|b| b.name.clone()).collect();+ assert_eq!(names.len(), 2, "{names:?}");+ unground_all(s);+ (names[0].clone(), names[1].clone())+}++fn shifted(a: solidcraft_geom::Aabb3, b: solidcraft_geom::Aabb3, by: [f64; 3]) -> bool {+ [+ (a.min.x, b.min.x, by[0]),+ (a.max.x, b.max.x, by[0]),+ (a.min.y, b.min.y, by[1]),+ (a.max.y, b.max.y, by[1]),+ (a.min.z, b.min.z, by[2]),+ (a.max.z, b.max.z, by[2]),+ ]+ .iter()+ .all(|(was, now, d)| about(was + d, *now))+}++/// #4768: every placement of a part placed twice, moved together, goes exactly the way asked,+/// however each placement is turned: the shared part was moved once per placement listed, each+/// turning the move its own way, so the turned copy went down Z instead of along Y. One undo+/// step puts both back.+#[test]+fn placements_of_one_part_moved_together_each_go_the_way_asked() {+ let mut s = Session::default();+ let (a, b) = twice_placed_blade(&mut s);+ let (a0, b0) = (placed_bounds(&s, &a), placed_bounds(&s, &b));+ let undo = s.undo.len();+ let r = run(&mut s, "solid.move", json!({"bodies": [a.clone(), b.clone()], "translate": ["240 mm", "-100 mm", "0 mm"]}));+ assert_eq!(r["placements"].as_array().map(Vec::len), Some(2), "{r}");+ assert!(shifted(a0, placed_bounds(&s, &a), [240.0, -100.0, 0.0]), "{a}: {:?}", placed_bounds(&s, &a));+ assert!(shifted(b0, placed_bounds(&s, &b), [240.0, -100.0, 0.0]), "{b}: {:?}", placed_bounds(&s, &b));+ assert_eq!(s.undo.len(), undo + 1, "one undo step");+ run(&mut s, "edit.undo", json!({}));+ assert!(shifted(a0, placed_bounds(&s, &a), [0.0; 3]) && shifted(b0, placed_bounds(&s, &b), [0.0; 3]), "undone");+ // A quarter turn about Z moves each placement about the world origin, as Move turns a body.+ run(&mut s, "solid.move", json!({"bodies": [a.clone(), b.clone()], "axis": [0, 0, 1], "angle": 90}));+ let turned = placed_bounds(&s, &a);+ assert!(about(turned.min.x, -8.0) && about(turned.max.x, 0.0) && about(turned.min.y, 0.0) && about(turned.max.y, 20.0), "{turned:?}");+ let turned = placed_bounds(&s, &b);+ assert!(about(turned.min.x, 0.0) && about(turned.max.x, 30.0) && about(turned.min.y, 100.0) && about(turned.max.y, 120.0), "{turned:?}");+}++/// The same part inserted from a STEP assembly, where a rigid group holds the placements in the+/// imported component: the move goes to the placement of the whole import, once.+#[test]+fn an_imported_assembly_with_a_repeated_part_moves_as_one() {+ let dir = std::env::temp_dir().join(format!("solidcraft-4768-{}", std::process::id()));+ std::fs::create_dir_all(&dir).unwrap();+ let path = dir.join("rep.step").to_string_lossy().to_string();+ let mut src = Session::default();+ twice_placed_blade(&mut src);+ run(&mut src, "file.export", json!({"path": path}));+ let mut s = Session::default();+ run(&mut s, "file.insert_step", json!({"path": path}));+ unground_all(&mut s);+ let names: Vec<String> = s.world_state().bodies.iter().map(|b| b.name.clone()).collect();+ assert_eq!(names.len(), 2, "{names:?}");+ let before: Vec<_> = names.iter().map(|n| placed_bounds(&s, n)).collect();+ let r = run(&mut s, "solid.move", json!({"bodies": names, "translate": [240, -100, 0]}));+ assert_eq!(r["placements"].as_array().map(Vec::len), Some(1), "the import's placement, once: {r}");+ for (n, b) in names.iter().zip(before) {+ assert!(shifted(b, placed_bounds(&s, n), [240.0, -100.0, 0.0]), "{n}: {:?}", placed_bounds(&s, n));+ }+ let _ = std::fs::remove_dir_all(&dir);+}diff --git a/crates/engine/src/frames.rs b/crates/engine/src/frames.rsindex ee7eef0cff..0536c724de 100644--- a/crates/engine/src/frames.rs+++ b/crates/engine/src/frames.rs@@ -370,6 +370,11 @@ pub fn to_local(s: &Session, id: &str, params: &Value) -> Option<Value> {out["targets"] = targets;return Some(out);}+ // Several placements of one part moved together are moved as placements, in the world+ // (`placements_moved`): their names and vectors stay as given.+ if id == "solid.move" && placements_moved(s, params).is_some() {+ return None;+ }if id == "timeline.redefine" {let cmd = params.get("command")?.as_str()?;let key = params.get("feature").and_then(|v| v.as_str().map(str::to_string).or_else(|| v.as_u64().map(|id| id.to_string())))?;@@ -536,3 +541,56 @@ fn same_coordinates(a: &Value, b: &Value) -> bool {#[cfg(test)]#[path = "frames_tests.rs"]mod tests;++/// What a `solid.move` of the placed model moves as placements (#4768). A part placed more than+/// once (an imported assembly's screws or fan corners) is one body: moving it once per placement+/// listed moved it that many times, each placement turning the move its own way, so the copies+/// flew apart. When `bodies` name one part through two or more placements, each listed body's+/// placement is moved instead, in the world, as `occurrence.move` moves it. A placement held by+/// a rigid group (an imported assembly) moves with the outermost placement that holds it, and one+/// inside another placement being moved is not moved again. Bodies of the root component, which+/// have no placement, are moved as bodies (`bodies`). `None`: an ordinary move of bodies (no part+/// named through two placements, or a copy).+pub(crate) struct PlacementMove {+ /// Occurrence paths (root first) to move.+ pub paths: Vec<Vec<u64>>,+ /// Root-component bodies listed, moved as bodies.+ pub bodies: Vec<String>,+}++pub(crate) fn placements_moved(s: &Session, params: &Value) -> Option<PlacementMove> {+ if params.get("copy").and_then(Value::as_bool) == Some(true) || !placed(s) {+ return None;+ }+ let names: Vec<&str> = params.get("bodies")?.as_array()?.iter().filter_map(Value::as_str).collect();+ let st = s.model.state();+ let doc = s.placed_document();+ let frames = doc.body_frames_with_source(&st);+ let listed: Vec<&(String, String, u64, Vec<u64>, Mat)> = names.iter().filter_map(|n| frames.iter().find(|f| f.0 == *n)).collect();+ // One part (a component's body) named through two different placements.+ let repeated = listed.iter().enumerate().any(|(i, a)| listed[..i].iter().any(|b| b.1 == a.1 && b.2 == a.2 && b.3 != a.3));+ if !repeated {+ return None;+ }+ let mut paths: Vec<Vec<u64>> = Vec::new();+ let mut bodies = Vec::new();+ for (world, _, _, path, _) in listed {+ if path.is_empty() {+ bodies.push(world.clone());+ continue;+ }+ // Up through the rigid groups that hold it (as `occurrence.move` asks for).+ let mut k = path.len();+ while k > 1 && path.get(k - 1).is_some_and(|o| s.held_by_rigid_group(*o).is_some()) {+ k -= 1;+ }+ let target = path[..k].to_vec();+ if !paths.contains(&target) {+ paths.push(target);+ }+ }+ // A placement inside another one being moved goes with it.+ let all = paths.clone();+ paths.retain(|p| !all.iter().any(|q| q.len() < p.len() && p.starts_with(q)));+ Some(PlacementMove { paths, bodies })+}