SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Two-entity constraints move only the second pick (tangent, parallel, perpendicular, equal, concentric, coincident, collinear, symmetric, midpoint): the constraint is applied with the first entity held (solve_holding), the second keeping its size where it can (lines turn and slide, circles translate), then resizing; if the second is fixed, projected or fully constrained the first moves instead, and if neither can the constraint is refused and nothing changes; later solves hold nothing. Context-menu constraints keep the selection order; a curve picked before a point puts the point on the curve
bherbruck7f9a8f2afd4f
diff --git a/crates/engine/src/cmd/sketch.rs b/crates/engine/src/cmd/sketch.rsindex dac9b67301..f1bf1b9167 100644--- a/crates/engine/src/cmd/sketch.rs+++ b/crates/engine/src/cmd/sketch.rs@@ -3,7 +3,7 @@use serde_json::{Value, json};use solvecraft_doc::{FeatureKind, PlaneRef};use solvecraft_geom::{Plane, Vec2, Vec3};-use solvecraft_sketch::{ConstraintKind, CurveKind, Sketch, solve};+use solvecraft_sketch::{ConstraintKind, CurveKind, Hold, Sketch, SolveReport, solve, solve_holding};use super::{CommandSpec, in_sketch};use crate::params::{bad, bool_, expr, num, req_vec2, str_, string_list, vec2, vec3};@@ -833,13 +833,155 @@ fn constrain(s: &mut Session, p: &Value, cmd: &str, f: impl FnOnce(&Sketch) -> Rlet mut before = None;let (id, info) = edit(s, p, cmd, true, |sk, _| {let k = f(sk)?;- before = Some(dof_now(sk));- add_c(sk, k)+ let rep = solve(&mut sk.clone());+ before = Some(rep.dof);+ let order = entity_order(sk, p);+ let id = add_c(sk, k)?;+ if let Some((first, second)) = order {+ apply_in_order(sk, &rep, &[first], second, cmd)?;+ }+ Ok(id)})?;reject_redundant(before, &info, cmd)?;Ok(json!({"constraint": id, "sketch": info}))}+/// A sketch entity a constraint is applied to.+#[derive(Clone, Copy, Debug, PartialEq)]+pub(super) enum Ent {+ Point(usize),+ Curve(usize),+}++fn ent(sk: &Sketch, r: &str) -> Option<Ent> {+ sk.resolve_point(r).map(Ent::Point).or_else(|| sk.curve_index(r).map(Ent::Curve))+}++/// The entities of a two-entity constraint in the order they were picked (`a` then `b`, or+/// `point` then `line`).+fn entity_order(sk: &Sketch, p: &Value) -> Option<(Ent, Ent)> {+ let r = |k: &str| p.get(k).and_then(Value::as_str).and_then(|r| ent(sk, r));+ Some((r("a").or_else(|| r("point"))?, r("b").or_else(|| r("line"))?))+}++/// Held in place: fixed or projected, or fully determined by the constraints already there.+fn ent_locked(sk: &Sketch, rep: &SolveReport, e: Ent) -> bool {+ match e {+ Ent::Point(i) => sk.point_locked(i) || rep.point_determined.get(i).copied().unwrap_or(false),+ Ent::Curve(c) => sk.curve_locked(c) || rep.curve_determined.get(c).copied().unwrap_or(false),+ }+}++/// Hold entities: their points, and with `radius` their radii too.+fn hold_of(sk: &Sketch, ents: &[Ent], radius: bool) -> Hold {+ let mut h = Hold::default();+ for e in ents {+ match *e {+ Ent::Point(i) => h.points.push(i),+ Ent::Curve(c) => {+ h.points.extend(sk.curves.get(c).map(|c| c.kind.point_ids()).unwrap_or_default());+ h.radii.push(c);+ }+ }+ }+ if !radius {+ h.radii.clear();+ }+ h+}++/// Did a solve shrink a line or an arc to nothing (a degenerate way to satisfy tangency)?+fn collapsed(before: &Sketch, after: &Sketch) -> bool {+ let size = |sk: &Sketch, i: usize| match sk.curves.get(i).map(|c| &c.kind) {+ Some(CurveKind::Line { .. }) => line_pts(sk, i).map(|(a, b)| a.dist(b)),+ Some(CurveKind::Arc { .. } | CurveKind::Circle { .. }) => sk.radius(i),+ _ => None,+ };+ (0..before.curves.len()).any(|i| match (size(before, i), size(after, i)) {+ (Some(b), Some(a)) => b > 1e-6 && a < b * 1e-3,+ _ => false,+ })+}++/// Keep an entity's size while it moves: a line's length (circles keep their radius by holding+/// it).+fn keep_size(sk: &Sketch, e: Ent) -> Vec<ConstraintKind> {+ match (+ e,+ line_pts(+ sk,+ match e {+ Ent::Curve(c) => c,+ Ent::Point(_) => usize::MAX,+ },+ ),+ ) {+ (Ent::Curve(l), Some((a, b))) => vec![ConstraintKind::Length { l, value: a.dist(b) }],+ _ => Vec::new(),+ }+}++/// Satisfy a just-added constraint the way Fusion applies it: the first-picked entities stay+/// put and only the second moves (first keeping its size, so it turns and slides, then also+/// resizing).+/// If the second can't move (fixed, projected or fully determined), the first moves instead;+/// if neither can, the constraint conflicts and nothing changes. Everything else moves as+/// little as it can. Later solves are ordinary ones (nothing is held).+pub(super) fn apply_in_order(sk: &mut Sketch, rep: &SolveReport, first: &[Ent], second: Ent, cmd: &str) -> Result<()> {+ let first_locked = first.iter().any(|e| ent_locked(sk, rep, *e));+ let second_locked = ent_locked(sk, rep, second);+ // (held geometry, temporary size constraints) to try in turn.+ let mut tries: Vec<(Hold, Vec<ConstraintKind>)> = Vec::new();+ let mut ordered = |stay: &[Ent], mover: Ent| {+ let mut h = hold_of(sk, stay, true);+ h.radii.extend(hold_of(sk, &[mover], true).radii);+ tries.push((h.clone(), keep_size(sk, mover)));+ tries.push((hold_of(sk, stay, true), Vec::new()));+ // An end point the two share may slide (a line tangent to an arc it ends on, whose+ // centre is pinned, has to turn about its other end).+ let shared = hold_of(sk, &[mover], false).points;+ if h.points.iter().any(|p| shared.contains(p)) {+ h.points.retain(|p| !shared.contains(p));+ tries.push((h.clone(), keep_size(sk, mover)));+ tries.push((h, Vec::new()));+ }+ };+ if !second_locked {+ ordered(first, second);+ }+ if !first_locked {+ for f in first {+ ordered(&[second], *f);+ }+ }+ const TEMP: &str = "__keep_size";+ for (h, extra) in tries {+ let mut trial = sk.clone();+ trial.constraints.extend(extra.into_iter().map(|kind| solvecraft_sketch::Constraint {+ id: TEMP.into(),+ kind,+ param: None,+ driven: false,+ text: None,+ }));+ let ok = solve_holding(&mut trial, &h).ok();+ trial.constraints.retain(|c| c.id != TEMP);+ if ok && !collapsed(sk, &trial) {+ *sk = trial;+ return Ok(());+ }+ }+ // Both could move but holding either one leads nowhere: solve as usual.+ if !first_locked && !second_locked {+ let mut trial = sk.clone();+ if solve(&mut trial).ok() {+ *sk = trial;+ return Ok(());+ }+ }+ Err(bad(cmd, "that conflicts with the sketch: neither entity can move to satisfy it (they are fixed or fully constrained)"))+}+/// Degrees of freedom of a sketch as it is.pub(super) fn dof_now(sk: &Sketch) -> usize {solve(&mut sk.clone()).dof@@ -890,8 +1032,13 @@ fn c_horizontal_vertical(s: &mut Session, p: &Value) -> Result<Value> {fn c_coincident(s: &mut Session, p: &Value) -> Result<Value> {let cmd = "ConstraintCoincident";constrain(s, p, cmd, |sk| {- let a = point_ref(sk, p.get("a"), cmd, "a")?;+ let aref = p.get("a").and_then(Value::as_str).unwrap_or_default();let bref = p.get("b").and_then(Value::as_str).ok_or_else(|| bad(cmd, "`b` must be a point or curve"))?;+ // A curve picked first and a point second: the point goes onto the curve.+ if let (None, Some(c), Some(q)) = (sk.resolve_point(aref), sk.curve_index(aref), sk.resolve_point(bref)) {+ return Ok(ConstraintKind::PointOnCurve { p: q, c });+ }+ let a = point_ref(sk, p.get("a"), cmd, "a")?;if let Some(b) = sk.resolve_point(bref) {return Ok(ConstraintKind::Coincident { p: a, q: b });}@@ -934,6 +1081,8 @@ fn c_symmetry(s: &mut Session, p: &Value) -> Result<Value> {let l = curve_ref(sk, p.get("line"), cmd, "line")?;let ra = p.get("a").and_then(Value::as_str).ok_or_else(|| bad(cmd, "`a` must be a point or curve"))?;let rb = p.get("b").and_then(Value::as_str).ok_or_else(|| bad(cmd, "`b` must be a point or curve"))?;+ let rep = solve(&mut sk.clone());+ let order = ent(sk, ra).zip(ent(sk, rb));let mut out = Vec::new();match (sk.resolve_point(ra), sk.resolve_point(rb)) {(Some(a), Some(b)) => out.push(add_c(sk, ConstraintKind::Symmetric { p: a, q: b, l })?),@@ -957,6 +1106,10 @@ fn c_symmetry(s: &mut Session, p: &Value) -> Result<Value> {}}}+ // The first entity and the symmetry line stay; the second mirrors onto it.+ if let Some((a, b)) = order {+ apply_in_order(sk, &rep, &[a, Ent::Curve(l)], b, cmd)?;+ }Ok(out)})?;Ok(json!({"constraints": ids, "sketch": info}))diff --git a/crates/engine/src/cmd/sketch_ux_tests.rs b/crates/engine/src/cmd/sketch_ux_tests.rsindex e4b72ade24..a052c44b37 100644--- a/crates/engine/src/cmd/sketch_ux_tests.rs+++ b/crates/engine/src/cmd/sketch_ux_tests.rs@@ -252,3 +252,151 @@ fn projected_geometry_can_become_construction() {let sk = sketch(&s);assert!(sk.curves.iter().any(|c| c.id == id && c.construction && c.link.is_some()));}++// ---------------------------------------------------------------------------------------------+// Two-entity constraints: the first pick stays, the second moves++/// Positions of an entity's points (and its radius).+fn snap(s: &Session, id: &str) -> (Vec<solvecraft_geom::Vec2>, Option<f64>) {+ let sk = sketch(s);+ if let Some(i) = sk.curve_index(id) {+ let pts = sk.curves[i].kind.point_ids().into_iter().filter_map(|p| sk.point(p)).collect();+ return (pts, sk.radius(i));+ }+ (vec![pt(s, id)], None)+}++fn same(a: &(Vec<solvecraft_geom::Vec2>, Option<f64>), b: &(Vec<solvecraft_geom::Vec2>, Option<f64>)) -> bool {+ a.0.len() == b.0.len() && a.0.iter().zip(&b.0).all(|(p, q)| p.dist(*q) < 1e-9) && a.1.zip(b.1).is_none_or(|(x, y)| (x - y).abs() < 1e-9)+}++/// A free line l1 (5,3)–(45,3) and a circle c1 at (20,18) with radius 5.+fn line_and_circle() -> Session {+ let mut s = new_sketch();+ run(&mut s, "DrawPolyline", json!({"points": [[5, 3], [45, 3]]}));+ run(&mut s, "CircleCenterRadius", json!({"center": [20, 18], "radius": 5}));+ s+}++/// Apply `cmd` with `a` then `b`; the first must not move, the second must.+fn check_order(mut s: Session, cmd: &str, a: &str, b: &str) {+ let (a0, b0) = (snap(&s, a), snap(&s, b));+ run(&mut s, cmd, json!({"a": a, "b": b}));+ assert!(same(&snap(&s, a), &a0), "{cmd}: first `{a}` moved: {a0:?} -> {:?}", snap(&s, a));+ assert!(!same(&snap(&s, b), &b0), "{cmd}: second `{b}` did not move");+}++#[test]+fn tangent_moves_only_the_second_pick() {+ // Line then circle: only the circle moves (and keeps its size).+ let mut s = line_and_circle();+ let l0 = snap(&s, "l1");+ run(&mut s, "ConstraintTangent", json!({"a": "l1", "b": "c1"}));+ assert!(same(&snap(&s, "l1"), &l0), "line moved: {:?}", snap(&s, "l1"));+ let c = snap(&s, "c1");+ assert!((c.1.unwrap_or(0.0) - 5.0).abs() < 1e-9 && (c.0[0].y - 8.0).abs() < 1e-6, "{c:?}");+ // Circle then line: only the line moves.+ check_order(line_and_circle(), "ConstraintTangent", "c1", "l1");+}++#[test]+fn a_fixed_second_pick_makes_the_first_move() {+ let mut s = line_and_circle();+ run(&mut s, "ConstraintFix", json!({"entity": "l1"}));+ let l0 = snap(&s, "l1");+ let c0 = snap(&s, "c1");+ run(&mut s, "ConstraintTangent", json!({"a": "c1", "b": "l1"}));+ assert!(same(&snap(&s, "l1"), &l0));+ assert!(!same(&snap(&s, "c1"), &c0));+ // Fixed first: the second moves as usual.+ let mut s = line_and_circle();+ run(&mut s, "ConstraintFix", json!({"entity": "c1"}));+ let c0 = snap(&s, "c1");+ run(&mut s, "ConstraintTangent", json!({"a": "c1", "b": "l1"}));+ assert!(same(&snap(&s, "c1"), &c0));+}++#[test]+fn two_fully_constrained_entities_conflict_and_nothing_moves() {+ let mut s = line_and_circle();+ run(&mut s, "ConstraintFix", json!({"entities": ["l1.start", "l1.end", "c1.center"]}));+ run(&mut s, "SketchDimension", json!({"entities": ["c1"], "type": "radius", "value": 5}));+ let si = run(&mut s, "sketch.inspect", json!({}));+ assert!(si["curves"].as_array().is_some_and(|c| c.iter().all(|c| c["fully_constrained"] == true)), "{si}");+ let before = sketch(&s);+ let e = s.execute("ConstraintTangent", &json!({"a": "l1", "b": "c1"}));+ assert!(e.is_err(), "{e:?}");+ assert_eq!(sketch(&s), before);+}++#[test]+fn line_pairs_keep_the_first_line() {+ let lines = || {+ let mut s = new_sketch();+ run(&mut s, "DrawPolyline", json!({"points": [[0, 0], [30, 2]]}));+ run(&mut s, "DrawPolyline", json!({"points": [[5, 20], [25, 35]]}));+ s+ };+ let len = |s: &Session, l: &str| {+ let p = snap(s, l).0;+ p[0].dist(p[1])+ };+ for cmd in ["ConstraintParallel", "ConstraintPerpendicular", "ConstraintEqual", "ConstraintCollinear"] {+ check_order(lines(), cmd, "l1", "l2");+ check_order(lines(), cmd, "l2", "l1");+ // The second line turns and slides; only Equal changes its length.+ let mut s = lines();+ let l0 = len(&s, "l2");+ run(&mut s, cmd, json!({"a": "l1", "b": "l2"}));+ if cmd != "ConstraintEqual" {+ assert!((len(&s, "l2") - l0).abs() < 1e-6, "{cmd}: {l0} -> {}", len(&s, "l2"));+ } else {+ assert!((len(&s, "l2") - len(&s, "l1")).abs() < 1e-6);+ }+ }+}++#[test]+fn circle_pairs_keep_the_first_circle() {+ let circles = || {+ let mut s = new_sketch();+ run(&mut s, "CircleCenterRadius", json!({"center": [0, 0], "radius": 5}));+ run(&mut s, "CircleCenterRadius", json!({"center": [30, 10], "radius": 8}));+ s+ };+ for cmd in ["ConstraintConcentric", "ConstraintEqual", "ConstraintTangent"] {+ check_order(circles(), cmd, "c1", "c2");+ check_order(circles(), cmd, "c2", "c1");+ }+ // Equal resizes the second to the first.+ let mut s = circles();+ run(&mut s, "ConstraintEqual", json!({"a": "c2", "b": "c1"}));+ assert!((snap(&s, "c1").1.unwrap_or(0.0) - 8.0).abs() < 1e-9);+}++#[test]+fn point_constraints_keep_the_first_pick() {+ let pts = || {+ let mut s = new_sketch();+ run(&mut s, "DrawPolyline", json!({"points": [[0, 0], [30, 0]]}));+ run(&mut s, "DrawPolyline", json!({"points": [[10, 10], [20, 25]]}));+ s+ };+ check_order(pts(), "ConstraintCoincident", "l2.start", "l1.end");+ check_order(pts(), "ConstraintCoincident", "l1.end", "l2.start");+ // Curve picked first, point second: the point goes onto the line.+ check_order(pts(), "ConstraintCoincident", "l1", "l2.start");+ // Midpoint: the point stays, the line moves.+ let mut s = pts();+ let p0 = snap(&s, "l2.end");+ run(&mut s, "ConstraintMidPoint", json!({"point": "l2.end", "line": "l1"}));+ assert!(same(&snap(&s, "l2.end"), &p0));+ // Symmetry: the first point and the line stay, the second mirrors.+ let mut s = pts();+ run(&mut s, "DrawPoint", json!({"point": [3, 7]}));+ run(&mut s, "DrawPoint", json!({"point": [4, -9]}));+ let (a0, l0) = (snap(&s, "p1"), snap(&s, "l1"));+ run(&mut s, "ConstraintSymmetry", json!({"a": "p1", "b": "p2", "line": "l1"}));+ assert!(same(&snap(&s, "p1"), &a0) && same(&snap(&s, "l1"), &l0));+ assert!(pt(&s, "p2").dist(solvecraft_geom::Vec2::new(3.0, -7.0)) < 1e-6, "{:?}", pt(&s, "p2"));+}diff --git a/crates/sketch/src/lib.rs b/crates/sketch/src/lib.rsindex eaa43b5ecc..a2a3d8d04e 100644--- a/crates/sketch/src/lib.rs+++ b/crates/sketch/src/lib.rs@@ -27,7 +27,7 @@ pub use link::{Link, LinkGeom, LinkKind, LinkSource, MAX_LINK_ENTITIES};pub use model::{Constraint, ConstraintKind, Curve, CurveKind, SPoint, Sketch, SketchError};pub use profiles::{Profile, find_drawn_profiles, find_profiles, merge_regions};pub use shape::{Shape, intersections};-pub use solver::{SolveReport, SolveStatus, solve};+pub use solver::{Hold, SolveReport, SolveStatus, solve, solve_holding};pub use text::{MAX_TEXT_CHARS, text_geometry};pub use wire::{MAX_WIRE_POINTS, Wire};diff --git a/crates/sketch/src/solver.rs b/crates/sketch/src/solver.rsindex e4d4a12658..11b5f57863 100644--- a/crates/sketch/src/solver.rs+++ b/crates/sketch/src/solver.rs@@ -61,8 +61,20 @@ struct Layout {n: usize,}-fn layout(sk: &Sketch) -> Layout {+/// Geometry held in place for one solve: point indices and curves whose radius is held.+#[derive(Clone, Debug, Default, PartialEq)]+pub struct Hold {+ pub points: Vec<usize>,+ pub radii: Vec<usize>,+}++fn layout(sk: &Sketch, hold: &Hold) -> Layout {let mut fixed: Vec<bool> = sk.points.iter().map(|p| p.fixed).collect();+ for p in &hold.points {+ if let Some(f) = fixed.get_mut(*p) {+ *f = true;+ }+ }for c in &sk.constraints {if let ConstraintKind::Fix { p } = c.kind&& let Some(f) = fixed.get_mut(p)@@ -92,8 +104,9 @@ fn layout(sk: &Sketch) -> Layout {let rvar = sk.curves.iter()- .map(|c| match c.kind {- CurveKind::Circle { .. } | CurveKind::Ellipse { .. } if c.link.is_none() && !c.fixed => {+ .enumerate()+ .map(|(i, c)| match c.kind {+ CurveKind::Circle { .. } | CurveKind::Ellipse { .. } if c.link.is_none() && !c.fixed && !hold.radii.contains(&i) => {n += 1;Some(n - 1)}@@ -774,7 +787,14 @@ fn lm(sk: &Sketch, lay: &Layout, blocks: &[(Block, Vec<usize>)], vars: &[usize],/// Solve the sketch in place. On failure the geometry is restored and the report lists the/// violated constraints.pub fn solve(sk: &mut Sketch) -> SolveReport {- let lay = layout(sk);+ solve_holding(sk, &Hold::default())+}++/// Solve with some geometry held as if it were fixed (for this solve only): applying a+/// constraint between two entities holds the first so only the second moves. Everything else+/// moves as little as it can. On failure the geometry is restored.+pub fn solve_holding(sk: &mut Sketch, hold: &Hold) -> SolveReport {+ let lay = layout(sk, hold);let mut x = vec![0.0; lay.n];for (i, p) in sk.points.iter().enumerate() {if let Some(v) = lay.pvar.get(i).copied().flatten() {diff --git a/crates/ui-egui/src/context_menu.rs b/crates/ui-egui/src/context_menu.rsindex 4d5a1fe6fb..33ea06d3c4 100644--- a/crates/ui-egui/src/context_menu.rs+++ b/crates/ui-egui/src/context_menu.rs@@ -421,9 +421,12 @@ fn sketch_entity_items(app: &SolveApp) -> Vec<Item> {let mut rounds = Vec::new();let mut curves = Vec::new();let mut points = Vec::new();+ // Selection order: a two-entity constraint keeps the first and moves the second.+ let mut picked: Vec<String> = Vec::new();for s in &app.session.selection {match s {Sel::SketchCurve { id } => {+ picked.push(id.clone());curves.push(id.clone());match ss.sketch.curve_index(id).and_then(|i| ss.sketch.curves.get(i)).map(|c| &c.kind) {Some(CurveKind::Line { .. }) => lines.push(id.clone()),@@ -431,7 +434,10 @@ fn sketch_entity_items(app: &SolveApp) -> Vec<Item> {_ => {}}}- Sel::SketchPoint { id } => points.push(id.clone()),+ Sel::SketchPoint { id } => {+ picked.push(id.clone());+ points.push(id.clone());+ }_ => {}}}@@ -461,7 +467,7 @@ fn sketch_entity_items(app: &SolveApp) -> Vec<Item> {c.push(cmd(app, "ConstraintHorizontalVertical", "Horizontal/Vertical").with(json!({ "points": points })));}if p == 1 && curves.len() == 1 && n == 2 {- c.push(cmd(app, "ConstraintCoincident", "Coincident").with(json!({ "a": points[0], "b": curves[0] })));+ c.push(cmd(app, "ConstraintCoincident", "Coincident").with(json!({ "a": picked[0], "b": picked[1] })));if l == 1 {c.push(cmd(app, "ConstraintMidPoint", "MidPoint").with(json!({ "point": points[0], "line": lines[0] })));}@@ -480,7 +486,7 @@ fn sketch_entity_items(app: &SolveApp) -> Vec<Item> {c.push(cmd(app, "ConstraintTangent", "Tangent").with(ab));}if l == 1 && r == 1 && n == 2 {- c.push(cmd(app, "ConstraintTangent", "Tangent").with(json!({ "a": lines[0], "b": rounds[0] })));+ c.push(cmd(app, "ConstraintTangent", "Tangent").with(json!({ "a": picked[0], "b": picked[1] })));}if p == 2 && l == 1 && n == 3 {c.push(cmd(app, "ConstraintSymmetry", "Symmetry").with(json!({ "a": points[0], "b": points[1], "line": lines[0] })));