Select Behind: test each object once instead of re-hitting the whole document
objects_at() found Select Behind targets by running hit_test_skipping() in a loop, skipping everything found so far. Each round is a full tree traversal, so a stack of n overlapping paths costs O(n^2) hit tests before the loop finds no further object. The fast path walks each editable top-level layer once. Every selectable object's subtree is visited only until its first hit, and a HashSet records found ids so subtrees already covered by an earlier hit are not searched again. Sublayers recurse the same way, so a stack of n paths costs one traversal total. The original traversal stays in charge where Select Behind semantics differ from the plain front-to-back order: isolation (scope), and Edit Contents, which exposes objects nested inside a top-level group. Non- layer roots in malformed files also fall back. objects_at_repeated() keeps the old loop for those cases. Three tests: a 256-path stack asserts front-to-back order and completeness; a mixed document (sublayer, groups, clipping group, outline and path-only options) asserts the one-pass result equals the repeated-traversal result; an envelope in Edit Contents asserts the fallback preserves the original order.
This commit is contained in:
Ayanprogrammer11
bflatastic
parent
dc64aaa41b
commit
507c6e0e63
|
|
@ -1,5 +1,7 @@
|
||||||
//! Hit testing over the document tree.
|
//! Hit testing over the document tree.
|
||||||
|
|
||||||
|
use std::collections::HashSet;
|
||||||
|
|
||||||
use vectorcraft_geom::hit::{fill_contains, stroke_contains};
|
use vectorcraft_geom::hit::{fill_contains, stroke_contains};
|
||||||
use vectorcraft_geom::{Point, Rect};
|
use vectorcraft_geom::{Point, Rect};
|
||||||
|
|
||||||
|
|
@ -83,6 +85,90 @@ pub fn hit_test_visible(doc: &Document, p: Point, opt: HitOptions) -> Option<Hit
|
||||||
/// first: what clicks there select, one below the other (Cmd/Ctrl-click selects behind).
|
/// first: what clicks there select, one below the other (Cmd/Ctrl-click selects behind).
|
||||||
pub fn objects_at(doc: &Document, p: Point, opt: HitOptions, scope: Option<NodeId>) -> Vec<NodeId> {
|
pub fn objects_at(doc: &Document, p: Point, opt: HitOptions, scope: Option<NodeId>) -> Vec<NodeId> {
|
||||||
let opt = HitOptions { scope: scope.or(opt.scope), ..opt };
|
let opt = HitOptions { scope: scope.or(opt.scope), ..opt };
|
||||||
|
// Normally one hit test per *object* suffices: layers and sublayers aren't selectable,
|
||||||
|
// while a group (including a clipping group) is selected as one object. Repeatedly
|
||||||
|
// searching the full tree for each hit made a stack of n overlapping paths O(n^2).
|
||||||
|
// Isolation and Edit Contents change where selection groups begin; keep the original
|
||||||
|
// traversal for those cases rather than change their Select Behind semantics.
|
||||||
|
if opt.scope.is_some() {
|
||||||
|
return objects_at_repeated(doc, p, opt, scope);
|
||||||
|
}
|
||||||
|
let mut tops = Vec::new();
|
||||||
|
let mut seen = HashSet::new();
|
||||||
|
for layer in doc.layers.iter().rev() {
|
||||||
|
// Malformed files may contain non-layer roots; let the general traversal handle them.
|
||||||
|
if !layer.is_layer() {
|
||||||
|
return objects_at_repeated(doc, p, opt, scope);
|
||||||
|
}
|
||||||
|
if !layer.visible || layer.locked || layer.is_template() || doc.pattern_edit.as_ref().is_some_and(|e| e.layer != layer.id) {
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
if !objects_at_layer(layer, p, opt, &mut tops, &mut seen) {
|
||||||
|
// An envelope in Edit Contents may expose objects *within* a top-level group.
|
||||||
|
// The repeated traversal handles that mixed hierarchy precisely.
|
||||||
|
return objects_at_repeated(doc, p, opt, scope);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
tops
|
||||||
|
}
|
||||||
|
|
||||||
|
/// One traversal through a layer and its sublayers. Each selectable object's subtree is
|
||||||
|
/// inspected once (only until its first hit). `false` asks the caller to use the general
|
||||||
|
/// algorithm for an envelope whose contents are currently being edited.
|
||||||
|
fn objects_at_layer(layer: &Node, p: Point, opt: HitOptions, tops: &mut Vec<NodeId>, seen: &mut HashSet<NodeId>) -> bool {
|
||||||
|
let Some(children) = layer.children() else { return true };
|
||||||
|
if layer.clips() && children.first().is_some_and(|clip| !clip_contains(clip, p)) {
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
let opt = if matches!(layer.kind, NodeKind::Layer { preview: false, .. }) { HitOptions { outline: true, ..opt } } else { opt };
|
||||||
|
for (i, c) in children.iter().enumerate().rev() {
|
||||||
|
if layer.extras().shaper.is_some() {
|
||||||
|
let construction = children.first().is_some_and(|source| Some(source.id) == opt.scope);
|
||||||
|
if (i == 0) != construction {
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if !c.visible || c.locked || c.is_template() || seen.contains(&c.id) {
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
if !(edits_contents(c)
|
||||||
|
|| c.extras().shaper.is_some() && c.children().and_then(|ch| ch.first()).is_some_and(|source| Some(source.id) == opt.scope))
|
||||||
|
&& let Some(b) = c.reach_bounds()
|
||||||
|
&& !b.inflate(opt.tol, opt.tol).contains(p)
|
||||||
|
{
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
if c.is_layer() {
|
||||||
|
if !objects_at_layer(c, p, opt, tops, seen) {
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
// Editing an envelope selects its contents rather than the containing object. Even
|
||||||
|
// when nested in a group, the old traversal may select both a member and the group.
|
||||||
|
if c.is_container() {
|
||||||
|
let mut editing = false;
|
||||||
|
c.walk(&mut |n| editing |= edits_contents(n));
|
||||||
|
if editing {
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
let skip = |id| seen.contains(&id);
|
||||||
|
let mut chain = Vec::new();
|
||||||
|
let hit = match &c.kind {
|
||||||
|
NodeKind::Group { .. } => hit_children(c, p, opt, &skip, &mut chain, true).is_some(),
|
||||||
|
NodeKind::Blend { .. } => hit_children(c, p, opt, &skip, &mut chain, true).is_some() || hit_leaf(c, p, opt).is_some(),
|
||||||
|
_ => hit_leaf(c, p, opt).is_some(),
|
||||||
|
};
|
||||||
|
if hit && seen.insert(c.id) {
|
||||||
|
tops.push(c.id);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
true
|
||||||
|
}
|
||||||
|
|
||||||
|
/// The general selection order also handles isolation and nested Edit Contents.
|
||||||
|
fn objects_at_repeated(doc: &Document, p: Point, opt: HitOptions, scope: Option<NodeId>) -> Vec<NodeId> {
|
||||||
let mut tops: Vec<NodeId> = vec![];
|
let mut tops: Vec<NodeId> = vec![];
|
||||||
// Each round leaves out the objects found so far (and everything inside them).
|
// Each round leaves out the objects found so far (and everything inside them).
|
||||||
while let Some(top) = hit_test_skipping(doc, p, opt, &|id| tops.contains(&id), true).map(|h| h.top_object(scope)) {
|
while let Some(top) = hit_test_skipping(doc, p, opt, &|id| tops.contains(&id), true).map(|h| h.top_object(scope)) {
|
||||||
|
|
@ -619,6 +705,94 @@ world",
|
||||||
assert!(at(90.0, None).is_empty());
|
assert!(at(90.0, None).is_empty());
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/// Many overlapping paths: Select Behind must list each exactly once, front to back.
|
||||||
|
/// This is quadratic with repeated full-document hit tests, but linear in tree size with
|
||||||
|
/// the per-object walk.
|
||||||
|
#[test]
|
||||||
|
fn objects_at_large_overlapping_stack() {
|
||||||
|
let mut d = Document::new(100.0, 100.0);
|
||||||
|
let layer = d.layers[0].id;
|
||||||
|
let mut ids = Vec::new();
|
||||||
|
for _ in 0..256 {
|
||||||
|
let id = d.alloc_id();
|
||||||
|
d.insert(Some(layer), usize::MAX, Node::path(id, shapes::rectangle(Rect::new(0.0, 0.0, 50.0, 50.0)), Appearance::default_art()))
|
||||||
|
.unwrap();
|
||||||
|
ids.push(id);
|
||||||
|
}
|
||||||
|
ids.reverse();
|
||||||
|
assert_eq!(objects_at(&d, Point::new(25.0, 25.0), HitOptions::default(), None), ids);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Match the original skip-and-retest algorithm for normal groups, sublayers, clipping,
|
||||||
|
/// invisibility, and path/outline-only settings.
|
||||||
|
#[test]
|
||||||
|
fn objects_at_one_pass_matches_repeated_hits() {
|
||||||
|
let mut d = Document::new(200.0, 200.0);
|
||||||
|
let layer = d.layers[0].id;
|
||||||
|
let add = |d: &mut Document, parent, bounds| {
|
||||||
|
let id = d.alloc_id();
|
||||||
|
d.insert(Some(parent), usize::MAX, Node::path(id, shapes::rectangle(bounds), Appearance::default_art())).unwrap();
|
||||||
|
id
|
||||||
|
};
|
||||||
|
add(&mut d, layer, Rect::new(0.0, 0.0, 60.0, 60.0));
|
||||||
|
let sub = d.alloc_id();
|
||||||
|
d.insert(Some(layer), usize::MAX, Node::layer(sub, "Sublayer", crate::LayerColor::Preset(2))).unwrap();
|
||||||
|
add(&mut d, sub, Rect::new(0.0, 0.0, 60.0, 60.0));
|
||||||
|
let group = d.alloc_id();
|
||||||
|
d.insert(Some(layer), usize::MAX, Node::group(group, Vec::new())).unwrap();
|
||||||
|
add(&mut d, group, Rect::new(0.0, 0.0, 60.0, 60.0));
|
||||||
|
add(&mut d, group, Rect::new(5.0, 5.0, 60.0, 60.0));
|
||||||
|
let clip = d.alloc_id();
|
||||||
|
let mask = Node::path(d.alloc_id(), shapes::rectangle(Rect::new(5.0, 5.0, 45.0, 45.0)), Appearance::default_art());
|
||||||
|
let content = Node::path(d.alloc_id(), shapes::rectangle(Rect::new(0.0, 0.0, 80.0, 80.0)), Appearance::default_art());
|
||||||
|
let mut clipping = Node::group(clip, vec![Arc::new(mask), Arc::new(content)]);
|
||||||
|
clipping.set_clips(true);
|
||||||
|
d.insert(Some(layer), usize::MAX, clipping).unwrap();
|
||||||
|
for (point, opt) in [
|
||||||
|
(Point::new(25.0, 25.0), HitOptions::default()),
|
||||||
|
(Point::new(3.0, 25.0), HitOptions::default()),
|
||||||
|
(Point::new(25.0, 25.0), HitOptions { outline: true, ..Default::default() }),
|
||||||
|
(Point::new(6.0, 25.0), HitOptions { path_only: true, ..Default::default() }),
|
||||||
|
(Point::new(100.0, 100.0), HitOptions::default()),
|
||||||
|
] {
|
||||||
|
assert_eq!(objects_at(&d, point, opt, None), objects_at_repeated(&d, point, opt, None), "point={point:?}, opt={opt:?}");
|
||||||
|
}
|
||||||
|
if let NodeKind::Layer { preview, .. } = &mut d.node_mut(sub).unwrap().kind {
|
||||||
|
*preview = false;
|
||||||
|
}
|
||||||
|
let p = Point::new(25.0, 25.0);
|
||||||
|
let opt = HitOptions::default();
|
||||||
|
assert_eq!(objects_at(&d, p, opt, None), objects_at_repeated(&d, p, opt, None));
|
||||||
|
d.node_mut(group).unwrap().locked = true;
|
||||||
|
assert_eq!(objects_at(&d, p, opt, None), objects_at_repeated(&d, p, opt, None));
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Edit Contents can expose descendants of a top-level group: preserve the original
|
||||||
|
/// selection order by falling back to the general hit traversal.
|
||||||
|
#[test]
|
||||||
|
fn objects_at_edit_contents_uses_general_order() {
|
||||||
|
let mut d = Document::new(100.0, 100.0);
|
||||||
|
let layer = d.layers[0].id;
|
||||||
|
let inner = |id| Arc::new(Node::path(id, shapes::rectangle(Rect::new(0.0, 0.0, 50.0, 50.0)), Appearance::default_art()));
|
||||||
|
let (a, b) = (d.alloc_id(), d.alloc_id());
|
||||||
|
let e = Node::new(
|
||||||
|
d.alloc_id(),
|
||||||
|
NodeKind::Envelope {
|
||||||
|
content: vec![inner(a), inner(b)],
|
||||||
|
kind: Box::new(crate::live::EnvelopeKind::Warp { style: "arc".to_string(), bend: 0.0, h: 0.0, v: 0.0, horizontal: true }),
|
||||||
|
fidelity: 100.0,
|
||||||
|
editing: true,
|
||||||
|
options: Default::default(),
|
||||||
|
frame: Box::new(vectorcraft_geom::Affine::IDENTITY),
|
||||||
|
},
|
||||||
|
);
|
||||||
|
d.insert(Some(layer), usize::MAX, e).unwrap();
|
||||||
|
let p = Point::new(25.0, 25.0);
|
||||||
|
let opt = HitOptions::default();
|
||||||
|
assert_eq!(objects_at(&d, p, opt, None), objects_at_repeated(&d, p, opt, None));
|
||||||
|
assert_eq!(objects_at(&d, p, opt, None), vec![b, a]);
|
||||||
|
}
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
fn locked_and_hidden_skip() {
|
fn locked_and_hidden_skip() {
|
||||||
let mut d = Document::new(200.0, 200.0);
|
let mut d = Document::new(200.0, 200.0);
|
||||||
|
|
|
||||||
Loading…
Reference in New Issue