mirror of
https://github.com/storytold/cadcraft.git
synced 2026-11-20 21:00:47 -06:00
Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
fe3b20a37a | ||
|
|
9746b6999a | ||
|
|
0ca0af9026 | ||
|
|
6971715295 | ||
|
|
5bfba91aa8 | ||
|
|
080c96aa06 | ||
|
|
a2f732118f | ||
|
|
c2af11dfa7 | ||
|
|
b1dcb46e08 | ||
|
|
c00bc59949 | ||
|
|
1b577e9eed | ||
|
|
29bf02b6ce | ||
|
|
1998da2643 | ||
|
|
28ed9c58a7 | ||
|
|
a3560a1442 | ||
|
|
c40ff9603e | ||
|
|
595ccf2b06 | ||
|
|
8acdceeb61 | ||
|
|
4ce72c668a | ||
|
|
55ec024e31 | ||
|
|
64cb95d8ec | ||
|
|
4a0063f5f6 | ||
|
|
f4f0702d08 | ||
|
|
98401d6de2 | ||
|
|
97fbaf7da4 | ||
|
|
90a239b410 |
@@ -343,6 +343,11 @@ fn eq_variants(o: &TanObj) -> Vec<Eq3> {
|
||||
|
||||
/// Circle tangent to three objects, nearest the pick points (Newton on all sign combinations).
|
||||
pub fn ttt(objs: [(TanObj, Vec2); 3]) -> Option<Circle> {
|
||||
ttt_where(objs, |_| true)
|
||||
}
|
||||
|
||||
/// [`ttt`] among the circles `ok` accepts.
|
||||
pub fn ttt_where(objs: [(TanObj, Vec2); 3], ok: impl Fn(&Circle) -> bool) -> Option<Circle> {
|
||||
let [(o1, p1), (o2, p2), (o3, p3)] = objs;
|
||||
let mut starts: Vec<[f64; 3]> = Vec::new();
|
||||
let cen = (p1 + p2 + p3) / 3.0;
|
||||
@@ -379,6 +384,9 @@ pub fn ttt(objs: [(TanObj, Vec2); 3]) -> Option<Circle> {
|
||||
continue;
|
||||
}
|
||||
let c = Circle::new(Vec2::new(x[0], x[1]), x[2]);
|
||||
if !ok(&c) {
|
||||
continue;
|
||||
}
|
||||
let sc = score(&c, &objs);
|
||||
if best.is_none_or(|(b, _)| sc < b - 1e-12) {
|
||||
best = Some((sc, c));
|
||||
|
||||
@@ -2,6 +2,7 @@ use super::{
|
||||
Accept, Arc, Circle, EntityKind, Input, Interactive, Prompt, Result, Session, Step, Value, Vec2, added, arc, bad, circle, f64_req, line, number,
|
||||
point_param, size_param,
|
||||
};
|
||||
use crate::snap;
|
||||
|
||||
pub(super) fn run_circle(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let c = if let Some(center) = point_param(p, "center") {
|
||||
@@ -51,6 +52,8 @@ pub(super) fn run_arc(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
pub(super) struct CircleM {
|
||||
mode: u8, // 0 center-radius, 1 = 3P, 2 = 2P, 3 = TTR
|
||||
pts: Vec<Vec2>,
|
||||
/// 3P: the circle or arc each point was picked on with a tangent snap, by point.
|
||||
tans: Vec<Option<snap::SnapCurve>>,
|
||||
diameter: bool,
|
||||
/// The `Ttr` option hands over to the tangent-circle machine.
|
||||
delegate: Option<Box<dyn Interactive>>,
|
||||
@@ -69,18 +72,22 @@ impl Interactive for CircleM {
|
||||
match (self.mode, n) {
|
||||
(0, 0) => Prompt::new("Specify center point for circle", Accept::POINT).kw(&["3P", "2P", "Ttr (tan tan radius)"]),
|
||||
(0, _) if self.diameter => {
|
||||
Prompt::new("Specify diameter of circle", Accept::POINT_OR_NUMBER).base_opt(self.pts.first().copied()).distance()
|
||||
Prompt::new("Specify diameter of circle", Accept::POINT_OR_NUMBER).base_opt(self.pts.first().copied()).distance().deferred()
|
||||
}
|
||||
(0, _) => {
|
||||
let p =
|
||||
Prompt::new("Specify radius of circle", Accept::POINT_OR_NUMBER).kw(&["Diameter"]).base_opt(self.pts.first().copied()).distance();
|
||||
let p = Prompt::new("Specify radius of circle", Accept::POINT_OR_NUMBER)
|
||||
.kw(&["Diameter"])
|
||||
.base_opt(self.pts.first().copied())
|
||||
.distance()
|
||||
.deferred();
|
||||
if last_r > 0.0 { p.default(format!("{last_r:.4}")) } else { p }
|
||||
}
|
||||
(1, k) => Prompt::new(
|
||||
["Specify first point on circle", "Specify second point on circle", "Specify third point on circle"].get(k).copied().unwrap_or(""),
|
||||
Accept::POINT,
|
||||
)
|
||||
.base_opt(self.pts.last().copied()),
|
||||
.base_opt(self.pts.last().copied())
|
||||
.deferred(),
|
||||
(2, k) => Prompt::new(
|
||||
if k == 0 { "Specify first end point of circle's diameter" } else { "Specify second end point of circle's diameter" },
|
||||
Accept::POINT,
|
||||
@@ -120,7 +127,14 @@ impl Interactive for CircleM {
|
||||
let r = if self.diameter { c.dist(*e) / 2.0 } else { c.dist(*e) };
|
||||
Some(Circle::new(*c, r))
|
||||
}
|
||||
1 if self.pts.len() == 3 => Circle::from_3_points(self.pts[0], self.pts[1], self.pts[2]),
|
||||
1 if self.pts.len() == 3 => match self.three_points() {
|
||||
Some(c) => Some(c),
|
||||
None => {
|
||||
self.pts.pop();
|
||||
self.tans.truncate(self.pts.len());
|
||||
return Err(crate::EngineError::Other("Circle does not exist.".into()));
|
||||
}
|
||||
},
|
||||
2 if self.pts.len() == 2 => Some(Circle::from_2_points(self.pts[0], self.pts[1])),
|
||||
_ => None,
|
||||
};
|
||||
@@ -130,6 +144,29 @@ impl Interactive for CircleM {
|
||||
}
|
||||
Ok(Step::Continue)
|
||||
}
|
||||
// 3P: a point picked with a tangent snap makes the circle tangent to that curve (#1512).
|
||||
Input::Deferred(d) if self.mode == 1 => {
|
||||
let tan = (d.mode == snap::mode::TAN && !matches!(d.curve, snap::SnapCurve::Line { .. })).then_some(d.curve);
|
||||
self.tans.resize(self.pts.len(), None);
|
||||
self.tans.push(tan);
|
||||
self.input(s, Input::Point(d.at))
|
||||
}
|
||||
// A tangent picked for the radius: the circle around the center that touches the
|
||||
// curve, on the side it was picked (#1512).
|
||||
Input::Deferred(d) if self.mode == 0 && self.pts.len() == 1 => {
|
||||
let Some(&c) = self.pts.first() else { return Ok(Step::Continue) };
|
||||
// Around the picked curve's own center the circle would lie on it, not touch it.
|
||||
let concentric =
|
||||
matches!(d.curve, snap::SnapCurve::Circle { center, .. } | snap::SnapCurve::Arc { center, .. } if center.near(c, 1e-9));
|
||||
let touch = d.curve.perpendiculars(c, d.at).into_iter().filter(|_| !concentric).min_by(|a, b| a.dist(d.at).total_cmp(&b.dist(d.at)));
|
||||
match touch.map(|t| c.dist(t)).filter(|r| *r > 1e-12 && r.is_finite()) {
|
||||
Some(r) => {
|
||||
finish_circle(s, Circle::new(c, r))?;
|
||||
Ok(Step::Done)
|
||||
}
|
||||
None => Err(crate::EngineError::Other("No circle around the center is tangent there.".into())),
|
||||
}
|
||||
}
|
||||
Input::Text(t) if self.mode == 0 && self.pts.len() == 1 => {
|
||||
let v = number(&t).ok_or_else(|| crate::EngineError::Other("Requires numeric distance or second point.".into()))?;
|
||||
let r = if self.diameter { v / 2.0 } else { v };
|
||||
@@ -174,6 +211,38 @@ impl Interactive for CircleM {
|
||||
}
|
||||
}
|
||||
|
||||
impl CircleM {
|
||||
/// The 3P circle: through the three points, or tangent to the curves picked with TAN.
|
||||
fn three_points(&self) -> Option<Circle> {
|
||||
let [a, b, c] = <[Vec2; 3]>::try_from(self.pts.as_slice()).ok()?;
|
||||
if self.tans.iter().all(Option::is_none) {
|
||||
return Circle::from_3_points(a, b, c);
|
||||
}
|
||||
let tan = |i: usize| self.tans.get(i).copied().flatten();
|
||||
// A plain point is a circle of radius zero to pass through; an arc is solved as its circle.
|
||||
let target = |i: usize, p: Vec2| {
|
||||
let circle = match tan(i) {
|
||||
Some(snap::SnapCurve::Circle { center, radius } | snap::SnapCurve::Arc { center, radius, .. }) => Circle::new(center, radius),
|
||||
_ => Circle::new(p, 0.0),
|
||||
};
|
||||
crate::cmd::curves::TanObj::Circle(circle)
|
||||
};
|
||||
let pts = [a, b, c];
|
||||
// The circle must touch an arc within its sweep, not elsewhere on the arc's circle, and
|
||||
// not be the picked circle itself (which lies on it rather than touching it).
|
||||
let touches = |found: &Circle| {
|
||||
pts.iter().enumerate().all(|(i, p)| {
|
||||
tan(i).is_none_or(|t| {
|
||||
let same = matches!(target(i, *p), crate::cmd::curves::TanObj::Circle(o)
|
||||
if o.center.dist(found.center) + (o.radius - found.radius).abs() <= 1e-9 * o.radius);
|
||||
!same && t.contains(target(i, *p).touch(found))
|
||||
})
|
||||
})
|
||||
};
|
||||
crate::cmd::curves::ttt_where([(target(0, a), a), (target(1, b), b), (target(2, c), c)], touches)
|
||||
}
|
||||
}
|
||||
|
||||
fn finish_circle(s: &mut Session, c: Circle) -> Result<()> {
|
||||
s.add_entity(circle(c.center, c.radius))?;
|
||||
s.doc_mut()?.header.set_f64("CIRCLERAD", c.radius);
|
||||
|
||||
@@ -466,3 +466,61 @@ fn plot_path_extension_picks_the_format_like_export() {
|
||||
assert!(!dir.join("w.png").exists(), "nothing written when `output` and the path disagree");
|
||||
std::fs::remove_dir_all(&dir).ok();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn osnap_in_mspace_skips_vplayer_frozen_layers() {
|
||||
let mut s = Session::new();
|
||||
s.execute("layer.new", &json!({"name": "Hidden"})).unwrap();
|
||||
s.execute("line", &json!({"points": [[60, -25], [70, -25]]})).unwrap();
|
||||
let line_h = s.doc().unwrap().model.iter().last().unwrap().handle;
|
||||
s.execute("properties.set", &json!({"handles": [line_h], "layer": "Hidden"})).unwrap();
|
||||
s.execute("layout.set", &json!({"name": "Layout1"})).unwrap();
|
||||
s.execute("mview", &json!({"p1": [20, 20], "p2": [220, 120]})).unwrap();
|
||||
let vp_h = viewports(&s, "Layout1").last().unwrap().0;
|
||||
s.execute("vplayer", &json!({"handles": [vp_h], "freeze": ["Hidden"]})).unwrap();
|
||||
s.execute("mspace", &json!({"handle": vp_h})).unwrap();
|
||||
|
||||
let ap = s.pixel_size() * s.settings.aperture.max(1.0);
|
||||
let d = ap * 0.5;
|
||||
let model_before = s.doc().unwrap().model.len();
|
||||
for (ovr, pt, name) in [
|
||||
("end", format!("{},-25", 60.0 + d), "Endpoint"),
|
||||
("mid", format!("{},-25", 65.0 + d), "Midpoint"),
|
||||
("nea", format!("63,{}", -25.0 + d), "Nearest"),
|
||||
] {
|
||||
s.cmdline("line").unwrap();
|
||||
s.cmdline(ovr).unwrap();
|
||||
s.cmdline(&pt).unwrap();
|
||||
assert_eq!(
|
||||
s.log.last().map(String::as_str),
|
||||
Some(format!("No {name} found for specified point.").as_str()),
|
||||
"{ovr} should not snap to a line on a VPLAYER-frozen layer; log: {:?}",
|
||||
s.log
|
||||
);
|
||||
s.cmdline("").unwrap();
|
||||
}
|
||||
assert_eq!(s.doc().unwrap().model.len(), model_before, "no new line should be created");
|
||||
|
||||
// Running osnaps through snap_cursor must also ignore the VPLAYER-frozen layer.
|
||||
s.settings.osmode = crate::snap::mode::END | crate::snap::mode::MID | crate::snap::mode::NEA;
|
||||
let cs = s.snap_cursor(
|
||||
cadcraft_geom::Vec2::new(60.0 + d, -25.0),
|
||||
&crate::snap::tracking::CursorQuery { base: None, deferred: false, corner: false, aperture: ap, tol: ap, now: 0.0, shift: false },
|
||||
);
|
||||
assert!(cs.snap.is_none(), "running osnap should not snap to a VPLAYER-frozen line: {:?}", cs.snap);
|
||||
|
||||
// A block reference on layer "0" containing an entity on "Hidden" must also not snap.
|
||||
s.execute("block", &json!({"name": "B", "base": [60, -25], "handles": [line_h]})).unwrap();
|
||||
let model_with_block = s.doc().unwrap().model.len();
|
||||
s.cmdline("line").unwrap();
|
||||
s.cmdline("end").unwrap();
|
||||
s.cmdline(&format!("{},-25", 60.0 + d)).unwrap();
|
||||
assert_eq!(
|
||||
s.log.last().map(String::as_str),
|
||||
Some("No Endpoint found for specified point."),
|
||||
"end should not snap to a block entity on a VPLAYER-frozen layer; log: {:?}",
|
||||
s.log
|
||||
);
|
||||
s.cmdline("").unwrap();
|
||||
assert_eq!(s.doc().unwrap().model.len(), model_with_block);
|
||||
}
|
||||
|
||||
@@ -127,18 +127,31 @@ pub fn snap_name(m: u32) -> &'static str {
|
||||
}
|
||||
|
||||
/// The candidate snaps near `cursor` for Tab cycling: the snap [`crate::snap::osnap`] picks
|
||||
/// first, then the closest snap of each other mode in `osmode`, nearest first, without repeats.
|
||||
/// first, then every other snap of the modes in `osmode` under the aperture (each endpoint of
|
||||
/// each object, each intersection …; [`crate::snap::osnap_all`]), best first, without repeats.
|
||||
pub fn snap_candidates(d: &Drawing, space: &Space, cursor: Vec2, aperture: f64, osmode: u32, base: Option<Vec2>, deferred: bool) -> Vec<SnapHit> {
|
||||
if osmode & !mode::HATCH == 0 || osmode & mode::OFF != 0 {
|
||||
snap_candidates_with_frozen(d, space, cursor, aperture, osmode, base, deferred, &[])
|
||||
}
|
||||
|
||||
/// [`snap_candidates`] skipping entities (and block leaves) on `frozen` layers in `space`.
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
pub fn snap_candidates_with_frozen(
|
||||
d: &Drawing,
|
||||
space: &Space,
|
||||
cursor: Vec2,
|
||||
aperture: f64,
|
||||
osmode: u32,
|
||||
base: Option<Vec2>,
|
||||
deferred: bool,
|
||||
frozen: &[String],
|
||||
) -> Vec<SnapHit> {
|
||||
// A base that is not a number would give meaningless perpendiculars and tangents.
|
||||
if osmode & !mode::HATCH == 0 || osmode & mode::OFF != 0 || base.is_some_and(|b| !b.is_finite()) {
|
||||
return Vec::new();
|
||||
}
|
||||
let osnap = |m: u32| crate::snap::osnap(d, space, cursor, aperture, m, base, deferred);
|
||||
let extra = osmode & mode::HATCH;
|
||||
let mut per_mode: Vec<SnapHit> = mode::ALL.iter().filter(|(b, _)| osmode & b != 0).filter_map(|(b, _)| osnap(*b | extra)).collect();
|
||||
per_mode.sort_by(|a, b| a.point.dist(cursor).total_cmp(&b.point.dist(cursor)));
|
||||
let mut out: Vec<SnapHit> = osnap(osmode).into_iter().collect();
|
||||
for h in per_mode {
|
||||
if !out.iter().any(|o| o.mode == h.mode && o.point.near(h.point, aperture * 1e-6)) {
|
||||
let mut out: Vec<SnapHit> = crate::snap::osnap_with_frozen(d, space, cursor, aperture, osmode, base, deferred, frozen).into_iter().collect();
|
||||
for h in crate::snap::osnap_all_with_frozen(d, space, cursor, aperture, osmode, base, deferred, frozen) {
|
||||
if !out.iter().any(|o| o.same(&h, aperture)) {
|
||||
out.push(h);
|
||||
}
|
||||
}
|
||||
@@ -352,12 +365,15 @@ impl Session {
|
||||
Frame::Snap { mode } => {
|
||||
// Snap the point with this mode alone, within the aperture.
|
||||
let prompt = self.current_prompt();
|
||||
let space = self.space();
|
||||
let (doc, space, frozen) = {
|
||||
let st = self.state()?;
|
||||
(st.doc.clone(), st.edit_space(), st.viewport_frozen().to_vec())
|
||||
};
|
||||
let aperture = self.pixel_size() * self.settings.aperture.max(1.0);
|
||||
let hatch = if self.settings.osnaphatch { mode::HATCH } else { 0 };
|
||||
let base = prompt.as_ref().and_then(|q| q.base);
|
||||
let deferred = prompt.as_ref().is_some_and(|q| q.deferred);
|
||||
let hit = crate::snap::osnap(self.doc()?, &space, p, aperture, mode | hatch, base, deferred);
|
||||
let hit = crate::snap::osnap_with_frozen(&doc, &space, p, aperture, mode | hatch, base, deferred, &frozen);
|
||||
match hit {
|
||||
Some(h) if self.point_mods.is_empty() => return self.input_snapped(h),
|
||||
Some(h) => p = h.point,
|
||||
|
||||
@@ -75,8 +75,9 @@ pub struct Prompt {
|
||||
/// Rubber-band origin (for direct distance entry, ortho and polar).
|
||||
pub base: Option<Vec2>,
|
||||
/// The command resolves deferred tangent/perpendicular snaps ([`Input::Deferred`]) at this
|
||||
/// prompt (a point with no base yet, e.g. the first point of a line). Elsewhere a deferred
|
||||
/// pick arrives as the plain point it was picked at.
|
||||
/// prompt (a point with no base yet, e.g. the first point of a line; with a base, only
|
||||
/// tangents, e.g. a circle's radius). Elsewhere a deferred pick arrives as the plain point it
|
||||
/// was picked at.
|
||||
pub deferred: bool,
|
||||
/// The base is a rectangle's first corner (ZOOM Window, PLOTWINDOW, RECTANG, ARRAYRECT's unit
|
||||
/// cell): ortho does not bend the opposite corner, so the rectangle keeps its area.
|
||||
|
||||
+520
-97
@@ -65,6 +65,21 @@ pub struct SnapHit {
|
||||
}
|
||||
|
||||
impl SnapHit {
|
||||
fn plain(mode: u32, point: Vec2) -> SnapHit {
|
||||
SnapHit { point, mode, name: name_of(mode), viewport: None, deferred: None }
|
||||
}
|
||||
|
||||
/// The same snap as `o`, for a Tab list without repeats: the same mode at the same point
|
||||
/// (within a millionth of `aperture`), deferred or not alike, and from the same source (this
|
||||
/// space, or one viewport). Overlapping viewports can show different model points at one paper
|
||||
/// point; each stays a candidate, since DIST measures in the model units of the viewport picked.
|
||||
pub(crate) fn same(&self, o: &SnapHit, aperture: f64) -> bool {
|
||||
self.mode == o.mode
|
||||
&& self.deferred.is_some() == o.deferred.is_some()
|
||||
&& self.viewport.map(|v| v.viewport) == o.viewport.map(|v| v.viewport)
|
||||
&& self.point.near(o.point, aperture * 1e-6)
|
||||
}
|
||||
|
||||
/// The command input a pick at this snap gives: a deferred snap or a plain point.
|
||||
pub fn input(&self) -> crate::Input {
|
||||
match self.deferred {
|
||||
@@ -110,7 +125,7 @@ impl SnapCurve {
|
||||
}
|
||||
/// Points on the curve whose perpendicular passes through `p`; `picked` is where the curve
|
||||
/// was picked, kept when `p` is the center of a circle or arc (every radius is perpendicular).
|
||||
fn perpendiculars(&self, p: Vec2, picked: Vec2) -> Vec<Vec2> {
|
||||
pub(crate) fn perpendiculars(&self, p: Vec2, picked: Vec2) -> Vec<Vec2> {
|
||||
match self {
|
||||
SnapCurve::Circle { center, radius } | SnapCurve::Arc { center, radius, .. } => {
|
||||
let u = (p - *center).normalized();
|
||||
@@ -202,15 +217,34 @@ fn prim_segments(p: &Prim) -> Vec<Segment> {
|
||||
/// Tangent and perpendicular snaps need the base point (the other end of the line). With no
|
||||
/// base and `deferred` set (the prompt says it can resolve them, `Prompt.deferred`),
|
||||
/// they snap as *deferred*: the hit carries the curve and is resolved once the other end is
|
||||
/// known. Deferred hits only win where no other snap does (they are as unspecific as Nearest).
|
||||
/// known. With a base and `deferred` set, tangents to circles and circular arcs are deferred too
|
||||
/// (CIRCLE's radius: the circle around the base that touches the curve, #1512); an elliptical arc
|
||||
/// or a spline keeps its ordinary tangent from the base. Deferred hits only win
|
||||
/// where no other snap does (they are as unspecific as Nearest).
|
||||
pub fn osnap(d: &Drawing, space: &Space, cursor: Vec2, aperture: f64, osmode: u32, base: Option<Vec2>, deferred: bool) -> Option<SnapHit> {
|
||||
osnap_with_frozen(d, space, cursor, aperture, osmode, base, deferred, &[])
|
||||
}
|
||||
|
||||
/// [`osnap`] skipping entities (and block leaves) on `frozen` layers in `space`.
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
pub fn osnap_with_frozen(
|
||||
d: &Drawing,
|
||||
space: &Space,
|
||||
cursor: Vec2,
|
||||
aperture: f64,
|
||||
osmode: u32,
|
||||
base: Option<Vec2>,
|
||||
deferred: bool,
|
||||
frozen: &[String],
|
||||
) -> Option<SnapHit> {
|
||||
if osmode == 0 || osmode & mode::OFF != 0 {
|
||||
return None;
|
||||
}
|
||||
let ix = crate::spatial::index(d, space);
|
||||
osnap_with(d, space, &ix, cursor, aperture, osmode, base, deferred)
|
||||
osnap_with_neighborhood(d, space, &ix, cursor, aperture, osmode, base, deferred, frozen).0
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
pub(crate) fn osnap_with(
|
||||
d: &Drawing,
|
||||
@@ -222,7 +256,7 @@ pub(crate) fn osnap_with(
|
||||
base: Option<Vec2>,
|
||||
deferred: bool,
|
||||
) -> Option<SnapHit> {
|
||||
osnap_with_neighborhood(d, space, ix, cursor, aperture, osmode, base, deferred).0
|
||||
osnap_with_neighborhood(d, space, ix, cursor, aperture, osmode, base, deferred, &[]).0
|
||||
}
|
||||
|
||||
/// Find the best object snap and retain the local-space primitives gathered for that query.
|
||||
@@ -236,17 +270,18 @@ pub(crate) fn osnap_with_neighborhood(
|
||||
osmode: u32,
|
||||
base: Option<Vec2>,
|
||||
deferred: bool,
|
||||
frozen: &[String],
|
||||
) -> (Option<SnapHit>, Option<Vec<Prim>>) {
|
||||
if osmode == 0 || osmode & mode::OFF != 0 || !cursor.is_finite() || !(aperture.is_finite() && aperture > 0.0) {
|
||||
return (None, None);
|
||||
}
|
||||
let (mut best, near_prims) = match osnap_in_with_prims(d, space, ix, cursor, aperture, osmode, base, deferred, &[], None) {
|
||||
let (mut best, near_prims) = match osnap_in_with_prims(d, space, ix, cursor, aperture, osmode, base, deferred, frozen, None) {
|
||||
Some((hit, prims)) => (hit, Some(prims)),
|
||||
None => (None, None),
|
||||
};
|
||||
let views = viewport::near(d, space, cursor, aperture);
|
||||
if views.is_empty() {
|
||||
return (best, near_prims);
|
||||
return (best.map(|(h, _)| h), near_prims);
|
||||
}
|
||||
let model = Space::Model;
|
||||
let model_ix = crate::spatial::index(d, &model);
|
||||
@@ -269,14 +304,35 @@ pub(crate) fn osnap_with_neighborhood(
|
||||
&view.viewport.frozen_layers,
|
||||
Some(view.model_clip),
|
||||
)
|
||||
.and_then(|h| view.hit(h));
|
||||
if let Some(hit) = hit
|
||||
&& best.as_ref().is_none_or(|b| snap_score(hit.mode, hit.point, cursor, aperture) < snap_score(b.mode, b.point, cursor, aperture))
|
||||
// The rank was found in model units: paper units are model units times the scale.
|
||||
.and_then(|(h, r)| Some((view.hit(h)?, Rank { score: r.score * view.scale, ..r })));
|
||||
if let Some((hit, rank)) = hit
|
||||
&& best.as_ref().is_none_or(|(_, b)| rank.beats(b))
|
||||
{
|
||||
best = Some(hit);
|
||||
best = Some((hit, rank));
|
||||
}
|
||||
}
|
||||
(best, near_prims)
|
||||
(best.map(|(h, _)| h), near_prims)
|
||||
}
|
||||
|
||||
/// How a hit ranks against the hits of another space (paper space, another viewport) and, for
|
||||
/// Tab, against the other candidates: first the order [`finish`] tries them in (snap points, then
|
||||
/// a perpendicular or tangent on the object under the cursor or a center found from its curve,
|
||||
/// then deferred snaps, then Nearest), then its score within that tier, in the units of the cursor.
|
||||
#[derive(Clone, Copy, Debug)]
|
||||
struct Rank {
|
||||
tier: u8,
|
||||
score: f64,
|
||||
}
|
||||
|
||||
impl Rank {
|
||||
fn cmp(&self, other: &Rank) -> std::cmp::Ordering {
|
||||
self.tier.cmp(&other.tier).then(self.score.total_cmp(&other.score))
|
||||
}
|
||||
|
||||
fn beats(&self, other: &Rank) -> bool {
|
||||
self.cmp(other).is_lt()
|
||||
}
|
||||
}
|
||||
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
@@ -291,7 +347,7 @@ fn osnap_in(
|
||||
deferred: bool,
|
||||
frozen: &[String],
|
||||
clip: Option<Bounds2>,
|
||||
) -> Option<SnapHit> {
|
||||
) -> Option<(SnapHit, Rank)> {
|
||||
osnap_in_with_prims(d, space, ix, cursor, aperture, osmode, base, deferred, frozen, clip).and_then(|(hit, _)| hit)
|
||||
}
|
||||
|
||||
@@ -307,7 +363,92 @@ fn osnap_in_with_prims(
|
||||
deferred: bool,
|
||||
frozen: &[String],
|
||||
clip: Option<Bounds2>,
|
||||
) -> Option<(Option<SnapHit>, Vec<Prim>)> {
|
||||
) -> Option<(Option<(SnapHit, Rank)>, Vec<Prim>)> {
|
||||
let (cands, near_prims) = collect_in(d, space, ix, cursor, aperture, osmode, frozen)?;
|
||||
let hit = finish(cands, &near_prims, cursor, aperture, osmode, base, deferred, clip);
|
||||
Some((hit, near_prims))
|
||||
}
|
||||
|
||||
/// Every snap of `osmode` under the aperture round `cursor`, best first: Tab cycles through
|
||||
/// these. Each mode's points of every object nearby, the intersections, perpendicular and
|
||||
/// tangent points from `base`, the centers found from their curves, the deferred snaps and the
|
||||
/// nearest point of each object, ranked as [`osnap`] ranks them, without repeats and at most
|
||||
/// [`MAX_CYCLE`]; in viewports too, as [`osnap`] snaps.
|
||||
pub fn osnap_all(d: &Drawing, space: &Space, cursor: Vec2, aperture: f64, osmode: u32, base: Option<Vec2>, deferred: bool) -> Vec<SnapHit> {
|
||||
osnap_all_with_frozen(d, space, cursor, aperture, osmode, base, deferred, &[])
|
||||
}
|
||||
|
||||
/// [`osnap_all`] skipping entities (and block leaves) on `frozen` layers in `space`.
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
pub fn osnap_all_with_frozen(
|
||||
d: &Drawing,
|
||||
space: &Space,
|
||||
cursor: Vec2,
|
||||
aperture: f64,
|
||||
osmode: u32,
|
||||
base: Option<Vec2>,
|
||||
deferred: bool,
|
||||
frozen: &[String],
|
||||
) -> Vec<SnapHit> {
|
||||
if osmode == 0
|
||||
|| osmode & mode::OFF != 0
|
||||
|| !cursor.is_finite()
|
||||
|| !(aperture.is_finite() && aperture > 0.0)
|
||||
|| base.is_some_and(|b| !b.is_finite())
|
||||
{
|
||||
return Vec::new();
|
||||
}
|
||||
let ix = crate::spatial::index(d, space);
|
||||
let mut out: Vec<(SnapHit, Rank)> = Vec::new();
|
||||
if let Some((cands, prims)) = collect_in(d, space, &ix, cursor, aperture, osmode, frozen) {
|
||||
out = finish_all(cands, &prims, cursor, aperture, osmode, base, deferred, None);
|
||||
}
|
||||
let model = Space::Model;
|
||||
let views = viewport::near(d, space, cursor, aperture);
|
||||
if !views.is_empty() {
|
||||
let model_ix = crate::spatial::index(d, &model);
|
||||
for view in views {
|
||||
let (mc, ma, mb) = (view.to_model(cursor), aperture / view.scale, base.map(|p| view.to_model(p)));
|
||||
if !mc.is_finite() || !(ma.is_finite() && ma > 0.0) || mb.is_some_and(|p| !p.is_finite()) {
|
||||
continue;
|
||||
}
|
||||
let Some((cands, prims)) = collect_in(d, &model, &model_ix, mc, ma, osmode, &view.viewport.frozen_layers) else { continue };
|
||||
// The rank was found in model units: paper units are model units times the scale.
|
||||
out.extend(
|
||||
finish_all(cands, &prims, mc, ma, osmode, mb, deferred, Some(view.model_clip))
|
||||
.into_iter()
|
||||
.filter_map(|(h, r)| Some((view.hit(h)?, Rank { score: r.score * view.scale, ..r }))),
|
||||
);
|
||||
}
|
||||
}
|
||||
out.sort_by(|a, b| a.1.cmp(&b.1));
|
||||
let mut unique: Vec<SnapHit> = Vec::with_capacity(out.len().min(MAX_CYCLE));
|
||||
for (h, _) in out {
|
||||
if unique.len() >= MAX_CYCLE {
|
||||
break;
|
||||
}
|
||||
if !unique.iter().any(|u| u.same(&h, aperture)) {
|
||||
unique.push(h);
|
||||
}
|
||||
}
|
||||
unique
|
||||
}
|
||||
|
||||
/// Most snaps [`osnap_all`] offers.
|
||||
const MAX_CYCLE: usize = 256;
|
||||
|
||||
/// The candidate snap points near `cursor` (each with its mode) and the primitives near it:
|
||||
/// [`gather_in`]'s, plus the intersections between those primitives.
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
fn collect_in(
|
||||
d: &Drawing,
|
||||
space: &Space,
|
||||
ix: &Option<std::sync::Arc<crate::spatial::SpatialIndex>>,
|
||||
cursor: Vec2,
|
||||
aperture: f64,
|
||||
osmode: u32,
|
||||
frozen: &[String],
|
||||
) -> Option<(Vec<(u32, Vec2)>, Vec<Prim>)> {
|
||||
let (mut cands, near_prims) = gather_in(d, space, ix, cursor, aperture, osmode, frozen)?;
|
||||
// Intersections between nearby primitives; Apparent Intersection also where their extensions
|
||||
// meet (lines extended, arcs as full circles: in 2D, the "apparent" crossing of objects
|
||||
@@ -345,8 +486,7 @@ fn osnap_in_with_prims(
|
||||
}
|
||||
}
|
||||
}
|
||||
let hit = finish(cands, &near_prims, cursor, aperture, osmode, base, deferred, clip);
|
||||
Some((hit, near_prims))
|
||||
Some((cands, near_prims))
|
||||
}
|
||||
|
||||
fn finite_intersection_probe(cursor: Vec2, aperture: f64) -> Option<Bounds2> {
|
||||
@@ -390,18 +530,7 @@ pub(crate) fn extendable(p: &Prim) -> bool {
|
||||
|
||||
/// The snap candidates of `osmode` and the primitives within `aperture` of `cursor`; `None`
|
||||
/// when the drawing can't be searched.
|
||||
pub(crate) fn gather(
|
||||
d: &Drawing,
|
||||
space: &Space,
|
||||
ix: &Option<std::sync::Arc<crate::spatial::SpatialIndex>>,
|
||||
cursor: Vec2,
|
||||
aperture: f64,
|
||||
osmode: u32,
|
||||
) -> Option<(Vec<(u32, Vec2)>, Vec<Prim>)> {
|
||||
gather_in(d, space, ix, cursor, aperture, osmode, &[])
|
||||
}
|
||||
|
||||
fn gather_in(
|
||||
pub(crate) fn gather_in(
|
||||
d: &Drawing,
|
||||
space: &Space,
|
||||
ix: &Option<std::sync::Arc<crate::spatial::SpatialIndex>>,
|
||||
@@ -458,7 +587,19 @@ fn gather_in(
|
||||
Some((cands, near_prims))
|
||||
}
|
||||
|
||||
/// Picks the best of the gathered candidates, adding the base-dependent and deferred snaps.
|
||||
/// Picks the best of the gathered candidates, adding the base-dependent and deferred snaps, with
|
||||
/// its [`Rank`].
|
||||
///
|
||||
/// In order of preference (the rank's tier):
|
||||
/// 0. the snap point within `aperture` of the cursor that scores best (see [`snap_score`]),
|
||||
/// perpendicular and tangent points from the base point included;
|
||||
/// 1. with a base point, a perpendicular or tangent on an object that passes within `aperture`,
|
||||
/// wherever its point lies (see [`from_base_on_objects`]), or the center of a circle, arc or
|
||||
/// ellipse under the cursor (see [`curve_centers`]): the object nearest the cursor;
|
||||
/// 2. a deferred perpendicular or tangent (no base point yet);
|
||||
/// 3. Nearest.
|
||||
///
|
||||
/// [`finish_all`] keeps every candidate in this order, for Tab.
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
fn finish(
|
||||
mut cands: Vec<(u32, Vec2)>,
|
||||
@@ -469,87 +610,248 @@ fn finish(
|
||||
base: Option<Vec2>,
|
||||
deferred: bool,
|
||||
clip: Option<Bounds2>,
|
||||
) -> Option<SnapHit> {
|
||||
// Perpendicular / tangent from the base point.
|
||||
if let Some(bp) = base {
|
||||
for p in near_prims {
|
||||
if osmode & mode::PER != 0 {
|
||||
match p {
|
||||
Prim::Seg(Segment::Line(l)) => cands.push((mode::PER, l.project(bp))),
|
||||
// Both antipodes, filtered to the arc's sweep: a perpendicular in the gap is
|
||||
// not offered, and the far side is still found.
|
||||
Prim::Seg(Segment::Arc { arc, .. }) => {
|
||||
let curve = SnapCurve::Arc { center: arc.center, radius: arc.radius, start: arc.start, end: arc.end };
|
||||
cands.extend(curve.perpendiculars(bp, bp).into_iter().map(|q| (mode::PER, q)));
|
||||
}
|
||||
Prim::Circle(c) => cands.push((mode::PER, c.closest(bp))),
|
||||
Prim::Infinite { base: b0, dir, .. } => cands.push((mode::PER, *b0 + *dir * (bp - *b0).dot(*dir))),
|
||||
Prim::Ellipse(e) => cands.extend(curves::ellipse_perpendiculars(e, bp).into_iter().map(|q| (mode::PER, q))),
|
||||
Prim::Spline(s) => cands.extend(curves::spline_perpendiculars(s, bp).into_iter().map(|q| (mode::PER, q))),
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
if osmode & mode::TAN != 0 {
|
||||
let pts = match p {
|
||||
// Only the tangent points that lie on the arc itself (not its circle).
|
||||
Prim::Seg(Segment::Arc { arc, .. }) => Circle::new(arc.center, arc.radius)
|
||||
.tangent_points(bp)
|
||||
.into_iter()
|
||||
.filter(|t| arc.contains_angle(arc.center.angle_to(*t)))
|
||||
.collect(),
|
||||
Prim::Circle(c) => c.tangent_points(bp),
|
||||
Prim::Ellipse(e) => curves::ellipse_tangents(e, bp),
|
||||
Prim::Spline(s) => curves::spline_tangents(s, bp),
|
||||
_ => Vec::new(),
|
||||
};
|
||||
cands.extend(pts.into_iter().map(|t| (mode::TAN, t)));
|
||||
}
|
||||
}
|
||||
}
|
||||
) -> Option<(SnapHit, Rank)> {
|
||||
let from_base = base_snaps(near_prims, osmode, base, cursor, deferred);
|
||||
cands.extend(from_base.iter().map(|f| (f.mode, f.point)));
|
||||
let visible = |p: Vec2| p.is_finite() && clip.is_none_or(|c| c.contains(p));
|
||||
let best = cands.iter().filter(|(_, p)| visible(*p) && p.dist(cursor) <= aperture).min_by(|a, b| {
|
||||
// Prefer more specific modes when nearly equidistant.
|
||||
let da = snap_score(a.0, a.1, cursor, aperture);
|
||||
let db = snap_score(b.0, b.1, cursor, aperture);
|
||||
da.total_cmp(&db)
|
||||
});
|
||||
if let Some((m, p)) = best {
|
||||
return Some(SnapHit { point: *p, mode: *m, name: name_of(*m), viewport: None, deferred: None });
|
||||
// Prefer more specific modes when nearly equidistant.
|
||||
let best = cands
|
||||
.iter()
|
||||
.filter(|(_, p)| visible(*p) && p.dist(cursor) <= aperture)
|
||||
.map(|(m, p)| (snap_score(*m, *p, cursor, aperture), *m, *p))
|
||||
.min_by(|a, b| a.0.total_cmp(&b.0));
|
||||
if let Some((score, m, p)) = best {
|
||||
return Some((SnapHit::plain(m, p), Rank { tier: 0, score }));
|
||||
}
|
||||
if base.is_none()
|
||||
&& deferred
|
||||
&& let Some(h) = deferred_hit(near_prims, cursor, aperture, osmode, clip)
|
||||
{
|
||||
return Some(h);
|
||||
// A perpendicular or tangent on the object under the cursor, or the center found from its
|
||||
// curve, only when no snap point is in the aperture: the Midpoint or Quadrant under the cursor
|
||||
// wins over the center of the same curve, as in AutoCAD. Of the two, the object nearer the
|
||||
// cursor; on a tie (the same curve), the perpendicular or tangent.
|
||||
let on_object = from_base_on_objects(&from_base, near_prims, cursor, aperture, visible)
|
||||
.into_iter()
|
||||
.min_by(|a, b| a.1.score.total_cmp(&b.1.score).then(a.2.total_cmp(&b.2)))
|
||||
.map(|(h, r, _)| (h, r));
|
||||
let center = curve_centers(near_prims, cursor, aperture, osmode)
|
||||
.into_iter()
|
||||
.filter(|(_, c)| visible(*c))
|
||||
.min_by(|a, b| a.0.total_cmp(&b.0))
|
||||
.map(|(score, c)| (SnapHit::plain(mode::CEN, c), Rank { tier: 1, score }));
|
||||
match (on_object, center) {
|
||||
(Some(o), Some(c)) => return Some(if c.1.beats(&o.1) { c } else { o }),
|
||||
(Some(h), None) | (None, Some(h)) => return Some(h),
|
||||
(None, None) => {}
|
||||
}
|
||||
// With a base, perpendiculars are resolved from it above; only tangents are left to defer.
|
||||
let deferrable = if base.is_some() { osmode & mode::TAN } else { osmode };
|
||||
if deferred && let Some(h) = deferred_hit(near_prims, cursor, aperture, deferrable, clip) {
|
||||
let score = h.point.dist(cursor);
|
||||
return Some((h, Rank { tier: 2, score }));
|
||||
}
|
||||
if osmode & mode::NEA != 0 {
|
||||
// The closest point of all nearby objects, whatever their drawing order.
|
||||
let mut nb: Option<(f64, Vec2)> = None;
|
||||
let mut consider = |c: Vec2| {
|
||||
let dd = c.dist(cursor);
|
||||
if visible(c) && dd <= aperture && nb.is_none_or(|(bd, _)| dd < bd) {
|
||||
nb = Some((dd, c));
|
||||
}
|
||||
};
|
||||
for p in near_prims {
|
||||
for s in prim_segments(p) {
|
||||
consider(fix_circle(&s).closest(cursor));
|
||||
}
|
||||
if let Prim::Circle(c) = p {
|
||||
consider(c.closest(cursor));
|
||||
}
|
||||
}
|
||||
if let Some((_, p)) = nb {
|
||||
return Some(SnapHit { point: p, mode: mode::NEA, name: "Nearest", viewport: None, deferred: None });
|
||||
let nb = near_prims.iter().filter_map(|p| nearest_point(p, cursor, aperture, &visible)).min_by(|a, b| a.0.total_cmp(&b.0));
|
||||
if let Some((score, p)) = nb {
|
||||
return Some((SnapHit::plain(mode::NEA, p), Rank { tier: 3, score }));
|
||||
}
|
||||
}
|
||||
None
|
||||
}
|
||||
|
||||
/// [`finish`], keeping every candidate with its [`Rank`], in the order [`finish`] prefers them:
|
||||
/// the snap points best first, then the perpendiculars and tangents on the objects under the
|
||||
/// cursor and the centers found from their curves, then the deferred snaps, then the nearest point
|
||||
/// of each object nearby.
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
fn finish_all(
|
||||
mut cands: Vec<(u32, Vec2)>,
|
||||
near_prims: &[Prim],
|
||||
cursor: Vec2,
|
||||
aperture: f64,
|
||||
osmode: u32,
|
||||
base: Option<Vec2>,
|
||||
deferred: bool,
|
||||
clip: Option<Bounds2>,
|
||||
) -> Vec<(SnapHit, Rank)> {
|
||||
let from_base = base_snaps(near_prims, osmode, base, cursor, deferred);
|
||||
cands.extend(from_base.iter().map(|f| (f.mode, f.point)));
|
||||
let visible = |p: Vec2| p.is_finite() && clip.is_none_or(|c| c.contains(p));
|
||||
let mut out: Vec<(SnapHit, Rank)> = cands
|
||||
.iter()
|
||||
.filter(|(_, p)| visible(*p) && p.dist(cursor) <= aperture)
|
||||
.map(|(m, p)| (SnapHit::plain(*m, *p), Rank { tier: 0, score: snap_score(*m, *p, cursor, aperture) }))
|
||||
.collect();
|
||||
// Of several points on one object (a circle's two tangents), the one nearer the cursor first,
|
||||
// as `finish` picks it; the sort below is stable.
|
||||
let mut on_object = from_base_on_objects(&from_base, near_prims, cursor, aperture, visible);
|
||||
on_object.sort_by(|a, b| a.1.score.total_cmp(&b.1.score).then(a.2.total_cmp(&b.2)));
|
||||
out.extend(on_object.into_iter().map(|(h, r, _)| (h, r)));
|
||||
out.extend(
|
||||
curve_centers(near_prims, cursor, aperture, osmode)
|
||||
.into_iter()
|
||||
.filter(|(_, c)| visible(*c))
|
||||
.map(|(score, c)| (SnapHit::plain(mode::CEN, c), Rank { tier: 1, score })),
|
||||
);
|
||||
let deferrable = if base.is_some() { osmode & mode::TAN } else { osmode };
|
||||
if deferred {
|
||||
let hits = deferred_hits(near_prims, cursor, aperture, deferrable, clip);
|
||||
out.extend(hits.into_iter().map(|h| (h, Rank { tier: 2, score: h.point.dist(cursor) })));
|
||||
}
|
||||
if osmode & mode::NEA != 0 {
|
||||
let near = near_prims.iter().filter_map(|p| nearest_point(p, cursor, aperture, &visible));
|
||||
out.extend(near.map(|(score, p)| (SnapHit::plain(mode::NEA, p), Rank { tier: 3, score })));
|
||||
}
|
||||
out.sort_by(|a, b| a.1.cmp(&b.1));
|
||||
out
|
||||
}
|
||||
|
||||
/// The point of `p` closest to `cursor` among its visible points within `aperture`, with its
|
||||
/// distance: each segment's closest point is checked before the closest is chosen, so a curve
|
||||
/// whose closest point is clipped away (outside a viewport) still offers the visible one.
|
||||
fn nearest_point(p: &Prim, cursor: Vec2, aperture: f64, visible: &impl Fn(Vec2) -> bool) -> Option<(f64, Vec2)> {
|
||||
let mut nb: Option<(f64, Vec2)> = None;
|
||||
let mut consider = |c: Vec2| {
|
||||
let dd = c.dist(cursor);
|
||||
if visible(c) && dd <= aperture && nb.is_none_or(|(bd, _)| dd < bd) {
|
||||
nb = Some((dd, c));
|
||||
}
|
||||
};
|
||||
for s in prim_segments(p) {
|
||||
consider(fix_circle(&s).closest(cursor));
|
||||
}
|
||||
if let Prim::Circle(c) = p {
|
||||
consider(c.closest(cursor));
|
||||
}
|
||||
nb
|
||||
}
|
||||
|
||||
/// The perpendicular and tangent points from the base point `base` (none without one), each
|
||||
/// with the index in `near_prims` of the object it lies on. At a `deferred` prompt the tangents to
|
||||
/// circles and arcs are left out: the prompt resolves them itself (CIRCLE's radius, #1512).
|
||||
fn base_snaps(near_prims: &[Prim], osmode: u32, base: Option<Vec2>, cursor: Vec2, deferred: bool) -> Vec<FromBase> {
|
||||
let mut from_base: Vec<FromBase> = Vec::new();
|
||||
let Some(bp) = base else { return from_base };
|
||||
for (prim, p) in near_prims.iter().enumerate() {
|
||||
let mut found = |mode: u32, points: Vec<Vec2>| from_base.extend(points.into_iter().map(|point| FromBase { mode, point, prim }));
|
||||
if osmode & mode::PER != 0 {
|
||||
let pts = match p {
|
||||
Prim::Seg(Segment::Line(l)) => vec![l.project(bp)],
|
||||
// Both antipodes, filtered to the arc's sweep: a perpendicular in the gap is
|
||||
// not offered, and the far side is still found.
|
||||
Prim::Seg(Segment::Arc { arc, .. }) => {
|
||||
SnapCurve::Arc { center: arc.center, radius: arc.radius, start: arc.start, end: arc.end }.perpendiculars(bp, bp)
|
||||
}
|
||||
// Both antipodes too, so a pick on the far side of the circle snaps there
|
||||
// rather than across it. From the centre every point is perpendicular: the
|
||||
// one under the cursor.
|
||||
Prim::Circle(c) => SnapCurve::Circle { center: c.center, radius: c.radius }.perpendiculars(bp, cursor),
|
||||
Prim::Infinite { base: b0, dir, .. } => vec![*b0 + *dir * (bp - *b0).dot(*dir)],
|
||||
Prim::Ellipse(e) => curves::ellipse_perpendiculars(e, bp),
|
||||
Prim::Spline(s) => curves::spline_perpendiculars(s, bp),
|
||||
_ => Vec::new(),
|
||||
};
|
||||
found(mode::PER, pts);
|
||||
}
|
||||
if osmode & mode::TAN != 0 {
|
||||
let pts = match p {
|
||||
// A deferred prompt resolves tangents to circles and arcs itself.
|
||||
Prim::Seg(Segment::Arc { .. }) | Prim::Circle(_) if deferred => Vec::new(),
|
||||
// Only the tangent points that lie on the arc itself (not its circle).
|
||||
Prim::Seg(Segment::Arc { arc, .. }) => Circle::new(arc.center, arc.radius)
|
||||
.tangent_points(bp)
|
||||
.into_iter()
|
||||
.filter(|t| arc.contains_angle(arc.center.angle_to(*t)))
|
||||
.collect(),
|
||||
Prim::Circle(c) => c.tangent_points(bp),
|
||||
Prim::Ellipse(e) => curves::ellipse_tangents(e, bp),
|
||||
Prim::Spline(s) => curves::spline_tangents(s, bp),
|
||||
_ => Vec::new(),
|
||||
};
|
||||
found(mode::TAN, pts);
|
||||
}
|
||||
}
|
||||
from_base
|
||||
}
|
||||
|
||||
/// Center, as in AutoCAD: with the cursor over a circle, an arc (also a polyline's) or an
|
||||
/// ellipse, the running Center snap finds its center however far away it is. Each center comes
|
||||
/// with how far the curve is from `cursor` (its score); [`finish`] tries them only when no snap
|
||||
/// point is in the aperture. Empty unless Center is among `osmode`.
|
||||
fn curve_centers(prims: &[Prim], cursor: Vec2, aperture: f64, osmode: u32) -> Vec<(f64, Vec2)> {
|
||||
let mut out = Vec::new();
|
||||
if osmode & mode::CEN == 0 {
|
||||
return out;
|
||||
}
|
||||
// The work limit counts the curves only, so straight segments before them can't hide them.
|
||||
let curves = prims.iter().filter_map(|p| match p {
|
||||
Prim::Circle(c) => Some((c.center, c.closest(cursor))),
|
||||
Prim::Seg(s @ Segment::Arc { arc, .. }) => Some((arc.center, fix_circle(s).closest(cursor))),
|
||||
Prim::Ellipse(e) => Some((e.center, e.closest(cursor))),
|
||||
_ => None,
|
||||
});
|
||||
for (center, on) in curves.take(2000) {
|
||||
let d = on.dist(cursor);
|
||||
if center.is_finite() && d.is_finite() && d <= aperture {
|
||||
out.push((d, center));
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
fn snap_score(mode: u32, point: Vec2, cursor: Vec2, aperture: f64) -> f64 {
|
||||
point.dist(cursor) - if mode == mode::INT || mode == mode::END { aperture * 0.15 } else { 0.0 }
|
||||
}
|
||||
|
||||
/// A perpendicular ([`mode::PER`]) or tangent ([`mode::TAN`]) point found from the base point,
|
||||
/// with the index in `near_prims` of the object it lies on.
|
||||
struct FromBase {
|
||||
mode: u32,
|
||||
point: Vec2,
|
||||
prim: usize,
|
||||
}
|
||||
|
||||
/// The perpendiculars and tangents from the base point on the objects that pass within
|
||||
/// `aperture` of the cursor, wherever the foot or tangent point lies (#2800), each with its
|
||||
/// [`Rank`] (tier 1, scored by the cursor's distance to the object) and its distance to the cursor.
|
||||
///
|
||||
/// These snaps name an object, not a spot on it: you can't know in advance where the foot of a
|
||||
/// perpendicular will be, so, as in AutoCAD, hovering anywhere over the object finds it and the
|
||||
/// point jumps there. [`finish`] asks for this only when no snap point lies within the aperture,
|
||||
/// so an endpoint, midpoint or intersection under the cursor still wins.
|
||||
///
|
||||
/// [`finish`] takes the object nearest the cursor; of several points on it (an arc's two
|
||||
/// antipodes, a circle's two tangents), the one nearest the cursor.
|
||||
fn from_base_on_objects(
|
||||
found: &[FromBase],
|
||||
near_prims: &[Prim],
|
||||
cursor: Vec2,
|
||||
aperture: f64,
|
||||
visible: impl Fn(Vec2) -> bool,
|
||||
) -> Vec<(SnapHit, Rank, f64)> {
|
||||
let mut out = Vec::new();
|
||||
if found.is_empty() {
|
||||
return out;
|
||||
}
|
||||
// `near_prims` holds every object whose box comes near the cursor, so the true distance is
|
||||
// checked here. It is measured once per object, and only for objects with a point to offer:
|
||||
// an ellipse or a spline is measured on its tessellation.
|
||||
let mut reach: Vec<Option<f64>> = vec![None; near_prims.len()];
|
||||
for f in found.iter().filter(|f| visible(f.point)) {
|
||||
let Some(slot) = reach.get_mut(f.prim) else { continue };
|
||||
let to_object = *slot.get_or_insert_with(|| near_prims.get(f.prim).map_or(f64::INFINITY, |p| distance_to_prim(p, cursor)));
|
||||
// A NaN distance (from a degenerate object) never qualifies.
|
||||
if to_object.is_nan() || to_object > aperture {
|
||||
continue;
|
||||
}
|
||||
out.push((SnapHit::plain(f.mode, f.point), Rank { tier: 1, score: to_object }, f.point.dist(cursor)));
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// The distance from `cursor` to the nearest point of `p`, measured as Nearest measures it.
|
||||
fn distance_to_prim(p: &Prim, cursor: Vec2) -> f64 {
|
||||
prim_segments(p).iter().map(|s| fix_circle(s).closest(cursor).dist(cursor)).fold(f64::INFINITY, f64::min)
|
||||
}
|
||||
|
||||
/// Upper bound on the block-reference objects one snap query looks at (hostile files).
|
||||
const MAX_BLOCK_LEAVES: usize = 20_000;
|
||||
|
||||
@@ -848,6 +1150,47 @@ fn xform_prim(p: &Prim, m: &Mat3) -> Prim {
|
||||
}
|
||||
}
|
||||
|
||||
/// Every deferred tangent and perpendicular within `aperture` of `cursor`, for Tab: one per curve
|
||||
/// and mode, in drawing order (the caller ranks them), so Tab can go from the tangent to the
|
||||
/// perpendicular on the same circle, and to the deferred snap of each curve nearby. A click takes
|
||||
/// the nearest one ([`deferred_hit`]).
|
||||
fn deferred_hits(prims: &[Prim], cursor: Vec2, aperture: f64, osmode: u32, clip: Option<Bounds2>) -> Vec<SnapHit> {
|
||||
let mut hits = Vec::new();
|
||||
if osmode & (mode::TAN | mode::PER) == 0 {
|
||||
return hits;
|
||||
}
|
||||
for p in prims {
|
||||
let curve = match p {
|
||||
Prim::Circle(c) => SnapCurve::Circle { center: c.center, radius: c.radius },
|
||||
Prim::Seg(Segment::Arc { arc, .. }) => SnapCurve::Arc { center: arc.center, radius: arc.radius, start: arc.start, end: arc.end },
|
||||
Prim::Seg(Segment::Line(l)) => SnapCurve::Line { a: l.a, b: l.b },
|
||||
Prim::Infinite { base, dir, .. } => SnapCurve::Line { a: *base, b: *base + *dir },
|
||||
_ => continue,
|
||||
};
|
||||
// Where the curve was picked: a circle's, an arc's or a segment's own span, an xline/ray
|
||||
// anywhere.
|
||||
let at = match curve {
|
||||
SnapCurve::Circle { center, radius } => Circle::new(center, radius).closest(cursor),
|
||||
SnapCurve::Arc { center, radius, start, end } => cadcraft_geom::Arc::new(center, radius, start, end).closest(cursor),
|
||||
SnapCurve::Line { a, b } => {
|
||||
let l = cadcraft_geom::Line::new(a, b);
|
||||
if matches!(p, Prim::Seg(_)) { l.closest(cursor) } else { l.project(cursor) }
|
||||
}
|
||||
};
|
||||
if !(at.is_finite() && clip.is_none_or(|c| c.contains(at)) && at.dist(cursor) <= aperture) {
|
||||
continue;
|
||||
}
|
||||
let modes: &[(u32, &'static str)] = match curve {
|
||||
SnapCurve::Circle { .. } | SnapCurve::Arc { .. } => &[(mode::TAN, "Deferred Tangent"), (mode::PER, "Deferred Perpendicular")],
|
||||
SnapCurve::Line { .. } => &[(mode::PER, "Deferred Perpendicular")],
|
||||
};
|
||||
for &(m, name) in modes.iter().filter(|(m, _)| osmode & m != 0) {
|
||||
hits.push(SnapHit { point: at, mode: m, name, viewport: None, deferred: Some(Deferred { mode: m, curve, at }) });
|
||||
}
|
||||
}
|
||||
hits
|
||||
}
|
||||
|
||||
/// The nearest deferred tangent/perpendicular within `aperture` of `cursor`.
|
||||
fn deferred_hit(prims: &[Prim], cursor: Vec2, aperture: f64, osmode: u32, clip: Option<Bounds2>) -> Option<SnapHit> {
|
||||
let mut best: Option<(f64, SnapHit)> = None;
|
||||
@@ -1121,6 +1464,17 @@ mod tests {
|
||||
assert_eq!(h.name, "Intersection");
|
||||
}
|
||||
|
||||
/// Tab cycling sees every deferred snap within the aperture: on a circle with no base point,
|
||||
/// its quadrant, then the deferred tangent and the deferred perpendicular at the same spot.
|
||||
#[test]
|
||||
fn osnap_all_ranks_every_candidate() {
|
||||
let d = drawing();
|
||||
let all = osnap_all(&d, &Space::Model, Vec2::new(22.1, 0.1), 0.5, mode::QUA | mode::TAN | mode::PER, None, true);
|
||||
let kinds: Vec<(u32, bool)> = all.iter().map(|h| (h.mode, h.deferred.is_some())).collect();
|
||||
assert_eq!(kinds, [(mode::QUA, false), (mode::TAN, true), (mode::PER, true)], "{all:?}");
|
||||
assert!(osnap_all(&d, &Space::Model, Vec2::new(50.0, 50.0), 0.5, mode::QUA | mode::TAN | mode::PER, None, true).is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn center_quadrant_tangent() {
|
||||
let d = drawing();
|
||||
@@ -1137,6 +1491,70 @@ mod tests {
|
||||
assert!(h.point.near(Vec2::new(3.0, 0.0), 1e-9));
|
||||
}
|
||||
|
||||
/// #2800: hovering anywhere over the line finds the perpendicular, though its foot (2,0) is
|
||||
/// six units from the cursor; it used to snap only within the aperture of the foot.
|
||||
#[test]
|
||||
fn perpendicular_from_base_anywhere_on_the_line() {
|
||||
let d = drawing();
|
||||
let h = osnap(&d, &Space::Model, Vec2::new(8.0, 0.1), 0.5, mode::PER, Some(Vec2::new(2.0, 4.0)), false).unwrap();
|
||||
assert!(h.point.near(Vec2::new(2.0, 0.0), 1e-9), "{h:?}");
|
||||
assert_eq!(h.mode, mode::PER);
|
||||
}
|
||||
|
||||
/// #2800: the tangent point is found from anywhere on the circle; of its two tangent points
|
||||
/// from the base, the one nearer the cursor.
|
||||
#[test]
|
||||
fn tangent_from_base_anywhere_on_the_circle() {
|
||||
let d = drawing();
|
||||
// From (30,0), 10 from the centre (20,0) of the radius-2 circle: the tangent points are
|
||||
// at cos = 2/10 from the line to the base, (20.4, ±1.9596).
|
||||
let upper = Vec2::new(20.4, 2.0 * (1.0f64 - 0.04).sqrt());
|
||||
let on_circle = Vec2::new(20.0 - 2.0 * std::f64::consts::FRAC_1_SQRT_2, 2.0 * std::f64::consts::FRAC_1_SQRT_2);
|
||||
let h = osnap(&d, &Space::Model, on_circle, 0.5, mode::TAN, Some(Vec2::new(30.0, 0.0)), false).unwrap();
|
||||
assert!(h.point.near(upper, 1e-9), "{h:?}");
|
||||
let mirrored = Vec2::new(on_circle.x, -on_circle.y);
|
||||
let h = osnap(&d, &Space::Model, mirrored, 0.5, mode::TAN, Some(Vec2::new(30.0, 0.0)), false).unwrap();
|
||||
assert!(h.point.near(Vec2::new(upper.x, -upper.y), 1e-9), "{h:?}");
|
||||
}
|
||||
|
||||
/// A circle offers both perpendicular points from the base, so a pick on its far side snaps
|
||||
/// there, not to the near side across the circle (CodeRabbit on #2825).
|
||||
#[test]
|
||||
fn perpendicular_from_base_on_a_circle_takes_the_side_under_the_cursor() {
|
||||
let d = drawing();
|
||||
// The circle at (20,0), radius 2, seen from (30,0): perpendicular at (22,0) and (18,0).
|
||||
let base = Some(Vec2::new(30.0, 0.0));
|
||||
let far = osnap(&d, &Space::Model, Vec2::new(18.1, 0.1), 0.5, mode::PER, base, false).unwrap();
|
||||
assert!(far.point.near(Vec2::new(18.0, 0.0), 1e-9), "{far:?}");
|
||||
// Away from both points, at (19, √3) on the circle: 2 from (18,0) and √12 from (22,0).
|
||||
let top = osnap(&d, &Space::Model, Vec2::new(19.0, 3.0f64.sqrt()), 0.5, mode::PER, base, false).unwrap();
|
||||
assert!(top.point.near(Vec2::new(18.0, 0.0), 1e-9), "{top:?}");
|
||||
let near = osnap(&d, &Space::Model, Vec2::new(21.9, 0.1), 0.5, mode::PER, base, false).unwrap();
|
||||
assert!(near.point.near(Vec2::new(22.0, 0.0), 1e-9), "{near:?}");
|
||||
}
|
||||
|
||||
/// With several objects under the aperture, the one nearest the cursor gives the
|
||||
/// perpendicular, even when another object's foot is nearer.
|
||||
#[test]
|
||||
fn perpendicular_from_base_takes_the_object_nearest_the_cursor() {
|
||||
let d = drawing();
|
||||
// 0.4 above the horizontal line and 0.2 right of the vertical one: the vertical line wins,
|
||||
// with its foot (5,4) farther from the cursor than the horizontal line's (2,0).
|
||||
let h = osnap(&d, &Space::Model, Vec2::new(5.2, 0.4), 0.5, mode::PER, Some(Vec2::new(2.0, 4.0)), false).unwrap();
|
||||
assert!(h.point.near(Vec2::new(5.0, 4.0), 1e-9), "{h:?}");
|
||||
}
|
||||
|
||||
/// A snap point under the cursor still beats a perpendicular whose foot is away from it, and
|
||||
/// an object outside the aperture gives none, though its box is near.
|
||||
#[test]
|
||||
fn perpendicular_from_base_yields_to_points_under_the_cursor() {
|
||||
let d = drawing();
|
||||
let base = Some(Vec2::new(2.0, 4.0));
|
||||
let h = osnap(&d, &Space::Model, Vec2::new(9.9, 0.05), 0.5, mode::END | mode::PER, base, false).unwrap();
|
||||
assert_eq!((h.point, h.mode), (Vec2::new(10.0, 0.0), mode::END));
|
||||
assert!(osnap(&d, &Space::Model, Vec2::new(8.0, 0.7), 0.5, mode::PER, base, false).is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn ortho_and_polar() {
|
||||
assert_eq!(ortho(Vec2::ZERO, Vec2::new(5.0, 1.0)), Vec2::new(5.0, 0.0));
|
||||
@@ -1179,9 +1597,14 @@ mod tests {
|
||||
let df = h.deferred.unwrap();
|
||||
assert_eq!(df.curve, SnapCurve::Circle { center: Vec2::new(20.0, 0.0), radius: 2.0 });
|
||||
assert_eq!(h.input(), crate::Input::Deferred(df));
|
||||
// With a base it is an ordinary tangent.
|
||||
let t = osnap(&d, &Space::Model, Vec2::new(19.9, 1.9), 1.0, mode::TAN, Some(Vec2::new(10.0, 0.0)), true).unwrap();
|
||||
// With a base it is an ordinary tangent, unless the prompt resolves it (CIRCLE's radius).
|
||||
let t = osnap(&d, &Space::Model, Vec2::new(19.9, 1.9), 1.0, mode::TAN, Some(Vec2::new(10.0, 0.0)), false).unwrap();
|
||||
assert!(t.deferred.is_none() && t.name == "Tangent");
|
||||
let t = osnap(&d, &Space::Model, at, 0.5, mode::TAN, Some(Vec2::new(10.0, 0.0)), true).unwrap();
|
||||
assert_eq!(t.name, "Deferred Tangent");
|
||||
// A perpendicular from the base is still resolved from it.
|
||||
let p = osnap(&d, &Space::Model, Vec2::new(2.0, 0.2), 0.5, mode::PER, Some(Vec2::new(2.0, 5.0)), true).unwrap();
|
||||
assert!(p.deferred.is_none() && p.point.near(Vec2::new(2.0, 0.0), 1e-9));
|
||||
// A specific snap still wins over a deferred one.
|
||||
let q = osnap(&d, &Space::Model, at, 0.5, mode::TAN | mode::QUA, None, true).unwrap();
|
||||
assert_eq!(q.mode, mode::QUA);
|
||||
|
||||
@@ -482,13 +482,38 @@ impl Tracker {
|
||||
cfg: &TrackConfig,
|
||||
base: Option<Vec2>,
|
||||
) -> Option<Track> {
|
||||
let t = self.find(d, space, cursor, aperture, tol, cfg, base);
|
||||
self.track_with_frozen(d, space, cursor, aperture, tol, cfg, base, &[])
|
||||
}
|
||||
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
pub(crate) fn track_with_frozen(
|
||||
&mut self,
|
||||
d: &Drawing,
|
||||
space: &Space,
|
||||
cursor: Vec2,
|
||||
aperture: f64,
|
||||
tol: f64,
|
||||
cfg: &TrackConfig,
|
||||
base: Option<Vec2>,
|
||||
frozen: &[String],
|
||||
) -> Option<Track> {
|
||||
let t = self.find(d, space, cursor, aperture, tol, cfg, base, frozen);
|
||||
self.last = t.clone();
|
||||
t
|
||||
}
|
||||
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
fn find(&self, d: &Drawing, space: &Space, cursor: Vec2, aperture: f64, tol: f64, cfg: &TrackConfig, base: Option<Vec2>) -> Option<Track> {
|
||||
fn find(
|
||||
&self,
|
||||
d: &Drawing,
|
||||
space: &Space,
|
||||
cursor: Vec2,
|
||||
aperture: f64,
|
||||
tol: f64,
|
||||
cfg: &TrackConfig,
|
||||
base: Option<Vec2>,
|
||||
frozen: &[String],
|
||||
) -> Option<Track> {
|
||||
if !(cursor.is_finite() && aperture.is_finite() && tol.is_finite() && aperture > 0.0 && tol > 0.0) {
|
||||
return None;
|
||||
}
|
||||
@@ -538,7 +563,7 @@ impl Tracker {
|
||||
// 2. A path crossing an object.
|
||||
if cfg.running(mode::INT | mode::APP) {
|
||||
let ix = crate::spatial::index(d, space);
|
||||
let prims = super::gather(d, space, &ix, cursor, aperture, mode::NEA).map(|(_, p)| p).unwrap_or_default();
|
||||
let prims = super::gather_in(d, space, &ix, cursor, aperture, mode::NEA, frozen).map(|(_, p)| p).unwrap_or_default();
|
||||
for prim in prims.iter().take(200) {
|
||||
let extend = cfg.running(mode::APP) && super::extendable(prim);
|
||||
for seg in super::prim_segments(prim) {
|
||||
@@ -588,12 +613,26 @@ pub fn candidate(
|
||||
aperture: f64,
|
||||
cfg: &TrackConfig,
|
||||
base: Option<Vec2>,
|
||||
) -> Option<Acquired> {
|
||||
candidate_with_frozen(d, space, cursor, hit, aperture, cfg, base, &[])
|
||||
}
|
||||
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
pub(crate) fn candidate_with_frozen(
|
||||
d: &Drawing,
|
||||
space: &Space,
|
||||
cursor: Vec2,
|
||||
hit: Option<&SnapHit>,
|
||||
aperture: f64,
|
||||
cfg: &TrackConfig,
|
||||
base: Option<Vec2>,
|
||||
frozen: &[String],
|
||||
) -> Option<Acquired> {
|
||||
if !can_acquire(cursor, aperture, cfg) {
|
||||
return None;
|
||||
}
|
||||
let ix = crate::spatial::index(d, space);
|
||||
let prims = super::gather(d, space, &ix, cursor, aperture, mode::NEA).map(|(_, p)| p).unwrap_or_default();
|
||||
let prims = super::gather_in(d, space, &ix, cursor, aperture, mode::NEA, frozen).map(|(_, p)| p).unwrap_or_default();
|
||||
candidate_from_prims(cursor, hit, aperture, cfg, base, &prims)
|
||||
}
|
||||
|
||||
@@ -789,7 +828,7 @@ impl crate::Session {
|
||||
s.orthomode ^= q.shift;
|
||||
let angbase = self.angle_settings().angbase;
|
||||
let Ok(st) = self.state() else { return CursorSnap { point: raw, ..Default::default() } };
|
||||
let (doc, space) = (st.doc.clone(), st.edit_space());
|
||||
let (doc, space, frozen) = (st.doc.clone(), st.edit_space(), st.viewport_frozen().to_vec());
|
||||
if !raw.is_finite() {
|
||||
return CursorSnap { point: raw, ..Default::default() };
|
||||
}
|
||||
@@ -798,10 +837,10 @@ impl crate::Session {
|
||||
let cfg = TrackConfig::relative_to(&s, angbase, last);
|
||||
let osmode = s.osmode | if s.osnaphatch { mode::HATCH } else { 0 };
|
||||
let ix = crate::spatial::index(&doc, &space);
|
||||
let (hit, near_prims) = super::osnap_with_neighborhood(&doc, &space, &ix, raw, q.aperture, osmode, q.base, q.deferred);
|
||||
let (hit, near_prims) = super::osnap_with_neighborhood(&doc, &space, &ix, raw, q.aperture, osmode, q.base, q.deferred, &frozen);
|
||||
let cand = match (osmode & mode::HATCH, near_prims.as_deref()) {
|
||||
(0, Some(prims)) => candidate_with_prims(raw, hit.as_ref(), q.aperture, &cfg, q.base, prims),
|
||||
_ => candidate(&doc, &space, raw, hit.as_ref(), q.aperture, &cfg, q.base),
|
||||
_ => candidate_with_frozen(&doc, &space, raw, hit.as_ref(), q.aperture, &cfg, q.base, &frozen),
|
||||
};
|
||||
let wait = self.tracking.hover(cand, q.now, cfg.shift_acquire, q.shift);
|
||||
if let Some(h) = hit {
|
||||
@@ -816,7 +855,7 @@ impl crate::Session {
|
||||
let (origin, angle) = super::grid_frame_in(&doc, &space);
|
||||
p = super::grid_snap(p, doc.header.snap_unit(), origin, angle);
|
||||
}
|
||||
if let Some(mut t) = self.tracking.track(&doc, &space, p, q.aperture, q.tol, &cfg, q.base) {
|
||||
if let Some(mut t) = self.tracking.track_with_frozen(&doc, &space, p, q.aperture, q.tol, &cfg, q.base, &frozen) {
|
||||
// PolarSnap (SNAPTYPE 1): steps of POLARDIST, or of the snap X spacing when it is 0.
|
||||
let step = if s.polardist > 0.0 { s.polardist } else { s.snapunit.x };
|
||||
if s.snapmode
|
||||
|
||||
@@ -115,6 +115,7 @@ mod offset_ellipse_side;
|
||||
mod offset_move;
|
||||
mod oops_command;
|
||||
mod options_profile;
|
||||
mod osnap_opened_drawings;
|
||||
mod overkill;
|
||||
mod parallel_display_list;
|
||||
mod pedit_multiple;
|
||||
@@ -157,10 +158,12 @@ mod setvar_coverage;
|
||||
mod shapes;
|
||||
mod snap_annotations;
|
||||
mod snap_blocks;
|
||||
mod snap_center_on_curve;
|
||||
mod snap_curves;
|
||||
mod snap_intersections_aperture;
|
||||
mod snap_nearest;
|
||||
mod snap_overrides;
|
||||
mod snap_tab_cycling;
|
||||
mod snap_tracking;
|
||||
mod snaps_more;
|
||||
mod solid_command;
|
||||
|
||||
@@ -1,8 +1,9 @@
|
||||
//! DIST snaps to the model geometry displayed in paper-space viewports (#516).
|
||||
|
||||
use cadcraft_engine::doc::{Block, Circle, Common, Drawing, Entity, EntityKind, Handle, Insert, Line, Space, Viewport};
|
||||
use cadcraft_engine::doc::{Block, Circle, Common, Drawing, Ellipse, Entity, EntityKind, Handle, Insert, Line, Space, Viewport};
|
||||
use cadcraft_engine::geom::{Vec2, Vec3};
|
||||
use cadcraft_engine::snap::{SnapCurve, SnapHit, mode, osnap};
|
||||
use cadcraft_engine::pointmod::snap_candidates;
|
||||
use cadcraft_engine::snap::{SnapCurve, SnapHit, mode, osnap, osnap_all};
|
||||
use cadcraft_engine::{Input, Session};
|
||||
use serde_json::json;
|
||||
|
||||
@@ -278,6 +279,46 @@ fn clipped_endpoints_do_not_hide_a_visible_candidate() {
|
||||
assert!(osnap(&d, &paper, Vec2::new(110.11, 51.0), 0.2, mode::END, None, false).is_none());
|
||||
}
|
||||
|
||||
/// Across spaces a click takes the viewport's Endpoint over a paper-space Nearest that scores
|
||||
/// closer, as within one space a snap point beats Nearest. Tab starts at the click's snap and
|
||||
/// still reaches the paper-space Nearest.
|
||||
#[test]
|
||||
fn a_viewport_endpoint_beats_a_closer_paper_space_nearest() {
|
||||
let (mut d, paper) = drawing();
|
||||
// A paper-space line 0.3 left of the model endpoint (0, 0), which the viewport shows at (95, 50).
|
||||
d.add(&paper, Common::default(), EntityKind::Line(Line { a: Vec3::new(94.7, 48.0, 0.0), b: Vec3::new(94.7, 52.0, 0.0) })).unwrap();
|
||||
let (cursor, modes) = (Vec2::new(94.8, 50.0), mode::END | mode::NEA);
|
||||
let hit = osnap(&d, &paper, cursor, 0.5, modes, None, false).unwrap();
|
||||
assert!(hit.mode == mode::END && hit.viewport.is_some() && hit.point.near(Vec2::new(95.0, 50.0), 1e-9), "{hit:?}");
|
||||
let all = snap_candidates(&d, &paper, cursor, 0.5, modes, None, false);
|
||||
assert_eq!(all.first(), Some(&hit), "Tab starts at the click's snap");
|
||||
assert!(
|
||||
all.iter().any(|h| h.mode == mode::NEA && h.viewport.is_none() && h.point.near(Vec2::new(94.7, 50.0), 1e-9)),
|
||||
"Tab reaches the paper-space Nearest: {all:?}"
|
||||
);
|
||||
}
|
||||
|
||||
/// Overlapping viewports can show different model points at one paper point; Tab offers each,
|
||||
/// since DIST measures in the model units of the viewport picked.
|
||||
#[test]
|
||||
fn overlapping_viewports_each_offer_their_model_point() {
|
||||
let (mut d, paper) = drawing();
|
||||
// This viewport shows the model endpoint (20, 0) at paper (100, 50), a second one over it (0, 0).
|
||||
edit_viewport(&mut d, &paper, |vp| vp.view_center = Vec2::new(20.0, 0.0));
|
||||
let mut vp = match &d.entity(viewport(&d, &paper)).unwrap().kind {
|
||||
EntityKind::Viewport(vp) => vp.clone(),
|
||||
_ => panic!("viewport fixture"),
|
||||
};
|
||||
vp.view_center = Vec2::new(0.0, 0.0);
|
||||
vp.id = 3;
|
||||
d.add(&paper, Common::default(), EntityKind::Viewport(vp)).unwrap();
|
||||
let all = osnap_all(&d, &paper, Vec2::new(100.05, 50.04), 0.5, mode::END, None, false);
|
||||
let mut models: Vec<Vec2> =
|
||||
all.iter().filter(|h| h.point.near(Vec2::new(100.0, 50.0), 1e-9)).filter_map(|h| h.viewport).map(|v| v.point).collect();
|
||||
models.sort_by(|a, b| a.x.total_cmp(&b.x));
|
||||
assert_eq!(models, [Vec2::new(0.0, 0.0), Vec2::new(20.0, 0.0)], "{all:?}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn viewport_frozen_layers_do_not_hide_paper_space_geometry() {
|
||||
let (mut d, paper) = drawing();
|
||||
@@ -389,3 +430,22 @@ fn malformed_and_paper_space_viewports_are_not_snap_sources() {
|
||||
assert!(osnap(&d, &paper, Vec2::new(95.1, 50.1), 0.5, mode::END, None, false).is_none());
|
||||
}
|
||||
}
|
||||
|
||||
/// Nearest on a curve that leaves the viewport: the curve's closest point to the cursor is outside
|
||||
/// the viewport, another point of it within the aperture is inside, and Nearest snaps there.
|
||||
#[test]
|
||||
fn nearest_takes_the_visible_part_of_a_curve_crossing_the_viewport_edge() {
|
||||
let (mut d, paper) = drawing();
|
||||
// The viewport shows model y up to 20. A tall ellipse peaks at (15, 20.1), just outside.
|
||||
let ellipse = Ellipse { center: Vec3::new(15.0, 0.0, 0.0), major: Vec3::new(0.0, 20.1, 0.0), ratio: 0.1, start: 0.0, end: std::f64::consts::TAU };
|
||||
d.add(&Space::Model, Common::default(), EntityKind::Ellipse(ellipse)).unwrap();
|
||||
// The viewport's border is on a layer that is off, so it offers no Nearest of its own.
|
||||
d.layers.push(cadcraft_engine::doc::Layer { name: "Border".into(), on: false, ..Default::default() });
|
||||
let vp = viewport(&d, &paper);
|
||||
d.modify_entity(vp, |e| e.common.layer = "Border".into()).unwrap();
|
||||
// Model (15, 19.99): 0.11 from the peak, about 0.2 from where the ellipse comes back inside.
|
||||
let cursor = Vec2::new(102.5, 59.995);
|
||||
let hit = osnap(&d, &paper, cursor, 0.5, mode::NEA, None, false).expect("a visible nearest point");
|
||||
let model = hit.viewport.expect("seen through the viewport").point;
|
||||
assert!(model.y <= 20.0 + 1e-9 && model.dist(Vec2::new(15.0, 19.99)) <= 1.0, "{hit:?}");
|
||||
}
|
||||
|
||||
@@ -0,0 +1,114 @@
|
||||
//! Running object snaps in a fresh drawing and in drawings opened from DXF and DWG files, with
|
||||
//! AutoCAD's default modes (OSMODE 4133: Endpoint, Center, Intersection, Extension).
|
||||
//!
|
||||
//! Moving onto a circle, an arc or a polyline arc finds its Center. OSMODE is a profile setting,
|
||||
//! as in AutoCAD (saved in the registry there, not the drawing): a file's `$OSMODE` header
|
||||
//! variable, 0 included, never changes the running snaps.
|
||||
|
||||
use cadcraft_engine::Session;
|
||||
use cadcraft_engine::doc::Drawing;
|
||||
use cadcraft_engine::geom::Vec2;
|
||||
use cadcraft_engine::snap::{mode, tracking::CursorQuery};
|
||||
use serde_json::json;
|
||||
|
||||
/// AutoCAD's default running snaps.
|
||||
const DEFAULT: u32 = 4133;
|
||||
|
||||
fn polar(c: Vec2, r: f64, deg: f64) -> Vec2 {
|
||||
let a = deg.to_radians();
|
||||
c + Vec2::new(r * a.cos(), r * a.sin())
|
||||
}
|
||||
|
||||
/// A line crossed by another, a circle, an arc and a polyline with a straight and an arc segment.
|
||||
fn draw(s: &mut Session) {
|
||||
s.execute("line", &json!({ "points": [[0, 0], [20, 0]] })).unwrap();
|
||||
s.execute("line", &json!({ "points": [[5, -5], [5, 5]] })).unwrap();
|
||||
s.execute("circle", &json!({ "center": [50, 0], "radius": 5 })).unwrap();
|
||||
s.execute("arc", &json!({ "center": [80, 0], "radius": 5, "start": 0, "end": 180 })).unwrap();
|
||||
// 100,0 to 110,0 straight, then a half circle (bulge 1) to 130,0 round 120,0, below the axis.
|
||||
s.execute("pline", &json!({ "vertices": [[100, 0], {"p": [110, 0], "bulge": 1.0}, [130, 0]] })).unwrap();
|
||||
}
|
||||
|
||||
fn drawing() -> Drawing {
|
||||
let mut s = Session::new();
|
||||
draw(&mut s);
|
||||
s.doc().unwrap().clone()
|
||||
}
|
||||
|
||||
/// Where a click at `cursor` lands while LINE asks for its first point (the drawing area's path).
|
||||
fn snap(s: &mut Session, cursor: Vec2) -> Option<(Vec2, u32)> {
|
||||
if s.running.is_none() {
|
||||
s.start("line").unwrap();
|
||||
}
|
||||
let q = CursorQuery { base: None, deferred: true, corner: false, aperture: 1.0, tol: 0.5, now: 0.0, shift: false };
|
||||
let r = s.snap_cursor(cursor, &q);
|
||||
r.snap.map(|h| (r.point, h.mode))
|
||||
}
|
||||
|
||||
fn assert_snaps(s: &mut Session, what: &str) {
|
||||
assert_eq!(s.settings.osmode, DEFAULT, "{what}: the running snaps are the profile's");
|
||||
let cases = [
|
||||
("the line's end", Vec2::new(20.2, 0.1), Vec2::new(20.0, 0.0), &[mode::END][..]),
|
||||
("the lines' crossing", Vec2::new(5.2, 0.15), Vec2::new(5.0, 0.0), &[mode::INT][..]),
|
||||
("the circle", polar(Vec2::new(50.0, 0.0), 5.3, 45.0), Vec2::new(50.0, 0.0), &[mode::CEN][..]),
|
||||
("the arc", polar(Vec2::new(80.0, 0.0), 5.2, 90.0), Vec2::new(80.0, 0.0), &[mode::CEN][..]),
|
||||
("the arc's end", Vec2::new(85.2, 0.1), Vec2::new(85.0, 0.0), &[mode::END][..]),
|
||||
("the polyline's vertex", Vec2::new(110.2, 0.1), Vec2::new(110.0, 0.0), &[mode::END][..]),
|
||||
("the polyline's arc", polar(Vec2::new(120.0, 0.0), 10.2, 270.0), Vec2::new(120.0, 0.0), &[mode::CEN][..]),
|
||||
];
|
||||
for (name, cursor, want, modes) in cases {
|
||||
let (p, m) = snap(s, cursor).unwrap_or_else(|| panic!("{what}: no snap on {name}"));
|
||||
assert!(modes.contains(&m), "{what}, {name}: mode {m}");
|
||||
assert!(p.near(want, 1e-6), "{what}, {name}: {p:?}");
|
||||
}
|
||||
// Away from everything: nothing.
|
||||
assert_eq!(snap(s, Vec2::new(35.0, 20.0)), None, "{what}");
|
||||
// F3 off: nothing; on again: back.
|
||||
s.execute("osnap", &json!({})).unwrap();
|
||||
assert_eq!(snap(s, Vec2::new(20.2, 0.1)), None, "{what}: F3 off");
|
||||
s.execute("osnap", &json!({})).unwrap();
|
||||
assert_eq!(snap(s, Vec2::new(20.2, 0.1)).map(|h| h.1), Some(mode::END), "{what}: F3 on");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn default_snaps_work_in_a_fresh_drawing() {
|
||||
let mut s = Session::new();
|
||||
draw(&mut s);
|
||||
assert_snaps(&mut s, "fresh drawing");
|
||||
}
|
||||
|
||||
/// `text` with `$OSMODE` set to `value` at the top of its header.
|
||||
fn with_osmode(text: &str, value: u32) -> String {
|
||||
let at = text.find("HEADER").expect("a header section") + "HEADER".len();
|
||||
let eol = if text.contains("\r\n") { "\r\n" } else { "\n" };
|
||||
let (head, tail) = text.split_at(at);
|
||||
format!("{head}{eol} 9{eol}$OSMODE{eol} 70{eol}{value}{tail}")
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_dxf_with_osmode_0_keeps_the_running_snaps() {
|
||||
let text = String::from_utf8(cadcraft_io::write(&drawing(), "snaps.dxf").unwrap()).unwrap();
|
||||
let text = with_osmode(&text, 0);
|
||||
let d = cadcraft_io::read(text.as_bytes(), "snaps.dxf").unwrap();
|
||||
let mut s = Session::new();
|
||||
// OSMODE is the profile's: the user's own choice survives opening the file.
|
||||
s.execute("setvar", &json!({ "name": "OSMODE", "value": DEFAULT })).unwrap();
|
||||
s.open_drawing(d, "snaps.dxf", None);
|
||||
assert_snaps(&mut s, "DXF with $OSMODE 0");
|
||||
// Nor does a file change a profile without Center.
|
||||
let mut s = Session::new();
|
||||
s.execute("setvar", &json!({ "name": "OSMODE", "value": mode::END })).unwrap();
|
||||
s.open_drawing(cadcraft_io::read(with_osmode(&text, DEFAULT).as_bytes(), "x.dxf").unwrap(), "x.dxf", None);
|
||||
assert_eq!(s.settings.osmode, mode::END);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn default_snaps_work_in_a_drawing_opened_from_dwg() {
|
||||
// The drawing is the test's own, so it is converted in this process.
|
||||
cadcraft_io::dwg_worker::allow_in_process();
|
||||
let bytes = cadcraft_io::write(&drawing(), "snaps.dwg").unwrap();
|
||||
let d = cadcraft_io::read(&bytes, "snaps.dwg").unwrap();
|
||||
let mut s = Session::new();
|
||||
s.open_drawing(d, "snaps.dwg", None);
|
||||
assert_snaps(&mut s, "DWG");
|
||||
}
|
||||
@@ -0,0 +1,202 @@
|
||||
//! Center snaps from the curve, as in AutoCAD: with the cursor over a circle, an arc, an
|
||||
//! ellipse or a polyline arc (also inside a block reference) the running Center snap finds its
|
||||
//! center, however far away it is. Before, the center was only found with the cursor on the
|
||||
//! center itself, so moving onto a circle with the default running snaps (END, CEN, INT, EXT)
|
||||
//! showed nothing.
|
||||
|
||||
use cadcraft_engine::Session;
|
||||
use cadcraft_engine::doc::{Common, EntityKind, Insert, Space};
|
||||
use cadcraft_engine::geom::{Vec2, Vec3};
|
||||
use cadcraft_engine::pointmod::snap_candidates;
|
||||
use cadcraft_engine::snap::{self, mode};
|
||||
use serde_json::json;
|
||||
|
||||
/// AutoCAD's default running snaps (OSMODE 4133).
|
||||
const DEFAULT: u32 = 4133;
|
||||
|
||||
fn snap_at(s: &Session, cursor: Vec2, aperture: f64, osmode: u32) -> Option<(Vec2, u32)> {
|
||||
snap::osnap(s.doc().unwrap(), &Space::Model, cursor, aperture, osmode, None, false).map(|h| (h.point, h.mode))
|
||||
}
|
||||
|
||||
fn polar(c: Vec2, r: f64, deg: f64) -> Vec2 {
|
||||
let a = deg.to_radians();
|
||||
c + Vec2::new(r * a.cos(), r * a.sin())
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn cursor_on_a_circle_snaps_to_its_center() {
|
||||
let mut s = Session::new();
|
||||
s.execute("circle", &json!({ "center": [100, 50], "radius": 20 })).unwrap();
|
||||
let c = Vec2::new(100.0, 50.0);
|
||||
for deg in [10.0, 45.0, 130.0, 250.0, 300.0] {
|
||||
// A hair off the circle, well inside the aperture; the center is 20 units away.
|
||||
let cursor = polar(c, 20.3, deg);
|
||||
let (p, m) = snap_at(&s, cursor, 1.0, DEFAULT).unwrap_or_else(|| panic!("no snap on the circle at {deg}°"));
|
||||
assert_eq!(m, mode::CEN, "at {deg}°");
|
||||
assert!(p.near(c, 1e-9), "at {deg}°: {p:?}");
|
||||
}
|
||||
// Away from the circle (outside the aperture) there is nothing.
|
||||
assert_eq!(snap_at(&s, polar(c, 23.0, 45.0), 1.0, DEFAULT), None);
|
||||
// Center off: no center.
|
||||
assert_eq!(snap_at(&s, polar(c, 20.3, 45.0), 1.0, mode::END), None);
|
||||
// On the center itself, as before.
|
||||
assert_eq!(snap_at(&s, c + Vec2::new(0.2, 0.1), 1.0, DEFAULT).map(|h| h.1), Some(mode::CEN));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn arcs_ellipses_and_polyline_arcs_snap_to_their_centers() {
|
||||
let mut s = Session::new();
|
||||
s.execute("arc", &json!({ "center": [0, 0], "radius": 10, "start": 0, "end": 90 })).unwrap();
|
||||
s.execute("ellipse", &json!({ "center": [50, 0], "major": [8, 0], "ratio": 0.5 })).unwrap();
|
||||
// A polyline with a half-circle bulge from (100,0) to (120,0): center (110,0), radius 10.
|
||||
s.execute("pline", &json!({ "vertices": [{"p": [100, 0], "bulge": 1.0}, [120, 0]] })).unwrap();
|
||||
let arc = snap_at(&s, polar(Vec2::ZERO, 10.2, 45.0), 1.0, DEFAULT).unwrap();
|
||||
assert_eq!(arc.1, mode::CEN);
|
||||
assert!(arc.0.near(Vec2::ZERO, 1e-9));
|
||||
// The arc runs 0°-90°: on its circle at 200° (not on the arc) there is no center.
|
||||
assert_eq!(snap_at(&s, polar(Vec2::ZERO, 10.2, 200.0), 1.0, DEFAULT), None);
|
||||
let el = snap_at(&s, Vec2::new(50.0, 4.2), 1.0, DEFAULT).unwrap();
|
||||
assert_eq!(el.1, mode::CEN);
|
||||
assert!(el.0.near(Vec2::new(50.0, 0.0), 1e-9));
|
||||
let pl = snap_at(&s, polar(Vec2::new(110.0, 0.0), 10.2, 270.0), 1.0, DEFAULT).unwrap();
|
||||
assert_eq!(pl.1, mode::CEN, "the bulge's arc");
|
||||
assert!(pl.0.near(Vec2::new(110.0, 0.0), 1e-9), "{:?}", pl.0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_nearer_endpoint_or_intersection_still_wins() {
|
||||
let mut s = Session::new();
|
||||
s.execute("circle", &json!({ "center": [0, 0], "radius": 10 })).unwrap();
|
||||
s.execute("line", &json!({ "points": [[10, 0], [30, 0]] })).unwrap();
|
||||
// At the line's end on the circle: Endpoint/Intersection, not the far center.
|
||||
let (p, m) = snap_at(&s, Vec2::new(10.2, 0.1), 1.0, DEFAULT).unwrap();
|
||||
assert!(m == mode::END || m == mode::INT, "{m}");
|
||||
assert!(p.near(Vec2::new(10.0, 0.0), 1e-9));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn circles_inside_block_references_snap_to_their_centers() {
|
||||
let mut s = Session::new();
|
||||
let c = s.execute("circle", &json!({ "center": [5, 0], "radius": 2 })).unwrap()["handle"].as_str().unwrap().to_string();
|
||||
s.execute("block", &json!({ "name": "H", "base": [0, 0], "handles": [c], "keep": "delete" })).unwrap();
|
||||
let kind = EntityKind::Insert(Insert {
|
||||
block: "H".into(),
|
||||
insert: Vec3::new(100.0, 100.0, 0.0),
|
||||
scale: Vec3::new(3.0, 3.0, 1.0),
|
||||
rotation: 0.0,
|
||||
attribs: Vec::new(),
|
||||
cols: 1,
|
||||
rows: 1,
|
||||
col_spacing: 0.0,
|
||||
row_spacing: 0.0,
|
||||
clip: None,
|
||||
});
|
||||
s.doc_mut().unwrap().add(&Space::Model, Common::default(), kind).unwrap();
|
||||
// The circle lands at (115,100) with radius 6.
|
||||
let (p, m) = snap_at(&s, polar(Vec2::new(115.0, 100.0), 6.2, 60.0), 1.0, DEFAULT).unwrap();
|
||||
assert_eq!(m, mode::CEN);
|
||||
assert!(p.near(Vec2::new(115.0, 100.0), 1e-9), "{p:?}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn tab_cycling_offers_the_center_from_the_curve() {
|
||||
let mut s = Session::new();
|
||||
s.execute("circle", &json!({ "center": [0, 0], "radius": 10 })).unwrap();
|
||||
let all = snap_candidates(s.doc().unwrap(), &Space::Model, polar(Vec2::ZERO, 10.2, 30.0), 1.0, DEFAULT, None, false);
|
||||
assert_eq!(all.iter().filter(|h| h.mode == mode::CEN && h.point.near(Vec2::ZERO, 1e-9)).count(), 1, "{all:?}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_cursor_query_snaps_to_the_center_from_the_curve() {
|
||||
// The path the drawing area uses (Session::snap_cursor): the point a click would take.
|
||||
let mut s = Session::new();
|
||||
s.execute("circle", &json!({ "center": [0, 0], "radius": 50 })).unwrap();
|
||||
s.start("line").unwrap();
|
||||
let q = snap::tracking::CursorQuery { base: None, deferred: true, corner: false, aperture: 1.0, tol: 0.5, now: 0.0, shift: false };
|
||||
let r = s.snap_cursor(polar(Vec2::ZERO, 50.4, 33.0), &q);
|
||||
assert_eq!(r.snap.map(|h| h.mode), Some(mode::CEN));
|
||||
assert!(r.point.near(Vec2::ZERO, 1e-9), "{:?}", r.point);
|
||||
}
|
||||
|
||||
/// The arc of the review of #2347 (and #1114's test): center (100,50), radius 80, 30°-150°.
|
||||
fn review_arc() -> Session {
|
||||
let mut s = Session::new();
|
||||
s.execute("arc", &json!({ "center": [100, 50], "radius": 80, "start": 30, "end": 150 })).unwrap();
|
||||
s
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_midpoint_under_the_cursor_beats_the_center_from_the_curve() {
|
||||
let s = review_arc();
|
||||
// On the arc's midpoint (100,130) with Center and Midpoint running: Midpoint, as in AutoCAD.
|
||||
for cursor in [Vec2::new(100.05, 130.0), Vec2::new(100.2, 130.1)] {
|
||||
assert_eq!(snap_at(&s, cursor, 0.5, mode::CEN | mode::MID), Some((Vec2::new(100.0, 130.0), mode::MID)), "at {cursor:?}");
|
||||
assert_eq!(snap_at(&s, cursor, 0.5, mode::MID), Some((Vec2::new(100.0, 130.0), mode::MID)), "at {cursor:?}");
|
||||
}
|
||||
// Elsewhere on the arc, with no snap point in the aperture, the center from the curve.
|
||||
let (p, m) = snap_at(&s, polar(Vec2::new(100.0, 50.0), 80.1, 70.0), 0.5, mode::CEN | mode::MID).unwrap();
|
||||
assert_eq!(m, mode::CEN);
|
||||
assert!(p.near(Vec2::new(100.0, 50.0), 1e-9), "{p:?}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_quadrant_under_the_cursor_beats_the_center_from_the_curve() {
|
||||
let mut s = Session::new();
|
||||
s.execute("circle", &json!({ "center": [20, 0], "radius": 2 })).unwrap();
|
||||
let cursor = Vec2::new(20.1, 2.0);
|
||||
assert_eq!(snap_at(&s, cursor, 0.5, mode::CEN | mode::QUA), Some((Vec2::new(20.0, 2.0), mode::QUA)));
|
||||
assert_eq!(snap_at(&s, cursor, 0.5, mode::QUA), Some((Vec2::new(20.0, 2.0), mode::QUA)));
|
||||
// Away from the quadrants the center from the curve.
|
||||
let (p, m) = snap_at(&s, polar(Vec2::new(20.0, 0.0), 2.1, 45.0), 0.5, mode::CEN | mode::QUA).unwrap();
|
||||
assert_eq!(m, mode::CEN);
|
||||
assert!(p.near(Vec2::new(20.0, 0.0), 1e-9), "{p:?}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn many_straight_segments_do_not_hide_a_circle_from_center() {
|
||||
// A polyline of 2,500 straight segments zigzagging over the cursor, then a circle: the
|
||||
// work limit counts circles and arcs only, so the circle's center is still found.
|
||||
let mut s = Session::new();
|
||||
let vertices: Vec<[f64; 2]> = (0..=2500).map(|i| [i as f64 * 0.04, if i % 2 == 0 { 0.0 } else { 100.0 }]).collect();
|
||||
s.execute("pline", &json!({ "vertices": vertices })).unwrap();
|
||||
s.execute("circle", &json!({ "center": [50, 50], "radius": 20 })).unwrap();
|
||||
let (p, m) = snap_at(&s, polar(Vec2::new(50.0, 50.0), 20.2, 100.0), 0.5, mode::CEN).unwrap();
|
||||
assert_eq!(m, mode::CEN);
|
||||
assert!(p.near(Vec2::new(50.0, 50.0), 1e-9), "{p:?}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_viewport_center_keeps_its_curve_distance_against_paper_space() {
|
||||
use cadcraft_engine::doc::{Circle, Drawing, Viewport};
|
||||
let mut d = Drawing::new_imperial();
|
||||
let paper = Space::Paper("Layout1".into());
|
||||
// Model circle (10,0) r16 seen through a viewport at half scale: paper center (100,50), radius 8.
|
||||
d.add(&Space::Model, Common::default(), EntityKind::Circle(Circle { center: Vec3::new(10.0, 0.0, 0.0), radius: 16.0 })).unwrap();
|
||||
let vp = Viewport {
|
||||
center: Vec3::new(100.0, 50.0, 0.0),
|
||||
width: 20.0,
|
||||
height: 20.0,
|
||||
view_center: Vec2::new(10.0, 0.0),
|
||||
view_height: 40.0,
|
||||
id: 2,
|
||||
locked: false,
|
||||
frozen_layers: Vec::new(),
|
||||
layer_colors: Vec::new(),
|
||||
clip: None,
|
||||
on: true,
|
||||
twist: 0.0,
|
||||
};
|
||||
d.add(&paper, Common::default(), EntityKind::Viewport(vp)).unwrap();
|
||||
// A small paper-space circle whose curve passes 0.3 from the cursor and whose center is
|
||||
// nearer the cursor (3.3) than the model circle's (8).
|
||||
d.add(&paper, Common::default(), EntityKind::Circle(Circle { center: Vec3::new(108.0, 53.3, 0.0), radius: 3.0 })).unwrap();
|
||||
// The cursor is on the model circle (0.1 off in paper units): its center wins.
|
||||
let h = snap::osnap(&d, &paper, Vec2::new(108.1, 50.0), 0.5, mode::CEN, None, false).unwrap();
|
||||
assert_eq!(h.mode, mode::CEN);
|
||||
assert!(h.point.near(Vec2::new(100.0, 50.0), 1e-9), "{h:?}");
|
||||
assert!(h.viewport.is_some());
|
||||
// On the paper circle, away from the model one: its center.
|
||||
let h = snap::osnap(&d, &paper, Vec2::new(108.0, 56.35), 0.5, mode::CEN, None, false).unwrap();
|
||||
assert!(h.point.near(Vec2::new(108.0, 53.3), 1e-9), "{h:?}");
|
||||
assert!(h.viewport.is_none());
|
||||
}
|
||||
@@ -70,6 +70,9 @@ fn elliptical_arc_perpendicular_and_tangent_from_a_base_point() {
|
||||
let (q, m) = along_quarter(&s, mode::TAN, Some(base)).expect("a tangent point on the arc");
|
||||
assert_eq!(m, mode::TAN);
|
||||
assert!(on_quarter(q) && Vec2::new(q.x / 16.0, q.y / 4.0).dot(q - base).abs() < 1e-9, "{q:?}");
|
||||
// The same tangent at a prompt that resolves deferred snaps (CIRCLE's 3P points, #1512).
|
||||
let h = snap::osnap(s.doc().unwrap(), &Space::Model, q, 0.3, mode::TAN, Some(base), true).expect("tangent at a deferred prompt");
|
||||
assert!(h.mode == mode::TAN && h.deferred.is_none() && h.point.near(q, 1e-9), "{h:?}");
|
||||
// Perpendicular from (10,10): the line from the base runs along the normal.
|
||||
let base = Vec2::new(10.0, 10.0);
|
||||
let (q, m) = along_quarter(&s, mode::PER, Some(base)).expect("a perpendicular foot on the arc");
|
||||
|
||||
@@ -21,6 +21,17 @@ fn last_line(s: &Session) -> (Vec2, Vec2) {
|
||||
s.doc().unwrap().model.iter().filter_map(|e| if let EntityKind::Line(l) = &e.kind { Some((l.a.xy(), l.b.xy())) } else { None }).last().unwrap()
|
||||
}
|
||||
|
||||
/// The last circle drawn as (center, radius).
|
||||
fn last_circle(s: &Session) -> (Vec2, f64) {
|
||||
s.doc()
|
||||
.unwrap()
|
||||
.model
|
||||
.iter()
|
||||
.filter_map(|e| if let EntityKind::Circle(c) = &e.kind { Some((c.center.xy(), c.radius)) } else { None })
|
||||
.last()
|
||||
.unwrap()
|
||||
}
|
||||
|
||||
fn near(p: Vec2, x: f64, y: f64) -> bool {
|
||||
p.near(Vec2::new(x, y), 1e-9)
|
||||
}
|
||||
@@ -80,6 +91,23 @@ fn nothing_to_snap_to_rejects_the_point() {
|
||||
assert!(near(s.last_point, 10.0, 10.0));
|
||||
}
|
||||
|
||||
/// #2800: a typed PER or TAN finds its point from a pick anywhere on the object, as in AutoCAD.
|
||||
/// The pick used to have to land within the aperture (0.125 here) of the foot or tangent point,
|
||||
/// which you can't know in advance; elsewhere it said "No Perpendicular found".
|
||||
#[test]
|
||||
fn typed_per_and_tan_snap_from_anywhere_on_the_object() {
|
||||
let mut s = drawing();
|
||||
// From (5,5), PER picked at (3,0) on the line 0,0–10,0: two units from the foot (5,0).
|
||||
s.script("LINE 5,5 PER 3,0\n\n").unwrap();
|
||||
let (a, b) = last_line(&s);
|
||||
assert!(near(a, 5.0, 5.0) && near(b, 5.0, 0.0), "{a:?} {b:?}");
|
||||
// From (30,20), TAN picked at the top of the circle (centre 20,20, radius 3): the tangent
|
||||
// points are at cos = 3/10 from the line to the base, and the upper one is nearer the pick.
|
||||
s.script("LINE 30,20 TAN 20,23\n\n").unwrap();
|
||||
let (a, b) = last_line(&s);
|
||||
assert!(near(a, 30.0, 20.0) && near(b, 20.9, 20.0 + 3.0 * 0.91f64.sqrt()), "{a:?} {b:?}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn from_nests_with_a_snap_override() {
|
||||
let mut s = drawing();
|
||||
@@ -116,3 +144,86 @@ fn a_command_keyword_wins_over_a_snap_word() {
|
||||
s.cmdline("arc _cen").unwrap();
|
||||
assert!(s.prompt_text().ends_with("Center of:"), "{}", s.prompt_text());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn tan_for_a_circle_radius_touches_the_picked_circle() {
|
||||
// #1512: the circle around the center that touches the circle at 20,20 radius 3, on the side
|
||||
// it was picked: the near side (radius 7), the far side (13), and through Diameter.
|
||||
for (script, center, r) in [
|
||||
("CIRCLE 30,20 TAN 23.02,20.03\n", (30.0, 20.0), 7.0),
|
||||
("CIRCLE 30,20 TAN 16.98,19.97\n", (30.0, 20.0), 13.0),
|
||||
("CIRCLE 20,10 D TAN 20.03,17.02\n", (20.0, 10.0), 7.0),
|
||||
] {
|
||||
let mut s = drawing();
|
||||
s.script(script).unwrap();
|
||||
assert!(s.running.is_none(), "{script}: {}", s.prompt_text());
|
||||
let (c, got) = last_circle(&s);
|
||||
assert!(near(c, center.0, center.1) && (got - r).abs() < 1e-9, "{script}: {c:?} r={got}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn tan_for_a_3p_circle_touches_the_picked_circles() {
|
||||
// #1512: through two points and tangent to the circle at 20,20 radius 3, the tangent pick
|
||||
// first or last.
|
||||
for script in ["CIRCLE 3P 26,20 26,26 TAN 23.02,20.03\n", "CIRCLE 3P TAN 23.02,20.03 26,20 26,26\n"] {
|
||||
let mut s = drawing();
|
||||
s.script(script).unwrap();
|
||||
assert!(s.running.is_none(), "{script}: {}", s.prompt_text());
|
||||
let (c, r) = last_circle(&s);
|
||||
assert!((c.dist(Vec2::new(26.0, 20.0)) - r).abs() < 1e-9 && (c.dist(Vec2::new(26.0, 26.0)) - r).abs() < 1e-9, "{script}");
|
||||
assert!((c.dist(Vec2::new(20.0, 20.0)) - (3.0 + r)).abs() < 1e-9, "{script}: {c:?} r={r}");
|
||||
}
|
||||
// Tan, Tan, Tan: the circle between three circles of radius 1, picked on their inner sides.
|
||||
let mut s = Session::new();
|
||||
s.script("CIRCLE 0,0 1\nCIRCLE 6,0 1\nCIRCLE 3,5 1\nCIRCLE 3P TAN 0.98,0.2 TAN 5.02,0.2 TAN 3.01,3.98\n").unwrap();
|
||||
assert!(s.running.is_none(), "{}", s.prompt_text());
|
||||
let (c, r) = last_circle(&s);
|
||||
for k in [(0.0, 0.0), (6.0, 0.0), (3.0, 5.0)] {
|
||||
assert!((c.dist(Vec2::new(k.0, k.1)) - (1.0 + r)).abs() < 1e-9, "{c:?} r={r}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn tan_for_a_3p_circle_touches_an_arc_within_its_sweep() {
|
||||
// #1512: through 26,20 and 26,26, the circles tangent to the circle at 20,20 radius 3 touch it
|
||||
// on the right or the far left, both off an arc swept from 90° to 100°: no circle.
|
||||
let mut s = Session::new();
|
||||
s.execute("arc", &serde_json::json!({"center": [20, 20], "radius": 3, "start": 90, "end": 100})).unwrap();
|
||||
s.script("CIRCLE 3P 26,20 26,26 TAN 19.74,22.99\n").unwrap();
|
||||
assert!(s.prompt_text().contains("third point"), "{}", s.prompt_text());
|
||||
assert!(!s.doc().unwrap().model.iter().any(|e| matches!(e.kind, EntityKind::Circle(_))));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn tan_for_a_3p_circle_takes_the_solution_that_touches_the_arc() {
|
||||
// #1512: through 26,20 and 26,26, the circles tangent to the circle at 20,20 radius 3 touch it
|
||||
// at about 29.6° and -103.3°. Picked at 20° on an arc swept from 200° to 25°, the 29.6°
|
||||
// circle is nearer the pick but off the arc: the -103.3° one (radius 6.0826) is drawn.
|
||||
let mut s = Session::new();
|
||||
s.execute("arc", &serde_json::json!({"center": [20, 20], "radius": 3, "start": 200, "end": 25})).unwrap();
|
||||
s.script("CIRCLE 3P 26,20 26,26 TAN 22.82,21.03\n").unwrap();
|
||||
assert!(s.running.is_none(), "{}", s.prompt_text());
|
||||
let (c, r) = last_circle(&s);
|
||||
assert!((c.dist(Vec2::new(20.0, 20.0)) - (r - 3.0)).abs() < 1e-9 && (r - 6.082575694955838).abs() < 1e-9, "{c:?} r={r}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn tan_for_a_circle_radius_refuses_the_picked_circles_own_center() {
|
||||
// #1512: a circle around 20,20 would lie on the circle there, not touch it.
|
||||
let mut s = drawing();
|
||||
s.script("CIRCLE 20,20 TAN 23.02,20.03\n").unwrap();
|
||||
assert!(s.prompt_text().contains("radius of circle"), "{}", s.prompt_text());
|
||||
assert!(s.log.iter().any(|l| l.contains("No circle around the center is tangent there.")), "{:?}", s.log);
|
||||
assert_eq!(s.doc().unwrap().model.iter().filter(|e| matches!(e.kind, EntityKind::Circle(_))).count(), 1);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn tan_for_a_3p_circle_refuses_the_picked_circle_itself() {
|
||||
// #1512: tangent twice to the circle and through a point on it is only the circle itself.
|
||||
let mut s = drawing();
|
||||
s.script("CIRCLE 3P TAN 23.02,20.03 TAN 16.98,20.03 20,23\n").unwrap();
|
||||
assert!(s.prompt_text().contains("third point"), "{}", s.prompt_text());
|
||||
assert!(s.log.iter().any(|l| l.contains("Circle does not exist.")), "{:?}", s.log);
|
||||
assert_eq!(s.doc().unwrap().model.iter().filter(|e| matches!(e.kind, EntityKind::Circle(_))).count(), 1);
|
||||
}
|
||||
|
||||
@@ -0,0 +1,89 @@
|
||||
//! Tab cycling through object snaps: a crowd of candidates is capped, hostile cursors and
|
||||
//! apertures give no candidates, and the list never repeats a snap.
|
||||
|
||||
use cadcraft_engine::Session;
|
||||
use cadcraft_engine::doc::Space;
|
||||
use cadcraft_engine::geom::Vec2;
|
||||
use cadcraft_engine::pointmod::snap_candidates;
|
||||
use cadcraft_engine::snap::mode;
|
||||
use serde_json::json;
|
||||
|
||||
#[test]
|
||||
fn a_crowd_of_snaps_is_capped_and_never_repeats() {
|
||||
let mut s = Session::new();
|
||||
// 600 short lines fanning out from points packed round the origin: 1,200 endpoints.
|
||||
for i in 0..600 {
|
||||
let a = f64::from(i) * 0.01;
|
||||
let p = [1e-3 * a.cos(), 1e-3 * a.sin()];
|
||||
s.execute("line", &json!({ "points": [p, [a.cos(), a.sin()]] })).unwrap();
|
||||
}
|
||||
let d = s.doc().unwrap();
|
||||
let cands = snap_candidates(d, &Space::Model, Vec2::ZERO, 0.5, mode::END | mode::INT | mode::NEA, None, false);
|
||||
assert!(!cands.is_empty());
|
||||
assert!(cands.len() <= 257, "{} candidates", cands.len());
|
||||
for (i, a) in cands.iter().enumerate() {
|
||||
assert!(a.point.is_finite());
|
||||
assert!(!cands.iter().skip(i + 1).any(|b| b.mode == a.mode && b.point == a.point), "{a:?} repeats");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn hostile_cursor_and_aperture_give_no_candidates() {
|
||||
let mut s = Session::new();
|
||||
s.execute("line", &json!({ "points": [[0, 0], [10, 0]] })).unwrap();
|
||||
let d = s.doc().unwrap();
|
||||
let space = Space::Model;
|
||||
let all = mode::END | mode::MID | mode::INT | mode::NEA | mode::PER;
|
||||
for (c, ap) in [
|
||||
(Vec2::new(f64::NAN, 0.0), 0.5),
|
||||
(Vec2::new(0.0, f64::INFINITY), 0.5),
|
||||
(Vec2::ZERO, f64::NAN),
|
||||
(Vec2::ZERO, 0.0),
|
||||
(Vec2::ZERO, -1.0),
|
||||
(Vec2::ZERO, f64::INFINITY),
|
||||
] {
|
||||
assert!(snap_candidates(d, &space, c, ap, all, None, false).is_empty(), "{c:?} {ap}");
|
||||
assert!(snap_candidates(d, &space, c, ap, all, Some(Vec2::new(f64::NAN, 1.0)), true).is_empty(), "{c:?} {ap}");
|
||||
}
|
||||
// A huge but finite aperture still answers, from the objects there are.
|
||||
let far = snap_candidates(d, &space, Vec2::ZERO, 1e300, mode::END, None, false);
|
||||
assert!(far.iter().all(|h| h.point.is_finite()));
|
||||
// Object snaps off (or only the OFF bit) offer nothing.
|
||||
assert!(snap_candidates(d, &space, Vec2::ZERO, 0.5, 0, None, false).is_empty());
|
||||
assert!(snap_candidates(d, &space, Vec2::ZERO, 0.5, mode::END | mode::OFF, None, false).is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn every_endpoint_under_the_aperture_is_offered_not_one_per_mode() {
|
||||
let mut s = Session::new();
|
||||
// Three line ends close together, all within the aperture of the cursor between them.
|
||||
for (a, b) in [([0.0, 0.0], [10.0, 0.0]), ([0.06, 0.05], [0.06, 10.0]), ([0.03, -0.06], [-10.0, -10.0])] {
|
||||
s.execute("line", &json!({ "points": [a, b] })).unwrap();
|
||||
}
|
||||
let d = s.doc().unwrap();
|
||||
let cands = snap_candidates(d, &Space::Model, Vec2::new(0.03, 0.0), 0.125, mode::END, None, false);
|
||||
let ends: Vec<Vec2> = cands.iter().filter(|h| h.mode == mode::END).map(|h| h.point).collect();
|
||||
assert_eq!(ends.len(), 3, "{cands:?}");
|
||||
for want in [Vec2::new(0.0, 0.0), Vec2::new(0.06, 0.05), Vec2::new(0.03, -0.06)] {
|
||||
assert!(ends.iter().any(|p| p.near(want, 1e-12)), "{want:?} in {ends:?}");
|
||||
}
|
||||
// The first is the snap a click would take.
|
||||
let first = snap_candidates(d, &Space::Model, Vec2::new(0.03, 0.0), 0.125, mode::END, None, false).first().map(|h| h.point);
|
||||
assert_eq!(first, cadcraft_engine::snap::osnap(d, &Space::Model, Vec2::new(0.03, 0.0), 0.125, mode::END, None, false).map(|h| h.point));
|
||||
}
|
||||
|
||||
/// A base point that is not a number gives no candidates, though the cursor is on an endpoint: the
|
||||
/// perpendicular and tangent points from it would be meaningless, as a viewport already treats it.
|
||||
#[test]
|
||||
fn a_non_finite_base_gives_no_candidates() {
|
||||
let mut s = Session::new();
|
||||
s.execute("line", &json!({ "points": [[0, 0], [10, 0]] })).unwrap();
|
||||
let d = s.doc().unwrap();
|
||||
let all = mode::END | mode::PER | mode::TAN | mode::NEA;
|
||||
for base in [Vec2::new(f64::NAN, 1.0), Vec2::new(1.0, f64::INFINITY), Vec2::new(f64::NEG_INFINITY, f64::NAN)] {
|
||||
assert!(snap_candidates(d, &Space::Model, Vec2::new(10.01, 0.0), 0.5, all, Some(base), false).is_empty(), "{base:?}");
|
||||
assert!(cadcraft_engine::snap::osnap_all(d, &Space::Model, Vec2::new(10.01, 0.0), 0.5, all, Some(base), true).is_empty(), "{base:?}");
|
||||
}
|
||||
// A finite base still offers them.
|
||||
assert!(!snap_candidates(d, &Space::Model, Vec2::new(10.01, 0.0), 0.5, all, Some(Vec2::new(5.0, 5.0)), false).is_empty());
|
||||
}
|
||||
@@ -200,12 +200,14 @@ pub(super) fn override_cursor(app: &mut CadApp, raw: Vec2, xf: &Xf) {
|
||||
let s = &app.session.settings;
|
||||
let osmode = over.unwrap_or(s.osmode) | if s.osnaphatch { snap::mode::HATCH } else { 0 };
|
||||
let Ok(st) = app.session.state() else { return };
|
||||
let space = st.edit_space();
|
||||
let frozen = st.viewport_frozen();
|
||||
let hit = match cycle {
|
||||
Some(i) => {
|
||||
let cands = cadcraft_engine::pointmod::snap_candidates(&st.doc, &st.edit_space(), raw, ap, osmode, base, deferred);
|
||||
let cands = cadcraft_engine::pointmod::snap_candidates_with_frozen(&st.doc, &space, raw, ap, osmode, base, deferred, frozen);
|
||||
cands.get(i % cands.len().max(1)).copied()
|
||||
}
|
||||
None => snap::osnap(&st.doc, &st.edit_space(), raw, ap, osmode, base, deferred),
|
||||
None => snap::osnap_with_frozen(&st.doc, &space, raw, ap, osmode, base, deferred, frozen),
|
||||
};
|
||||
let p = match (hit, app.canvas.snap) {
|
||||
(Some(h), _) => {
|
||||
|
||||
@@ -42,6 +42,7 @@ mod shared_controls;
|
||||
mod shortcut_menus;
|
||||
mod shortcuts_checked;
|
||||
mod slow_clicks;
|
||||
mod snap_tab_cycling;
|
||||
mod space_at_options;
|
||||
mod status_bar_toggles;
|
||||
mod style_dialogs;
|
||||
|
||||
@@ -0,0 +1,136 @@
|
||||
//! Tab at a point prompt steps through every object snap under the aperture (each endpoint of
|
||||
//! each object nearby), not just the closest snap of each running mode, and comes back round.
|
||||
|
||||
use cadcraft_engine::Session;
|
||||
use cadcraft_engine::doc::{Common, Drawing, EntityKind, Line, Space};
|
||||
use cadcraft_engine::snap::mode;
|
||||
use cadcraft_geom::Vec2;
|
||||
use cadcraft_ui_egui::{CadApp, Services};
|
||||
use egui::{Event, Modifiers, PointerButton, Pos2, vec2};
|
||||
use egui_kittest::Harness;
|
||||
use serde_json::json;
|
||||
|
||||
#[test]
|
||||
fn tab_cycles_through_every_endpoint_under_the_aperture() {
|
||||
let mut s = Session::new();
|
||||
// Three line ends close together (within the aperture of the cursor between them).
|
||||
for (a, b) in [([0.0, 0.0], [10.0, 0.0]), ([0.06, 0.05], [0.06, 10.0]), ([0.03, -0.06], [-10.0, -10.0])] {
|
||||
s.execute("line", &json!({ "points": [a, b] })).unwrap();
|
||||
}
|
||||
s.execute("setvar", &json!({ "name": "OSMODE", "value": 1 })).unwrap();
|
||||
s.execute("view.set", &json!({ "center": [0, 0], "height": 20 })).unwrap();
|
||||
let mut app = CadApp::new(s, Services::default());
|
||||
app.canvas.zoom_pending = false;
|
||||
let mut h = Harness::builder().with_size(vec2(1600.0, 1000.0)).build_ui_state(
|
||||
|ui, app: &mut CadApp| {
|
||||
app.logic(ui.ctx());
|
||||
app.ui(ui);
|
||||
},
|
||||
app,
|
||||
);
|
||||
h.run_steps(3);
|
||||
h.state_mut().session.start("line").unwrap();
|
||||
h.run_steps(2);
|
||||
let xf = h.state().canvas.xf.unwrap();
|
||||
let at = xf.to_screen(Vec2::new(0.03, 0.0));
|
||||
h.event(Event::PointerMoved(at));
|
||||
h.run_steps(2);
|
||||
let mut seen: Vec<Vec2> = Vec::new();
|
||||
for i in 0..4 {
|
||||
let p = h.state().canvas.snap.map(|s| s.point).unwrap();
|
||||
if i < 3 {
|
||||
assert!(!seen.iter().any(|q| q.near(p, 1e-9)), "Tab {i} repeats {p:?} ({seen:?})");
|
||||
} else {
|
||||
assert!(seen.first().is_some_and(|q| q.near(p, 1e-9)), "the fourth Tab comes back round");
|
||||
}
|
||||
seen.push(p);
|
||||
h.event(Event::Text("\t".into()));
|
||||
h.run_steps(2);
|
||||
}
|
||||
for want in [Vec2::new(0.0, 0.0), Vec2::new(0.06, 0.05), Vec2::new(0.03, -0.06)] {
|
||||
assert!(seen.iter().any(|q| q.near(want, 1e-9)), "{want:?} in {seen:?}");
|
||||
}
|
||||
}
|
||||
|
||||
/// Three endpoints near 10,0: 10,0 (the nearest to the cursor), 10.03,0 and 9.95,0. Endpoint is
|
||||
/// the only running snap, so every candidate is an endpoint.
|
||||
fn three_ends() -> Harness<'static, CadApp> {
|
||||
let mut d = Drawing::new_imperial();
|
||||
for (a, b) in [((0.0, 0.0), (10.0, 0.0)), ((10.03, 0.0), (20.0, 0.0)), ((9.95, 0.0), (9.95, -5.0))] {
|
||||
let line = Line { a: Vec2::new(a.0, a.1).to3(0.0), b: Vec2::new(b.0, b.1).to3(0.0) };
|
||||
d.add(&Space::Model, Common::default(), EntityKind::Line(line)).unwrap();
|
||||
}
|
||||
let mut session = Session::empty();
|
||||
session.open_drawing(d, "Tab snap cycling", None);
|
||||
session.execute("view.set", &json!({"center":[10,0],"height":8})).unwrap();
|
||||
session.settings.osmode = mode::END;
|
||||
session.settings.snapmode = false;
|
||||
session.settings.orthomode = false;
|
||||
let mut app = CadApp::new(session, Services::default());
|
||||
app.canvas.zoom_pending = false;
|
||||
let mut h = Harness::builder().with_size(vec2(1600.0, 1000.0)).build_ui_state(
|
||||
|ui, app: &mut CadApp| {
|
||||
app.logic(ui.ctx());
|
||||
app.ui(ui);
|
||||
},
|
||||
app,
|
||||
);
|
||||
h.run_steps(5);
|
||||
h.state_mut().start("line");
|
||||
h.run_steps(2);
|
||||
assert_eq!(h.state().session.running.as_ref().unwrap().id, "line");
|
||||
let ap = h.state().session.settings.aperture / h.state().canvas.xf.unwrap().scale;
|
||||
assert!(ap > 0.07, "all three endpoints lie in the aperture ({ap})");
|
||||
h
|
||||
}
|
||||
|
||||
const CURSOR: Vec2 = Vec2::new(10.01, 0.0);
|
||||
|
||||
fn hover(h: &mut Harness<'_, CadApp>, p: Vec2) -> Pos2 {
|
||||
let pos = h.state().canvas.xf.unwrap().to_screen(p);
|
||||
h.event(Event::PointerMoved(pos));
|
||||
h.run_steps(3);
|
||||
pos
|
||||
}
|
||||
|
||||
/// Tab, as the command line receives it (`cmdline::capture_tab`).
|
||||
fn tab(h: &mut Harness<'_, CadApp>) {
|
||||
h.event(Event::Text("\t".into()));
|
||||
h.run_steps(3);
|
||||
}
|
||||
|
||||
fn snapped(h: &Harness<'_, CadApp>) -> Vec2 {
|
||||
let hit = h.state().canvas.snap.expect("a snap marker");
|
||||
assert_eq!(hit.mode, mode::END);
|
||||
hit.point
|
||||
}
|
||||
|
||||
fn assert_at(got: Vec2, x: f64) {
|
||||
assert!(got.near(Vec2::new(x, 0.0), 1e-9), "{got:?}, expected {x},0");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn moving_the_cursor_away_starts_the_cycle_over() {
|
||||
let mut h = three_ends();
|
||||
hover(&mut h, CURSOR);
|
||||
tab(&mut h);
|
||||
assert_at(snapped(&h), 10.03);
|
||||
hover(&mut h, Vec2::new(10.0, 2.0));
|
||||
assert!(h.state().canvas.snap.is_none());
|
||||
hover(&mut h, CURSOR);
|
||||
assert_at(snapped(&h), 10.0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_click_places_the_candidate_tab_chose() {
|
||||
let mut h = three_ends();
|
||||
let pos = hover(&mut h, CURSOR);
|
||||
tab(&mut h);
|
||||
assert_at(snapped(&h), 10.03);
|
||||
for pressed in [true, false] {
|
||||
h.event(Event::PointerButton { pos, button: PointerButton::Primary, pressed, modifiers: Modifiers::NONE });
|
||||
h.run_steps(2);
|
||||
}
|
||||
let base = h.state().session.current_prompt().and_then(|p| p.base).expect("LINE asks for the next point");
|
||||
assert_at(base, 10.03);
|
||||
}
|
||||
Reference in New Issue
Block a user