Skip to content

SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.

Merge remote-tracking branch 'origin/main' into fix/loft-section-order

CypherNaugh_0x3dc0a6024e59
diff --cc crates/engine/src/cmd/features_more_tests.rs
index 8db8d43e1b,9fc84134a6..6c15454dbd
--- a/crates/engine/src/cmd/features_more_tests.rs
+++ b/crates/engine/src/cmd/features_more_tests.rs
@@@ -138,50 -436,121 +436,169 @@@ fn coil_and_loft_to_a_point()
assert!(s.execute("solid.loft", &json!({"sections": [{"sketch": "Base"}, {"sketch": "Top", "point": "nope"}]})).is_err());
}
+/// A 3 mm shelled basin (100 x 60 x 30, open top) with a fall lofted from its whole outline
+/// 10 up down to a drain pad (`pad`: corners, 1 up), in either section order. The loft's top
+/// edges lie on the outer walls; the cut used to fail for one order of the sections (an
+/// `Option::unwrap()` panic inside the kernel, or "shell not oriented and closed").
+fn basin_fall(pad: [f64; 4], reverse: bool, op: &str) -> (Session, std::result::Result<Value, String>) {
+ let mut s = Session::default();
+ run(&mut s, "solid.box", json!({"length": 100, "width": 60, "height": 30, "corner": [0, 0, 0]}));
+ run(&mut s, "solid.shell", json!({"faces": [[50, 30, 30]], "thickness": 3}));
+ run(&mut s, "sketch.create", json!({"plane": {"origin": [0, 0, 10], "x_dir": [1, 0, 0], "y_dir": [0, 1, 0]}, "name": "Rim"}));
+ run(&mut s, "sketch.rectangle.two_point", json!({"p0": [0, 0], "p1": [100, 60]}));
+ run(&mut s, "sketch.finish", json!({}));
+ run(&mut s, "sketch.create", json!({"plane": {"origin": [0, 0, 1], "x_dir": [1, 0, 0], "y_dir": [0, 1, 0]}, "name": "Pad"}));
+ run(&mut s, "sketch.rectangle.two_point", json!({"p0": [pad[0], pad[1]], "p1": [pad[2], pad[3]]}));
+ run(&mut s, "sketch.finish", json!({}));
+ let mut secs = vec![json!({"sketch": "Rim"}), json!({"sketch": "Pad"})];
+ if reverse {
+ secs.reverse();
+ }
+ let r = s.execute("solid.loft", &json!({"sections": secs, "operation": op})).map_err(|e| e.to_string());
+ (s, r)
+}
+
+#[test]
+fn loft_cut_through_a_shelled_basin_in_either_order() {
+ // What is left after the cut: the basin less the loft's part of the floor and walls
+ // (integrated over the height), the same for a pad in any corner.
+ let want = 41582.028;
+ for pad in [[80.0, 40.0, 90.0, 50.0], [10.0, 40.0, 20.0, 50.0], [10.0, 10.0, 20.0, 20.0], [80.0, 10.0, 90.0, 20.0]] {
+ for reverse in [false, true] {
+ let (mut s, r) = basin_fall(pad, reverse, "cut");
+ assert!(r.is_ok(), "{pad:?} reverse {reverse}: {r:?}");
+ let v = volume(&mut s);
+ assert!((v - want).abs() < 1.0, "{pad:?} reverse {reverse}: {v} vs {want}");
+ assert_eq!(measure(&mut s)["body_count"], 1);
+ }
+ }
+ // As a new body and joined: a valid solid of positive volume either way.
+ for op in ["new", "join"] {
+ let mut vols = Vec::new();
+ for reverse in [false, true] {
+ let (mut s, r) = basin_fall([80.0, 40.0, 90.0, 50.0], reverse, op);
+ assert!(r.is_ok(), "{op} reverse {reverse}: {r:?}");
+ vols.push(volume(&mut s));
+ }
+ assert!(vols[0] > 42948.0 && rel(vols[0], vols[1]) < 1e-6, "{op}: {vols:?}");
+ }
+}
++
+ #[test]
+ fn cylinder_auto_inference_saves_a_profile_anchor_and_replays_both_depth_signs() {
+ use solvecraft_geom::Vec3;
+ for mode in ["emboss", "deboss"] {
+ let mut s = cylinder_badge();
+ let before = exact_cylinder_volume(&s);
+ let initial = s.doc.to_json();
+ run(&mut s, "solid.emboss", json!({"sketch":"Badge","profiles":"all","depth":"badge_depth","mode":mode,"name":"Auto Badge"}));
+ let feature = s.doc.find_feature("Auto Badge").unwrap().clone();
+ let solvecraft_doc::FeatureKind::Emboss { face: Some(face), targets, .. } = &feature.kind else {
+ panic!("missing inferred association");
+ };
+ assert_eq!(targets, &["Sleeve"]);
+ assert_eq!(face.body, "Sleeve");
+ assert!(face.at.z > 0. && face.at.z < 20.);
+ assert!((face.at.x.hypot(face.at.y) - 10.).abs() < 1e-10);
+ assert!(!feature.face_names.first().unwrap().is_empty());
+ let expected = if mode == "emboss" { 21. } else { -19. };
+ assert!((exact_cylinder_volume(&s) - before - expected).abs() < 0.02);
+ let state = s.model.state();
+ let body = &state.body("Sleeve").unwrap().body;
+ assert_eq!(body.shell_count(), 1);
+ assert_eq!(
+ body.tessellate_with(0.001, true).unwrap().contains(Vec3::new(0., if mode == "emboss" { 10.5 } else { 9.5 }, 7.5)),
+ mode == "emboss"
+ );
+ run(&mut s, "edit.undo", json!({}));
+ assert_eq!(s.doc.to_json(), initial);
+ run(&mut s, "edit.redo", json!({}));
+ assert_eq!(s.doc.find_feature("Auto Badge").unwrap().kind, feature.kind);
+ let mut loaded = Session { doc: solvecraft_doc::Document::from_json(&s.doc.to_json()).unwrap().into(), ..Default::default() };
+ loaded.refresh();
+ assert!(loaded.model.results.iter().all(|r| r.error.is_none()), "{:?}", loaded.model.results);
+ run(
+ &mut loaded,
+ "timeline.redefine",
+ json!({"feature":feature.id,"command":"solid.emboss","params":{"sketch":"Badge","profiles":"all","depth":"badge_depth","mode":mode}}),
+ );
+ assert_eq!(loaded.doc.feature(feature.id).unwrap().kind, feature.kind);
+ assert_eq!(loaded.doc.feature(feature.id).unwrap().face_names, feature.face_names);
+ run(&mut loaded, "parameters.change", json!({"name":"badge_depth","expression":"2mm"}));
+ assert!((exact_cylinder_volume(&loaded) - before - if mode == "emboss" { 44. } else { -36. }).abs() < 0.02);
+ }
+ }
+
+ #[test]
+ fn cylinder_auto_inference_ignores_remote_finite_tangent_walls_in_each_body_order() {
+ for remote_first in [false, true] {
+ let mut s = Session::default();
+ for (name, z) in if remote_first { [("Remote", 100.), ("Sleeve", 0.)] } else { [("Sleeve", 0.), ("Remote", 100.)] } {
+ run(&mut s, "solid.cylinder", json!({"radius":10,"height":20,"base":[0,0,z],"body_name":name}));
+ }
+ run(&mut s, "solid.cylinder", json!({"radius":8,"height":10,"base":[0,0,120],"body_name":"Remote Step"}));
+ run(&mut s, "solid.combine", json!({"target":"Remote","tools":["Remote Step"],"operation":"join"}));
+ run(&mut s, "sketch.create", json!({"plane":{"origin":[0,10,0],"x_dir":[-1,0,0],"y_dir":[0,0,1]},"name":"Badge"}));
+ run(&mut s, "sketch.rectangle.two_point", json!({"p0":[-2,5],"p1":[2,10]}));
+ run(&mut s, "sketch.finish", json!({}));
+ let before = exact_cylinder_volume(&s);
+ let remote = s.model.state().body("Remote").unwrap().body.tessellate_with(1e-4, true).unwrap().measure().volume;
+ run(&mut s, "solid.emboss", json!({"sketch":"Badge","depth":1}));
+ assert!((exact_cylinder_volume(&s) - before - 21.).abs() < 0.02);
+ assert_eq!(s.model.state().body("Remote").unwrap().body.tessellate_with(1e-4, true).unwrap().measure().volume, remote);
+ }
+ }
+
+ #[test]
+ fn cylinder_auto_inference_retains_selected_holes_and_nested_islands() {
+ use solvecraft_geom::Vec3;
+ for mode in ["emboss", "deboss"] {
+ let mut s = cylinder_badge();
+ run(&mut s, "sketch.edit", json!({"sketch":"Badge"}));
+ run(&mut s, "sketch.rectangle.two_point", json!({"p0":[-1,6],"p1":[1,9]}));
+ run(&mut s, "sketch.rectangle.two_point", json!({"p0":[-0.5,6.5],"p1":[0.5,8.5]}));
+ run(&mut s, "sketch.finish", json!({}));
+ let before = exact_cylinder_volume(&s);
+ run(&mut s, "solid.emboss", json!({"sketch":"Badge","profiles":[{"point":[1.5,7.5]},{"point":[0,7.5]}],"depth":1,"mode":mode}));
+ let depth = if mode == "emboss" { 1. } else { -1. };
+ let expected = 16. * (depth + depth * depth / 20.);
+ assert!((exact_cylinder_volume(&s) - before - expected).abs() < 0.02);
+ let st = s.model.state();
+ let body = &st.body("Sleeve").unwrap().body;
+ assert_eq!(body.shell_count(), 1);
+ let mesh = body.tessellate_with(0.001, true).unwrap();
+ for (s, raised) in [(0., true), (0.75, false), (1.5, true)] {
+ let theta = s / 10.0_f64;
+ let radius = if mode == "emboss" { 10.5 } else { 9.5 };
+ assert_eq!(mesh.contains(Vec3::new(-radius * theta.sin(), radius * theta.cos(), 7.5)), if mode == "emboss" { raised } else { !raised });
+ }
+ }
+ }
+
+ #[test]
+ fn cylinder_auto_inference_refuses_ambiguity_curves_and_seam_crossing_atomically() {
+ let mut s = cylinder_badge();
+ run(&mut s, "solid.cylinder", json!({"radius":10,"height":20,"body_name":"Coincident"}));
+ let before = s.doc.to_json();
+ let error = s.execute("solid.emboss", &json!({"sketch":"Badge","depth":1})).unwrap_err().to_string();
+ assert!(error.contains("multiple tangent cylinders"), "{error}");
+ assert_eq!(s.doc.to_json(), before);
+ run(&mut s, "solid.emboss", json!({"sketch":"Badge","depth":1,"targets":["Sleeve"]}));
+ assert!(matches!(&s.doc.features.last().unwrap().kind,solvecraft_doc::FeatureKind::Emboss{face:Some(face),..} if face.body=="Sleeve"));
+ for circle in [false, true] {
+ let mut s = cylinder_badge();
+ run(&mut s, "sketch.create", json!({"plane":{"origin":[0,10,0],"x_dir":[-1,0,0],"y_dir":[0,0,1]},"name":"Unsupported"}));
+ if circle {
+ run(&mut s, "sketch.circle.center", json!({"center":[0,7.5],"radius":1}));
+ } else {
+ run(&mut s, "sketch.rectangle.two_point", json!({"p0":[-20,5],"p1":[20,10]}));
+ }
+ run(&mut s, "sketch.finish", json!({}));
+ let before = s.doc.to_json();
+ let volume = exact_cylinder_volume(&s);
+ let error = s.execute("solid.emboss", &json!({"sketch":"Unsupported","depth":1})).unwrap_err().to_string();
+ assert!(error.contains(if circle { "orthogonal line" } else { "seam" }), "{error}");
+ assert_eq!(s.doc.to_json(), before);
+ assert_eq!(exact_cylinder_volume(&s), volume);
+ }
+ }