From fb87cde6a1b96ce66990796d0ac94148f9f46d4e Mon Sep 17 00:00:00 2001 From: fkirill Date: Tue, 20 Oct 2026 16:26:19 +0000 Subject: [PATCH] Sketch: persist Shift-picked midpoints with ordinary constraints (#2087) (#2378) --- ROADMAP.md | 2 +- crates/engine/src/cmd/sketch.rs | 62 +++++- .../src/cmd/sketch_constraints_tests.rs | 199 ++++++++++++++++++ crates/ui-egui/src/sketch_tools.rs | 1 + crates/ui-egui/src/tools.rs | 81 +++++-- crates/ui-egui/src/viewport.rs | 20 +- crates/ui-egui/tests/point_alignment.rs | 168 ++++++++++++++- docs/book/src/guide/sketching.md | 17 +- 8 files changed, 512 insertions(+), 38 deletions(-) diff --git a/ROADMAP.md b/ROADMAP.md index c7b5de281..c269a33ec 100644 --- a/ROADMAP.md +++ b/ROADMAP.md @@ -50,7 +50,7 @@ PCB / Package, Render, Animation, Simulation, Manufacture/CAM, Drawings. | # | Milestone | Status | Hours left | |---|---|---|---| | M0 | Vertical slice | done | — | -| M1 | Sketch depth: command coverage implemented — projection/intersect/include as linked geometry (auto-project on faces, lost-reference warnings, break link), full SKETCH create/modify set (slots, polygons, tangent arcs/circles, ellipse, fit/control splines, conic, text, trim/extend/break, fillet/chamfer, offset, mirror, patterns, move/scale, blend curve, centerline), constraints incl. curvature and polygon with over-constraint refusal, driven/arc-length/linear-diameter dimensions, AutoConstrain, DXF/SVG insert, 3D sketch curves (Project To Surface, Intersection Curve, Isoparametric Curve, Spun Profile), exact free-form profiles (B-spline/NURBS edges, any spline degree, curves cut by crossings), sweeps and pipes along 3D sketch curves, canvases and decals, curvature combs. Exact free-form Extend and certified associative offsets now preserve geometry and IDs through edits, deletion and reopen. Occurrence-frame 3D wires now store explicit coordinate spaces and retain points and analytic fits through moves, refresh, undo and reopen. Constructive sketch solving (Owen 1991, Fudos & Hoffmann 1997) ahead of the numerical solver: points and rigid clusters are placed on the branch the sketch had, so dimension edits and drags keep their solution; edits that would turn a sketch over are refused; drags re-solve only the sketch per frame. Remaining workflow repairs: mixed offset junctions, legacy natural-spline seams, and damaged legacy wire links lacking frame provenance | in progress | 4 | +| M1 | Sketch depth: command coverage implemented — projection/intersect/include as linked geometry (auto-project on faces, lost-reference warnings, break link), full SKETCH create/modify set (slots, polygons, tangent arcs/circles, ellipse, fit/control splines, conic, text, trim/extend/break, fillet/chamfer, offset, mirror, patterns, move/scale, blend curve, centerline), constraints incl. curvature and polygon with over-constraint refusal, Shift-picked line midpoints in Horizontal/Vertical using persisted points and ordinary constraints (#2087), driven/arc-length/linear-diameter dimensions, AutoConstrain, DXF/SVG insert, 3D sketch curves (Project To Surface, Intersection Curve, Isoparametric Curve, Spun Profile), exact free-form profiles (B-spline/NURBS edges, any spline degree, curves cut by crossings), sweeps and pipes along 3D sketch curves, canvases and decals, curvature combs. Exact free-form Extend and certified associative offsets now preserve geometry and IDs through edits, deletion and reopen. Occurrence-frame 3D wires now store explicit coordinate spaces and retain points and analytic fits through moves, refresh, undo and reopen. Constructive sketch solving (Owen 1991, Fudos & Hoffmann 1997) ahead of the numerical solver: points and rigid clusters are placed on the branch the sketch had, so dimension edits and drags keep their solution; edits that would turn a sketch over are refused; drags re-solve only the sketch per frame. Remaining workflow repairs: mixed offset junctions, legacy natural-spline seams, and damaged legacy wire links lacking frame provenance | in progress | 4 | | M2 | Robust modelling: coplanar booleans in the kernel, holes (placed on faces and on sketch points), threads (cosmetic, then modelled), patterns, mirror, shell, draft, split, construction geometry | in progress | 16 | | M3 | General fillets and chamfers (curved edges, chains, vertex blends); saddle rolling-ball surfaces now use continuous seam sections and arc-length fitting with shared contact boundaries and bounded accuracy checks; tiny rim edges remain selected instead of nearby wall seams when filleting (#2498) | in progress | 30 | | M4 | Files: STEP import (done — [docs/step-import.md](docs/step-import.md)), FreeCAD/Rhino solids through cadmpeg (done, desktop and CLI), 3MF export and 3MF/STL import as mesh bodies (done), 3MF with B-rep face tags ([docs/formats/3mf-face-tags.md](docs/formats/3mf-face-tags.md), done), constant-section parametric mesh reconstruction, DXF sketches, OBJ import | in progress | 6 | diff --git a/crates/engine/src/cmd/sketch.rs b/crates/engine/src/cmd/sketch.rs index 77c1b4f7f..63f827732 100644 --- a/crates/engine/src/cmd/sketch.rs +++ b/crates/engine/src/cmd/sketch.rs @@ -117,7 +117,7 @@ pub static COMMANDS: &[CommandSpec] = &[ .at("SKETCH", "CONSTRAINTS") .icon("c_hv") .enabled(in_sketch) - .params("line: id | points: [a, b]; mode?: horizontal|vertical"), + .params("line: id | points: [a, b] (point ids or {midpoint: line_id}; accepted midpoints reuse or create a point with a Midpoint constraint); mode?: horizontal|vertical"), CommandSpec::new("sketch.constraint.coincident", "Coincident", c_coincident) .at("SKETCH", "CONSTRAINTS") .icon("c_coincident") @@ -1625,14 +1625,68 @@ pub(super) fn residual_of(sk: &Sketch, id: &str) -> Option { sk.constraints.iter().position(|c| c.id == id).and_then(|ci| solidcraft_sketch::constraint_residual(sk, ci)) } +/// Temporary pick intent. Saved sketches use ordinary points and constraints only. +#[derive(Clone, Copy, PartialEq, Eq)] +enum AlignmentTarget { + Point(usize), + Midpoint(usize), +} + +impl AlignmentTarget { + fn materialize(self, sk: &mut Sketch) -> Result { + match self { + Self::Point(p) => Ok(p), + Self::Midpoint(l) => { + // Reuse an existing associative midpoint, including one created by drawing. + // Coincident coordinates alone are insufficient: its relationship must exist. + if let Some(p) = sk.constraints.iter().find_map(|c| match c.kind { + ConstraintKind::Midpoint { p, l: line } if line == l && !c.driven => Some(p), + _ => None, + }) { + return Ok(p); + } + let cmd = "sketch.constraint.horizontal_vertical"; + let (a, b) = line_pts(sk, l).ok_or_else(|| bad(cmd, "a midpoint reference needs a line"))?; + let p = sk.add_point((a + b) * 0.5, None)?; + add_c(sk, ConstraintKind::Midpoint { p, l })?; + Ok(p) + } + } + } +} + fn c_horizontal_vertical(s: &mut Session, p: &Value) -> Result { let cmd = "sketch.constraint.horizontal_vertical"; let mode = str_(p, "mode").map(str::to_ascii_lowercase); constrain(s, p, cmd, |sk| { if let Some(pts) = p.get("points").and_then(Value::as_array) { - let a = point_ref(sk, pts.first(), cmd, "points[0]")?; - let b = point_ref(sk, pts.get(1), cmd, "points[1]")?; - let d = sk.point(b).unwrap_or_default() - sk.point(a).unwrap_or_default(); + if pts.len() != 2 { + return Err(bad(cmd, "`points` needs exactly two point references")); + } + let target = |v: &Value| -> Result { + if let Some(line) = v.get("midpoint") { + let l = curve_ref(sk, Some(line), cmd, "midpoint")?; + if !matches!(sk.curves.get(l).map(|c| &c.kind), Some(CurveKind::Line { .. })) { + return Err(bad(cmd, "a midpoint reference needs a line")); + } + Ok(AlignmentTarget::Midpoint(l)) + } else { + Ok(AlignmentTarget::Point(point_ref(sk, Some(v), cmd, "points")?)) + } + }; + // Validate both intents before materializing either. Hover and a pending first + // pick never change the sketch; this command accepts both in one undo step. + let a = target(pts.first().ok_or_else(|| bad(cmd, "missing first point"))?)?; + let b = target(pts.get(1).ok_or_else(|| bad(cmd, "missing second point"))?)?; + if a == b { + return Err(bad(cmd, "alignment needs two distinct point references")); + } + let a = a.materialize(sk)?; + let b = b.materialize(sk)?; + if a == b { + return Err(bad(cmd, "alignment needs two distinct points")); + } + let d = sk.point(b).ok_or_else(|| bad(cmd, "invalid second point"))? - sk.point(a).ok_or_else(|| bad(cmd, "invalid first point"))?; let horiz = match mode.as_deref() { Some("horizontal") => true, Some("vertical") => false, diff --git a/crates/engine/src/cmd/sketch_constraints_tests.rs b/crates/engine/src/cmd/sketch_constraints_tests.rs index de5e2e114..f835ded7e 100644 --- a/crates/engine/src/cmd/sketch_constraints_tests.rs +++ b/crates/engine/src/cmd/sketch_constraints_tests.rs @@ -373,3 +373,202 @@ fn symmetry_moves_a_free_line_between_two_fixed_lines() { assert!((at(end).x - x).abs() < 1e-9, "{end} moved to {:?}", at(end)); } } + +#[test] +fn midpoint_alignment_persists_undoes_and_survives_endpoint_edits() { + use solidcraft_sketch::ConstraintKind; + for mode in ["horizontal", "vertical"] { + for reverse in [false, true] { + let mut s = new_sketch(); + run(&mut s, "sketch.line", json!({"points":[[10,10],[30,20]],"infer":false,"connect":false})); + run(&mut s, "sketch.point", json!({"point":[24,40],"id":"target"})); + let before = s.doc.to_json(); + let undo = s.undo.len(); + let refs = if reverse { json!(["target",{"midpoint":"l1"}]) } else { json!([{"midpoint":"l1"},"target"]) }; + let result = run(&mut s, "sketch.constraint.horizontal_vertical", json!({"points":refs,"mode":mode})); + assert_eq!(result["created"]["points"].as_array().unwrap().len(), 1); + assert_eq!(result["created"]["constraints"].as_array().unwrap().len(), 2); + assert_eq!(result["sketch"]["dof"], 5, "H/V removes one degree of freedom; the midpoint adds none"); + assert!(result["created"]["curves"].as_array().unwrap().is_empty()); + assert_eq!(s.undo.len(), undo + 1); + let after = s.doc.to_json(); + run(&mut s, "edit.undo", json!({})); + assert_eq!(s.doc.to_json(), before); + run(&mut s, "edit.redo", json!({})); + assert_eq!(s.doc.to_json(), after); + let mut reopened = Session::new(solidcraft_doc::Document::from_json(&after).unwrap()); + reopened.active_sketch = s.active_sketch; + for end in [[50., -15.], [-20., 65.]] { + run(&mut reopened, "sketch.move_point", json!({"point":"l1.end","to":end})); + let sk = sketch(&reopened); + let point = sk.point(sk.resolve_point("target").unwrap()).unwrap(); + let mid = line_midpoint(&sk, "l1"); + assert!((if mode == "horizontal" { point.y - mid.y } else { point.x - mid.x }).abs() < 1e-6); + assert_eq!(sk.points.len(), 5); + } + let sk = sketch(&reopened); + assert!(sk.constraints.iter().any(|c| matches!(c.kind, ConstraintKind::Midpoint { .. }))); + assert!(sk.constraints.iter().any(|c| matches!(c.kind, ConstraintKind::HorizontalPoints { .. } | ConstraintKind::VerticalPoints { .. }))); + run(&mut reopened, "sketch.delete", json!({"entities":["l1"]})); + assert!(!sketch(&reopened).constraints.iter().any(|c| matches!(c.kind, ConstraintKind::Midpoint { .. }))); + assert!(sketch(&reopened).constraints.iter().any(|c| c.id == result["constraint"].as_str().unwrap())); + } + } +} + +#[test] +fn midpoint_alignment_rejects_invalid_or_conflicting_references_atomically() { + let mut s = new_sketch(); + run(&mut s, "sketch.line", json!({"points":[[10,10],[30,20]],"infer":false,"connect":false})); + run(&mut s, "sketch.circle.center", json!({"center":[40,50],"radius":3})); + run(&mut s, "sketch.constraint.fix", json!({"entities":["l1","c1"]})); + for points in [ + json!([{"midpoint":"l1"},"c1.center"]), + json!([{"midpoint":"c1"},"origin"]), + json!([{"midpoint":"missing"},"origin"]), + json!([{"midpoint":"l1"},{"midpoint":"l1"}]), + json!([{"midpoint":12},"origin"]), + json!([{"midpoint":"l1"}]), + json!([{"midpoint":"l1"},"origin","c1.center"]), + ] { + let before = s.doc.to_json(); + let undo = s.undo.len(); + assert!(s.execute("sketch.constraint.horizontal_vertical", &json!({"points":points,"mode":"vertical"})).is_err(), "{points}"); + assert_eq!(s.doc.to_json(), before); + assert_eq!(s.undo.len(), undo); + } +} + +fn line_midpoint(sk: &solidcraft_sketch::Sketch, id: &str) -> Vec2 { + // Read the curve's current endpoints: after a corner cut an original endpoint + // id can still name the retained construction side's corner. + let solidcraft_sketch::CurveKind::Line { a, b } = sk.curves[sk.curve_index(id).unwrap()].kind else { panic!("expected line") }; + (sk.point(a).unwrap() + sk.point(b).unwrap()) * 0.5 +} + +#[test] +fn midpoint_alignment_reuses_associative_points_and_rejects_self_alignment() { + use solidcraft_sketch::ConstraintKind; + let mut s = new_sketch(); + run(&mut s, "sketch.line", json!({"points":[[10,10],[30,20]],"infer":false,"connect":false})); + // A drawing-time midpoint is an ordinary, reusable point too. + run(&mut s, "sketch.line", json!({"points":["mid:l1",[20,40]],"infer":false,"connect":false})); + run(&mut s, "sketch.point", json!({"point":[24,50],"id":"target"})); + let count = sketch(&s).points.len(); + let result = run(&mut s, "sketch.constraint.horizontal_vertical", json!({"points":[{"midpoint":"l1"},"target"],"mode":"vertical"})); + assert!(result["created"]["points"].as_array().unwrap().is_empty()); + assert_eq!(result["created"]["constraints"].as_array().unwrap().len(), 1); + let sk = sketch(&s); + assert_eq!(sk.points.len(), count); + assert_eq!(sk.constraints.iter().filter(|c| matches!(c.kind, ConstraintKind::Midpoint { .. })).count(), 1); + for refs in [json!([{"midpoint":"l1"},"l2.start"]), json!(["l2.start",{"midpoint":"l1"}])] { + let before = s.doc.to_json(); + let undo = s.undo.len(); + assert!(s.execute("sketch.constraint.horizontal_vertical", &json!({"points":refs})).is_err()); + assert_eq!(s.doc.to_json(), before); + assert_eq!(s.undo.len(), undo); + } +} + +#[test] +fn midpoint_alignment_constraints_delete_independently_and_leave_the_point() { + use solidcraft_sketch::ConstraintKind; + for delete_midpoint in [false, true] { + let mut s = new_sketch(); + run(&mut s, "sketch.line", json!({"points":[[10,10],[30,20]],"infer":false,"connect":false})); + run(&mut s, "sketch.point", json!({"point":[24,40],"id":"target"})); + run(&mut s, "sketch.constraint.fix", json!({"entity":"l1"})); + let result = run(&mut s, "sketch.constraint.horizontal_vertical", json!({"points":[{"midpoint":"l1"},"target"],"mode":"vertical"})); + let sk = sketch(&s); + let helper = result["created"]["points"][0].as_str().unwrap().to_string(); + let mid = sk.constraints.iter().find(|c| matches!(c.kind, ConstraintKind::Midpoint { .. })).unwrap().id.clone(); + let hv = result["constraint"].as_str().unwrap().to_string(); + let deleted = if delete_midpoint { &mid } else { &hv }; + let retained = if delete_midpoint { &hv } else { &mid }; + let before = s.doc.to_json(); + run(&mut s, "sketch.delete", json!({"entities":[deleted]})); + let sk = sketch(&s); + assert!(sk.resolve_point(&helper).is_some()); + assert!(sk.constraints.iter().any(|c| &c.id == retained)); + assert!(!sk.constraints.iter().any(|c| &c.id == deleted)); + assert_eq!(sk.points.len(), 5); + let after = s.doc.to_json(); + run(&mut s, "edit.undo", json!({})); + assert_eq!(s.doc.to_json(), before); + run(&mut s, "edit.redo", json!({})); + assert_eq!(s.doc.to_json(), after); + let mut reopened = Session::new(solidcraft_doc::Document::from_json(&after).unwrap()); + reopened.active_sketch = s.active_sketch; + assert_eq!(sketch(&reopened).points.len(), 5); + if delete_midpoint { + // Once its defining relation is deleted it is an ordinary free point. + run(&mut reopened, "sketch.move_point", json!({"point":helper,"to":[55,65]})); + let sk = sketch(&reopened); + let helper = sk.point(sk.resolve_point(&helper).unwrap()).unwrap(); + let target = sk.point(sk.resolve_point("target").unwrap()).unwrap(); + assert!((helper.x - target.x).abs() < 1e-6); + assert!(helper.dist(line_midpoint(&sk, "l1")) > 1.0); + } else { + run(&mut reopened, "sketch.move_point", json!({"point":"target","to":[55,65]})); + let sk = sketch(&reopened); + let helper = sk.point(sk.resolve_point(&helper).unwrap()).unwrap(); + assert!(helper.dist(line_midpoint(&sk, "l1")) < 1e-6); + assert!((sk.point(sk.resolve_point("target").unwrap()).unwrap().x - helper.x).abs() > 1.0); + } + } +} + +#[test] +fn midpoint_alignment_keeps_original_side_after_fillet_and_chamfer() { + use solidcraft_sketch::ConstraintKind; + for (command, params) in + [("sketch.fillet", json!({"point":"l1.end","radius":3})), ("sketch.chamfer.equal_distance", json!({"point":"l1.end","distance":3}))] + { + let mut s = new_sketch(); + run(&mut s, "sketch.line", json!({"points":[[10,10],[50,10],[50,40]],"infer":true})); + run(&mut s, "sketch.point", json!({"point":[32,60],"id":"target"})); + let aligned = run(&mut s, "sketch.constraint.horizontal_vertical", json!({"points":[{"midpoint":"l1"},"target"],"mode":"vertical"})); + let helper = aligned["created"]["points"][0].as_str().unwrap(); + let before = sketch(&s); + let original_mid = before.point(before.resolve_point(helper).unwrap()).unwrap(); + run(&mut s, command, params); + let after = s.doc.to_json(); + let mut reopened = Session::new(solidcraft_doc::Document::from_json(&after).unwrap()); + reopened.active_sketch = s.active_sketch; + let sk = sketch(&reopened); + let (point, line) = sk + .constraints + .iter() + .find_map(|c| match c.kind { + ConstraintKind::Midpoint { p, l } => Some((p, l)), + _ => None, + }) + .unwrap(); + assert!(sk.curves[line].construction); + let mid = sk.point(point).unwrap(); + assert!(mid.dist(original_mid) < 1e-5, "{command}: {mid:?} vs {original_mid:?}"); + assert!((sk.point(sk.resolve_point("target").unwrap()).unwrap().x - mid.x).abs() < 1e-6); + assert!(mid.dist(line_midpoint(&sk, "l1")) > 0.5, "midpoint belongs to original full side"); + assert!(mid.dist(line_midpoint(&sk, &sk.curves[line].id)) < 1e-6); + } +} + +#[test] +fn midpoint_alignment_remaps_after_unrelated_geometry_is_deleted() { + use solidcraft_sketch::ConstraintKind; + let mut s = new_sketch(); + run(&mut s, "sketch.line", json!({"points":[[-30,-20],[-10,-10]],"infer":false,"connect":false})); + run(&mut s, "sketch.line", json!({"points":[[10,10],[30,20]],"infer":false,"connect":false})); + run(&mut s, "sketch.point", json!({"point":[24,40],"id":"target"})); + let result = run(&mut s, "sketch.constraint.horizontal_vertical", json!({"points":[{"midpoint":"l2"},"target"],"mode":"vertical"})); + run(&mut s, "sketch.delete", json!({"entities":["l1"]})); + run(&mut s, "sketch.move_point", json!({"point":"l2.end","to":[60,-10]})); + let sk = sketch(&s); + let helper = sk.point(sk.resolve_point(result["created"]["points"][0].as_str().unwrap()).unwrap()).unwrap(); + assert!(helper.dist(line_midpoint(&sk, "l2")) < 1e-6); + assert!((sk.point(sk.resolve_point("target").unwrap()).unwrap().x - helper.x).abs() < 1e-6); + assert!(sk.constraints.iter().any(|c| matches!(c.kind, ConstraintKind::Midpoint { l: 0, .. }))); + // Deleting the helper itself removes its H/V and Midpoint relationships. + run(&mut s, "sketch.delete", json!({"entities":[result["created"]["points"][0]]})); + assert!(sketch(&s).constraints.is_empty()); +} diff --git a/crates/ui-egui/src/sketch_tools.rs b/crates/ui-egui/src/sketch_tools.rs index 2e702599b..8ae0f8674 100644 --- a/crates/ui-egui/src/sketch_tools.rs +++ b/crates/ui-egui/src/sketch_tools.rs @@ -578,6 +578,7 @@ pub fn tool_for(id: &str) -> Option { pts: Vec::new(), hover: None, picks: Vec::new(), + point_picks: Vec::new(), dims: Vec::new(), dim_history: Vec::new(), dims_stage: usize::MAX, diff --git a/crates/ui-egui/src/tools.rs b/crates/ui-egui/src/tools.rs index c434a46df..31e413f26 100644 --- a/crates/ui-egui/src/tools.rs +++ b/crates/ui-egui/src/tools.rs @@ -78,6 +78,8 @@ pub struct Tool { pub hover: Option<(Vec2, Option)>, /// Picked entity ids. pub picks: Vec, + /// Horizontal/Vertical point references: point ids or `{midpoint: line_id}`. + pub point_picks: Vec, /// Inline dimension boxes for the shape being drawn, the point count they were made for, /// and whether the first box should take the keyboard. pub dims: Vec, @@ -126,6 +128,7 @@ impl Tool { pts: Vec::new(), hover: None, picks: Vec::new(), + point_picks: Vec::new(), dims: Vec::new(), dim_history: Vec::new(), dims_stage: usize::MAX, @@ -145,7 +148,7 @@ pub fn hint(id: &str) -> String { "sketch.arc.three_point" => "Arc: click start, end, then a point on the arc".into(), "sketch.arc.center_point" => "Arc: click centre and start, then click end or type a signed sweep".into(), "sketch.dimension" => "Dimension: pick one or two entities and type the value (or click to place it first); Enter applies".into(), - "sketch.constraint.horizontal_vertical" => "Horizontal/Vertical: pick a line or two points to align".into(), + "sketch.constraint.horizontal_vertical" => "Horizontal/Vertical: pick a line or two points; hold Shift to pick a line midpoint".into(), "sketch.slot.center_to_center" | "sketch.slot.overall" => "Slot: click both ends, then the width".into(), _ if id.starts_with("sketch.constraint.") => "Constraint: pick the sketch entities".into(), _ => crate::sketch_tools::hint(id).unwrap_or_else(|| "Click in the sketch".into()), @@ -163,9 +166,32 @@ fn xy(p: &(Vec2, Option)) -> Value { json!([p.0.x, p.0.y]) } -pub fn on_hover(app: &mut SolveApp, proj: &Proj, pos: Pos2) { +/// Shift exposes a line midpoint as a point target, only in the alignment tool. +fn midpoint_at(app: &SolveApp, proj: &Proj, pos: Pos2, radius: f32) -> Option<(Vec2, String)> { + let sid = app.session.active_sketch?; + let state = app.session.world_state(); + let ss = state.sketch(sid)?; + pick(app, proj, pos).into_iter().find_map(|hit| { + let Hit::SketchCurve { sketch, id, straight: true, .. } = hit else { return None }; + if sketch != sid { + return None; + } + let l = ss.sketch.curve_index(&id)?; + let solidcraft_engine::sketch::Shape::Line { a, b } = ss.sketch.shape(l)? else { return None }; + let mid = (a + b) * 0.5; + let screen = proj.to_screen(ss.plane.to_world(mid))?; + (screen.distance(pos) <= radius).then_some((mid, id)) + }) +} + +pub fn on_hover(app: &mut SolveApp, proj: &Proj, pos: Pos2, shift: bool) { crate::sketch3d::on_hover(app, proj, pos); - let h = if let Some(point) = app.tool.as_ref().and_then(|tool| crate::sketch_tools::periodic_start_snap(app, tool, proj, pos)) { + let midpoint = (shift && app.tool.as_ref().is_some_and(|t| t.kind == Kind::HorizontalVertical)) + .then(|| midpoint_at(app, proj, pos, f32::INFINITY)) + .flatten(); + let h = if let Some((point, _)) = midpoint { + Some((point, Some("Midpoint".into()))) + } else if let Some(point) = app.tool.as_ref().and_then(|tool| crate::sketch_tools::periodic_start_snap(app, tool, proj, pos)) { Some((point, Some("Close smooth loop".into()))) } else { sketch_point_at(app, proj, pos) @@ -175,7 +201,7 @@ pub fn on_hover(app: &mut SolveApp, proj: &Proj, pos: Pos2) { } } -pub fn on_click(app: &mut SolveApp, proj: &Proj, pos: Pos2) { +pub fn on_click(app: &mut SolveApp, proj: &Proj, pos: Pos2, shift: bool) { // A click away dismisses the inline editor; it must not also pick the first entity of // the next dimension before that cancellation has been processed. The type-first value // of the Dimension tool takes clicks itself (a second pick, or where its text goes). @@ -206,25 +232,28 @@ pub fn on_click(app: &mut SolveApp, proj: &Proj, pos: Pos2) { } Kind::HorizontalVertical => { let hits = pick(app, proj, pos); + let midpoint = shift.then(|| midpoint_at(app, proj, pos, 12.0)).flatten(); let hit = hits.iter().find(|hit| match hit { Hit::SketchPoint { sketch, .. } | Hit::SketchCurve { sketch, .. } => Some(*sketch) == app.session.active_sketch, _ => false, }); - match hit { - Some(Hit::SketchPoint { id, .. }) => { - if let Some(first) = tool.picks.first() { - if first != id { - let _ = app.run(tool.cmd, json!({"points": [first, id]})); - tool.picks.clear(); - } - } else { - tool.picks.push(id.clone()); + let point = midpoint.map(|(_, id)| json!({"midpoint": id})).or_else(|| match hit { + Some(Hit::SketchPoint { id, .. }) => Some(json!(id)), + _ => None, + }); + if let Some(point) = point { + if let Some(first) = tool.point_picks.first() { + if first != &point && app.run(tool.cmd, json!({"points": [first, point]})).is_ok() { + tool.point_picks.clear(); } + } else { + tool.point_picks.push(point); } - Some(Hit::SketchCurve { id, straight: true, .. }) if tool.picks.is_empty() => { - let _ = app.run(tool.cmd, json!({"line": id})); - } - _ => {} + } else if !shift + && tool.point_picks.is_empty() + && let Some(Hit::SketchCurve { id, straight: true, .. }) = hit + { + let _ = app.run(tool.cmd, json!({"line": id})); } } Kind::Pick(n) => { @@ -826,6 +855,9 @@ pub fn preview(app: &SolveApp, t: &Tool, painter: &egui::Painter, proj: &Proj) { && let Some(sp) = to(*hp) { painter.circle_stroke(sp, if snap.is_some() { 6.0 } else { 3.0 }, stroke); + if snap.as_deref() == Some("Midpoint") && t.kind == Kind::HorizontalVertical { + painter.circle_stroke(sp, 8.0, Stroke::new(2.0, tk.accent)); + } painter.text( sp + egui::vec2(10.0, 10.0), egui::Align2::LEFT_TOP, @@ -834,6 +866,21 @@ pub fn preview(app: &SolveApp, t: &Tool, painter: &egui::Painter, proj: &Proj) { tk.text_dim, ); } + if t.kind == Kind::HorizontalVertical { + for target in &t.point_picks { + let point = if let Some(id) = target.get("midpoint").and_then(Value::as_str) { + ss.sketch.curve_index(id).and_then(|l| match ss.sketch.shape(l)? { + solidcraft_engine::sketch::Shape::Line { a, b } => Some((a + b) * 0.5), + _ => None, + }) + } else { + target.as_str().and_then(|id| ss.sketch.resolve_point(id)).and_then(|p| ss.sketch.point(p)) + }; + if let Some(sp) = point.and_then(to) { + painter.circle_stroke(sp, 6.0, Stroke::new(2.0, tk.accent)); + } + } + } let Some(hover) = t.hover.as_ref() else { return }; let h = crate::sketch_dims::shown(app, t, hover); if let Some(corners) = polygon_outline(t, h, crate::sketch_dims::locked_value(app, t, "Sides").unwrap_or(6.0)) { diff --git a/crates/ui-egui/src/viewport.rs b/crates/ui-egui/src/viewport.rs index 1a8942798..aaae8c4a2 100644 --- a/crates/ui-egui/src/viewport.rs +++ b/crates/ui-egui/src/viewport.rs @@ -2520,8 +2520,8 @@ pub fn show(app: &mut SolveApp, ui: &mut egui::Ui) { if let Some(p) = ui.input(|i| i.pointer.latest_pos()).filter(|p| rect.contains(*p)) && app.tool.is_some() { - crate::tools::on_hover(app, &proj, p); - crate::tools::on_click(app, &proj, p); + crate::tools::on_hover(app, &proj, p, mods.shift); + crate::tools::on_click(app, &proj, p, mods.shift); } } // A two-point shape being dragged out (#1630) follows the pointer and ends where it is let go, @@ -2542,11 +2542,11 @@ pub fn show(app: &mut SolveApp, ui: &mut egui::Ui) { t.pts.clear(); crate::sketch_dims::reset(t); } - crate::tools::on_hover(app, &proj, p); - crate::tools::on_click(app, &proj, p); + crate::tools::on_hover(app, &proj, p, mods.shift); + crate::tools::on_click(app, &proj, p, mods.shift); } } else if let Some(p) = at { - crate::tools::on_hover(app, &proj, p); + crate::tools::on_hover(app, &proj, p, mods.shift); } } // A Trim drag's path follows the pointer; letting go trims what it crossed. A path that @@ -2559,8 +2559,8 @@ pub fn show(app: &mut SolveApp, ui: &mut egui::Ui) { && let Some(p) = at && app.tool.is_some() { - crate::tools::on_hover(app, &proj, p); - crate::tools::on_click(app, &proj, p); + crate::tools::on_hover(app, &proj, p, mods.shift); + crate::tools::on_click(app, &proj, p, mods.shift); } } else if let Some(p) = at { crate::sketch_tools::trim_drag_to(app, &proj, p); @@ -2572,7 +2572,7 @@ pub fn show(app: &mut SolveApp, ui: &mut egui::Ui) { crate::sketch_text::set_one_letter(mods.shift); if let Some(p) = hover.filter(|_| inside) { if app.tool.is_some() { - crate::tools::on_hover(app, &proj, p); + crate::tools::on_hover(app, &proj, p, mods.shift); } // Trim also trims by press and drag across the pieces to remove (its own release handling, // so not a click that moved on the way below). @@ -2598,7 +2598,7 @@ pub fn show(app: &mut SolveApp, ui: &mut egui::Ui) { && resp.drag_started_by(egui::PointerButton::Primary) && let Some(a) = ui.input(|i| i.pointer.press_origin()) { - crate::tools::on_click(app, &proj, a); + crate::tools::on_click(app, &proj, a, mods.shift); app.viewport.draw_drag = app.tool.as_ref().is_some_and(|t| t.pts.len() == 1).then_some(a); } else if app.tool.is_some() && !app.viewport.trim_drag @@ -2617,7 +2617,7 @@ pub fn show(app: &mut SolveApp, ui: &mut egui::Ui) { && crate::dim_view::pick_reference(ui.ctx(), p, resp.double_clicked()); if resp.clicked() && !held && !reference_pick { if app.tool.is_some() { - crate::tools::on_click(app, &proj, p); + crate::tools::on_click(app, &proj, p, mods.shift); } else if app.dialog.as_ref().is_some_and(|d| d.wants_picks()) { if let Some((hit, Some(sel))) = cand { dialog_pick(app, &hit, sel); diff --git a/crates/ui-egui/tests/point_alignment.rs b/crates/ui-egui/tests/point_alignment.rs index a3fc4b151..5e526d868 100644 --- a/crates/ui-egui/tests/point_alignment.rs +++ b/crates/ui-egui/tests/point_alignment.rs @@ -4,6 +4,12 @@ use serde_json::json; use solidcraft_engine::sketch::ConstraintKind; use solidcraft_ui_egui::scenario::Harness; +fn line_midpoint(sk: &solidcraft_engine::sketch::Sketch, id: &str) -> solidcraft_engine::geom::Vec2 { + let a = sk.point(sk.resolve_point(&format!("{id}.start")).unwrap()).unwrap(); + let b = sk.point(sk.resolve_point(&format!("{id}.end")).unwrap()).unwrap(); + (a + b) * 0.5 +} + #[test] fn horizontal_vertical_uses_preselected_line_and_preserves_rejection() { for fixed in [false, true] { @@ -54,7 +60,7 @@ fn horizontal_vertical_leaves_ambiguous_preselection_to_pick_tool() { h.app.session.selection = selection.clone(); let undo = h.app.session.undo.len(); h.run(&json!([{"start":"sketch.constraint.horizontal_vertical"}])).unwrap(); - assert!(h.app.tool.as_ref().unwrap().picks.is_empty()); + assert!(h.app.tool.as_ref().unwrap().point_picks.is_empty()); assert_eq!(h.app.session.undo.len(), undo); assert_eq!(h.app.session.selection, selection); assert!(!h.app.status.as_ref().is_some_and(|(_, _, error)| *error)); @@ -110,7 +116,7 @@ fn horizontal_vertical_aligns_origin_and_circle_center() { let (first, second) = if origin_first { ([0.0, 0.0], center) } else { (center, [0.0, 0.0]) }; let undo = h.app.session.undo.len(); h.run(&json!([{"click":{"sketch":first}}, {"expect":{"errors":0}}])).unwrap(); - assert_eq!(h.app.tool.as_ref().unwrap().picks.len(), 1); + assert_eq!(h.app.tool.as_ref().unwrap().point_picks.len(), 1); assert!(!h.app.status.as_ref().is_some_and(|(_, _, error)| *error)); assert_eq!(h.app.session.undo.len(), undo); // Repeating the first point must not complete a self-constraint. @@ -128,7 +134,7 @@ fn horizontal_vertical_aligns_origin_and_circle_center() { matches!(c.kind, ConstraintKind::VerticalPoints { .. }) })); assert_eq!(h.app.session.undo.len(), undo + 1); - assert!(h.app.tool.as_ref().unwrap().picks.is_empty()); + assert!(h.app.tool.as_ref().unwrap().point_picks.is_empty()); h.run(&json!([{"call":"engine.execute","params":{"command":"edit.undo","params":{}}}])).unwrap(); assert!((aligned(&h) - 3.0).abs() < 1e-6); h.run(&json!([{"call":"engine.execute","params":{"command":"edit.redo","params":{}}}])).unwrap(); @@ -167,11 +173,11 @@ fn horizontal_vertical_ignores_curves_and_cancels_a_pending_point() { {"click":{"sketch":[25,3]}} ])) .unwrap(); - assert!(h.app.tool.as_ref().unwrap().picks.is_empty()); + assert!(h.app.tool.as_ref().unwrap().point_picks.is_empty()); assert!(!h.app.status.as_ref().is_some_and(|(_, _, error)| *error)); let undo = h.app.session.undo.len(); h.run(&json!([{"click":{"sketch":[0,0]}}, {"click":{"sketch":[25,3]}}])).unwrap(); - assert_eq!(h.app.tool.as_ref().unwrap().picks.len(), 1); + assert_eq!(h.app.tool.as_ref().unwrap().point_picks.len(), 1); h.run(&json!([{"key":"Escape"}])).unwrap(); assert!(h.app.tool.is_none()); assert_eq!(h.app.session.undo.len(), undo); @@ -179,3 +185,155 @@ fn horizontal_vertical_ignores_curves_and_cancels_a_pending_point() { let p = sk.point(sk.resolve_point("c1.center").unwrap()).unwrap(); assert!((p.y - 3.0).abs() < 1e-6); } + +#[test] +fn shift_picks_midpoint_in_either_order_and_persists_ordinary_constraints() { + for (target, horizontal) in [([50., 18.], true), ([23., 50.], false)] { + for midpoint_first in [true, false] { + let mut h = Harness::new(); + h.app.run("sketch.create", json!({"plane":"XY"})).unwrap(); + h.app.run("sketch.line", json!({"points":[[10,10],[30,20]],"infer":false,"connect":false})).unwrap(); + h.app.run("sketch.circle.center", json!({"center":target,"radius":3})).unwrap(); + h.call("ui.view", json!({"view":"top"})); + h.step(&json!({"start":"sketch.constraint.horizontal_vertical"})).unwrap(); + let before = h.app.session.doc.to_json(); + let undo = h.app.session.undo.len(); + h.step(&json!({"move":{"sketch":[20,15]},"shift":true})).unwrap(); + assert_eq!(h.app.tool.as_ref().unwrap().hover.as_ref().unwrap().1.as_deref(), Some("Midpoint")); + let midpoint = json!({"click":{"sketch":[20,15]},"shift":true}); + let target = json!({"click":{"sketch":target}}); + let (first, second) = if midpoint_first { (&midpoint, &target) } else { (&target, &midpoint) }; + h.step(first).unwrap(); + h.step(first).unwrap(); + assert_eq!(h.app.tool.as_ref().unwrap().point_picks.len(), 1); + assert_eq!(h.app.session.undo.len(), undo); + h.step(second).unwrap(); + assert!(!h.app.status.as_ref().is_some_and(|(_, _, error)| *error), "{:?}", h.app.status); + assert!(h.app.tool.as_ref().unwrap().point_picks.is_empty()); + assert_eq!(h.app.session.undo.len(), undo + 1); + let sk = &h.app.session.model.state().sketches[0].sketch; + assert_eq!(sk.points.len(), 5); + assert_eq!(sk.curves.len(), 2); + let p = sk.point(sk.resolve_point("c1.center").unwrap()).unwrap(); + let mid = line_midpoint(sk, "l1"); + assert!((if horizontal { p.y - mid.y } else { p.x - mid.x }).abs() < 1e-6); + assert!(sk.constraints.iter().any(|c| matches!(c.kind, ConstraintKind::Midpoint { .. }))); + let constraint = sk + .constraints + .iter() + .find(|c| matches!(c.kind, ConstraintKind::HorizontalPoints { .. } | ConstraintKind::VerticalPoints { .. })) + .unwrap() + .id + .clone(); + h.step(&json!({"expect":{"glyphs":{constraint.clone():1}}})).unwrap(); + let after = h.app.session.doc.to_json(); + h.app.run("edit.undo", json!({})).unwrap(); + assert_eq!(h.app.session.doc.to_json(), before); + h.app.run("edit.redo", json!({})).unwrap(); + assert_eq!(h.app.session.doc.to_json(), after); + // The ordinary constraint glyph remains selectable and deletable. + h.step(&json!({"key":"Escape"})).unwrap(); + let glyph = solidcraft_ui_egui::sketch_tools::glyph_positions().into_iter().find(|(id, _)| id == &constraint).unwrap().1; + h.step(&json!({"click":[glyph.x,glyph.y]})).unwrap(); + h.step(&json!({"key":"Delete"})).unwrap(); + let sk = &h.app.session.model.state().sketches[0].sketch; + assert!(!sk.constraints.iter().any(|c| c.id == constraint)); + assert_eq!(sk.points.len(), 5); + let midpoint_constraint = sk.constraints.iter().find(|c| matches!(c.kind, ConstraintKind::Midpoint { .. })).unwrap().id.clone(); + // The defining Midpoint relationship is editable through the same glyph UI. + let glyph = solidcraft_ui_egui::sketch_tools::glyph_positions().into_iter().find(|(id, _)| id == &midpoint_constraint).unwrap().1; + h.step(&json!({"click":[glyph.x,glyph.y]})).unwrap(); + h.step(&json!({"key":"Delete"})).unwrap(); + let sk = &h.app.session.model.state().sketches[0].sketch; + assert!(!sk.constraints.iter().any(|c| c.id == midpoint_constraint)); + assert_eq!(sk.points.len(), 5); + } + } +} + +#[test] +fn shift_midpoint_pick_cancels_and_ignores_round_curves() { + let mut h = Harness::new(); + h.app.run("sketch.create", json!({"plane":"XY"})).unwrap(); + h.app.run("sketch.line", json!({"points":[[10,10],[30,20]],"infer":false,"connect":false})).unwrap(); + h.app.run("sketch.circle.center", json!({"center":[40,40],"radius":3})).unwrap(); + h.call("ui.view", json!({"view":"top"})); + h.step(&json!({"start":"sketch.constraint.horizontal_vertical"})).unwrap(); + let before = h.app.session.doc.to_json(); + h.step(&json!({"click":{"sketch":[43,40]},"shift":true})).unwrap(); + assert!(h.app.tool.as_ref().unwrap().point_picks.is_empty()); + h.step(&json!({"click":{"sketch":[20,15]},"shift":true})).unwrap(); + assert_eq!(h.app.tool.as_ref().unwrap().point_picks, vec![json!({"midpoint":"l1"})]); + h.step(&json!({"key":"Escape"})).unwrap(); + assert!(h.app.tool.is_none()); + assert_eq!(h.app.session.doc.to_json(), before); +} + +#[test] +fn shift_can_align_two_midpoints_and_reveal_one_from_anywhere_on_the_line() { + let mut h = Harness::new(); + h.app.run("sketch.create", json!({"plane":"XY"})).unwrap(); + for points in [json!([[10, 10], [30, 20]]), json!([[15, 40], [35, 50]])] { + h.app.run("sketch.line", json!({"points":points,"infer":false,"connect":false})).unwrap(); + } + h.call("ui.view", json!({"view":"top"})); + h.step(&json!({"start":"sketch.constraint.horizontal_vertical"})).unwrap(); + h.step(&json!({"move":{"sketch":[13,11.5]},"shift":true})).unwrap(); + let hover = h.app.tool.as_ref().unwrap().hover.as_ref().unwrap(); + assert_eq!([hover.0.x, hover.0.y], [20., 15.]); + assert_eq!(hover.1.as_deref(), Some("Midpoint")); + h.step(&json!({"click":{"sketch":[20,15]},"shift":true})).unwrap(); + h.step(&json!({"click":{"sketch":[25,45]},"shift":true})).unwrap(); + assert!(!h.app.status.as_ref().is_some_and(|(_, _, error)| *error), "{:?}", h.app.status); + let sk = &h.app.session.model.state().sketches[0].sketch; + assert_eq!(sk.points.len(), 7); + assert_eq!(sk.curves.len(), 2); + let mid = |id| line_midpoint(sk, id); + assert!((mid("l1").x - mid("l2").x).abs() < 1e-6); +} + +#[test] +fn midpoint_aligns_to_the_fixed_origin_without_straightening_the_line() { + for midpoint_first in [true, false] { + let mut h = Harness::new(); + h.app.run("sketch.create", json!({"plane":"XY"})).unwrap(); + h.app.run("sketch.line", json!({"points":[[-10,15],[16,25]],"infer":false,"connect":false})).unwrap(); + h.call("ui.view", json!({"view":"top"})); + h.step(&json!({"start":"sketch.constraint.horizontal_vertical"})).unwrap(); + let midpoint = json!({"click":{"sketch":[3,20]},"shift":true}); + let origin = json!({"click":{"sketch":[0,0]}}); + let (first, second) = if midpoint_first { (&midpoint, &origin) } else { (&origin, &midpoint) }; + h.step(first).unwrap(); + h.step(second).unwrap(); + assert!(!h.app.status.as_ref().is_some_and(|(_, _, error)| *error), "{:?}", h.app.status); + let sk = &h.app.session.model.state().sketches[0].sketch; + assert_eq!(sk.points.len(), 4); + let a = sk.point(sk.resolve_point("l1.start").unwrap()).unwrap(); + let b = sk.point(sk.resolve_point("l1.end").unwrap()).unwrap(); + assert!(((a + b) * 0.5).x.abs() < 1e-6); + assert!((b.x - a.x).abs() > 1. && (b.y - a.y).abs() > 1., "only the midpoint is aligned"); + assert_eq!(sk.point(0).unwrap(), solidcraft_engine::geom::Vec2::ZERO); + } +} + +#[test] +fn conflicting_midpoint_pick_keeps_pending_preview_without_creating_geometry() { + let mut h = Harness::new(); + h.app.run("sketch.create", json!({"plane":"XY"})).unwrap(); + h.app.run("sketch.line", json!({"points":[[10,10],[30,20]],"infer":false,"connect":false})).unwrap(); + h.app.run("sketch.circle.center", json!({"center":[24,50],"radius":3})).unwrap(); + h.app.run("sketch.constraint.fix", json!({"entities":["l1","c1"]})).unwrap(); + h.call("ui.view", json!({"view":"top"})); + h.step(&json!({"start":"sketch.constraint.horizontal_vertical"})).unwrap(); + let before = h.app.session.doc.to_json(); + let undo = h.app.session.undo.len(); + h.step(&json!({"click":{"sketch":[20,15]},"shift":true})).unwrap(); + h.step(&json!({"click":{"sketch":[24,50]}})).unwrap(); + assert!(h.app.status.as_ref().is_some_and(|(_, _, error)| *error)); + assert_eq!(h.app.session.doc.to_json(), before); + assert_eq!(h.app.session.undo.len(), undo); + assert_eq!(h.app.tool.as_ref().unwrap().point_picks, vec![json!({"midpoint":"l1"})]); + h.step(&json!({"key":"Escape"})).unwrap(); + assert!(h.app.tool.is_none()); + assert_eq!(h.app.session.doc.to_json(), before); +} diff --git a/docs/book/src/guide/sketching.md b/docs/book/src/guide/sketching.md index c74d2c301..08752de01 100644 --- a/docs/book/src/guide/sketching.md +++ b/docs/book/src/guide/sketching.md @@ -174,7 +174,22 @@ fresh link once the source is available; their stored point values are preserved **Horizontal/Vertical** accepts a click on a line or clicks on two distinct sketch points, including the origin, endpoints and circle centres. For two points, it chooses horizontal -or vertical alignment from their current positions. Esc cancels a pending first point. +or vertical alignment from their current positions. Hold **Shift** near a line's midpoint to +highlight and select it as either point. The midpoint follows both endpoints as the line moves, +resizes or rotates. Two line midpoints can also be aligned. Hovering and the first pick are +only previews; Esc cancels them without changing the sketch. Accepting the second pick reuses +or creates a sketch point with an ordinary Midpoint constraint, then adds the H/V constraint +in one undo step. Both constraints can be selected and deleted independently; deleting either +keeps the point. After a fillet or chamfer, its Midpoint constraint refers to the original full +side, retained as construction geometry, just like a manually constrained midpoint. + +Scripts use the same command, with a midpoint reference in the `points` array: + +```json +{"command":"sketch.constraint.horizontal_vertical","params":{"points":[{"midpoint":"l1"},"c1.center"],"mode":"vertical"}} +``` + +`mode` can be `horizontal` or `vertical`; omitting it chooses from the current positions. The solver is SolidCraft's own (damped Gauss–Newton with degree-of-freedom analysis). Constraints: coincident, horizontal/vertical, parallel, perpendicular, tangent, equal, concentric, collinear,