From a9b219bc9f96f7e54ef0da6bcb9d8a050e80b0ed Mon Sep 17 00:00:00 2001 From: PapaEcho <95265719+PapaEcho13@users.noreply.github.com> Date: Thu, 5 Nov 2026 01:06:11 +0000 Subject: [PATCH] joint: let the origin be the design origin or a sketch point (#10290) (#10584) The joint origin input only accepted faces, edges and vertices, so the world origin and sketch points could not be picked to place a joint. Extend the origin input's snap mask with ORIGIN and POINTS and resolve a sketch point (and the empty-body world-origin vertex) to a world snap in snap_of, so a joint can be placed on the design origin or a hole centre like Fusion. --- crates/ui-egui/src/dialogs_assembly.rs | 35 +++++++++++++---- crates/ui-egui/src/dialogs_assembly_tests.rs | 41 +++++++++++++++++++- 2 files changed, 67 insertions(+), 9 deletions(-) diff --git a/crates/ui-egui/src/dialogs_assembly.rs b/crates/ui-egui/src/dialogs_assembly.rs index 3e34c1d41..2656a14c0 100644 --- a/crates/ui-egui/src/dialogs_assembly.rs +++ b/crates/ui-egui/src/dialogs_assembly.rs @@ -21,7 +21,9 @@ use solidcraft_engine::geom::{Aabb3, Mesh}; use crate::SolveApp; use crate::dialogs::{Dialog, Kind, combo, field, form_row}; use crate::preview::{Built, Colors}; -use crate::selection::{BODIES, EDGES, FACES, SelInput, SelectionExt as _, VERTICES, items as sel_items, point_value as pt, polyline_mid}; +use crate::selection::{ + BODIES, EDGES, FACES, ORIGIN, POINTS, SelInput, SelectionExt as _, VERTICES, items as sel_items, point_value as pt, polyline_mid, +}; use crate::theme::Tokens; use crate::viewport::Proj; @@ -72,8 +74,9 @@ pub(crate) fn joint_choice(name: &str, kind: JointKind) -> String { format!("{name} ({})", crate::i18n::tr_label(kind_label(kind))) } -/// What a joint origin input accepts (snaps on faces, edges and vertices). -pub const SNAPS: u16 = FACES | EDGES | VERTICES; +/// What a joint origin input accepts: snaps on faces, edges and vertices, the world origin, and +/// a sketch point (so a joint can be placed on the design origin or a hole centre, like Fusion's). +pub const SNAPS: u16 = FACES | EDGES | VERTICES | ORIGIN | POINTS; /// Commands whose effect is where occurrences sit (previewed on the placed model). const MOVES: &[&str] = &[ "joint.create", @@ -650,13 +653,13 @@ pub fn snap_of(s: &Session, sel: &Sel) -> Option { let tol = (b.body.size() * 2e-3).max(1e-3); let f = b.body.faces(tol).ok()?.into_iter().find(|f| f.index == *index)?; match f.plane_normal { - Some(n) => (body, SnapPt { at: f.centroid, z: n, kind: SnapKind::FaceCenter, param: json!({"face": pt(*point)}) }), + Some(n) => (body.as_str(), SnapPt { at: f.centroid, z: n, kind: SnapKind::FaceCenter, param: json!({"face": pt(*point)}) }), None => { let c = solidcraft_engine::kernel::cylinder_face_at(&b.body, *point)?; let sv = (*point - c.axis_point).dot(c.axis); let (at, dir) = if (sv - c.start).abs() <= (c.end - sv).abs() { (c.start, -1.0) } else { (c.end, 1.0) }; ( - body, + body.as_str(), SnapPt { at: c.axis_point + c.axis * at, z: c.axis * dir, @@ -679,7 +682,7 @@ pub fn snap_of(s: &Session, sel: &Sel) -> Option { let z = if out.dot(n) < 0.0 { -n } else { n }; // Its round end, kept by name so it follows the hole or boss as the part // changes (a point where it has none). - (body, SnapPt { at: c, z, kind: SnapKind::CircleCenter, param: json!({"circle": pt(c), "z": pt(z)}) }) + (body.as_str(), SnapPt { at: c, z, kind: SnapKind::CircleCenter, param: json!({"circle": pt(c), "z": pt(z)}) }) } None => { let mid = polyline_mid(e); @@ -687,7 +690,7 @@ pub fn snap_of(s: &Session, sel: &Sel) -> Option { .or_else(|| m.edge_faces.get(*index).and_then(|fs| fs.first()).and_then(|f| face_normal_near(&m, *f, mid))) .unwrap_or(Vec3::Z); // Its middle, kept by the edge's name. - (body, SnapPt { at: mid, z, kind: SnapKind::EdgeMid, param: json!({"edge": pt(mid), "z": pt(z)}) }) + (body.as_str(), SnapPt { at: mid, z, kind: SnapKind::EdgeMid, param: json!({"edge": pt(mid), "z": pt(z)}) }) } } } @@ -696,7 +699,23 @@ pub fn snap_of(s: &Session, sel: &Sel) -> Option { // as a point's is. let z = occurrence_of_body(s, body) .map_or(Vec3::Z, |o| solidcraft_engine::doc::apply_vector(&solidcraft_engine::doc::joints::occurrence_world(&s.doc, o), Vec3::Z)); - (body, SnapPt { at: *point, z: Vec3::Z, kind: SnapKind::Vertex, param: json!({"edge": pt(*point), "corner": pt(*point), "z": pt(z)}) }) + ( + body.as_str(), + SnapPt { at: *point, z: Vec3::Z, kind: SnapKind::Vertex, param: json!({"edge": pt(*point), "corner": pt(*point), "z": pt(z)}) }, + ) + } + Sel::SketchPoint { id } => { + // A sketch point's world position, its plane's normal as the joint's z, kept by its + // sketch and id so it follows the sketch as the part changes. No body names it, so the + // engine finds the occurrence from the world point (its own body). + let (sketch, point) = match id.split_once(':') { + Some((sketch, point)) => (sketch.parse().ok()?, point), + None => (s.active_sketch?, id.as_str()), + }; + let ss = st.sketch(sketch)?; + let at = ss.plane.to_world(ss.sketch.point(ss.sketch.resolve_point(point)?)?); + let z = ss.plane.normal(); + ("", SnapPt { at, z, kind: SnapKind::Vertex, param: json!({"point": pt(at), "z": pt(z)}) }) } _ => return None, }; diff --git a/crates/ui-egui/src/dialogs_assembly_tests.rs b/crates/ui-egui/src/dialogs_assembly_tests.rs index 90630f4fc..f0e8057f9 100644 --- a/crates/ui-egui/src/dialogs_assembly_tests.rs +++ b/crates/ui-egui/src/dialogs_assembly_tests.rs @@ -60,7 +60,46 @@ fn joint_from_two_snaps() { assert_eq!(app.session.doc.assembly.joints.len(), 1); } -/// A straight edge is the revolute axis, even when both adjacent faces are perpendicular to it. +/// A joint origin can be the design origin or a sketch point, not just faces, edges and vertices +/// (#10290). The origin snaps to the world origin with z up; a sketch point snaps to its world +/// position with the sketch plane's normal as z, and both make a joint. +#[test] +fn joint_origin_can_be_the_origin_or_a_sketch_point() { + let mut app = two_boxes(); + // A sketch point on B's top face, at world (35, 5, 10). + app.session.execute("component.activate", &json!({"component": "B"})).unwrap(); + app.session + .execute("sketch.create", &json!({"plane": {"origin": [30.0, 0.0, 10.0], "x_dir": [1.0, 0.0, 0.0], "y_dir": [0.0, 1.0, 0.0]}, "name": "S"})) + .unwrap(); + app.session.execute("sketch.point", &json!({"point": [5.0, 5.0], "id": "q"})).unwrap(); + app.session.execute("sketch.finish", &json!({})).unwrap(); + let sketch = app.session.doc.find_feature("S").unwrap().id; + + // The two picks a joint origin input now accepts. + let origin = Sel::Vertex { body: String::new(), point: Vec3::ZERO }; + let sketch_point = Sel::SketchPoint { id: format!("{sketch}:q") }; + let so = |s: &Sel| snap_of(&app.session, s).expect("a snap for the pick"); + let o = so(&origin); + let sp = so(&sketch_point); + assert!(o.at.dist(Vec3::ZERO) < 1e-6, "the world origin snaps to the origin: {o:?}"); + assert!(o.z.dist(Vec3::Z) < 1e-9, "the origin's z is up: {o:?}"); + assert!(sp.at.dist(Vec3::new(35.0, 5.0, 10.0)) < 1e-6, "the sketch point snaps to its world position: {sp:?}"); + assert!(sp.z.dist(Vec3::Z) < 1e-9, "the sketch point's z is the plane normal: {sp:?}"); + + // And a joint can be made from them. + app.start("joint.create"); + let mut d = app.dialog.clone().unwrap(); + d.pick(&app.session, origin); + d.pick(&app.session, sketch_point); + if let Kind::Assembly(Asm::Joint(f)) = &mut d.kind { + f.kind = 1; + f.fit_limits(&app.session.doc); + } + for (id, p) in apply_commands(&app, &d).unwrap() { + app.run(&id, p).unwrap(); + } + assert_eq!(app.session.doc.assembly.joints.len(), 1, "a joint was made from the origin and the sketch point"); +} #[test] fn revolute_joint_uses_the_picked_straight_edges() { let mut app = two_boxes();