SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Sketch: an offset slot can still be moved by the dimension that places it (#6569) (#6697)
semmelrindee2c9f908f89d
diff --git a/crates/engine/src/cmd/sketch_modify_tests.rs b/crates/engine/src/cmd/sketch_modify_tests.rsindex a2be9291b0..aa5be825c9 100644--- a/crates/engine/src/cmd/sketch_modify_tests.rs+++ b/crates/engine/src/cmd/sketch_modify_tests.rs@@ -2056,6 +2056,47 @@ fn an_offset_leaves_its_source_lines_free_to_turn() {assert_eq!(o["sketch"]["dof"], corners["sketch"]["dof"], "{o}");}+#[test]+fn an_offset_slot_still_moves_with_the_dimension_that_places_it() {+ // #6569: an offset arc shares its source's centre and its ends are held while the sketch+ // solves. Its own arc condition tied that centre to the middle of the held ends: the slot+ // lost a degree of freedom, and the length that places it was refused as conflicting.+ let build = |offset: bool| {+ let mut s = new_sketch();+ run(&mut s, "sketch.line", json!({"points": [[0, 20], [0, 10]], "construction": true}));+ run(&mut s, "sketch.constraint.fix", json!({"entity": "l1.start"}));+ run(&mut s, "sketch.constraint.horizontal_vertical", json!({"line": "l1", "mode": "vertical"}));+ run(&mut s, "sketch.dimension", json!({"entities": ["l1"], "value": "a = 10"}));+ let slot = run(&mut s, "sketch.slot.center_to_center", json!({"p0": [0, 10], "p1": [8, 10], "width": 3}));+ let dof = if offset {+ run(&mut s, "sketch.offset", json!({"curves": ["l2"], "distance": 1, "side": [4, 5]}))["sketch"]["dof"].clone()+ } else {+ slot["sketch"]["dof"].clone()+ };+ (s, dof)+ };+ let (mut plain, without) = build(false);+ let (mut s, with) = build(true);+ assert_eq!(with, without, "the offset takes no freedom away from the slot");+ for s in [&mut plain, &mut s] {+ run(s, "parameters.change", json!({"name": "a", "expression": "8"}));+ }+ // The slot moves as it does without the offset, and the offset follows it, 1 mm out.+ let (a, b) = (sketch(&plain), sketch(&s));+ for p in &a.points {+ let q = b.points.iter().find(|q| q.id == p.id).unwrap();+ assert!(p.pos.dist(q.pos) < 1e-9, "{} at {:?}, without the offset at {:?}", p.id, q.pos, p.pos);+ }+ let arc = |id: &str| match b.curves[b.curve_index(id).unwrap()].kind {+ CurveKind::Arc { c, a, .. } => (c, b.points[a].pos.dist(b.points[c].pos)),+ ref other => panic!("{id} is {other:?}"),+ };+ for (source, output) in [("a1", "a3"), ("a2", "a4")] {+ let ((c, r), (oc, or)) = (arc(source), arc(output));+ assert!(c == oc && close(or - r, 1.0), "{output} is round {source}'s centre, 1 mm out: {r} and {or}");+ }+}+#[test]fn offset_driver_covers_disconnected_selections_and_refuses_bad_values_atomically() {let mut s = new_sketch();diff --git a/crates/sketch/src/loci.rs b/crates/sketch/src/loci.rsindex 2dbe5d758c..b8215ecb39 100644--- a/crates/sketch/src/loci.rs+++ b/crates/sketch/src/loci.rs@@ -988,6 +988,10 @@ pub(crate) fn read(sk: &Sketch, before: &dyn Fn(usize) -> Option<Vec2>, on_curve}for (k, rd) in rounds.iter().enumerate() {let Some(Round { c, ends: Some((a, b)) }) = *rd else { continue };+ // An offset's arc follows its source's centre; its held ends don't place it (#6569).+ if sk.offset_arc_follows_source(k) {+ continue;+ }match r_of(k) {Some(r) => {rel(c, a, Rel::Dist(r));diff --git a/crates/sketch/src/offset.rs b/crates/sketch/src/offset.rsindex 0e2fabc23a..23b013dab4 100644--- a/crates/sketch/src/offset.rs+++ b/crates/sketch/src/offset.rs@@ -52,6 +52,21 @@ impl Sketch {})}+ /// An arc an offset made round its source's own centre (#6569). Its ends are held while the+ /// sketch solves, so its own condition, both ends as far from the centre, only tied that+ /// centre (and the source with it) to the middle of the held ends: a slot offset by 1 mm+ /// could no longer be moved by the dimension that places it. The source's own arc keeps the+ /// centre, and the offset is rebuilt from the source after the solve.+ pub(crate) fn offset_arc_follows_source(&self, curve: usize) -> bool {+ if self.offsets.is_empty() {+ return false;+ }+ let Some(arc) = self.curves.get(curve) else { return false };+ let CurveKind::Arc { c: centre, .. } = arc.kind else { return false };+ let output = |id: &str| self.offsets.iter().any(|o| o.owns_output(id));+ output(&arc.id) && self.curves.iter().enumerate().any(|(k, other)| k != curve && other.kind.uses(centre) && !output(&other.id))+ }+/// Endpoints of a normal-distance annotation, evaluated from its source curve.pub fn offset_dimension_points(&self, output: &str) -> Option<(Vec2, Vec2)> {let (source, forward, distance) = selfdiff --git a/crates/sketch/src/solver.rs b/crates/sketch/src/solver.rsindex 2c4d371e84..6521bbb382 100644--- a/crates/sketch/src/solver.rs+++ b/crates/sketch/src/solver.rs@@ -1817,14 +1817,16 @@ fn initial_x(sk: &Sketch, lay: &Layout) -> Vec<f64> {/// point.fn build_blocks<'a>(sk: &'a Sketch, lay: &Layout, on_curve: &[(usize, usize)]) -> (Vec<(Block<'a>, Vec<usize>)>, Vec<bool>) {let mut raw = Vec::new();- for c in &sk.curves {+ for (k, c) in sk.curves.iter().enumerate() {if let CurveKind::Spline { pts, periodic: true, .. } = &c.kind&& let (Some(a), Some(b)) = (pts.first(), pts.last())&& a != b{raw.push(Block::Closure { a: *a, b: *b });}- if let CurveKind::Arc { c, a, b } = c.kind {+ if let CurveKind::Arc { c, a, b } = c.kind+ && !sk.offset_arc_follows_source(k)+ {raw.push(Block::Arc { c, a, b });}}