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

* claim: #7828

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

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

While drawing, the pointer lines up horizontally with the nearest sketch
point level with it and vertically with the nearest one plumb with it, at
the same time, as a dragged point already does; holding H/V with the
previous point still lines up across with another point. Dotted guides run
from the points lined up with (H, V or H+V), and the click adds a
Horizontal or Vertical constraint with each, in the shape's undo step,
unless the sketch already has it.

A click takes the tool out of the app while it runs, so refine_snap
treated every tool as the Line tool then: a rectangle's click could take a
line-extension inference its hover never showed. The tool's points and
kind are kept from the last hover, as the previous point was.

Preferences > Sketch > "Line up with other sketch points while drawing"
(sketch_align_points) turns it off for the old behaviour.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* Sketch: lining up with other points is off unless turned on

Review on #8474: sketch_align_points defaults to off, so nothing changes for anyone who
doesn't turn it on. With it off, a click also treats the tool as before (the Line tool's
inferences), instead of keeping the tool's kind from the hover.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Ryan
2026-10-29 17:11:42 +00:00
committed by GitHub
parent 6255a10e80
commit 791abbd9b1
7 changed files with 303 additions and 14 deletions
@@ -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": "绘制时,点可同时与一个草图点水平对齐、与另一个草图点竖直对齐,并显示虚线参考线;单击后保留两个对齐约束。关闭:仅与上一点对齐,每次一个方向。"
}
}
+5
View File
@@ -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),
];
+2
View File
@@ -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}));
@@ -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"
);
}
+130 -14
View File
@@ -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);
+12
View File
@@ -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();
}
}
}
+11
View File
@@ -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