Skip to content

SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.

Sketch: hold horizontal/vertical and line up with other points at once while drawing (#7828) (#8474)

Ryan791abbd9b10e
diff --git a/assets/locales/pending/sketch-align-points.json b/assets/locales/pending/sketch-align-points.json
new file mode 100644
index 0000000000..6e697b75bb
--- /dev/null
+++ b/assets/locales/pending/sketch-align-points.json
@@ -0,0 +1,34 @@
+{
+ "en": {
+ "prefs.sketch_align_points": "Line up with other sketch points while drawing",
+ "prefs.sketch_align_points_note": "While drawing, a point lines up horizontally with one sketch point and vertically with another at the same time, with a dotted guide, and the click keeps both alignments. Off: only with the previous point, one axis at a time."
+ },
+ "ar": {
+ "prefs.sketch_align_points": "المحاذاة مع نقاط الرسم الأخرى أثناء الرسم",
+ "prefs.sketch_align_points_note": "أثناء الرسم، تتحاذى النقطة أفقيًا مع نقطة رسم وعموديًا مع نقطة أخرى في الوقت نفسه، مع خط إرشادي منقط، وتحتفظ النقرة بالمحاذاتين. عند الإيقاف: مع النقطة السابقة فقط، محور واحد في كل مرة."
+ },
+ "de": {
+ "prefs.sketch_align_points": "Beim Zeichnen an anderen Skizzenpunkten ausrichten",
+ "prefs.sketch_align_points_note": "Beim Zeichnen richtet sich ein Punkt zugleich waagerecht an einem Skizzenpunkt und senkrecht an einem anderen aus, mit einer gepunkteten Hilfslinie; der Klick behält beide Ausrichtungen. Aus: nur am vorherigen Punkt, jeweils eine Achse."
+ },
+ "he": {
+ "prefs.sketch_align_points": "יישור לנקודות סקיצה אחרות בזמן השרטוט",
+ "prefs.sketch_align_points_note": "בזמן השרטוט, נקודה מתיישרת אופקית עם נקודת סקיצה אחת ואנכית עם אחרת בו-זמנית, עם קו עזר מנוקד, והלחיצה שומרת את שני היישורים. כבוי: רק עם הנקודה הקודמת, ציר אחד בכל פעם."
+ },
+ "ja": {
+ "prefs.sketch_align_points": "描画中にほかのスケッチ点に揃える",
+ "prefs.sketch_align_points_note": "描画中、点が一つのスケッチ点と水平に、別の点と垂直に同時に揃い、点線のガイドが表示されます。クリックすると両方の整列が保持されます。オフ: 直前の点にのみ、一度に一方向だけ揃えます。"
+ },
+ "ko": {
+ "prefs.sketch_align_points": "그리는 동안 다른 스케치 점에 맞추기",
+ "prefs.sketch_align_points_note": "그리는 동안 점이 한 스케치 점과 수평으로, 다른 점과 수직으로 동시에 맞춰지고 점선 안내선이 표시됩니다. 클릭하면 두 정렬이 모두 유지됩니다. 끄기: 이전 점에만, 한 번에 한 축씩 맞춥니다."
+ },
+ "vi": {
+ "prefs.sketch_align_points": "Căn theo các điểm phác thảo khác khi vẽ",
+ "prefs.sketch_align_points_note": "Khi vẽ, một điểm được căn ngang theo một điểm phác thảo và căn dọc theo điểm khác cùng lúc, kèm đường dẫn chấm; cú nhấp giữ cả hai ràng buộc căn. Tắt: chỉ căn theo điểm trước, mỗi lần một trục."
+ },
+ "zh": {
+ "prefs.sketch_align_points": "绘制时与其他草图点对齐",
+ "prefs.sketch_align_points_note": "绘制时,点可同时与一个草图点水平对齐、与另一个草图点竖直对齐,并显示虚线参考线;单击后保留两个对齐约束。关闭:仅与上一点对齐,每次一个方向。"
+ }
+}
diff --git a/crates/ui-egui/src/prefs.rs b/crates/ui-egui/src/prefs.rs
index 4d3c1eb099..681e49cd5e 100644
--- a/crates/ui-egui/src/prefs.rs
+++ b/crates/ui-egui/src/prefs.rs
@@ -1229,6 +1229,10 @@ 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;
+ /// Drawing lines a point up with the sketch's points on both axes at once, keeping the
+ /// horizontal or vertical snap to the previous point, and the click adds the alignments
+ /// (#7828). Off by default: only with the previous point, one axis at a time, as before.
+ sketch_align_points: bool = false, 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).
@@ -4806,6 +4810,7 @@ mod tests {
("suppress_sketch_snap", json!(ModifierCombo::NONE), PAGE_SKETCH),
("sketch_state_icons", json!(false), PAGE_SKETCH),
("sketch_tracking_guides", json!(false), PAGE_SKETCH),
+ ("sketch_align_points", json!(true), PAGE_SKETCH),
("msaa", json!(8), PAGE_GRAPHICS),
("single_surface_analysis", json!(false), PAGE_GRAPHICS),
];
diff --git a/crates/ui-egui/src/prefs/sketch.rs b/crates/ui-egui/src/prefs/sketch.rs
index b72466c2c8..6455f88352 100644
--- a/crates/ui-egui/src/prefs/sketch.rs
+++ b/crates/ui-egui/src/prefs/sketch.rs
@@ -7,6 +7,8 @@ pub(super) fn show(app: &mut SolveApp, ui: &mut egui::Ui) {
ui_kit::settings_section(ui, "sketch", app.tr("prefs.sketching"), |ui| {
ui_kit::checkbox(ui, app.tr("prefs.sketch_tracking_guides"), &mut app.preferences.sketch_tracking_guides)
.on_hover_text(app.tr("prefs.sketch_tracking_guides_note"));
+ ui_kit::checkbox(ui, app.tr("prefs.sketch_align_points"), &mut app.preferences.sketch_align_points)
+ .on_hover_text(app.tr("prefs.sketch_align_points_note"));
let mut auto = app.session.auto_project;
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}));
diff --git a/crates/ui-egui/src/sketch_guidance_ui_tests.rs b/crates/ui-egui/src/sketch_guidance_ui_tests.rs
index 8a659ec812..63185e10a0 100644
--- a/crates/ui-egui/src/sketch_guidance_ui_tests.rs
+++ b/crates/ui-egui/src/sketch_guidance_ui_tests.rs
@@ -355,3 +355,112 @@ fn tracking_does_not_leak_outside_the_viewport_or_into_another_sketch() {
h.frames(3);
assert!(h.app.viewport.tracking.guide.is_none());
}
+
+/// Lining up while drawing (#7828), turned on (it is off by default): a fixture whose points sit
+/// off the grid, so that only lining up can place a point exactly on them, seen from the top at
+/// about 1 mm of snap tolerance.
+fn lining_up_fixture(points: &[(&str, Value)]) -> Harness {
+ let mut h = Harness::new();
+ h.app.home.open = false;
+ h.app.preferences.look_at_anim = false;
+ assert!(!h.app.preferences.sketch_align_points, "off unless turned on");
+ h.app.preferences.sketch_align_points = true;
+ h.app.run("sketch.create", json!({"plane":"XY"})).unwrap();
+ for (command, params) in points {
+ h.app.run(command, params.clone()).unwrap();
+ }
+ h.call("ui.view", json!({"view":"top"}));
+ h.call("ui.camera", json!({"target":[25,0,0],"distance":180}));
+ h.frames(3);
+ h
+}
+
+/// The active sketch's point at `at`, and the points level (`Horizontal`) or plumb (`Vertical`)
+/// constraints tie it to.
+fn point_and_alignments(h: &Harness, at: [f64; 2]) -> Option<(String, Vec<(&'static str, String)>)> {
+ use solidcraft_engine::sketch::ConstraintKind::{HorizontalPoints, VerticalPoints};
+ let st = h.app.session.world_state();
+ let sk = &st.sketch(h.app.session.active_sketch?)?.sketch;
+ let at = solidcraft_engine::geom::Vec2::new(at[0], at[1]);
+ let i = sk.points.iter().position(|p| p.pos.dist(at) < 1e-9)?;
+ let id = |k: usize| sk.points.get(k).map(|p| p.id.clone()).unwrap_or_default();
+ let tied = sk
+ .constraints
+ .iter()
+ .filter_map(|c| match c.kind {
+ HorizontalPoints { p, q } if p == i || q == i => Some(("Horizontal", id(if p == i { q } else { p }))),
+ VerticalPoints { p, q } if p == i || q == i => Some(("Vertical", id(if p == i { q } else { p }))),
+ _ => None,
+ })
+ .collect();
+ Some((id(i), tied))
+}
+
+#[test]
+fn line_up_takes_the_nearest_point_on_each_axis_on_its_own() {
+ use crate::sketch_tools::{Lined, line_up};
+ use solidcraft_engine::geom::Vec2;
+ let points = [(Some("a".to_string()), Vec2::new(0.0, 10.4)), (Some("b".to_string()), Vec2::new(50.3, -30.0)), (None, Vec2::new(5.0, 10.2))];
+ let (level, plumb) = line_up(&points, Vec2::new(50.0, 10.0), 0.5);
+ assert_eq!(level, Some(Lined { id: None, at: Vec2::new(5.0, 10.2), horizontal: true }), "the nearer of the two level points");
+ assert_eq!(plumb, Some(Lined { id: Some("b".into()), at: Vec2::new(50.3, -30.0), horizontal: false }));
+ // Right on a point is a point snap's business, not lining up; far from all, nothing.
+ assert_eq!(line_up(&points, Vec2::new(50.3, -30.1), 0.5), (None, None));
+ assert_eq!(line_up(&points, Vec2::new(25.0, -10.0), 0.5), (None, None));
+}
+
+/// #8089, a duplicate of #7828: a rectangle drawn beside another takes its height from one
+/// rectangle and its width from a point below, both at once, and keeps both alignments, in the
+/// rectangle's one undo step. With the preference off, only one axis lines up, as before.
+#[test]
+fn a_rectangle_corner_lines_up_with_two_points_at_once_and_keeps_both() {
+ for aligning in [true, false] {
+ let mut h = lining_up_fixture(&[
+ ("sketch.rectangle.two_point", json!({"p0":[0,0],"p1":[20.37,10.43]})),
+ ("sketch.point", json!({"point":[50.37,-30.21]})),
+ ]);
+ h.app.preferences.sketch_align_points = aligning;
+ let undo = h.app.session.undo.len();
+ let below = point_and_alignments(&h, [50.37, -30.21]).unwrap().0;
+ step(&mut h, json!({"start":"sketch.rectangle.two_point"}));
+ step(&mut h, json!({"click":{"sketch":[30,0.3]}}));
+ step(&mut h, json!({"move":{"sketch":[50.2,10.6]}}));
+ if aligning {
+ step(&mut h, json!({"expect":{"count":{"name":"sketch_align_guides","value":2}}}));
+ }
+ step(&mut h, json!({"click":{"sketch":[50.2,10.6]}}));
+ let corner = point_and_alignments(&h, [50.37, 10.43]);
+ if !aligning {
+ assert!(corner.is_none(), "off: the corner follows the grid, not the other points");
+ continue;
+ }
+ let (_, tied) = corner.expect("the corner lands level with the rectangle's top and plumb with the point");
+ assert!(tied.iter().any(|(kind, to)| *kind == "Vertical" && *to == below), "{tied:?}");
+ assert!(tied.iter().any(|(kind, _)| *kind == "Horizontal"), "{tied:?}");
+ let (_, start) = point_and_alignments(&h, [30.0, 0.0]).expect("the first corner lines up with the bottom");
+ assert!(start.iter().any(|(kind, _)| *kind == "Horizontal"), "{start:?}");
+ assert_eq!(h.app.session.undo.len(), undo + 1, "the alignments are in the rectangle's undo step");
+ }
+}
+
+/// #7828: a line kept horizontal from its start also lines up under a point above, and the
+/// click keeps both: the line's Horizontal and the end's alignment with that point.
+#[test]
+fn a_horizontal_line_ends_plumb_with_a_point_above_and_keeps_both() {
+ let mut h = lining_up_fixture(&[("sketch.point", json!({"point":[20.37,30.13]}))]);
+ let above = point_and_alignments(&h, [20.37, 30.13]).unwrap().0;
+ step(&mut h, json!({"start":"sketch.line"}));
+ step(&mut h, json!({"click":{"sketch":[0,0]}}));
+ step(&mut h, json!({"move":{"sketch":[20.2,0.15]}}));
+ step(&mut h, json!({"expect":{"count":{"name":"sketch_align_guides","value":1}}}));
+ step(&mut h, json!({"click":{"sketch":[20.2,0.15]}}));
+ step(&mut h, json!({"key":"Escape"}));
+ let (_, tied) = point_and_alignments(&h, [20.37, 0.0]).expect("the end is level with the start and plumb with the point");
+ assert_eq!(tied, [("Vertical", above)]);
+ let st = h.app.session.world_state();
+ let sk = &st.sketch(h.app.session.active_sketch.unwrap()).unwrap().sketch;
+ assert!(
+ sk.constraints.iter().any(|c| matches!(c.kind, solidcraft_engine::sketch::ConstraintKind::Horizontal { .. })),
+ "the line stays horizontal"
+ );
+}
diff --git a/crates/ui-egui/src/sketch_tools.rs b/crates/ui-egui/src/sketch_tools.rs
index 0a8fa3a9ff..d64c84aafd 100644
--- a/crates/ui-egui/src/sketch_tools.rs
+++ b/crates/ui-egui/src/sketch_tools.rs
@@ -85,7 +85,11 @@ thread_local! {
static PICKED: RefCell<Option<String>> = const { RefCell::new(None) };
/// The inference the cursor snapped to last (label, sketch point), for the hint.
static SNAP: RefCell<Option<(&'static str, Vec2)>> = const { RefCell::new(None) };
- static PREV: Cell<Option<Vec2>> = const { Cell::new(None) };
+ /// The points that snap lined the cursor up with, and where it went (#7828).
+ static LINED: RefCell<Option<(Vec2, Vec<Lined>)>> = const { RefCell::new(None) };
+ /// The drawing tool's points so far and whether it is the Line tool, from the last hover: a
+ /// click takes the tool out of the app while it runs, and must place what the hover showed.
+ static TOOL: RefCell<(Vec<Vec2>, bool)> = const { RefCell::new((Vec::new(), true)) };
/// Curvature comb teeth (foot, tip) shown while the comb tool is active.
static COMBS: RefCell<Vec<Vec<[Vec3; 2]>>> = const { RefCell::new(Vec::new()) };
/// The image file a Canvas or Decal tool places.
@@ -381,6 +385,82 @@ fn combs(app: &SolveApp, painter: &egui::Painter, proj: &Proj) {
});
}
+/// A point the cursor lined up with while drawing (#7828): its sketch point id (none for a point
+/// of the shape being drawn, not in the sketch yet), where it is, and the axis the cursor
+/// shares with it: level (`horizontal`, the same y) or plumb (the same x).
+#[derive(Clone, Debug, PartialEq)]
+pub struct Lined {
+ pub id: Option<String>,
+ pub at: Vec2,
+ pub horizontal: bool,
+}
+
+/// The points the cursor can line up with: the sketch's visible points on screen (line ends,
+/// centres, standalone points, the origin) and the shape's own points so far.
+fn align_targets(
+ proj: &Proj,
+ sk: &solidcraft_engine::sketch::Sketch,
+ plane: &solidcraft_engine::geom::Plane,
+ own: &[Vec2],
+) -> Vec<(Option<String>, Vec2)> {
+ let visible = solidcraft_engine::view::SketchPointVisibility::new(sk);
+ let on_screen = |p: Vec2| proj.to_screen(plane.to_world(p)).is_some_and(|q| proj.rect.contains(q));
+ let mut out: Vec<(Option<String>, Vec2)> =
+ sk.points.iter().filter(|p| visible.takes(p) && on_screen(p.pos)).map(|p| (Some(p.id.clone()), p.pos)).collect();
+ out.extend(own.iter().map(|p| (None, *p)));
+ out
+}
+
+/// The nearest point level with `lp` (within `tol` across, more than `tol` along) and the
+/// nearest plumb with it, each on its own axis, as a dragged point lines up (`drag_snap::find`).
+pub(crate) fn line_up(points: &[(Option<String>, Vec2)], lp: Vec2, tol: f64) -> (Option<Lined>, Option<Lined>) {
+ let (mut level, mut plumb): (Option<(f64, Lined)>, Option<(f64, Lined)>) = (None, None);
+ for (id, p) in points {
+ let (dx, dy) = ((lp.x - p.x).abs(), (lp.y - p.y).abs());
+ if dy < tol && dx > tol && level.as_ref().is_none_or(|l| dy < l.0) {
+ level = Some((dy, Lined { id: id.clone(), at: *p, horizontal: true }));
+ }
+ if dx < tol && dy > tol && plumb.as_ref().is_none_or(|l| dx < l.0) {
+ plumb = Some((dx, Lined { id: id.clone(), at: *p, horizontal: false }));
+ }
+ }
+ (level.map(|l| l.1), plumb.map(|l| l.1))
+}
+
+/// What the last snap lined a point placed at `at` up with (#7828).
+pub(crate) fn lined_at(at: Vec2) -> Vec<Lined> {
+ LINED.with(|l| l.borrow().as_ref().filter(|(p, _)| p.dist(at) < 1e-9).map(|(_, lined)| lined.clone()).unwrap_or_default())
+}
+
+/// The active sketch's point ids, to tell the points a command makes from those it had.
+pub(crate) fn point_ids(app: &SolveApp) -> Vec<String> {
+ let st = app.session.world_state();
+ app.session.active_sketch.and_then(|id| st.sketch(id)).map(|ss| ss.sketch.points.iter().map(|p| p.id.clone()).collect()).unwrap_or_default()
+}
+
+/// Once a shape is made (#7828): each new point that was placed lined up with a sketch point
+/// (`placed`, the shape's points) stays level or plumb with it. Only what the sketch doesn't
+/// already have is added, in the shape's undo step.
+pub(crate) fn constrain_lined(app: &mut SolveApp, tool: &mut Tool, placed: &[Vec2], before: &[String]) {
+ let lined = std::mem::take(&mut tool.lined);
+ let new: Vec<(String, Vec2)> = {
+ let st = app.session.world_state();
+ let Some(ss) = app.session.active_sketch.and_then(|id| st.sketch(id)) else { return };
+ ss.sketch.points.iter().filter(|p| !before.contains(&p.id)).map(|p| (p.id.clone(), p.pos)).collect()
+ };
+ let history = std::mem::take(&mut app.session.undo);
+ for (at, targets) in lined.iter().filter(|(at, _)| placed.iter().any(|p| p.dist(*at) < 1e-9)) {
+ let Some((point, _)) = new.iter().find(|(_, p)| p.dist(*at) < 1e-6) else { continue };
+ for target in targets {
+ let Some(id) = &target.id else { continue };
+ let mode = if target.horizontal { "horizontal" } else { "vertical" };
+ let params = json!({"points": [point, id], "mode": mode, "if_redundant": "refuse"});
+ let _ = app.session.execute("sketch.constraint.horizontal_vertical", &params);
+ }
+ }
+ app.session.undo = history;
+}
+
/// Snap a cursor point on the sketch plane to what is inferred while drawing: a crossing of
/// two curves, a line's midpoint, or alignment (horizontal/vertical) with the previous point
/// of the tool. None: nothing near, use the grid.
@@ -392,6 +472,7 @@ pub fn refine_snap(
lp: Vec2,
) -> Option<(Vec2, Option<String>)> {
crate::inference::clear();
+ LINED.with(|l| *l.borrow_mut() = None);
// Millimetres per pixel here.
let (a, b) = (proj.to_screen(plane.to_world(lp))?, proj.to_screen(plane.to_world(lp + Vec2::X))?);
let px = 1.0 / (a.distance(b) as f64).max(1e-9);
@@ -430,19 +511,21 @@ pub fn refine_snap(
}
}
}
- // The tool's previous point (a click takes the tool out of the app while it runs, so the
- // last hover's is kept).
- let prev = match app.tool.as_ref() {
+ // The tool's points and kind (a click takes the tool out of the app while it runs, so the
+ // last hover's are kept: a rectangle's click takes no Line tool inference its hover didn't).
+ let (own, line_tool) = match app.tool.as_ref() {
Some(t) => {
- let p = t.pts.last().map(|p| p.0);
- PREV.with(|c| c.set(p));
- p
+ let own: (Vec<Vec2>, bool) = (t.pts.iter().map(|p| p.0).collect(), t.cmd == "sketch.line");
+ TOOL.with(|c| *c.borrow_mut() = own.clone());
+ own
}
- None => PREV.with(Cell::get),
+ None => TOOL.with(|c| c.borrow().clone()),
};
+ // With `sketch_align_points` off, a click takes the Line tool's inferences, as before.
+ let line_tool = if app.preferences.sketch_align_points { line_tool } else { app.tool.as_ref().is_none_or(|t| t.cmd == "sketch.line") };
+ let prev = own.last().copied();
// Line tool: the tangent point of a circle or arc, then a line through its centre
// (before plain "on the curve", which would leave a chord free to miss the centre).
- let line_tool = app.tool.as_ref().is_none_or(|t| t.cmd == "sketch.line");
if !mid_only
&& best.is_none()
&& line_tool
@@ -472,18 +555,26 @@ pub fn refine_snap(
}
}
}
+ // The free coordinate still follows the grid.
+ let step = solidcraft_engine::view::grid_step(app.cam.half_height()).0 / 10.0;
+ let g = |v: f64| (v / step).round() * step;
+ // Points to line up with as well (#7828): with `sketch_align_points` off, none, so only the
+ // previous point, one axis at a time, as before.
+ let targets = if app.preferences.sketch_align_points { align_targets(proj, sk, plane, &own) } else { Vec::new() };
+ let mut lined = Vec::new();
if !mid_only
&& best.is_none()
&& let Some(prev) = prev
{
let (dx, dy) = ((lp.x - prev.x).abs(), (lp.y - prev.y).abs());
- // The free coordinate still follows the grid.
- let step = solidcraft_engine::view::grid_step(app.cam.half_height()).0 / 10.0;
- let g = |v: f64| (v / step).round() * step;
+ // Level with (or plumb with) the previous point, and lined up across with another.
+ let (level, plumb) = line_up(&targets, lp, tol);
if dy < tol && dx > tol {
- best = Some((dy, "H", Vec2::new(g(lp.x), prev.y)));
+ best = Some((dy, if plumb.is_some() { "H+V" } else { "H" }, Vec2::new(plumb.as_ref().map_or(g(lp.x), |p| p.at.x), prev.y)));
+ lined.extend(plumb);
} else if dx < tol && dy > tol {
- best = Some((dx, "V", Vec2::new(prev.x, g(lp.y))));
+ best = Some((dx, if level.is_some() { "H+V" } else { "V" }, Vec2::new(prev.x, level.as_ref().map_or(g(lp.y), |l| l.at.y))));
+ lined.extend(level);
}
}
// Line tool: parallel or perpendicular to a line, or on a line's extension.
@@ -495,7 +586,25 @@ pub fn refine_snap(
{
best = Some((i.dist, i.label(), i.at));
}
+ // Lined up with other points, on one axis or on both at once (#7828).
+ if !mid_only && best.is_none() {
+ let (level, plumb) = line_up(&targets, lp, tol);
+ let at = Vec2::new(plumb.as_ref().map_or(g(lp.x), |p| p.at.x), level.as_ref().map_or(g(lp.y), |l| l.at.y));
+ let off = |l: &Lined| if l.horizontal { (lp.y - l.at.y).abs() } else { (lp.x - l.at.x).abs() };
+ let label = match (&level, &plumb) {
+ (Some(_), Some(_)) => Some("H+V"),
+ (Some(_), None) => Some("H"),
+ (None, Some(_)) => Some("V"),
+ (None, None) => None,
+ };
+ if let Some(label) = label {
+ best = Some((level.iter().chain(&plumb).map(off).fold(f64::INFINITY, f64::min), label, at));
+ lined.extend(level);
+ lined.extend(plumb);
+ }
+ }
SNAP.with(|s| *s.borrow_mut() = best.map(|(_, l, p)| (l, p)));
+ LINED.with(|l| *l.borrow_mut() = best.filter(|_| !lined.is_empty()).map(|(_, _, at)| (at, lined)));
// A midpoint snap is a point argument the commands understand ("mid:<line>").
// "x:a+b:x,y" is a crossing of two curves; "on:<curve>:x,y" is a point on one curve.
best.map(|(_, l, p)| {
@@ -643,6 +752,7 @@ pub fn tool_for(id: &str) -> Option<Tool> {
dims_stage: usize::MAX,
dims_focus: false,
arc_turn: 0.0,
+ lined: Vec::new(),
})
}
@@ -1584,6 +1694,12 @@ fn snap_hint(app: &SolveApp, painter: &egui::Painter, proj: &Proj) {
let Some(ss) = active_sketch(app).and_then(|s| st.sketch(s)) else { return };
let Some(sp) = proj.to_screen(ss.plane.to_world(p)) else { return };
let tk = crate::theme::Tokens::get();
+ // A dotted guide from each point the snap lined the cursor up with (#7828).
+ let guides = LINED.with(|l| l.borrow().as_ref().filter(|(at, _)| at.dist(p) < 1e-9).map(|(_, lined)| lined.clone()).unwrap_or_default());
+ for from in guides.iter().filter_map(|l| proj.to_screen(ss.plane.to_world(l.at))) {
+ painter.add(egui::Shape::dashed_line(&[from, sp], Stroke::new(1.0, tk.rubber_band), 5.0, 4.0));
+ }
+ crate::scenario::publish_count("sketch_align_guides", guides.len() as f64);
let r = egui::Rect::from_min_size(sp + egui::vec2(12.0, -24.0), egui::vec2(24.0, 14.0));
painter.rect_filled(r, tk.radius_sm.saturating_sub(1), tk.accent_soft);
painter.text(r.center(), egui::Align2::CENTER_CENTER, label, egui::FontId::proportional(crate::theme::Tokens::get().font_micro), tk.text);
diff --git a/crates/ui-egui/src/tools.rs b/crates/ui-egui/src/tools.rs
index 2780e35a8c..4eca51a7b2 100644
--- a/crates/ui-egui/src/tools.rs
+++ b/crates/ui-egui/src/tools.rs
@@ -94,6 +94,9 @@ pub struct Tool {
/// How far (radians, signed) the cursor has gone round a centre-point arc's centre since its
/// start was placed: its sign is the way the arc runs (#6645).
pub arc_turn: f64,
+ /// Where each point was placed and the sketch points the snap lined it up with (#7828):
+ /// constrained to them once the shape is made.
+ pub lined: Vec<(Vec2, Vec<crate::sketch_tools::Lined>)>,
}
impl Tool {
@@ -145,6 +148,7 @@ impl Tool {
dims_stage: usize::MAX,
dims_focus: false,
arc_turn: 0.0,
+ lined: Vec::new(),
})
}
}
@@ -496,7 +500,9 @@ pub fn place(app: &mut SolveApp, p: (Vec2, Option<String>)) {
app.tool = Some(tool);
return;
}
+ tool.lined.push((p.0, crate::sketch_tools::lined_at(p.0)));
tool.pts.push(p);
+ let before = crate::sketch_tools::point_ids(app);
if tool.cmd == "sketch.line" {
if tool.pts.len() >= 2 {
let (a, b) = (tool.pts[tool.pts.len() - 2].clone(), tool.pts[tool.pts.len() - 1].clone());
@@ -508,11 +514,13 @@ pub fn place(app: &mut SolveApp, p: (Vec2, Option<String>)) {
if let Some(id) = curves.first() {
if angled {
crate::inference::clear();
+ tool.lined.clear();
} else {
// Endpoint inference is part of this drawing. Preserve its original
// undo history even when the history is already at the engine's cap.
let history = dimensioned.then(|| std::mem::take(&mut app.session.undo));
crate::inference::commit(app, id, b.0);
+ crate::sketch_tools::constrain_lined(app, &mut tool, &[a.0, b.0], &before);
if let Some(history) = history {
app.session.undo = history;
}
@@ -525,17 +533,21 @@ pub fn place(app: &mut SolveApp, p: (Vec2, Option<String>)) {
crate::sketch_dims::reset(&mut tool);
} else {
tool.pts.pop();
+ tool.lined.pop();
}
}
} else if n > 0 && tool.pts.len() >= n {
match run_shape(app, &tool) {
Ok(_) => {
+ let placed: Vec<Vec2> = tool.pts.iter().map(|p| p.0).collect();
+ crate::sketch_tools::constrain_lined(app, &mut tool, &placed, &before);
tool.pts.clear();
crate::sketch_dims::reset(&mut tool);
}
Err(error) => {
app.set_status(error, true);
tool.pts.pop();
+ tool.lined.pop();
}
}
}
diff --git a/docs/book/src/guide/sketching.md b/docs/book/src/guide/sketching.md
index a0d0474b99..9501d56165 100644
--- a/docs/book/src/guide/sketching.md
+++ b/docs/book/src/guide/sketching.md
@@ -199,6 +199,17 @@ to prefer a line midpoint instead; hold Ctrl/Cmd or Alt/Option (the default supp
to stop snapping for that gesture. Scripts pass `"x:<curve>+<curve>:x,y"` as a point
argument, the same way `"mid:<line>"` and `"on:<curve>:x,y"` work.
+With Preferences › Sketch › **Line up with other sketch points while drawing** turned on (it's
+off by default), the pointer also **lines up** while drawing with the sketch's points on screen:
+line ends, centres, standalone points and the origin, and the shape's own earlier points. It
+lines up on both axes at once, level with one point and plumb with another, so a rectangle drawn
+beside another can take its height from one and its width from a point below. A line kept
+horizontal or vertical from its start can still end under or beside another point. A dotted guide
+runs from each point it lines up with, and the snap hint shows **H**, **V** or **H+V**. The click
+keeps the alignment: the new point gets a Horizontal or Vertical constraint with each sketch
+point it lined up with, in the shape's undo step, unless the sketch already sets it. With the
+preference off, drawing lines up only with the previous point, one axis at a time.
+
Enable **3D Sketch** in the Sketch Palette to draw lines, fit splines and points off the plane.
While placing these points, you can snap to points on other visible sketches. For a bridge
line, start Line and click an endpoint on each source sketch; each endpoint uses its source