Skip to content

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.rs
index 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.rs
index 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.rs
index 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) = self
diff --git a/crates/sketch/src/solver.rs b/crates/sketch/src/solver.rs
index 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 });
}
}