solid.mirror: a plane's {origin} takes length expressions and follows them (#1492) (#1501)

Thanks @erkexzcx.

crates/engine/src/cmd/features.rs

@@ -48,7 +48,7 @@ pub static COMMANDS: &[CommandSpec] = &[
         .at("SOLID", "CREATE")
         .icon("pattern_rect")
         .params("features: [names] | bodies: [names]; path_sketch: sketch; path: [curve ids in order]; count; spacing (between instances) | distance (first to last); orientation?: identical|path; flip?: bool"),
-    CommandSpec::new("solid.mirror", "Mirror", mirror).at("SOLID", "CREATE").icon("mirror").params("features: [names] | bodies: [names] (combine?: join with the original); plane: XY|XZ|YZ|construction plane name or id|{origin, normal}|{origin, x_dir, y_dir} (a construction plane keeps the mirror following it)"),
+    CommandSpec::new("solid.mirror", "Mirror", mirror).at("SOLID", "CREATE").icon("mirror").params("features: [names] | bodies: [names] (combine?: join with the original); plane: XY|XZ|YZ|construction plane name or id|{origin, normal}|{origin, x_dir, y_dir} (origin coordinates may be length expressions; the mirror follows them, or a construction plane)"),
     CommandSpec::new("solid.hole", "Hole", hole)
         .at("SOLID", "CREATE")
         .icon("hole")
@@ -1303,7 +1303,7 @@ pub(super) fn check_plane_name(name: &str, cmd: &str) -> Result<()> {
 /// plane reads it here.
 pub(super) fn plane_param(s: &Session, v: Option<&Value>, cmd: &str) -> Result<solidcraft_doc::PlaneRef> {
     use solidcraft_doc::PlaneRef;
-    const WANT: &str = "XY, XZ, YZ, a construction plane name or id, or {origin, normal}";
+    const WANT: &str = "XY, XZ, YZ, a construction plane name or id, or {origin, normal} (origin coordinates may be length expressions)";
     let construction = |r: &str| match s.doc.find_feature(r) {
         Some(f) if matches!(f.kind, FeatureKind::ConstructionPlane { .. }) => Ok(PlaneRef::Construction { name: f.name.clone() }),
         Some(f) => Err(bad(cmd, format!("`{}` is not a construction plane (a plane is {WANT})", f.name))),
@@ -1332,16 +1332,24 @@ pub(super) fn plane_param(s: &Session, v: Option<&Value>, cmd: &str) -> Result<s
             None => Err(bad(cmd, format!("`plane` must be {WANT}"))),
         },
         Some(o @ Value::Object(_)) => {
+            // The origin's coordinates are numbers or length expressions; expressions are kept,
+            // so the plane follows its parameters.
             let origin = match o.get("origin") {
-                None => Vec3::ZERO,
-                Some(x) => vec3(x).ok_or_else(|| bad(cmd, "the plane's `origin` must be a point [x, y, z]"))?,
+                None => point_expr(Vec3::ZERO),
+                Some(_) => point_param(s, o, "origin", cmd)?.unwrap_or_else(|| point_expr(Vec3::ZERO)),
             };
+            let at = |e: &String| s.doc.eval(e, Kind::Length).unwrap_or(0.0);
+            let here = Vec3::new(at(&origin[0]), at(&origin[1]), at(&origin[2]));
             let pl = match (o.get("x_dir").and_then(vec3), o.get("y_dir").and_then(vec3), o.get("normal").and_then(vec3)) {
-                (Some(x), Some(y), _) => solidcraft_geom::Plane::new(origin, x, y),
-                (_, _, Some(n)) => solidcraft_geom::Plane::from_normal(origin, n),
+                (Some(x), Some(y), _) => solidcraft_geom::Plane::new(here, x, y),
+                (_, _, Some(n)) => solidcraft_geom::Plane::from_normal(here, n),
                 _ => None,
             };
-            Ok(PlaneRef::Custom { plane: pl.ok_or_else(|| bad(cmd, "plane needs x_dir and y_dir, or normal"))? })
+            let plane = pl.ok_or_else(|| bad(cmd, "plane needs x_dir and y_dir, or normal"))?;
+            if origin.iter().all(|e| solidcraft_doc::expr::is_literal(e)) {
+                return Ok(PlaneRef::Custom { plane });
+            }
+            Ok(PlaneRef::Placed { origin, x_dir: plane.x, y_dir: plane.y })
         }
         _ => Err(bad(cmd, format!("`plane` must be {WANT}"))),
     }

crates/engine/src/tests/mirror_planes.rs

@@ -39,6 +39,41 @@ fn mirror_across_a_construction_plane_follows_it() {
     }
 }
 
+/// A plane `{origin, normal}` takes length expressions in its origin, as a primitive's corner
+/// does, and the mirror follows them through parameter changes, renames and a save (#1492).
+#[test]
+fn mirror_plane_origin_follows_its_parameters() {
+    let mut s = Session::default();
+    run(&mut s, "parameters.add", json!({"name": "half", "expression": "50 mm"}));
+    run(&mut s, "solid.box", json!({"length": 20, "width": 20, "height": 20}));
+    run(&mut s, "solid.mirror", json!({"features": ["Box1"], "plane": {"origin": ["half", 0, 0], "normal": [1, 0, 0]}, "name": "Twin"}));
+    let at = |s: &Session| min_x(s, &last_body(s));
+    // The box spans x = 0…20; mirrored about x = 50 it spans 80…100.
+    assert!((at(&s) - 80.0).abs() < 1e-6, "{}", at(&s));
+    run(&mut s, "parameters.change", json!({"name": "half", "expression": "30 mm"}));
+    assert!((at(&s) - 40.0).abs() < 1e-6, "{}", at(&s));
+    run(&mut s, "parameters.rename", json!({"name": "half", "new_name": "mid"}));
+    run(&mut s, "parameters.change", json!({"name": "mid", "expression": "25 mm"}));
+    assert!((at(&s) - 30.0).abs() < 1e-6, "{}", at(&s));
+    // Saved and opened again, the plane still names the parameter.
+    let mut s2 = Session::new(solidcraft_doc::Document::from_json(&s.doc.to_json()).unwrap());
+    assert!(s2.doc.to_json().contains("\"mid\""));
+    run(&mut s2, "parameters.change", json!({"name": "mid", "expression": "60 mm"}));
+    assert!((at(&s2) - 100.0).abs() < 1e-6, "{}", at(&s2));
+    // A parameter the plane uses can't be deleted from under it.
+    assert!(s2.execute("parameters.delete", &json!({"name": "mid"})).is_err());
+    // Plain numbers still make a fixed plane.
+    let r = run(&mut s2, "solid.mirror", json!({"features": ["Box1"], "plane": {"origin": [-10, 0, 0], "normal": [1, 0, 0]}}));
+    let id = r["feature"].as_u64().unwrap();
+    let f = s2.doc.feature(id).unwrap();
+    assert!(matches!(f.kind, solidcraft_doc::FeatureKind::Mirror { plane: solidcraft_doc::PlaneRef::Custom { .. }, .. }), "{:?}", f.kind);
+    assert!((at(&s2) + 40.0).abs() < 1e-6, "{}", at(&s2));
+}
+
+fn last_body(s: &Session) -> String {
+    s.model.state().bodies.last().map(|b| b.name.clone()).unwrap()
+}
+
 #[test]
 fn unknown_mirror_planes_are_refused_with_the_choices() {
     let mut s = Session::default();