SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Sketch Intersect: add Faces/Bodies and Projection Link options (#1110) (#7989)
Frank162b3cd4ed1f
diff --git a/assets/locales/pending/sketch-intersect-options.json b/assets/locales/pending/sketch-intersect-options.jsonnew file mode 100644index 0000000000..ff28ff5b68--- /dev/null+++ b/assets/locales/pending/sketch-intersect-options.json@@ -0,0 +1,66 @@+{+ "en": {+ "prefs.project_options_dialog": "Project options dialog",+ "prefs.project_options_dialog_note": "On: choose Geometry or Bodies and Projection Link before projecting. Off: keep the previous direct-pick workflow.",+ "ui.sketch_intersect_geometry": "Geometry",+ "ui.sketch_intersect_selection_filter": "Selection Filter",+ "ui.sketch_intersect_projection_link": "Projection Link",+ "ui.sketch_project_geometry": "Geometry"+ },+ "ja": {+ "prefs.project_options_dialog": "Projectのオプションダイアログ",+ "prefs.project_options_dialog_note": "オン: 投影前に「ジオメトリ」または「ボディ」と「投影リンク」を選択します。オフ: 従来の直接選択方式を使用します。",+ "ui.sketch_intersect_geometry": "ジオメトリ",+ "ui.sketch_intersect_selection_filter": "選択フィルター",+ "ui.sketch_intersect_projection_link": "投影リンク",+ "ui.sketch_project_geometry": "ジオメトリ"+ },+ "zh": {+ "prefs.project_options_dialog": "Project 选项对话框",+ "prefs.project_options_dialog_note": "开启:投影前选择“几何体”或“实体”以及“投影链接”。关闭:保留原有的直接选择工作流。",+ "ui.sketch_intersect_geometry": "几何体",+ "ui.sketch_intersect_selection_filter": "选择过滤器",+ "ui.sketch_intersect_projection_link": "投影链接",+ "ui.sketch_project_geometry": "几何体"+ },+ "ar": {+ "prefs.project_options_dialog": "مربع حوار خيارات Project",+ "prefs.project_options_dialog_note": "تشغيل: اختر الهندسة أو الأجسام ورابط الإسقاط قبل الإسقاط. إيقاف: الإبقاء على سير العمل السابق بالاختيار المباشر.",+ "ui.sketch_intersect_geometry": "الهندسة",+ "ui.sketch_intersect_selection_filter": "مرشح التحديد",+ "ui.sketch_intersect_projection_link": "رابط الإسقاط",+ "ui.sketch_project_geometry": "الهندسة"+ },+ "he": {+ "prefs.project_options_dialog": "תיבת האפשרויות של Project",+ "prefs.project_options_dialog_note": "פעיל: לבחור גאומטריה או גופים וקישור הטלה לפני ההטלה. כבוי: להשאיר את זרימת העבודה הקודמת של בחירה ישירה.",+ "ui.sketch_intersect_geometry": "גאומטריה",+ "ui.sketch_intersect_selection_filter": "מסנן בחירה",+ "ui.sketch_intersect_projection_link": "קישור הטלה",+ "ui.sketch_project_geometry": "גאומטריה"+ },+ "vi": {+ "prefs.project_options_dialog": "Hộp thoại tùy chọn Project",+ "prefs.project_options_dialog_note": "Bật: chọn Hình học hoặc Thân và Liên kết chiếu trước khi chiếu. Tắt: giữ quy trình chọn trực tiếp trước đây.",+ "ui.sketch_intersect_geometry": "Hình học",+ "ui.sketch_intersect_selection_filter": "Bộ lọc lựa chọn",+ "ui.sketch_intersect_projection_link": "Liên kết chiếu",+ "ui.sketch_project_geometry": "Hình học"+ },+ "de": {+ "prefs.project_options_dialog": "Project-Optionendialog",+ "prefs.project_options_dialog_note": "Ein: Vor dem Projizieren Geometrie oder Körper und die Projektionsverknüpfung auswählen. Aus: Den bisherigen Direktwahl-Ablauf beibehalten.",+ "ui.sketch_intersect_geometry": "Geometrie",+ "ui.sketch_intersect_selection_filter": "Auswahlfilter",+ "ui.sketch_intersect_projection_link": "Projektionsverknüpfung",+ "ui.sketch_project_geometry": "Geometrie"+ },+ "ko": {+ "prefs.project_options_dialog": "Project 옵션 대화상자",+ "prefs.project_options_dialog_note": "켜기: 투영 전에 지오메트리 또는 바디와 투영 링크를 선택합니다. 끄기: 기존 직접 선택 작업 흐름을 유지합니다.",+ "ui.sketch_intersect_geometry": "형상",+ "ui.sketch_intersect_selection_filter": "선택 필터",+ "ui.sketch_intersect_projection_link": "투영 링크",+ "ui.sketch_project_geometry": "형상"+ }+}diff --git a/crates/doc/src/project.rs b/crates/doc/src/project.rsindex e77c249700..0889952654 100644--- a/crates/doc/src/project.rs+++ b/crates/doc/src/project.rs@@ -729,9 +729,14 @@ fn refresh_links_in(// Words built from text parameters change shape when the parameters do: that// rebuild is the text following them, not a reference that changed under it.let words_follow = matches!(&l.source, LinkSource::Text { exprs, .. } if exprs.text.is_some());+ let others = |sk: &Sketch| (sk.constraints.len(), sk.curves.len().saturating_sub(sk.link_curves(&l.id).len()));+ let before = others(sk);match sk.update_link(&l.id, &r.geom) {Ok(true) if words_follow => {}- Ok(true) => warn.push(format!("projected {} changed shape and was rebuilt", l.source.describe())),+ // A rebuilt projection is only worth a warning when it took something of+ // the user's with it: a constraint, a dimension or a curve drawn on it.+ Ok(true) if others(sk) == before => {}+ Ok(true) => warn.push(format!("projected {} changed shape and was rebuilt; constraints on it were removed", l.source.describe())),Ok(false) if r.moved => warn.push(format!("projected {} was re-found on the nearest geometry", l.source.describe())),Ok(false) => {}Err(e) => {@@ -1079,7 +1084,7 @@ fn silhouette(plane: &Plane, m: &Mesh) -> Vec<LinkGeom> {}).map(|(a, b, _)| (plane.to_local(*a), plane.to_local(*b))).collect();- fit_segments(&segs, size)+ fit_segments(&segs, size, true)}/// Section of a mesh (or one of its faces) with the sketch plane.@@ -1088,7 +1093,13 @@ pub(crate) fn section(plane: &Plane, m: &Mesh, face: Option<u32>) -> Vec<LinkGeolet (segs, exact) = section_segments(plane, m, face);let segs: Vec<(Vec2, Vec2)> = segs.into_iter().map(|(a, b, _)| (a, b)).collect();let loose = size * 2e-3;- fit_segments(&segs, size).into_iter().map(|g| refine_round(g, &exact, loose)).collect()+ let refine = |v: Vec<LinkGeom>| -> Vec<LinkGeom> { v.into_iter().map(|g| refine_round(g, &exact, loose)).collect() };+ let lossy = refine(fit_segments(&segs, size, false));+ // Lines and arcs that follow the section closely (the corners of a rounded profile stay+ // where they are) are kept when they take no more curves than the loose fit.+ let close = refine(fit_segments(&segs, size, true));+ let plain = |v: &[LinkGeom]| v.iter().all(|g| matches!(g, LinkGeom::Line(..) | LinkGeom::Arc { .. } | LinkGeom::Circle(..)));+ if plain(&close) && close.len() <= lossy.len() { close } else { lossy }}/// The segments where the plane crosses the mesh's triangles (in plane coordinates, each with@@ -1253,9 +1264,11 @@ fn refine_round(g: LinkGeom, exact: &[Vec2], tol: f64) -> LinkGeom {}/// Chain loose 2D segments into polylines (merging coincident ends) and fit each chain.-fn fit_segments(segs: &[(Vec2, Vec2)], size: f64) -> Vec<LinkGeom> {+fn fit_segments(segs: &[(Vec2, Vec2)], size: f64, preserve_arcs: bool) -> Vec<LinkGeom> {// Mesh chords stray from the surface by up to the display tolerance (1/1000 of the size).- let loose = Some(size * 2e-3);+ // A silhouette's vertices lie on the surface, so it is fitted tightly: a loose fit lets a line+ // swallow the start of a tangent arc, or an arc run on into the straight edge after it.+ let loose = Some(if preserve_arcs { size * 1e-5 } else { size * 2e-3 });let q = size * 1e-7;let key = |p: Vec2| ((p.x / q).round() as i64, (p.y / q).round() as i64);let mut nodes: BTreeMap<(i64, i64), (Vec2, Vec<usize>)> = BTreeMap::new();@@ -1303,19 +1316,96 @@ fn fit_segments(segs: &[(Vec2, Vec2)], size: f64) -> Vec<LinkGeom> {for s in starts {while nodes.get(&s).is_some_and(|n| n.1.iter().any(|e| !used.get(*e).copied().unwrap_or(true))) {let c = walk(s, &mut used);- fit_chain(&c, loose, &mut out);+ fit_chain_with_arcs(&c, loose, &mut out, preserve_arcs);}}let keys: Vec<(i64, i64)> = nodes.keys().copied().collect();for s in keys {while nodes.get(&s).is_some_and(|n| n.1.iter().any(|e| !used.get(*e).copied().unwrap_or(true))) {let c = walk(s, &mut used);- fit_chain(&c, loose, &mut out);+ fit_chain_with_arcs(&c, loose, &mut out, preserve_arcs);}}+ if preserve_arcs {+ snap_tangent_arcs(&mut out, size * 1e-3);+ }out}+/// A fitted arc is only a least-squares circle: make it exactly tangent to the straight edges+/// it runs into, ending on them where they touch it, with one radius.+fn snap_tangent_arcs(out: &mut [LinkGeom], tol: f64) {+ for i in 0..out.len() {+ let Some(LinkGeom::Arc { c, a, b }) = out.get(i).cloned() else { continue };+ let r = (c.dist(a) + c.dist(b)) / 2.0;+ // (arc end, line index, line end index, tangent point, unit normal towards the centre, centre distance)+ let mut hits: Vec<(usize, usize, usize, Vec2, Vec2, f64)> = Vec::new();+ for (end, e) in [a, b].into_iter().enumerate() {+ for (j, g) in out.iter().enumerate() {+ let LinkGeom::Line(p, q) = g else { continue };+ let Some(u) = (*q - *p).normalized() else { continue };+ let foot = *p + u * (c - *p).dot(u);+ let d = c.dist(foot);+ if (d - r).abs() > tol || foot.dist(e) > 0.5 * r {+ continue;+ }+ let Some(n) = (c - foot).normalized() else { continue };+ // The end of the line nearest the arc, and the tangent point must lie before it.+ let (near, far) = if p.dist(e) <= q.dist(e) { (0, *q) } else { (1, *p) };+ let near_pt = if near == 0 { *p } else { *q };+ // The line must itself end next to the arc: not just lie on the same infinite line.+ if (foot - far).dot(near_pt - far) <= 0.0 || near_pt.dist(foot) > 0.25 * r {+ continue;+ }+ hits.push((end, j, near, foot, n, d));+ }+ }+ let mut hits_by_end: [Option<(usize, usize, Vec2, Vec2, f64)>; 2] = [None, None];+ for (end, j, near, foot, n, d) in hits {+ if let Some(slot) = hits_by_end.get_mut(end)+ && slot.is_none()+ {+ *slot = Some((j, near, foot, n, d));+ }+ }+ let (mut c, mut r) = (c, r);+ if let [Some((_, _, _, n1, d1)), Some((_, _, _, n2, d2))] = hits_by_end {+ // One circle tangent to both lines: equal distance to each.+ let det = n1.cross(n2);+ if det.abs() > 1e-6 {+ let m = (d1 + d2) / 2.0;+ let (r1, r2) = (m - d1, m - d2);+ let delta = Vec2::new((r1 * n2.y - r2 * n1.y) / det, (n1.x * r2 - n2.x * r1) / det);+ c += delta;+ r = m;+ }+ } else if let [Some((_, _, _, _, d)), None] | [None, Some((_, _, _, _, d))] = hits_by_end {+ r = d;+ }+ let on = |q: Vec2| c + (q - c).normalized().unwrap_or(Vec2::X) * r;+ let (mut na, mut nb) = (on(a), on(b));+ for (end, hit) in hits_by_end.into_iter().enumerate() {+ let Some((j, near, _, n, _)) = hit else { continue };+ let t = c - n * r;+ if let Some(LinkGeom::Line(p, q)) = out.get_mut(j) {+ if near == 0 {+ *p = t;+ } else {+ *q = t;+ }+ }+ if end == 0 {+ na = t;+ } else {+ nb = t;+ }+ }+ if let Some(LinkGeom::Arc { c: cc, a: aa, b: bb }) = out.get_mut(i) {+ (*cc, *aa, *bb) = (c, na, nb);+ }+ }+}+// ---------------------------------------------------------------------------------------------// Fitting@@ -1392,9 +1482,9 @@ fn fits_line(p: &[Vec2], tol: f64) -> bool {/// Circle through the chain (centre, radius, signed sweep from the first to the last point)./// `exact`: the points lie on the curve (edge tessellation), else they are approximate/// (mesh sections and silhouettes) and the circle is a least-squares fit.-fn fits_circle(p: &[Vec2], tol: f64, exact: bool) -> Option<(Vec2, f64, f64)> {+fn fits_circle(p: &[Vec2], tol: f64, exact: bool, preserve_arcs: bool) -> Option<(Vec2, f64, f64)> {let n = p.len();- if n < 3 || (!exact && n < 5) {+ if n < 3 || (!exact && !preserve_arcs && n < 5) {return None;}let closed = p.first()?.dist(*p.last()?) <= tol;@@ -1442,6 +1532,10 @@ fn arc_geom(p: &[Vec2], c: Vec2, r: f64, sweep: f64, tol: f64) -> Option<LinkGeo/// else greedy maximal pieces. `loose`: the points are approximate (within `loose` mm), and/// sharp corners always split the chain.pub(crate) fn fit_chain(raw: &[Vec2], loose: Option<f64>, out: &mut Vec<LinkGeom>) {+ fit_chain_with_arcs(raw, loose, out, false);+}++fn fit_chain_with_arcs(raw: &[Vec2], loose: Option<f64>, out: &mut Vec<LinkGeom>, preserve_arcs: bool) {let mut p: Vec<Vec2> = Vec::with_capacity(raw.len());let scale = raw.iter().fold(0.0_f64, |m, q| m.max(q.x.abs()).max(q.y.abs())).max(1.0);let ext = match (@@ -1491,10 +1585,12 @@ pub(crate) fn fit_chain(raw: &[Vec2], loose: Option<f64>, out: &mut Vec<LinkGeom_ => 0.0,}};- let corners: Vec<usize> = (0..n).filter(|i| turn(*i) > 30f64.to_radians()).collect();+ // A coarsely tessellated round turns up to ~35 degrees per chord; keep those together.+ let corner_turn = if preserve_arcs { 50f64 } else { 30f64 }.to_radians();+ let corners: Vec<usize> = (0..n).filter(|i| turn(*i) > corner_turn).collect();let cut = |a: usize, b: usize, out: &mut Vec<LinkGeom>| {if let Some(s) = p.get(a..=b) {- fit_piece(s, tol, exact, out);+ fit_piece(s, tol, exact, preserve_arcs, out);}};if closed && let Some(&c0) = corners.first() {@@ -1508,7 +1604,7 @@ pub(crate) fn fit_chain(raw: &[Vec2], loose: Option<f64>, out: &mut Vec<LinkGeomlet mut start = 0;for c in cs.into_iter().chain([m - 1]) {if let Some(s) = q.get(start..=c) {- fit_piece(s, tol, exact, out);+ fit_piece(s, tol, exact, preserve_arcs, out);}start = c;}@@ -1521,22 +1617,30 @@ pub(crate) fn fit_chain(raw: &[Vec2], loose: Option<f64>, out: &mut Vec<LinkGeom}return;}- fit_piece(&p, tol, exact, out);+ fit_piece(&p, tol, exact, preserve_arcs, out);}-fn fit_piece(p: &[Vec2], tol: f64, exact: bool, out: &mut Vec<LinkGeom>) {+fn fit_piece(p: &[Vec2], tol: f64, exact: bool, preserve_arcs: bool, out: &mut Vec<LinkGeom>) {if p.len() < 2 {return;}+ // A near-straight run is a line, not an arc of huge radius.+ let curved = |sw: f64| !preserve_arcs || exact || sw.abs() >= 20f64.to_radians();+ let fitted_arc = || fits_circle(p, tol, exact, preserve_arcs).filter(|(_, _, sw)| curved(*sw)).and_then(|(c, r, sw)| arc_geom(p, c, r, sw, tol));+ if preserve_arcs+ && (exact || p.len() >= 4)+ && let Some(g) = fitted_arc()+ {+ out.push(g);+ return;+ }if fits_line(p, tol) {if let (Some(a), Some(b)) = (p.first(), p.last()) {out.push(LinkGeom::Line(*a, *b));}return;}- if let Some((c, r, sw)) = fits_circle(p, tol, exact)- && let Some(g) = arc_geom(p, c, r, sw, tol)- {+ if !preserve_arcs && let Some(g) = fitted_arc() {out.push(g);return;}@@ -1553,7 +1657,7 @@ fn fit_piece(p: &[Vec2], tol: f64, exact: bool, out: &mut Vec<LinkGeom>) {let mut jc = i + 1;let mut arc = None;while jc + 1 < n {- match p.get(i..=jc + 1).and_then(|s| fits_circle(s, tol, exact)) {+ match p.get(i..=jc + 1).and_then(|s| fits_circle(s, tol, exact, preserve_arcs)) {Some(f) => {arc = Some(f);jc += 1;@@ -1563,7 +1667,7 @@ fn fit_piece(p: &[Vec2], tol: f64, exact: bool, out: &mut Vec<LinkGeom>) {}if jc >= jl + 2&& jc - i >= 3- && let Some((c, r, sw)) = arc+ && let Some((c, r, sw)) = arc.filter(|(_, _, sw)| curved(*sw))&& let Some(g) = p.get(i..=jc).and_then(|s| arc_geom(s, c, r, sw, tol)){out.push(g);diff --git a/crates/doc/src/project_order.rs b/crates/doc/src/project_order.rsindex d6fdace2a9..f59cdfa799 100644--- a/crates/doc/src/project_order.rs+++ b/crates/doc/src/project_order.rs@@ -206,6 +206,35 @@ mod tests {assert!(family_edges(&mesh, &selected, &Plane::XY).is_err());}+ #[test]+ fn coarsely_tessellated_round_silhouette_fits_an_arc() {+ use solidcraft_geom::Vec2;+ use solidcraft_sketch::LinkGeom;+ let on = |deg: f64| Vec2::new(5. + 5. * deg.to_radians().cos(), 5. + 5. * deg.to_radians().sin());+ let mut chain = vec![Vec2::new(0., -20.)];+ chain.extend([180., 169.5, 135., 100.5, 90.].map(on));+ chain.push(Vec2::new(45., 10.));+ let mut out = Vec::new();+ super::super::fit_chain_with_arcs(&chain, Some(0.05), &mut out, true);+ assert!(out.iter().any(|g| matches!(g, LinkGeom::Arc { .. })), "{out:?}");+ }++ #[test]+ fn tangent_snapping_leaves_unrelated_collinear_lines_alone() {+ use solidcraft_geom::Vec2;+ use solidcraft_sketch::LinkGeom;+ let v = Vec2::new;+ // A rounded corner of radius 2 meeting the top edge, and an unrelated collinear edge.+ let mut out = vec![+ LinkGeom::Line(v(21., 8.), v(25., 8.)),+ LinkGeom::Arc { c: v(2.0008, 5.9992), a: v(2.2808, 8.0), b: v(0., 6.0) },+ LinkGeom::Line(v(2.0668, 8.), v(48., 8.)),+ ];+ super::super::snap_tangent_arcs(&mut out, 0.05);+ assert_eq!(out.first(), Some(&LinkGeom::Line(v(21., 8.), v(25., 8.))));+ let (Some(LinkGeom::Arc { a, .. }), Some(LinkGeom::Line(p, _))) = (out.get(1), out.get(2)) else { panic!("{out:?}") };+ assert!(a.dist(*p) < 1e-9, "{out:?}");+ }#[test]fn boundaries_touching_at_a_vertex_project() {// Two squares of one face family meet only at the corner (1, 1): four boundary edges meetdiff --git a/crates/engine/src/cmd/sketch_project.rs b/crates/engine/src/cmd/sketch_project.rsindex e0603c73ea..e7b830e961 100644--- a/crates/engine/src/cmd/sketch_project.rs+++ b/crates/engine/src/cmd/sketch_project.rs@@ -21,9 +21,11 @@ macro_rules! refs_doc {}pub static COMMANDS: &[CommandSpec] = &[- CommandSpec::new("sketch.project", "Project", project_cmd).at("SKETCH", "CREATE").icon("project").key("P").enabled(in_sketch).params(concat!(refs_doc!(), created_doc!())),+ CommandSpec::new("sketch.project", "Project", project_cmd).at("SKETCH", "CREATE").icon("project").key("P").enabled(in_sketch).params(+ concat!(refs_doc!(), "; projection_link?: bool (default true)", created_doc!()),+ ),CommandSpec::new("sketch.intersect", "Intersect", intersect_cmd).at("SKETCH", "CREATE").icon("intersect").enabled(in_sketch).params(- concat!("refs: [{body}, {face: [x,y,z], body?}, {edge: [x,y,z], body?}, {sketch, curve}]: section curves (or points) with the sketch plane, linked", created_doc!()),+ concat!("refs: [{body}, {face: [x,y,z], body?}, {edge: [x,y,z], body?}, {sketch, curve}]: section curves (or points) with the sketch plane; projection_link?: bool (default true)", created_doc!()),),CommandSpec::new("sketch.include_3d", "Include 3D Geometry", include_cmd).at("SKETCH", "CREATE")@@ -307,7 +309,7 @@ fn link_json(sk: &Sketch, link: &str) -> Value {json!({"link": link, "curves": curves, "points": points})}-fn run_links(s: &mut Session, p: &Value, cmd: &str, kind: LinkKind) -> Result<Value> {+fn run_links(s: &mut Session, p: &Value, cmd: &str, kind: LinkKind, projection_link: bool) -> Result<Value> {let refs: Vec<Value> = match p.get("refs").or_else(|| p.get("ref")) {Some(Value::Array(a)) => a.iter().take(1000).cloned().collect(),Some(v) => vec![v.clone()],@@ -327,7 +329,14 @@ fn run_links(s: &mut Session, p: &Value, cmd: &str, kind: LinkKind) -> Result<Vafor src in sources {let what = src.describe();match add_link_unless_present(s, doc, id, sk, kind, src, kind == LinkKind::Project) {- Ok(Some(l)) => out.push(link_json(sk, &l)),+ Ok(Some(l)) => {+ let mut result = link_json(sk, &l);+ if !projection_link {+ result["link"] = Value::Null;+ sk.break_link(&l)?;+ }+ out.push(result);+ }Ok(None) => present.push(what),Err(e) => return Err(bad(cmd, format!("{what}: {e}"))),}@@ -346,15 +355,25 @@ fn run_links(s: &mut Session, p: &Value, cmd: &str, kind: LinkKind) -> Result<Va}fn project_cmd(s: &mut Session, p: &Value) -> Result<Value> {- run_links(s, p, "sketch.project", LinkKind::Project)+ let projection_link = match p.get("projection_link") {+ None => true,+ Some(Value::Bool(value)) => *value,+ Some(_) => return Err(bad("sketch.project", "`projection_link` must be a boolean")),+ };+ run_links(s, p, "sketch.project", LinkKind::Project, projection_link)}fn intersect_cmd(s: &mut Session, p: &Value) -> Result<Value> {- run_links(s, p, "sketch.intersect", LinkKind::Intersect)+ let projection_link = match p.get("projection_link") {+ None => true,+ Some(Value::Bool(value)) => *value,+ Some(_) => return Err(bad("sketch.intersect", "`projection_link` must be a boolean")),+ };+ run_links(s, p, "sketch.intersect", LinkKind::Intersect, projection_link)}fn include_cmd(s: &mut Session, p: &Value) -> Result<Value> {- run_links(s, p, "sketch.include_3d", LinkKind::Include)+ run_links(s, p, "sketch.include_3d", LinkKind::Include, true)}/// A constraint's operands may be model geometry (#6348): an `{edge: [x,y,z], body?}` ordiff --git a/crates/engine/src/cmd/sketch_project_tests.rs b/crates/engine/src/cmd/sketch_project_tests.rsindex 066c5bc41e..7204ee9c4d 100644--- a/crates/engine/src/cmd/sketch_project_tests.rs+++ b/crates/engine/src/cmd/sketch_project_tests.rs@@ -216,6 +216,20 @@ fn project_edges_bodies_sketches_and_origin() {assert!(s.execute("sketch.project", &json!({"refs": [{"plane": "XY"}]})).is_err(), "parallel plane projects to nothing");}+#[test]+fn project_whole_body_can_create_unlinked_geometry() {+ let mut s = Session::default();+ box_part(&mut s);+ let sketch = run(&mut s, "sketch.create", json!({"plane":"XY"}))["sketch"].as_u64().unwrap();+ let body = s.model.state().bodies[0].name.clone();+ let r = run(&mut s, "sketch.project", json!({"refs":[{"body":body}],"projection_link":false}));+ assert_eq!(r["links"][0]["link"], Value::Null);+ let sk = s.doc.sketch(sketch).unwrap();+ assert!(sk.links.is_empty());+ assert_eq!(sk.curves.len(), 4);+ assert!(s.execute("sketch.project", &json!({"refs":[{"body":body}],"projection_link":"false"})).is_err());+}+#[test]fn intersect_cuts_a_body_with_the_sketch_plane() {let mut s = Session::default();@@ -873,3 +887,199 @@ fn intersect_on_a_top_face_gives_its_outline() {ends.sort_by(|a, b| a.partial_cmp(b).unwrap());assert_eq!(ends, vec![[0.0, 0.0, 40.0, 0.0], [0.0, 30.0, 0.0, 0.0], [40.0, 0.0, 40.0, 30.0], [40.0, 30.0, 0.0, 30.0]]);}++#[test]+fn intersect_whole_body_can_create_unlinked_section_geometry() {+ let mut s = Session::default();+ run(&mut s, "solid.box", json!({"length": 40, "width": 30, "height": 20, "body_name": "Post"}));+ run(&mut s, "sketch.create", json!({"plane": "XY", "offset": 10}));++ let result = run(&mut s, "sketch.intersect", json!({"refs": [{"body": "Post"}], "projection_link": false}));+ assert_eq!(result["links"][0]["link"], Value::Null, "{result}");+ assert_eq!(result["links"][0]["curves"].as_array().unwrap().len(), 4, "{result}");++ let sketch = s.doc.sketch(s.active_sketch.unwrap()).unwrap();+ assert!(sketch.links.is_empty(), "projection links were disabled");+ assert_eq!(sketch.curves.len(), 4, "the whole body's section remains as normal sketch geometry");+ assert!(s.execute("sketch.intersect", &json!({"refs": [{"body": "Post"}], "projection_link": "false"})).is_err());+}++#[test]+fn whole_body_project_preserves_the_arc_of_a_chamfered_round_edge() {+ let mut s = Session::default();+ run(&mut s, "solid.box", json!({"length": 40, "width": 30, "height": 20, "body_name": "Plate"}));+ run(&mut s, "solid.fillet", json!({"edges": [[40, 0, 10]], "radius": 5}));+ let sketch = run(&mut s, "sketch.create", json!({"plane": {"face": [20, 15, 20]}, "project_edges": false}))["sketch"].as_u64().unwrap();+ run(&mut s, "sketch.project", json!({"refs": [{"body": "Plate"}]}));+ run(&mut s, "sketch.finish", json!({}));++ run(&mut s, "timeline.roll_to", json!({"position": 2}));+ run(&mut s, "solid.chamfer", json!({"edges": [[40, 15, 20]], "distance": 1}));+ run(&mut s, "timeline.roll_to", json!({}));++ let result = s.model.result(sketch).unwrap();+ let state = s.model.state();+ let solved = state.sketch(sketch).unwrap();+ let sketch = &solved.sketch;+ assert!(result.error.is_none(), "{:?}", result.error);+ assert!(result.warning.is_none(), "a rebuilt projection nothing depends on needs no warning: {:?}", result.warning);+ assert!((solved.plane.origin.z - 20.).abs() < 1e-6);+ assert!(+ sketch.curves.iter().any(|curve| matches!(curve.kind, solidcraft_sketch::CurveKind::Arc { .. })),+ "the rounded chamfer silhouette should contain an arc, not only line segments: {:?}",+ sketch.curves+ );+}++#[test]+fn whole_body_project_stays_on_the_body_outline_after_a_late_chamfer() {+ use solidcraft_sketch::CurveKind;+ let planes: [([i32; 3], &str); 3] = [([20, 15, 20], "top"), ([20, 0, 10], "front"), ([40, 15, 10], "side")];+ let chamfers: [[i32; 3]; 4] = [[40, 15, 20], [20, 0, 20], [40, 0, 10], [38, 2, 20]];+ for (face, plane) in planes {+ for chamfer in chamfers {+ let mut s = Session::default();+ run(&mut s, "solid.box", json!({"length": 40, "width": 30, "height": 20, "body_name": "Plate"}));+ run(&mut s, "solid.fillet", json!({"edges": [[40, 0, 10]], "radius": 5}));+ let sketch = run(&mut s, "sketch.create", json!({"plane": {"face": face}, "project_edges": false}))["sketch"].as_u64().unwrap();+ run(&mut s, "sketch.project", json!({"refs": [{"body": "Plate"}]}));+ run(&mut s, "sketch.finish", json!({}));+ run(&mut s, "timeline.roll_to", json!({"position": 2}));+ if s.execute("solid.chamfer", &json!({"edges": [chamfer], "distance": 1})).is_err() {+ continue;+ }+ run(&mut s, "timeline.roll_to", json!({}));+ let state = s.model.state();+ let solved = state.sketch(sketch).unwrap();+ let sk = &solved.sketch;+ let pts: Vec<_> = sk.points.iter().map(|p| p.pos).collect();+ let (x0, x1) = pts.iter().fold((f64::MAX, f64::MIN), |a, p| (a.0.min(p.x), a.1.max(p.x)));+ let (y0, y1) = pts.iter().fold((f64::MAX, f64::MIN), |a, p| (a.0.min(p.y), a.1.max(p.y)));+ let mut worst = 0.0_f64;+ for curve in &sk.curves {+ if let CurveKind::Arc { c, a, b } = curve.kind {+ let (c, a, b) = (pts[c], pts[a], pts[b]);+ let r = c.dist(a);+ let (t0, mut sweep) = ((a - c).angle(), (b - c).angle() - (a - c).angle());+ while sweep < 0.0 {+ sweep += std::f64::consts::TAU;+ }+ for i in 0..=16 {+ let t = t0 + sweep * f64::from(i) / 16.0;+ let q = solidcraft_geom::Vec2::new(c.x + r * t.cos(), c.y + r * t.sin());+ worst = worst.max((x0 - q.x).max(q.x - x1).max(y0 - q.y).max(q.y - y1));+ }+ assert!(sweep < std::f64::consts::PI + 0.01, "{plane} {chamfer:?}: arc sweeps {sweep} rad, not a rounded corner");+ }+ }+ assert!(worst < 0.01, "{plane} {chamfer:?}: an arc leaves the body outline by {worst}");+ }+ }+}++#[test]+fn whole_body_project_of_a_filleted_plate_keeps_exact_lines_and_arcs() {+ use solidcraft_sketch::CurveKind;+ let mut s = Session::default();+ run(&mut s, "solid.box", json!({"length": 80, "width": 50, "height": 8, "body_name": "Plate"}));+ run(&mut s, "solid.fillet", json!({"edges": [[0, 0, 4], [80, 0, 4], [80, 50, 4], [0, 50, 4]], "radius": 6}));+ let sketch = run(&mut s, "sketch.create", json!({"plane": "YZ", "offset": 36, "project_edges": false}))["sketch"].as_u64().unwrap();+ run(&mut s, "sketch.project", json!({"refs": [{"body": "Plate"}]}));+ run(&mut s, "sketch.finish", json!({}));+ run(&mut s, "timeline.roll_to", json!({"position": 2}));+ let top = [[40., 0.], [1.7574, 1.7574], [78.2426, 1.7574], [80., 25.], [78.2426, 48.2426], [40., 50.], [1.7574, 48.2426], [0., 25.]];+ let edges: Vec<_> = top.iter().map(|p| json!([p[0], p[1], 8])).collect();+ run(&mut s, "solid.fillet", json!({"edges": edges, "radius": 2}));+ run(&mut s, "timeline.roll_to", json!({}));++ let state = s.model.state();+ let sk = &state.sketch(sketch).unwrap().sketch;+ let pos = |i: usize| sk.points[i].pos;+ let mut arcs = Vec::new();+ for curve in &sk.curves {+ match curve.kind {+ CurveKind::Line { a, b } => {+ let d = pos(b) - pos(a);+ assert!(d.x.abs() < 1e-3 || d.y.abs() < 1e-3, "slanted line {:?} -> {:?}", pos(a), pos(b));+ }+ CurveKind::Arc { c, a, .. } => arcs.push(pos(c).dist(pos(a))),+ _ => {}+ }+ }+ assert_eq!(arcs.len(), 2, "{arcs:?}");+ assert!(arcs.iter().all(|r| (r - 2.).abs() < 5e-3), "{arcs:?}");+ // Every arc end is exactly the end of a straight edge, and meets it tangentially.+ for curve in &sk.curves {+ let CurveKind::Arc { c, a, b } = curve.kind else { continue };+ for end in [a, b] {+ let touching = sk+ .curves+ .iter()+ .filter(|o| matches!(o.kind, CurveKind::Line { a: p, b: q } if pos(p).dist(pos(end)) < 1e-6 || pos(q).dist(pos(end)) < 1e-6))+ .count();+ assert!(touching >= 1, "arc end {:?} meets no line end", pos(end));+ let radial = pos(end) - pos(c);+ assert!((radial.len() - 2.).abs() < 5e-3);+ }+ }+}++#[test]+fn whole_body_intersect_of_a_filleted_plate_keeps_exact_lines_and_arcs() {+ use solidcraft_sketch::CurveKind;+ let mut s = Session::default();+ run(&mut s, "solid.box", json!({"length": 80, "width": 50, "height": 8, "body_name": "Plate"}));+ let sketch = run(&mut s, "sketch.create", json!({"plane": "YZ", "offset": 36, "project_edges": false}))["sketch"].as_u64().unwrap();+ run(&mut s, "sketch.intersect", json!({"refs": [{"body": "Plate"}]}));+ run(&mut s, "sketch.finish", json!({}));+ run(&mut s, "timeline.roll_to", json!({"position": 1}));+ let top = [[40., 0.], [80., 25.], [40., 50.], [0., 25.]];+ let edges: Vec<_> = top.iter().map(|p| json!([p[0], p[1], 8])).collect();+ run(&mut s, "solid.fillet", json!({"edges": edges, "radius": 2}));+ run(&mut s, "timeline.roll_to", json!({}));++ let result = s.model.result(sketch).unwrap().warning.clone();+ assert!(result.is_none(), "{result:?}");+ let state = s.model.state();+ let sk = &state.sketch(sketch).unwrap().sketch;+ let pos = |i: usize| sk.points[i].pos;+ let mut arcs = Vec::new();+ for curve in &sk.curves {+ match curve.kind {+ CurveKind::Line { a, b } => {+ let d = pos(b) - pos(a);+ assert!(d.x.abs() < 1e-3 || d.y.abs() < 1e-3, "slanted line {:?} -> {:?}", pos(a), pos(b));+ }+ CurveKind::Arc { c, a, .. } => arcs.push(pos(c).dist(pos(a))),+ _ => {}+ }+ }+ assert_eq!(sk.curves.len(), 6, "{} curves", sk.curves.len());+ assert_eq!(arcs.len(), 2, "{arcs:?}");+ assert!(arcs.iter().all(|r| (r - 2.).abs() < 5e-3), "{arcs:?}");+}+#[test]+fn a_rebuilt_projection_keeps_user_constraints_without_a_warning() {+ for dimensioned in [false, true] {+ let mut s = Session::default();+ run(&mut s, "solid.box", json!({"length": 40, "width": 30, "height": 20, "body_name": "Plate"}));+ run(&mut s, "solid.fillet", json!({"edges": [[40, 0, 10]], "radius": 5}));+ let sketch = run(&mut s, "sketch.create", json!({"plane": {"face": [20, 15, 20]}, "project_edges": false}))["sketch"].as_u64().unwrap();+ run(&mut s, "sketch.project", json!({"refs": [{"body": "Plate"}]}));+ if dimensioned {+ // A line of the user's, pinned to the projected corner.+ let line = ids(&run(&mut s, "sketch.line", json!({"points": [[5, 5], [10, 5]]}))["curves"]);+ run(&mut s, "sketch.constraint.coincident", json!({"a": format!("{}.start", line[0]), "b": "p4"}));+ }+ run(&mut s, "sketch.finish", json!({}));+ run(&mut s, "timeline.roll_to", json!({"position": 2}));+ run(&mut s, "solid.chamfer", json!({"edges": [[40, 15, 20]], "distance": 1}));+ run(&mut s, "timeline.roll_to", json!({}));+ let warning = s.model.result(sketch).unwrap().warning.clone();+ let st = s.model.state();+ let k = &st.sketch(sketch).unwrap().sketch;+ // The user's constraint survives the rebuild, so there is nothing to warn about.+ assert_eq!(k.constraints.len(), usize::from(dimensioned));+ assert!(warning.is_none(), "{warning:?}");+ }+}diff --git a/crates/sketch/src/profiles.rs b/crates/sketch/src/profiles.rsindex 956b8eab1e..db843c19c9 100644--- a/crates/sketch/src/profiles.rs+++ b/crates/sketch/src/profiles.rs@@ -608,9 +608,11 @@ pub fn find_drawn_profiles(sk: &Sketch) -> Vec<Profile> {if sk.links.iter().all(|l| l.kind == crate::LinkKind::Text) {return find_profiles(sk);}+ let intersect_links: std::collections::HashSet<&str> =+ sk.links.iter().filter(|link| link.kind == crate::LinkKind::Intersect).map(|link| link.id.as_str()).collect();let mut d = sk.clone();for (ci, c) in d.curves.iter_mut().enumerate() {- if c.link.is_some() && !sk.is_text_curve(ci) {+ if c.link.as_ref().is_some_and(|link| !intersect_links.contains(link.as_str())) && !sk.is_text_curve(ci) {c.construction = true;}}diff --git a/crates/sketch/src/tests.rs b/crates/sketch/src/tests.rsindex 11b19ab606..3bf233a733 100644--- a/crates/sketch/src/tests.rs+++ b/crates/sketch/src/tests.rs@@ -831,17 +831,19 @@ fn text_beside_other_curves_is_drawn_geometry() {}assert_areas(&sorted_areas(&find_drawn_profiles(&sk)), vec![13.5557, 600.0]);// Projected reference geometry still doesn't count as drawn.- let square = |s: f64| {+ let square = |x: f64, s: f64| {vec![- LinkGeom::Line(v(100.0, 0.0), v(100.0 + s, 0.0)),- LinkGeom::Line(v(100.0 + s, 0.0), v(100.0 + s, s)),- LinkGeom::Line(v(100.0 + s, s), v(100.0, s)),- LinkGeom::Line(v(100.0, s), v(100.0, 0.0)),+ LinkGeom::Line(v(x, 0.0), v(x + s, 0.0)),+ LinkGeom::Line(v(x + s, 0.0), v(x + s, s)),+ LinkGeom::Line(v(x + s, s), v(x, s)),+ LinkGeom::Line(v(x, s), v(x, 0.0)),]};- sk.add_link(LinkKind::Project, LinkSource::Origin, &square(5.0)).unwrap();+ sk.add_link(LinkKind::Project, LinkSource::Origin, &square(100.0, 5.0)).unwrap();assert_eq!(find_profiles(&sk).len(), 3);assert_areas(&sorted_areas(&find_drawn_profiles(&sk)), vec![13.5557, 600.0]);+ sk.add_link(LinkKind::Intersect, LinkSource::Origin, &square(110.0, 7.0)).unwrap();+ assert_areas(&sorted_areas(&find_drawn_profiles(&sk)), vec![13.5557, 49.0, 600.0]);}#[test]diff --git a/crates/ui-egui/src/dialogs.rs b/crates/ui-egui/src/dialogs.rsindex 4737b92c1b..af5c63b32c 100644--- a/crates/ui-egui/src/dialogs.rs+++ b/crates/ui-egui/src/dialogs.rs@@ -97,6 +97,8 @@ const WALL_LABELS: [&str; 4] = ["Center", "Inside", "Outside", "Two Sides"];/// What an extrude's first input picks: profiles or planar faces, or curves too when thin.const EXTRUDE_ACCEPT: Accept = PROFILES | PLANAR_FACES;const THIN_ACCEPT: Accept = PROFILES | CURVES;+const PROJECT_GEOMETRY: Accept =+ EDGES | FACES | selection::VERTICES | PLANES | AXES | selection::SKETCH_LINES | selection::EXTERNAL_POINTS | selection::ORIGIN;const HOLE_TYPES: [&str; 3] = ["simple", "counterbore", "countersink"];const HOLE_LABELS: [&str; 3] = ["Simple", "Counterbore", "Countersink"];@@ -388,6 +390,14 @@ crate::dialog_descriptor::dialog_descriptors! {/// Sketch-space modify tools: scale and offset, and later fillet, chamfer, the patterns,/// mirror and move (`sketch_modify_ui`).SketchModify(crate::sketch_modify_ui::Mod),+ SketchIntersect {+ bodies: bool,+ projection_link: bool,+ },+ SketchProject {+ bodies: bool,+ projection_link: bool,+ },}}}@@ -797,6 +807,20 @@ impl Dialog {let has_bodies = !s.world_state().bodies.is_empty();let mut d = match id {"sketch.create" => Dialog::new(Kind::Sketch, vec![SelInput::new("Plane", PLANES | PLANAR_FACES, false)]),+ "sketch.intersect" => {+ let bodies = s.selection.iter().any(|sel| matches!(sel, Sel::Body { .. }));+ Dialog::new(+ Kind::SketchIntersect { bodies, projection_link: true },+ vec![SelInput::new("ui.sketch_intersect_geometry", if bodies { BODIES } else { FACES }, true)],+ )+ }+ "sketch.project" => {+ let bodies = s.selection.iter().any(|sel| matches!(sel, Sel::Body { .. }));+ Dialog::new(+ Kind::SketchProject { bodies, projection_link: true },+ vec![SelInput::new("ui.sketch_project_geometry", if bodies { BODIES } else { PROJECT_GEOMETRY }, true)],+ )+ }"solid.extrude" => Dialog::new(Kind::Extrude {distance: length_default(s, "10"),@@ -2122,6 +2146,8 @@ fn publish_check(ui: &egui::Ui, response: &egui::Response, selected: bool) {fn title(k: &Kind) -> &'static str {match k {Kind::Sketch => "CREATE SKETCH",+ Kind::SketchIntersect { .. } => "INTERSECT",+ Kind::SketchProject { .. } => "PROJECT",Kind::Extrude { .. } => "EXTRUDE",Kind::Revolve { .. } => "REVOLVE",Kind::Fillet { chamfer: false, .. } => "FILLET",@@ -4752,6 +4778,24 @@ fn dialog_commands(app: &SolveApp, d: &Dialog) -> Result<Vec<(String, Value)>, SKind::EditParam { name, expr } => ("parameters.change", json!({"name": name, "expression": expr})),Kind::Rename { feature, name } => ("timeline.rename", json!({"feature": feature, "name": name})),Kind::ConfirmDelete { features, groups, .. } => ("timeline.delete", crate::timeline::delete_params(features, groups)),+ Kind::SketchIntersect { projection_link, .. } => {+ need(0, "faces or bodies")?;+ let refs = sels(d, 0)+ .iter()+ .map(|sel| match sel {+ Sel::Body { name } => Ok(json!({"body": name})),+ Sel::Face { body, point, .. } => Ok(json!({"face": [point.x, point.y, point.z], "body": body})),+ _ => Err("select faces or bodies".to_string()),+ })+ .collect::<Result<Vec<_>, _>>()?;+ ("sketch.intersect", json!({"refs": refs, "projection_link": projection_link}))+ }+ Kind::SketchProject { projection_link, .. } => {+ need(0, "geometry or bodies")?;+ let refs =+ crate::tools::projection_preselection(sels(d, 0)).ok_or_else(|| "select geometry or bodies that can be projected".to_string())?;+ ("sketch.project", json!({"refs": refs, "projection_link": projection_link}))+ }Kind::Sketch | Kind::Measure { .. } => return Ok(Vec::new()),Kind::Assembly(k) => return crate::dialogs_assembly::commands(app, k, &d.inputs),Kind::Sheet(k) => return crate::dialogs_sheet::commands(app, k, &d.inputs, &d.extra),diff --git a/crates/ui-egui/src/dialogs_dense.rs b/crates/ui-egui/src/dialogs_dense.rsindex 793933d790..2c0701fb3d 100644--- a/crates/ui-egui/src/dialogs_dense.rs+++ b/crates/ui-egui/src/dialogs_dense.rs@@ -19,6 +19,8 @@ pub(super) fn command(kind: &Kind) -> Option<&'static str> {Kind::ViewDxf { .. } => Some("file.export_view_dxf"),Kind::InsertDrawing(p) => Some(if p.command.ends_with("dxf") { "sketch.insert_dxf" } else { "sketch.insert_svg" }),Kind::Sketch => Some("sketch.create"),+ Kind::SketchIntersect { .. } => Some("sketch.intersect"),+ Kind::SketchProject { .. } => Some("sketch.project"),Kind::SketchModify(k) => Some(crate::sketch_modify_ui::command(k)),Kind::Text(_) => Some("sketch.edit_text"),Kind::TextMove(_) => Some("sketch.move"),@@ -212,6 +214,30 @@ pub(super) fn rows(app: &mut SolveApp, ctx: &egui::Context, d: &mut Dialog, ui:}}}+ Kind::SketchIntersect { bodies, projection_link } => {+ let mut selected = if *bodies { 1 } else { 0 };+ let changed = ui_kit::row(ui, tr("ui.sketch_intersect_selection_filter"), |ui| {+ ui_kit::segmented(ui, &mut selected, &[tr("Faces"), tr("Bodies")], Default::default())+ });+ if changed && let Some(input) = d.inputs.first_mut() {+ *bodies = selected == 1;+ input.accept = if *bodies { BODIES } else { FACES };+ input.items.clear();+ }+ ui_kit::row(ui, tr("ui.sketch_intersect_projection_link"), |ui| ui_kit::checkbox(ui, "", projection_link));+ }+ Kind::SketchProject { bodies, projection_link } => {+ let mut selected = if *bodies { 1 } else { 0 };+ let changed = ui_kit::row(ui, tr("ui.sketch_intersect_selection_filter"), |ui| {+ ui_kit::segmented(ui, &mut selected, &[tr("Geometry"), tr("Bodies")], Default::default())+ });+ if changed && let Some(input) = d.inputs.first_mut() {+ *bodies = selected == 1;+ input.accept = if *bodies { BODIES } else { super::PROJECT_GEOMETRY };+ input.items.clear();+ }+ ui_kit::row(ui, tr("ui.sketch_intersect_projection_link"), |ui| ui_kit::checkbox(ui, "", projection_link));+ }Kind::SketchModify(k) => enter |= crate::sketch_modify_ui::rows(ui, k, &app.session.doc),Kind::Text(k) => enter |= crate::sketch_text::rows(ui, k, &mut d.inputs, &mut d.active),Kind::TextMove(k) => enter |= crate::sketch_text_move::rows(ui, k),diff --git a/crates/ui-egui/src/dialogs_sketch_tests.rs b/crates/ui-egui/src/dialogs_sketch_tests.rsindex f28699998d..c58298fc03 100644--- a/crates/ui-egui/src/dialogs_sketch_tests.rs+++ b/crates/ui-egui/src/dialogs_sketch_tests.rs@@ -101,6 +101,82 @@ fn create_sketch_uses_card_and_still_starts_immediately_on_plane_pick() {assert!(h.app.session.active_sketch.is_some());}+#[test]+fn intersect_dialog_filters_faces_or_whole_bodies_and_controls_projection_link() {+ let mut h = Harness::new();+ h.app.run("solid.box", json!({"length":40,"width":30,"height":20,"body_name":"Post"})).unwrap();+ h.app.run("sketch.create", json!({"plane":"XY","offset":10})).unwrap();+ h.app.session.selection = vec![Sel::Body { name: "Post".into() }];+ h.app.start("sketch.intersect");+ h.frames(4);++ let d = h.app.dialog.as_ref().expect("Intersect opens an options dialog");+ assert!(matches!(d.kind, Kind::SketchIntersect { bodies: true, projection_link: true }));+ assert_eq!(d.inputs[0].accept, super::BODIES);+ assert_eq!(d.inputs[0].items, vec![Sel::Body { name: "Post".into() }]);+ assert!(scenario::rect_of("dialog:row:ui.sketch_intersect_geometry").is_some());+ assert!(scenario::handle_at("dialog:Selection Filter:Faces").is_some());+ assert!(scenario::handle_at("dialog:Selection Filter:Bodies").is_some());+ assert!(scenario::rect_of("dialog:row:Projection Link").is_some());++ h.step(&json!({"click":{"handle":"dialog:Selection Filter:Faces"}})).unwrap();+ assert_eq!(h.app.dialog.as_ref().unwrap().inputs[0].accept, super::FACES);+ assert!(h.app.dialog.as_ref().unwrap().inputs[0].items.is_empty());+ h.step(&json!({"click":{"handle":"dialog:Selection Filter:Bodies"}})).unwrap();+ assert_eq!(h.app.dialog.as_ref().unwrap().inputs[0].accept, super::BODIES);+ h.step(&json!({"click":{"handle":"dialog:Projection Link"}})).unwrap();+ assert!(matches!(h.app.dialog.as_ref().unwrap().kind, Kind::SketchIntersect { projection_link: false, .. }));++ {+ let d = h.app.dialog.as_mut().unwrap();+ d.inputs[0].items = vec![Sel::Body { name: "Post".into() }];+ }+ let d = h.app.dialog.as_ref().unwrap();+ assert_eq!(apply_commands(&h.app, d).unwrap(), vec![("sketch.intersect".into(), json!({"refs":[{"body":"Post"}],"projection_link":false}))]);+}++#[test]+fn project_dialog_keeps_geometry_targets_and_can_project_whole_bodies_unlinked() {+ let mut h = Harness::new();+ h.app.run("solid.box", json!({"length":40,"width":30,"height":20,"body_name":"Plate"})).unwrap();+ h.app.run("sketch.create", json!({"plane":"XY","offset":10})).unwrap();+ h.app.session.selection = vec![Sel::Body { name: "Plate".into() }];+ h.app.start("sketch.project");+ h.frames(4);++ let d = h.app.dialog.as_ref().expect("Project opens an options dialog");+ assert!(matches!(d.kind, Kind::SketchProject { bodies: true, projection_link: true }));+ assert_eq!(d.inputs[0].accept, super::BODIES);+ assert_eq!(d.inputs[0].items, vec![Sel::Body { name: "Plate".into() }]);+ assert!(scenario::handle_at("dialog:Selection Filter").is_some());+ assert!(scenario::rect_of("dialog:row:Projection Link").is_some());++ h.step(&json!({"click":{"handle":"dialog:Selection Filter"}})).unwrap();+ assert!(scenario::handle_at("dialog:Selection Filter:Geometry").is_some());+ h.step(&json!({"click":{"handle":"dialog:Selection Filter:Geometry"}})).unwrap();+ assert_eq!(h.app.dialog.as_ref().unwrap().inputs[0].accept, super::PROJECT_GEOMETRY);+ assert!(h.app.dialog.as_ref().unwrap().inputs[0].items.is_empty());+ h.step(&json!({"click":{"handle":"dialog:Selection Filter"}})).unwrap();+ h.step(&json!({"click":{"handle":"dialog:Selection Filter:Bodies"}})).unwrap();+ h.step(&json!({"click":{"handle":"dialog:Projection Link"}})).unwrap();+ assert!(matches!(h.app.dialog.as_ref().unwrap().kind, Kind::SketchProject { projection_link: false, .. }));++ {+ let d = h.app.dialog.as_mut().unwrap();+ d.inputs[0].items = vec![Sel::Body { name: "Plate".into() }];+ }+ let d = h.app.dialog.as_ref().unwrap();+ assert_eq!(apply_commands(&h.app, d).unwrap(), vec![("sketch.project".into(), json!({"refs":[{"body":"Plate"}],"projection_link":false}))]);+ h.step(&json!({"click":{"handle":"dialog:ok"}})).unwrap();+ h.settle();+ assert!(h.app.dialog.is_none());+ let sketch = h.app.session.active_sketch.expect("Project leaves the sketch active");+ let state = h.app.session.world_state();+ let sketch = &state.sketch(sketch).unwrap().sketch;+ assert!(sketch.links.is_empty());+ assert!(!sketch.curves.is_empty());+}+#[test]fn apply_commits_once_keeps_values_and_waits_for_new_selection_ok_closes() {for command in ["sketch.offset", "sketch.mirror", "sketch.pattern.rectangular", "sketch.pattern.circular"] {diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rsindex f4ba4e0a92..8862391399 100644--- a/crates/ui-egui/src/lib.rs+++ b/crates/ui-egui/src/lib.rs@@ -1704,6 +1704,19 @@ impl SolveApp {{self.last_command = Some((spec.id.to_string(), spec.label.to_string()));}+ if id == "sketch.project"+ && self.preferences.project_options_dialog+ && let Some(mut d) = dialogs::Dialog::for_command(self, id)+ {+ if let Some(sketch) = finished_sketch {+ d.take_sketch_profile(&self.session, sketch);+ }+ if d.wants_picks() && !self.session.selection.is_empty() {+ let _ = self.session.execute("select.clear", &json!({}));+ }+ self.dialog = Some(d);+ return;+ }if let Some(mut t) = tools::Tool::for_command(id) {let state = self.session.world_state();let sketch = self.session.active_sketch.and_then(|s| state.sketch(s)).map(|ss| &ss.sketch);diff --git a/crates/ui-egui/src/prefs.rs b/crates/ui-egui/src/prefs.rsindex a1bc93599d..0a8461d193 100644--- a/crates/ui-egui/src/prefs.rs+++ b/crates/ui-egui/src/prefs.rs@@ -1224,6 +1224,8 @@ preference_settings! {suppress_sketch_snap: ModifierCombo = ModifierCombo::CTRL_ALT, PAGE_SKETCH;/// Temporary horizontal/vertical guides from hovered centres and edge midpoints.sketch_tracking_guides: bool = true, PAGE_SKETCH;+ /// Open Project's options before picking; off restores its previous direct-pick workflow.+ project_options_dialog: bool = true, PAGE_SKETCH;/// Whether Alt/Option also frees gizmo / canvas manipulator arrows (Primary always does).manipulator_free_alt: bool = true, PAGE_SKETCH;/// A sketch's icon in History and the browser takes the colour of its solve state, and itsdiff --git a/crates/ui-egui/src/prefs/sketch.rs b/crates/ui-egui/src/prefs/sketch.rsindex 3ace7d3f11..87facca5e4 100644--- a/crates/ui-egui/src/prefs/sketch.rs+++ b/crates/ui-egui/src/prefs/sketch.rs@@ -11,6 +11,8 @@ pub(super) fn show(app: &mut SolveApp, ui: &mut egui::Ui) {if ui_kit::checkbox(ui, crate::i18n::tr_label("Project face edges into new sketches"), &mut auto).changed() {let _ = app.run("sketch.auto_project", json!({"value": auto}));}+ ui_kit::checkbox(ui, app.tr("prefs.project_options_dialog"), &mut app.preferences.project_options_dialog)+ .on_hover_text(app.tr("prefs.project_options_dialog_note"));ui_kit::checkbox(ui, crate::i18n::tr_label("Pressing a tool's shortcut again switches its mode"), &mut app.preferences.shortcut_cycles_modes).on_hover_text(crate::i18n::tr_label("Before the first point, pressing a sketch tool's shortcut again steps through its creation modes. Off: it starts the tool again.",diff --git a/crates/ui-egui/src/select_other.rs b/crates/ui-egui/src/select_other.rsindex 9afd44cd02..320c8bd6c3 100644--- a/crates/ui-egui/src/select_other.rs+++ b/crates/ui-egui/src/select_other.rs@@ -267,13 +267,14 @@ fn sketch_name(app: &SolveApp, sketch: u64) -> String {}/// "Line 3" (its kind and number), with what kind of geometry it is when that matters.-fn curve_label(sk: &solidcraft_engine::sketch::Sketch, id: &str) -> String {+pub(crate) fn curve_label(sk: &solidcraft_engine::sketch::Sketch, id: &str) -> String {if let Some((i, c)) = sk.curves.iter().enumerate().find(|(_, c)| c.id == id) {let kind = curve_kind_name(&c.kind);let n = id_number(id).unwrap_or_else(|| sk.curves.iter().take(i + 1).filter(|x| curve_kind_name(&x.kind) == kind).count() as u64);let mut s = format!("{kind} {n}");- if c.link.is_some() {- s.push_str(" (projected)");+ if let Some(link) = &c.link {+ let kind = sk.links.iter().find(|l| &l.id == link).map(|l| l.kind);+ s.push_str(if kind == Some(solidcraft_engine::sketch::LinkKind::Intersect) { " (intersected)" } else { " (projected)" });} else if c.construction {s.push_str(" (construction)");}diff --git a/crates/ui-egui/src/select_other_tests.rs b/crates/ui-egui/src/select_other_tests.rsindex 258988f863..28d2759d76 100644--- a/crates/ui-egui/src/select_other_tests.rs+++ b/crates/ui-egui/src/select_other_tests.rs@@ -615,3 +615,22 @@ fn a_small_body_on_a_large_one_is_not_picked_through() {assert!(point.x > 0.9, "at {distance} mm away the pick is behind the near face: {first:?}");}}++#[test]+fn a_curve_from_intersect_is_labelled_intersected_and_one_from_project_projected() {+ use solidcraft_engine::sketch::LinkKind;+ let mut h = Harness::new();+ h.app.run("solid.box", json!({"length":40,"width":10,"height":10,"body_name":"Block"})).unwrap();+ let label = |h: &Harness, kind: LinkKind| {+ let sk = h.app.session.doc.sketch(h.app.session.active_sketch.unwrap()).unwrap();+ let c = sk.curves.iter().find(|c| c.link.as_deref().and_then(|l| sk.link(l)).is_some_and(|l| l.kind == kind)).unwrap();+ crate::select_other::curve_label(sk, &c.id)+ };+ h.app.run("sketch.create", json!({"plane":"XY","offset":5,"project_edges":false})).unwrap();+ h.app.run("sketch.intersect", json!({"refs":[{"body":"Block"}]})).unwrap();+ assert!(label(&h, LinkKind::Intersect).ends_with("(intersected)"));+ h.app.run("sketch.finish", json!({})).unwrap();+ h.app.run("sketch.create", json!({"plane":"XY","offset":20,"project_edges":false})).unwrap();+ h.app.run("sketch.project", json!({"refs":[{"body":"Block"}]})).unwrap();+ assert!(label(&h, LinkKind::Project).ends_with("(projected)"));+}diff --git a/crates/ui-egui/src/sketch_shortcut_tests.rs b/crates/ui-egui/src/sketch_shortcut_tests.rsindex 1b9c2557fb..2776a6120d 100644--- a/crates/ui-egui/src/sketch_shortcut_tests.rs+++ b/crates/ui-egui/src/sketch_shortcut_tests.rs@@ -81,11 +81,28 @@ fn sketch_keys_outside_a_sketch_sketch_on_the_selected_plane_and_start_their_tooassert!(h.app.session.active_sketch.is_some(), "{key}: no sketch opened");assert_eq!(h.app.session.world_state().sketches.len(), 1, "{key}");assert!(normal(&h).y.abs() > 0.999, "{key}: not on XZ: {:?}", normal(&h));- assert_eq!(tool(&h), Some(cmd), "{key}");- assert!(h.app.dialog.is_none(), "{key}: dialog left open");+ if cmd == "sketch.project" {+ assert!(h.app.preferences.project_options_dialog, "{key}: options are enabled by default");+ assert!(matches!(h.app.dialog.as_ref().map(|d| &d.kind), Some(crate::dialogs::Kind::SketchProject { .. })), "{key}");+ assert!(tool(&h).is_none(), "{key}: Project should open its options dialog");+ } else {+ assert_eq!(tool(&h), Some(cmd), "{key}");+ assert!(h.app.dialog.is_none(), "{key}: dialog left open");+ }}}+#[test]+fn project_can_keep_its_previous_direct_pick_workflow() {+ let mut h = Harness::new();+ h.app.preferences.project_options_dialog = false;+ h.app.run("sketch.create", json!({"plane":"XY"})).unwrap();+ h.app.start("sketch.project");+ h.settle();+ assert!(h.app.dialog.is_none());+ assert_eq!(tool(&h), Some("sketch.project"));+}+#[test]fn a_sketch_key_sketches_on_the_selected_planar_face() {let mut h = Harness::new();diff --git a/crates/ui-egui/src/sketch_tools.rs b/crates/ui-egui/src/sketch_tools.rsindex 46b9d4baa8..0a8fa3a9ff 100644--- a/crates/ui-egui/src/sketch_tools.rs+++ b/crates/ui-egui/src/sketch_tools.rs@@ -277,6 +277,15 @@ fn marks(app: &SolveApp, painter: &egui::Painter, proj: &Proj) {/// Commands that start with a step of their own: Canvas and Decal ask for the image first,/// Edit Canvas opens the canvas panel. False when the command should not go on.pub fn start_hook(app: &mut SolveApp, id: &str) -> bool {+ if id == "sketch.intersect"+ && let Some(dialog) = crate::dialogs::Dialog::for_command(app, id)+ {+ if dialog.wants_picks() && !app.session.selection.is_empty() {+ let _ = app.session.execute("select.clear", &json!({}));+ }+ app.dialog = Some(dialog);+ return false;+ }if id == "sketch.edit_text"&& let Some(dialog) = crate::dialogs::Dialog::for_command(app, id){diff --git a/crates/ui-egui/tests/projection_preselection.rs b/crates/ui-egui/tests/projection_preselection.rsindex 28ffdef422..116b8f3e48 100644--- a/crates/ui-egui/tests/projection_preselection.rs+++ b/crates/ui-egui/tests/projection_preselection.rs@@ -4,6 +4,8 @@ use solidcraft_ui_egui::scenario::Harness;fn setup() -> (Harness, u64) {let mut h = Harness::new();+ // These cover the direct pick workflow; the options dialog is covered in dialogs_sketch_tests.+ h.app.preferences.project_options_dialog = false;let source = h.app.run("sketch.create", json!({"plane":"XY","offset":10})).unwrap()["sketch"].as_u64().unwrap();h.app.run("sketch.line", json!({"points":[[10,10],[30,10]],"infer":false})).unwrap();h.app.run("sketch.point", json!({"point":[20,20],"id":"p"})).unwrap();