Skip to content

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

Fix extrude preview placement in placed components (#2103) (#10596)

Dahak Builds462de5b9d2df
diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rs
index 5be45b590c..8dfdf51c05 100644
--- a/crates/ui-egui/src/lib.rs
+++ b/crates/ui-egui/src/lib.rs
@@ -206,6 +206,8 @@ mod prefs_search;
#[cfg(test)]
mod preselect_tests;
pub mod preview;
+#[cfg(test)]
+mod preview_placement_tests;
mod primitive_placement;
#[cfg(test)]
mod primitive_units_tests;
diff --git a/crates/ui-egui/src/preview_placement_tests.rs b/crates/ui-egui/src/preview_placement_tests.rs
new file mode 100644
index 0000000000..6d0cc98b86
--- /dev/null
+++ b/crates/ui-egui/src/preview_placement_tests.rs
@@ -0,0 +1,121 @@
+//! #2103: the live preview of an Extrude (Cut) on a sketch attached to a face of a body inside
+//! a placed component occurrence must be drawn where the viewport shows the sketch, not at the
+//! component's own frame. The committed result was always correct; the preview used to be built
+//! from the component-local model state (`Session::preview`) while the viewport shows placed
+//! occurrences, so the tool appeared offset by the placement — seen on a mirrored STEP copy,
+//! and on a plain translated copy of a component. The fix routes the tool preview through
+//! `Session::preview_world` (shipped in #4455); these tests pin the placement of the cut tool
+//! the preview draws.
+
+use serde_json::{Value, json};
+use solidcraft_engine::Session;
+use solidcraft_engine::doc::{FeatureKind, PlaneRef};
+use solidcraft_engine::geom::Vec3;
+
+fn run(s: &mut Session, command: &str, params: Value) -> Value {
+ s.execute(command, &params).unwrap_or_else(|e| panic!("{command} {params}: {e}"))
+}
+
+/// The ear component: a 40 × 20 × 10 block `EarBlock` (local 0..40 x, 0..20 y, 0..10 z),
+/// optionally with its body mirrored in the component's own YZ plane (the mirrored body of the
+/// STEP copy — a document keeps every occurrence placement rigid, so an import's mirror lives
+/// in the geometry), then its occurrence moved by [10, 20, 0] and left uncaptured: the
+/// occurrence transform is what the viewport draws.
+fn ear(mirror: bool) -> (Session, u64, u64) {
+ let mut s = Session::default();
+ let created = run(&mut s, "component.create", json!({"name": "Ear", "grounded": false}));
+ let (component, occurrence) = (created["component"].as_u64().unwrap(), created["occurrence"].as_u64().unwrap());
+ run(&mut s, "solid.box", json!({"length": 40, "width": 20, "height": 10, "body_name": "EarBlock"}));
+ if mirror {
+ run(&mut s, "solid.mirror", json!({"bodies": ["EarBlock"], "plane": "YZ"}));
+ }
+ run(&mut s, "component.activate", json!({"component": 0}));
+ run(&mut s, "occurrence.move", json!({"occurrence": occurrence, "translate": [10, 20, 0]}));
+ (s, component, occurrence)
+}
+
+/// A face-attached sketch on the placed block's top face at `face_point` (world), with two
+/// circular cut profiles 8 mm either side of the picked point along the face plane's x axis,
+/// and the Cut command the dialog would apply: One Side, 5 mm into the material.
+/// Returns the command and the sketch.
+fn two_circle_cut_on_face(s: &mut Session, component: u64, occurrence: u64, face_point: [f64; 3]) -> (Vec<(String, Value)>, u64) {
+ run(s, "component.activate", json!({"component": component, "occurrence": occurrence}));
+ let sketch = run(s, "sketch.create", json!({"plane": {"face": face_point}, "project_edges": false}))["sketch"].as_u64().unwrap();
+ // The face plane's origin is the component's own, not the pick: place the circles around
+ // the picked point in the plane's coordinates so both profiles sit on the face.
+ let FeatureKind::Sketch { plane: PlaneRef::Face { plane, at, .. }, .. } = &s.doc.feature(sketch).unwrap().kind else {
+ panic!("a sketch on a face")
+ };
+ let centre = plane.to_local(*at);
+ for d in [-8.0, 8.0] {
+ run(s, "sketch.circle.center", json!({"center": [centre.x + d, centre.y], "radius": 3}));
+ }
+ run(s, "sketch.finish", json!({}));
+ let commands =
+ vec![("solid.extrude".to_string(), json!({"sketch": sketch, "profiles": "all", "operation": "cut", "distance": 5, "direction": "negative"}))];
+ (commands, sketch)
+}
+
+/// The vertices the cut preview draws as the see-through red tool (`GpuScene::xray`: 28-byte
+/// records of position, normal and palette index), as their world bounds.
+fn tool_bounds(xray: &[u8]) -> (Vec3, Vec3) {
+ assert!(!xray.is_empty() && xray.len().is_multiple_of(28), "the cut preview must draw its tool");
+ let (mut lo, mut hi) = ([f64::MAX; 3], [f64::MIN; 3]);
+ for record in xray.as_chunks::<28>().0 {
+ for k in 0..3 {
+ let v = f32::from_le_bytes(record[k * 4..k * 4 + 4].try_into().unwrap()) as f64;
+ lo[k] = lo[k].min(v);
+ hi[k] = hi[k].max(v);
+ }
+ }
+ (Vec3::new(lo[0], lo[1], lo[2]), Vec3::new(hi[0], hi[1], hi[2]))
+}
+
+/// The tool must sit at `want` (world): its bounds centre within a tenth of a millimetre, its
+/// spans within half a millimetre (an inscribed tessellation), and far from `buggy` — where a
+/// preview built from the component-local state would draw it (#2103).
+fn assert_tool_at(built: &crate::preview::Built, want: [f64; 3], buggy: [f64; 3]) {
+ assert_eq!(built.error, None, "the cut preview must not fail");
+ let (lo, hi) = tool_bounds(&built.scene.xray);
+ let mid = [(lo.x + hi.x) / 2.0, (lo.y + hi.y) / 2.0, (lo.z + hi.z) / 2.0];
+ let span = [hi.x - lo.x, hi.y - lo.y, hi.z - lo.z];
+ for k in 0..3 {
+ assert!((mid[k] - want[k]).abs() < 0.1, "tool centre {mid:?}, want {want:?} (the local-frame bug drew it centred near {buggy:?})");
+ }
+ let off = ((mid[0] - buggy[0]).powi(2) + (mid[1] - buggy[1]).powi(2) + (mid[2] - buggy[2]).powi(2)).sqrt();
+ assert!(off > 15.0, "the tool sits at the component-local place the bug drew it ({buggy:?}, off by {off})");
+ let want_span = [22.0, 6.0, 5.0];
+ for k in 0..3 {
+ assert!((span[k] - want_span[k]).abs() < 0.5, "tool span {span:?}, want {want_span:?}");
+ }
+}
+
+/// #2103: a copy of a component translated by [10, 20, 0], a sketch on its top face with two
+/// circular cut profiles: the red Cut preview sits on the sketch where the viewport shows it
+/// (centred at the placed face, spanning both circles, 5 mm down into the material), not at the
+/// component's own frame offset by the placement.
+#[test]
+fn extrude_cut_preview_on_a_face_sketch_in_a_translated_component_sits_at_the_sketch() {
+ let (mut s, component, occurrence) = ear(false);
+ let (commands, sketch) = two_circle_cut_on_face(&mut s, component, occurrence, [30.0, 30.0, 10.0]);
+ let colors = crate::preview::Colors::from_tokens(&crate::theme::Tokens::dark());
+ let built = crate::preview::compute(&s, &commands, colors).unwrap();
+ // Placed: the local top-face centre (20, 10, 10) plus [10, 20, 0]; the tool cuts 5 mm down.
+ assert_tool_at(&built, [30.0, 30.0, 7.5], [20.0, 10.0, 7.5]);
+ // The sketch is anchored to the face of the placed body, as in the issue.
+ let FeatureKind::Sketch { plane: PlaneRef::Face { .. }, .. } = s.doc.feature(sketch).unwrap().kind else { panic!("a sketch on a face") };
+}
+
+/// #2103: the shape of the STEP repro — a component whose body was mirrored, placed as a copy
+/// (a document keeps occurrence placements rigid, so an import's mirror sits in the geometry).
+/// The Cut preview must still sit on the sketch at its world position, not at the component's
+/// own frame, and not be thrown off by the mirrored body beside it.
+#[test]
+fn extrude_cut_preview_on_a_face_sketch_in_a_mirrored_component_sits_at_the_sketch() {
+ let (mut s, component, occurrence) = ear(true);
+ let (commands, sketch) = two_circle_cut_on_face(&mut s, component, occurrence, [30.0, 30.0, 10.0]);
+ let colors = crate::preview::Colors::from_tokens(&crate::theme::Tokens::dark());
+ let built = crate::preview::compute(&s, &commands, colors).unwrap();
+ assert_tool_at(&built, [30.0, 30.0, 7.5], [20.0, 10.0, 7.5]);
+ let FeatureKind::Sketch { plane: PlaneRef::Face { .. }, .. } = s.doc.feature(sketch).unwrap().kind else { panic!("a sketch on a face") };
+}