SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Sketch on an origin plane faces the side you clicked (#1587)
bherbruck26bf1af93b92
diff --git a/crates/doc/src/assembly.rs b/crates/doc/src/assembly.rsindex 6687078420..a52580e3d2 100644--- a/crates/doc/src/assembly.rs+++ b/crates/doc/src/assembly.rs@@ -145,7 +145,7 @@ fn map_plane_ref(m: &Mat, p: &mut PlaneRef) {*plane = map_plane(m, plane);*at = apply_point(m, *at);}- PlaneRef::Offset { base, .. } => map_plane_ref(m, base),+ PlaneRef::Offset { base, .. } | PlaneRef::Flipped { base, .. } => map_plane_ref(m, base),PlaneRef::AtAngle { base, axis_origin, axis_dir, .. } => {map_plane_ref(m, base);*axis_origin = apply_point(m, *axis_origin);diff --git a/crates/doc/src/clipboard.rs b/crates/doc/src/clipboard.rsindex b8679b44a7..5581892cb3 100644--- a/crates/doc/src/clipboard.rs+++ b/crates/doc/src/clipboard.rs@@ -113,7 +113,9 @@ fn remap_plane(return Err(crate::DocError::Invalid("clone plane reference depth exceeded".into()));}match p {- PlaneRef::Offset { base, .. } | PlaneRef::AtAngle { base, .. } => remap_plane(base, ids, names, bodies, depth + 1)?,+ PlaneRef::Offset { base, .. } | PlaneRef::AtAngle { base, .. } | PlaneRef::Flipped { base, .. } => {+ remap_plane(base, ids, names, bodies, depth + 1)?+ }PlaneRef::Construction { name } => mapped_name(&mut name.0, names),PlaneRef::Face { name, anchor, .. } => {if let Some(name) = name {@@ -283,7 +285,7 @@ fn checked_plane(p: &PlaneRef, depth: usize) -> crate::Result<()> {return Err(crate::DocError::Invalid("copy reference nesting exceeds 64".into()));}match p {- PlaneRef::Offset { base, .. } | PlaneRef::AtAngle { base, .. } => checked_plane(base, depth + 1)?,+ PlaneRef::Offset { base, .. } | PlaneRef::AtAngle { base, .. } | PlaneRef::Flipped { base, .. } => checked_plane(base, depth + 1)?,PlaneRef::Midplane { a, b } | PlaneRef::TwoEdges { a, b } => {checked_geo(a, depth + 1)?;checked_geo(b, depth + 1)?;diff --git a/crates/doc/src/construct.rs b/crates/doc/src/construct.rsindex da42a77eb3..5940eab9e2 100644--- a/crates/doc/src/construct.rs+++ b/crates/doc/src/construct.rs@@ -633,7 +633,7 @@ impl PlaneRef {PlaneRef::ThreePoints { a, b, c } => vec![a.as_mut(), b.as_mut(), c.as_mut()],PlaneRef::Tangent { face, .. } => vec![face.as_mut()],PlaneRef::AlongPath { path, .. } => vec![path.as_mut()],- PlaneRef::Offset { base, .. } | PlaneRef::AtAngle { base, .. } => base.refs_mut(),+ PlaneRef::Offset { base, .. } | PlaneRef::AtAngle { base, .. } | PlaneRef::Flipped { base, .. } => base.refs_mut(),_ => Vec::new(),}}diff --git a/crates/doc/src/document.rs b/crates/doc/src/document.rsindex 81e79c06d1..c7c142f9aa 100644--- a/crates/doc/src/document.rs+++ b/crates/doc/src/document.rs@@ -58,6 +58,14 @@ pub enum PlaneRef {AtAngle { base: Box<PlaneRef>, axis_origin: Vec3, axis_dir: Vec3, angle: Expr },/// A construction plane feature (by name).Construction { name: FeatureName },+ /// `base` seen from its other side: the normal reversed by a half turn about the base's+ /// own x axis (y reversed), or about its y axis (x reversed) when `about_y`. A sketch+ /// started from behind a plane faces the viewer this way.+ Flipped {+ base: Box<PlaneRef>,+ #[serde(default, skip_serializing_if = "std::ops::Not::not")]+ about_y: bool,+ },/// Halfway between two planes (or planar faces); bisecting them when they meet at an angle.Midplane { a: Box<GeoRef>, b: Box<GeoRef> },/// Through two straight edges (lines) that lie in one plane.@@ -2884,6 +2892,7 @@ impl Document {let o = *axis_origin + rot(b.origin - *axis_origin);Plane::new(o, rot(b.x), rot(b.y)).ok_or_else(|| DocError::Invalid("degenerate plane".into()))}+ PlaneRef::Flipped { base, about_y } => Ok(self.resolve_plane_in(vals, base, depth + 1, st)?.flipped(*about_y)),PlaneRef::Construction { name } => {// Evaluated already: as it came out.if let Some(c) = st.and_then(|st| st.construct.iter().find(|c| &c.name == name))diff --git a/crates/doc/src/eval.rs b/crates/doc/src/eval.rsindex 8b42a9227e..10fecf9712 100644--- a/crates/doc/src/eval.rs+++ b/crates/doc/src/eval.rs@@ -3998,6 +3998,9 @@ pub(crate) fn sheet_face_plane_in_frame(doc: &Document, st: &ModelState, comp: uaxis_dir: *axis_dir,angle: angle.clone(),},+ PlaneRef::Flipped { base, about_y } => {+ PlaneRef::Flipped { base: Box::new(sheet_face_plane_in_frame(doc, st, comp, base)?), about_y: *about_y }+ }other => other.clone(),})}diff --git a/crates/doc/src/face_anchor.rs b/crates/doc/src/face_anchor.rsindex a6e1df446a..8d32d9268d 100644--- a/crates/doc/src/face_anchor.rs+++ b/crates/doc/src/face_anchor.rs@@ -82,7 +82,7 @@ impl FaceAnchor {pub fn plane_face_anchor(plane: &PlaneRef) -> Option<&FaceAnchor> {match plane {PlaneRef::Face { anchor, .. } => anchor.as_deref(),- PlaneRef::Offset { base, .. } | PlaneRef::AtAngle { base, .. } => plane_face_anchor(base),+ PlaneRef::Offset { base, .. } | PlaneRef::AtAngle { base, .. } | PlaneRef::Flipped { base, .. } => plane_face_anchor(base),_ => None,}}@@ -90,7 +90,7 @@ pub fn plane_face_anchor(plane: &PlaneRef) -> Option<&FaceAnchor> {fn has_face_reference(plane: &PlaneRef) -> bool {match plane {PlaneRef::Face { .. } => true,- PlaneRef::Offset { base, .. } | PlaneRef::AtAngle { base, .. } => has_face_reference(base),+ PlaneRef::Offset { base, .. } | PlaneRef::AtAngle { base, .. } | PlaneRef::Flipped { base, .. } => has_face_reference(base),_ => false,}}@@ -110,7 +110,9 @@ impl Document {}match plane {PlaneRef::Face { anchor: Some(anchor), .. } => *plane = PlaneRef::Custom { plane: doc.resolve_face_anchor(anchor, author, state)? },- PlaneRef::Offset { base, .. } | PlaneRef::AtAngle { base, .. } => replace(doc, base, author, state, depth + 1)?,+ PlaneRef::Offset { base, .. } | PlaneRef::AtAngle { base, .. } | PlaneRef::Flipped { base, .. } => {+ replace(doc, base, author, state, depth + 1)?+ }_ => {}}Ok(())diff --git a/crates/doc/src/format/pending/flipped-sketch-plane.rs b/crates/doc/src/format/pending/flipped-sketch-plane.rsnew file mode 100644index 0000000000..973f13f6cc--- /dev/null+++ b/crates/doc/src/format/pending/flipped-sketch-plane.rs@@ -0,0 +1,5 @@+//! A sketch can sit on a plane seen from its other side: `{"type": "flipped", "base": <plane>}`+//! (with `"about_y": true` when it turns about the plane's y axis rather than its x axis). New+//! sketches started from behind an origin or construction plane save this, so they face the+//! viewer. Older designs have no flipped planes and open unchanged; the last release refuses a+//! design that has one (it asks for an update) instead of putting the sketch on the wrong side.diff --git a/crates/doc/src/sheet.rs b/crates/doc/src/sheet.rsindex 6538b3bbb1..b8dcc0eca5 100644--- a/crates/doc/src/sheet.rs+++ b/crates/doc/src/sheet.rs@@ -4257,7 +4257,9 @@ pub fn rename_plane_sheet_body(plane: &mut crate::PlaneRef, old: &str, new: &str*name = renamed;}}- crate::PlaneRef::Offset { base, .. } | crate::PlaneRef::AtAngle { base, .. } => rename_plane_sheet_body(base, old, new),+ crate::PlaneRef::Offset { base, .. } | crate::PlaneRef::AtAngle { base, .. } | crate::PlaneRef::Flipped { base, .. } => {+ rename_plane_sheet_body(base, old, new)+ }_ => {}}}@@ -4267,7 +4269,9 @@ pub fn rename_plane_sheet_body(plane: &mut crate::PlaneRef, old: &str, new: &strpub fn plane_sheet_face(plane: &crate::PlaneRef) -> Option<&str> {match plane {crate::PlaneRef::Face { name: Some(name), anchor: None, .. } if split_sheet_face_name(name).is_some() => Some(name),- crate::PlaneRef::Offset { base, .. } | crate::PlaneRef::AtAngle { base, .. } => plane_sheet_face(base),+ crate::PlaneRef::Offset { base, .. } | crate::PlaneRef::AtAngle { base, .. } | crate::PlaneRef::Flipped { base, .. } => {+ plane_sheet_face(base)+ }_ => None,}}diff --git a/crates/doc/src/walk.rs b/crates/doc/src/walk.rsindex d7c54c8f15..64726064c6 100644--- a/crates/doc/src/walk.rs+++ b/crates/doc/src/walk.rs@@ -364,7 +364,7 @@ impl Walk for PlaneRef {let mut p = self;for _ in 0..64 {match p {- PlaneRef::Offset { base, .. } | PlaneRef::AtAngle { base, .. } => p = base,+ PlaneRef::Offset { base, .. } | PlaneRef::AtAngle { base, .. } | PlaneRef::Flipped { base, .. } => p = base,PlaneRef::Construction { name } => return f(Ref::Feature(name)),_ => return,}@@ -374,7 +374,7 @@ impl Walk for PlaneRef {let mut p = self;for _ in 0..64 {match p {- PlaneRef::Offset { base, .. } | PlaneRef::AtAngle { base, .. } => p = base,+ PlaneRef::Offset { base, .. } | PlaneRef::AtAngle { base, .. } | PlaneRef::Flipped { base, .. } => p = base,PlaneRef::Construction { name } => return f(Ref::Feature(name)),_ => return,}diff --git a/crates/engine/src/cmd/clipboard.rs b/crates/engine/src/cmd/clipboard.rsindex 4b37b39a3e..eff00a90b7 100644--- a/crates/engine/src/cmd/clipboard.rs+++ b/crates/engine/src/cmd/clipboard.rs@@ -45,7 +45,7 @@ fn explicit_planes(p: &mut PlaneRef) {*p = PlaneRef::Custom { plane };}}- PlaneRef::Offset { base, .. } | PlaneRef::AtAngle { base, .. } => explicit_planes(base),+ PlaneRef::Offset { base, .. } | PlaneRef::AtAngle { base, .. } | PlaneRef::Flipped { base, .. } => explicit_planes(base),_ => {}}}diff --git a/crates/engine/src/cmd/sketch.rs b/crates/engine/src/cmd/sketch.rsindex 6cc69a3d7d..4cf5e4b0eb 100644--- a/crates/engine/src/cmd/sketch.rs+++ b/crates/engine/src/cmd/sketch.rs@@ -29,7 +29,7 @@ pub static COMMANDS: &[CommandSpec] = &[CommandSpec::new("sketch.create", "Create Sketch", create_sketch).at("SOLID", "CREATE").icon("sketch")- .params("plane: XY|XZ|YZ | construction plane name or id | {origin, x_dir, y_dir} | {face: [world x,y,z], body?: exact world body, index?: face index, path?: complete occurrence ids, fixed?: bool}; new face attachments require a unique certified source (a flat face of a sheet metal body attaches to its panel instead, in the flat pattern's coordinates), fixed:true explicitly freezes the selected plane; offset?: expr, project_edges?: bool, name?"),+ .params("plane: XY|XZ|YZ | construction plane name or id | {origin, x_dir, y_dir} | {face: [world x,y,z], body?: exact world body, index?: face index, path?: complete occurrence ids, fixed?: bool}; new face attachments require a unique certified source (a flat face of a sheet metal body attaches to its panel instead, in the flat pattern's coordinates), fixed:true explicitly freezes the selected plane; offset?: expr, flip?: bool | \"x\" | \"y\" (not on a face: sketch the plane from its other side, so the normal and the default extrude direction are reversed; a half turn about the plane's own x or y axis, true picks the one keeping the sketch's y axis upward; offset still moves along the unflipped normal), project_edges?: bool, name?"),CommandSpec::new("sketch.edit", "Edit Sketch", edit_sketch).noundo().icon("sketch").params("sketch: id or name"),CommandSpec::new("sketch.finish", "Finish Sketch", finish_sketch).at("SKETCH", "FINISH SKETCH").icon("finish").enabled(in_sketch).noundo(),CommandSpec::new("sketch.line", "Line", draw_line)@@ -543,7 +543,7 @@ pub(crate) fn author_path_for_rebind(s: &Session, feature: &solidcraft_doc::Featlet mut plane = plane;loop {match plane {- PlaneRef::Offset { base, .. } | PlaneRef::AtAngle { base, .. } => plane = base,+ PlaneRef::Offset { base, .. } | PlaneRef::AtAngle { base, .. } | PlaneRef::Flipped { base, .. } => plane = base,PlaneRef::Face { anchor: Some(anchor), .. } => {saved = Some(anchor.author_path.clone());break;@@ -635,7 +635,31 @@ fn create_sketch(s: &mut Session, p: &Value) -> Result<Value> {return Err(bad(cmd, format!("`{key}` belongs inside `plane`: {example}")));}}- create_sketch_with_plane(s, p, plane_ref(s, p, cmd)?, None)+ let mut plane = plane_ref(s, p, cmd)?;+ if let Some(about_y) = flip_param(s, p, &plane, cmd)? {+ plane = PlaneRef::Flipped { base: Box::new(plane), about_y };+ }+ create_sketch_with_plane(s, p, plane, None)+}++/// `flip` of `sketch.create`: `None` keeps the plane's own side, otherwise the axis to turn+/// about (`true`: about y when the plane's y axis points upward, so it stays up, else about x).+fn flip_param(s: &Session, p: &Value, plane: &PlaneRef, cmd: &str) -> Result<Option<bool>> {+ let about_y = match p.get("flip") {+ None | Some(Value::Null) | Some(Value::Bool(false)) => return Ok(None),+ Some(Value::String(a)) if a.eq_ignore_ascii_case("x") => false,+ Some(Value::String(a)) if a.eq_ignore_ascii_case("y") => true,+ Some(Value::Bool(true)) => {+ let (vals, _) = s.doc.param_values();+ let resolved = s.doc.resolve_plane_in(&vals, plane, 0, Some(&s.model.state()))?;+ resolved.y.z > 1e-9+ }+ Some(_) => return Err(bad(cmd, "`flip` must be true, false, \"x\" or \"y\"")),+ };+ if face::is_face(p) {+ return Err(bad(cmd, "`flip` is for origin, construction and explicit planes; a face already faces outward"));+ }+ Ok(Some(about_y))}/// Used only by face Extrude/Revolve/PressPull, preserving pre-certificate linked profiles.@@ -2493,6 +2517,10 @@ fn solve_cmd(s: &mut Session, p: &Value) -> Result<Value> {Ok(json!({"status": ss.report.status, "dof": ss.report.dof, "failing": ss.report.failing, "profiles": ss.profiles.len()}))}+#[cfg(test)]+#[path = "sketch_flip_tests.rs"]+mod flip_tests;+#[cfg(test)]#[path = "sketch_rect_tests.rs"]mod rect_tests;diff --git a/crates/engine/src/cmd/sketch_face.rs b/crates/engine/src/cmd/sketch_face.rsindex 985cdf0c6f..35d30953a0 100644--- a/crates/engine/src/cmd/sketch_face.rs+++ b/crates/engine/src/cmd/sketch_face.rs@@ -206,7 +206,7 @@ fn capture_impl(s: &Session, value: &Value, cmd: &str, internal: bool) -> Resultpub(in crate::cmd) fn anchor(mut plane: &PlaneRef) -> Option<&solidcraft_doc::FaceAnchor> {loop {match plane {- PlaneRef::Offset { base, .. } | PlaneRef::AtAngle { base, .. } => plane = base,+ PlaneRef::Offset { base, .. } | PlaneRef::AtAngle { base, .. } | PlaneRef::Flipped { base, .. } => plane = base,PlaneRef::Face { anchor, .. } => return anchor.as_deref(),_ => return None,}@@ -216,7 +216,7 @@ pub(in crate::cmd) fn anchor(mut plane: &PlaneRef) -> Option<&solidcraft_doc::Fapub(in crate::cmd) fn anchor_mut(mut plane: &mut PlaneRef) -> Option<&mut solidcraft_doc::FaceAnchor> {loop {match plane {- PlaneRef::Offset { base, .. } | PlaneRef::AtAngle { base, .. } => plane = base,+ PlaneRef::Offset { base, .. } | PlaneRef::AtAngle { base, .. } | PlaneRef::Flipped { base, .. } => plane = base,PlaneRef::Face { anchor, .. } => return anchor.as_deref_mut(),_ => return None,}diff --git a/crates/engine/src/cmd/sketch_flip_tests.rs b/crates/engine/src/cmd/sketch_flip_tests.rsnew file mode 100644index 0000000000..2385cb7439--- /dev/null+++ b/crates/engine/src/cmd/sketch_flip_tests.rs@@ -0,0 +1,136 @@+//! `sketch.create` `flip`: a sketch on a plane seen from its other side (#1586). Without it a+//! sketch keeps the plane's own side, and older designs open, rebuild and save as before.++use serde_json::{Value, json};+use solidcraft_doc::{FeatureKind, PlaneRef};+use solidcraft_geom::{Plane, Vec3};++use crate::Session;++fn run(s: &mut Session, id: &str, p: Value) -> Value {+ match s.execute(id, &p) {+ Ok(v) => v,+ Err(e) => panic!("{id} {p}: {e}"),+ }+}++fn sketch_plane(s: &Session, id: u64) -> Plane {+ s.model.state().sketch(id).map(|ss| ss.plane).expect("an evaluated sketch")+}++fn measured(s: &mut Session) -> Value {+ run(s, "inspect.measure", json!({}))["bodies"].clone()+}++fn close(a: Vec3, b: Vec3) -> bool {+ a.dist(b) < 1e-9+}++#[test]+fn without_flip_a_sketch_keeps_the_planes_own_side_and_saves_as_before() {+ for name in ["XY", "XZ", "YZ"] {+ let mut s = Session::default();+ let id = run(&mut s, "sketch.create", json!({"plane": name}))["sketch"].as_u64().unwrap();+ let saved = serde_json::to_value(&s.doc.feature(id).unwrap().kind).unwrap();+ assert_eq!(saved["plane"], json!({"type": "origin", "name": name}), "{name}");+ assert_eq!(sketch_plane(&s, id), Plane::named(name).unwrap(), "{name}");+ }+}++#[test]+fn flip_turns_the_plane_about_the_axis_asked_for() {+ // (plane, flip, expected x, expected y)+ let cases = [+ ("XZ", json!(true), Vec3::X, Vec3::Z),+ ("XZ", json!("y"), -Vec3::X, -Vec3::Z),+ ("YZ", json!(true), -Vec3::Y, Vec3::Z),+ ("YZ", json!("x"), Vec3::Y, -Vec3::Z),+ ("XY", json!(true), Vec3::X, -Vec3::Y),+ ("XY", json!("Y"), -Vec3::X, Vec3::Y),+ ];+ for (name, flip, x, y) in cases {+ let mut s = Session::default();+ let id = run(&mut s, "sketch.create", json!({"plane": name, "flip": flip}))["sketch"].as_u64().unwrap();+ let p = sketch_plane(&s, id);+ assert!(close(p.x, x) && close(p.y, y), "{name} flip {flip}: {p:?}");+ assert!(close(p.normal(), -Plane::named(name).unwrap().normal()), "{name} flip {flip}");+ assert!(matches!(&s.doc.feature(id).unwrap().kind, FeatureKind::Sketch { plane: PlaneRef::Flipped { .. }, .. }));+ }+ let mut s = Session::default();+ let id = run(&mut s, "sketch.create", json!({"plane": "XZ", "flip": false}))["sketch"].as_u64().unwrap();+ assert!(matches!(&s.doc.feature(id).unwrap().kind, FeatureKind::Sketch { plane: PlaneRef::Origin { .. }, .. }));+ assert!(s.execute("sketch.create", &json!({"plane": "XZ", "flip": "z"})).is_err());+}++#[test]+fn a_flipped_sketch_extrudes_the_other_way_and_offsets_along_the_planes_own_normal() {+ let mut s = Session::default();+ let id = run(&mut s, "sketch.create", json!({"plane": "XZ", "flip": true, "offset": "5 mm"}))["sketch"].as_u64().unwrap();+ assert!(close(sketch_plane(&s, id).origin, Vec3::new(0.0, 5.0, 0.0)));+ run(&mut s, "sketch.rectangle.two_point", json!({"p0": [0, 0], "p1": [10, 4]}));+ run(&mut s, "sketch.finish", json!({}));+ run(&mut s, "solid.extrude", json!({"sketch": id, "distance": 3, "operation": "new_body", "body_name": "B"}));+ let bounds = s.model.state().body("B").map(|b| b.mesh().bounds()).unwrap();+ // Sketch y is world +Z; extruded along -Y, from y = 5 to y = 2.+ assert!((bounds.min.y - 2.0).abs() < 1e-9 && (bounds.max.y - 5.0).abs() < 1e-9, "{bounds:?}");+ assert!((bounds.min.z).abs() < 1e-9 && (bounds.max.z - 4.0).abs() < 1e-9, "{bounds:?}");+ // Saved and opened again, it is the same.+ let path = std::env::temp_dir().join(format!("solidcraft-flip-{}.solidcraft", std::process::id()));+ run(&mut s, "file.save", json!({"path": path}));+ let mut reopened = Session::default();+ run(&mut reopened, "doc.open", json!({"path": path}));+ assert_eq!(*reopened.doc, *s.doc);+ assert_eq!(measured(&mut reopened), measured(&mut s));+ std::fs::remove_file(path).unwrap();+}++#[test]+fn a_construction_plane_flips_too_and_follows_its_parameter() {+ let mut s = Session::default();+ run(&mut s, "parameters.add", json!({"name": "h", "expression": "7 mm"}));+ run(&mut s, "construct.plane.offset", json!({"base": "XY", "offset": "h", "name": "P"}));+ let id = run(&mut s, "sketch.create", json!({"plane": "P", "flip": true}))["sketch"].as_u64().unwrap();+ let p = sketch_plane(&s, id);+ assert!(close(p.origin, Vec3::new(0.0, 0.0, 7.0)) && close(p.normal(), -Vec3::Z), "{p:?}");+ run(&mut s, "sketch.finish", json!({}));+ run(&mut s, "parameters.change", json!({"name": "h", "expression": "9 mm"}));+ let p = sketch_plane(&s, id);+ assert!(close(p.origin, Vec3::new(0.0, 0.0, 9.0)) && close(p.normal(), -Vec3::Z), "{p:?}");+}++#[test]+fn flip_is_refused_on_a_face() {+ let mut s = Session::default();+ run(&mut s, "solid.box", json!({"length": 10, "width": 10, "height": 10}));+ assert!(s.execute("sketch.create", &json!({"plane": {"face": [5, 5, 10]}, "flip": true})).is_err());+}++/// Designs from before `flip` open with every sketch where it was, never flipped, rebuild the+/// same bodies and save and reopen unchanged.+#[test]+fn older_designs_open_rebuild_and_save_unchanged() {+ let dir = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("../../apps/solidcraft-cli/tests/corpus");+ let mut files: Vec<_> =+ std::fs::read_dir(&dir).unwrap().flatten().map(|e| e.path()).filter(|p| p.extension().is_some_and(|x| x == "solidcraft")).collect();+ files.sort();+ assert!(files.len() >= 7, "corpus designs in {}", dir.display());+ for old in files {+ let mut s = Session::default();+ run(&mut s, "doc.open", json!({"path": old}));+ assert!(!serde_json::to_string(&*s.doc).unwrap().contains("\"flipped\""), "{}", old.display());+ // The oldest one's XZ sketch: sketch y along +Z, as it was drawn.+ if old.ends_with("m0-revolve-primitives.solidcraft") {+ let id = s.doc.features.iter().find(|f| matches!(f.kind, FeatureKind::Sketch { .. })).map(|f| f.id).unwrap();+ let p = sketch_plane(&s, id);+ assert!(close(p.origin, Vec3::ZERO) && close(p.x, Vec3::X) && close(p.y, Vec3::Z), "{p:?}");+ }+ let bodies = measured(&mut s);+ let path = std::env::temp_dir().join(format!("solidcraft-old-{}.solidcraft", std::process::id()));+ run(&mut s, "file.save", json!({"path": path}));+ let mut reopened = Session::default();+ run(&mut reopened, "doc.open", json!({"path": path}));+ assert_eq!(*reopened.doc, *s.doc, "{}", old.display());+ assert_eq!(measured(&mut reopened), bodies, "{}", old.display());+ std::fs::remove_file(path).unwrap();+ }+}diff --git a/crates/engine/src/occurrences.rs b/crates/engine/src/occurrences.rsindex daf3ea8d2b..0fd615cfe6 100644--- a/crates/engine/src/occurrences.rs+++ b/crates/engine/src/occurrences.rs@@ -240,7 +240,7 @@ impl Session {let mut plane = plane;loop {match plane {- PlaneRef::Offset { base, .. } | PlaneRef::AtAngle { base, .. } => plane = base,+ PlaneRef::Offset { base, .. } | PlaneRef::AtAngle { base, .. } | PlaneRef::Flipped { base, .. } => plane = base,// A face attachment that names no exact source: which body it sits on is unknown,// so none is taken from the view.PlaneRef::Face { anchor: None, .. } => return none,diff --git a/crates/geom/src/plane.rs b/crates/geom/src/plane.rsindex ee51a010c3..1d7d882ec8 100644--- a/crates/geom/src/plane.rs+++ b/crates/geom/src/plane.rs@@ -39,6 +39,12 @@ impl Plane {Plane::new(origin, x, n.cross(x))}+ /// The same plane seen from its other side: a half turn about the sketch x axis (y+ /// reversed), or about the y axis (x reversed) when `about_y`. Still right-handed.+ pub fn flipped(&self, about_y: bool) -> Plane {+ if about_y { Plane { x: -self.x, ..*self } } else { Plane { y: -self.y, ..*self } }+ }+/// Named origin plane: `XY`, `XZ`, `YZ` (case-insensitive).pub fn named(name: &str) -> Option<Plane> {match name.to_ascii_uppercase().as_str() {diff --git a/crates/ui-egui/src/dialogs.rs b/crates/ui-egui/src/dialogs.rsindex 2f6911c6c8..2d4ab062ed 100644--- a/crates/ui-egui/src/dialogs.rs+++ b/crates/ui-egui/src/dialogs.rs@@ -3327,13 +3327,18 @@ pub(crate) fn change_param(app: &mut SolveApp, name: &str, expression: &str) ->/// Start a sketch on a picked plane or planar face and turn the view to face it.pub fn start_sketch(app: &mut SolveApp, sel: &Sel) -> Result<(), String> {- let plane = match sel {- Sel::Plane { name } => json!(name),- Sel::Face { .. } => crate::sketch_attachment_ui::face_plane(app, sel).ok_or("Selected face placement no longer exists")?,+ let mut params = match sel {+ Sel::Plane { name } => json!({ "plane": name }),+ Sel::Face { .. } => json!({ "plane": crate::sketch_attachment_ui::face_plane(app, sel).ok_or("Selected face placement no longer exists")? }),_ => return Err("Select an origin plane, construction plane or planar body face".into()),};+ if let Sel::Plane { name } = sel+ && let Some(flip) = flip_toward_viewer(app, name)+ {+ params["flip"] = json!(flip);+ }let before = app.cam;- app.run("sketch.create", json!({ "plane": plane })).map_err(|error| crate::friendly_error("sketch.create", &error))?;+ app.run("sketch.create", params).map_err(|error| crate::friendly_error("sketch.create", &error))?;app.pre_sketch_cam = Some(before);look_at_sketch(app);// On a face: look at the picked point, not the plane's origin (a corner of the face),@@ -3347,6 +3352,40 @@ pub fn start_sketch(app: &mut SolveApp, sel: &Sel) -> Result<(), String> {Ok(())}+/// A new sketch on origin or construction plane `name` faces the viewer: when the camera is+/// behind the plane's normal, the in-plane axis to turn the plane about (`"x"` or `"y"`), chosen+/// so the sketch's y axis stays as upright on screen as it can (x then runs to the right).+fn flip_toward_viewer(app: &SolveApp, name: &str) -> Option<&'static str> {+ let plane = plane_by_name(app, name)?;+ let n = plane.normal();+ // Where the eye is: in perspective its position, in orthographic only its direction counts.+ let side = if app.cam.fov > 0.0 { (app.cam.eye() - plane.origin).dot(n) } else { app.cam.basis().2.dot(n) };+ if side >= -1e-9 {+ return None;+ }+ let up = app.cam.up.dir();+ Some(if plane.y.dot(up) > 1e-9 { "y" } else { "x" })+}++/// The world plane of an origin plane or a construction plane by name.+fn plane_by_name(app: &SolveApp, name: &str) -> Option<solidcraft_engine::geom::Plane> {+ if let Some(p) = solidcraft_engine::geom::Plane::named(name) {+ // In an active component its origin planes are the component's.+ let m = app.session.active_component_frame();+ let (o, x, y) = (+ solidcraft_engine::doc::apply_point(&m, p.origin),+ solidcraft_engine::doc::apply_vector(&m, p.x),+ solidcraft_engine::doc::apply_vector(&m, p.y),+ );+ return solidcraft_engine::geom::Plane::new(o, x, y);+ }+ let st = app.session.world_state();+ st.construct.iter().find(|c| c.name == name).and_then(|c| match &c.geom {+ solidcraft_engine::doc::construct::ConstructGeom::Plane(pl) => Some(*pl),+ _ => None,+ })+}+/// Animate the camera to look straight at the active sketch plane.pub fn look_at_sketch(app: &mut SolveApp) {let st = app.session.world_state();@@ -4352,6 +4391,7 @@ pub(crate) fn plane_sel(s: &Session, pl: &PlaneRef) -> Option<Sel> {PlaneRef::Origin { name } => Some(Sel::Plane { name: name.clone() }),PlaneRef::Construction { name } => Some(Sel::Plane { name: name.to_string() }),PlaneRef::Custom { plane } | PlaneRef::Face { plane, .. } => face_sel(s, plane.origin),+ PlaneRef::Flipped { base, .. } => plane_sel(s, base),_ => None,}}diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rsindex f09b2e48bf..8e5a2a439b 100644--- a/crates/ui-egui/src/lib.rs+++ b/crates/ui-egui/src/lib.rs@@ -149,6 +149,8 @@ pub mod sketch_modify_ui;mod sketch_modify_ui_tests;pub mod sketch_palette;mod sketch_pattern_tree;+#[cfg(test)]+mod sketch_side_ui_tests;pub(crate) mod sketch_text;mod sketch_text_handles;mod sketch_text_move;diff --git a/crates/ui-egui/src/sketch_side_ui_tests.rs b/crates/ui-egui/src/sketch_side_ui_tests.rsnew file mode 100644index 0000000000..bb62fa6147--- /dev/null+++ b/crates/ui-egui/src/sketch_side_ui_tests.rs@@ -0,0 +1,87 @@+//! Sketch on an origin plane from either side: the new sketch faces the viewer and the view+//! turns to it from where it was, never round to the far side (#1586).++use crate::scenario::Harness;+use serde_json::json;+use solidcraft_engine::doc::{FeatureKind, PlaneRef};+use solidcraft_engine::geom::{Plane, Vec3};++fn sketch_from(yaw: f64, pitch: f64, name: &str) -> (Harness, Vec3, Plane) {+ let mut h = Harness::new();+ h.app.preferences.look_at_anim = false;+ h.app.cam.yaw = yaw;+ h.app.cam.pitch = pitch;+ let eye = h.app.cam.eye();+ h.step(&json!({"start":"sketch.create"})).unwrap();+ h.step(&json!({"click":{"plane":name}})).unwrap();+ h.settle();+ let plane = h.app.session.world_state().sketches.first().map(|s| s.plane).expect("a sketch on the plane");+ (h, eye, plane)+}++#[test]+fn a_new_sketch_on_an_origin_plane_faces_the_side_it_was_started_from() {+ // (yaw, pitch, plane, the plane's own normal); each plane from both of its sides.+ let cases = [+ (0.4, 0.4, "XZ", Vec3::Y),+ (std::f64::consts::PI - 0.4, 0.4, "XZ", Vec3::Y),+ (-1.2, 0.4, "YZ", Vec3::X),+ (1.2, 0.4, "YZ", Vec3::X),+ (-0.6, 0.5, "XY", Vec3::Z),+ (-0.6, -0.5, "XY", Vec3::Z),+ ];+ for (yaw, pitch, name, own) in cases {+ let (h, eye, plane) = sketch_from(yaw, pitch, name);+ let n = plane.normal();+ let what = format!("{name} from yaw {yaw} pitch {pitch}");+ assert!(n.dot(own).abs() > 0.999, "{what}: sketched on {n:?}");+ assert!(eye.dot(n) > 0.0, "{what}: the sketch normal {n:?} points away from the eye {eye:?}");+ // The view looks straight at the sketch from the side it was looking from.+ let after = h.app.cam.eye();+ assert!(after.dot(own * eye.dot(own).signum()) > 0.0, "{what}: the view turned to the far side {after:?}");+ let (right, up, back) = h.app.cam.basis();+ assert!(back.dot(n) > 0.999, "{what}: not looking straight at the sketch ({back:?})");+ // Only a sketch from behind the plane saves the flip, turned so its x runs right and+ // its y up on screen (a plane's own side keeps its own axes, as before).+ let sketch = h.app.session.active_sketch.unwrap();+ let FeatureKind::Sketch { plane: saved, .. } = &h.app.session.doc.feature(sketch).unwrap().kind else { panic!() };+ let behind = eye.dot(own) < 0.0;+ if behind {+ assert!(right.dot(plane.x) > 0.999 && up.dot(plane.y) > 0.999, "{what}: sketch axes {:?} {:?} on screen", plane.x, plane.y);+ }+ assert_eq!(matches!(saved, PlaneRef::Flipped { .. }), behind, "{what}: saved {saved:?}");+ }+}++#[test]+fn a_flipped_sketch_extrudes_toward_the_viewer_and_reopens_the_same() {+ let (mut h, _, plane) = sketch_from(0.4, 0.4, "XZ");+ assert!(plane.normal().dot(Vec3::Y) < -0.999);+ h.app.run("sketch.rectangle.two_point", json!({"p0":[0,0],"p1":[10,5]})).unwrap();+ let sketch = h.app.session.active_sketch.unwrap();+ h.app.finish_sketch();+ h.app.run("solid.extrude", json!({"sketch":sketch,"distance":4,"operation":"new_body","body_name":"Block"})).unwrap();+ let bounds = |h: &Harness| h.app.session.world_state().body("Block").map(|b| b.mesh().bounds()).expect("an extruded body");+ let before = bounds(&h);+ assert!(before.min.y < -3.9 && before.max.y < 1e-6, "extruded away from the viewer: {before:?}");+ let path = h.dir.join("flipped-sketch.solidcraft");+ h.app.run("file.save", json!({"path":path})).unwrap();+ h.app.run("doc.open", json!({"path":path})).unwrap();+ assert_eq!(bounds(&h), before);+}++#[test]+fn a_construction_plane_seen_from_below_gets_a_sketch_facing_down() {+ let mut h = Harness::new();+ h.app.preferences.look_at_anim = false;+ h.app.run("construct.plane.offset", json!({"base":"XY","offset":"5 mm","name":"P"})).unwrap();+ h.app.cam.yaw = -0.6;+ h.app.cam.pitch = -0.5;+ h.app.session.selection = vec![solidcraft_engine::Sel::Plane { name: "P".into() }];+ h.step(&json!({"key":"L"})).unwrap();+ h.settle();+ let sketch = h.app.session.active_sketch.expect("a sketch on P");+ let plane = h.app.session.world_state().sketch(sketch).map(|s| s.plane).unwrap();+ assert!(plane.normal().z < -0.999 && (plane.origin.z - 5.0).abs() < 1e-9, "{plane:?}");+ assert!(h.app.cam.eye().z < 5.0, "the view stays below the plane");+}diff --git a/crates/ui-egui/tests/scenarios/s07_components_joint_drive.json b/crates/ui-egui/tests/scenarios/s07_components_joint_drive.jsonindex 8d4e318c72..34cc697c8d 100644--- a/crates/ui-egui/tests/scenarios/s07_components_joint_drive.json+++ b/crates/ui-egui/tests/scenarios/s07_components_joint_drive.json@@ -113,7 +113,7 @@"click": {"sketch": [50,- -10+ 10]}},diff --git a/crates/ui-egui/tests/scenarios/s20_section_with_joint_drive.json b/crates/ui-egui/tests/scenarios/s20_section_with_joint_drive.jsonindex aaefdc3464..845f4ea58c 100644--- a/crates/ui-egui/tests/scenarios/s20_section_with_joint_drive.json+++ b/crates/ui-egui/tests/scenarios/s20_section_with_joint_drive.json@@ -113,7 +113,7 @@"click": {"sketch": [50,- -10+ 10]}},diff --git a/crates/ui-egui/tests/scenarios/s26_drive_joint_typed.json b/crates/ui-egui/tests/scenarios/s26_drive_joint_typed.jsonindex 1785b79976..1838107577 100644--- a/crates/ui-egui/tests/scenarios/s26_drive_joint_typed.json+++ b/crates/ui-egui/tests/scenarios/s26_drive_joint_typed.json@@ -113,7 +113,7 @@"click": {"sketch": [50,- -10+ 10]}},diff --git a/crates/ui-egui/tests/scenarios/s32_cut_in_active_component.json b/crates/ui-egui/tests/scenarios/s32_cut_in_active_component.jsonindex a02cef5c89..5141ca64d4 100644--- a/crates/ui-egui/tests/scenarios/s32_cut_in_active_component.json+++ b/crates/ui-egui/tests/scenarios/s32_cut_in_active_component.json@@ -102,7 +102,7 @@"click": {"sketch": [52,- -10+ 10]}},diff --git a/crates/ui-egui/tests/scenarios/s37_browser_chevrons.json b/crates/ui-egui/tests/scenarios/s37_browser_chevrons.jsonindex 124b89f422..cff6376757 100644--- a/crates/ui-egui/tests/scenarios/s37_browser_chevrons.json+++ b/crates/ui-egui/tests/scenarios/s37_browser_chevrons.json@@ -116,7 +116,7 @@"click": {"sketch": [50,- -10+ 10]}},