mirror of
https://github.com/storytold/vectorcraft.git
synced 2026-11-18 16:37:32 +00:00
Merge pull request #8519 from dotCooCoo/perf/proxy-mixed-index-paths
Color: the Fill and Stroke proxies find the selected objects through the id cache
This commit is contained in:
@@ -424,6 +424,44 @@ impl Document {
|
||||
out
|
||||
}
|
||||
|
||||
/// Every node whose id is in `ids`, in tree order (the order of [`Document::walk`]): unlike
|
||||
/// [`Document::index_paths`], an id that appears more than once (a damaged file) gives every
|
||||
/// node that has it. When the cache ([`id_index`]) holds each id once, at a path that still
|
||||
/// checks out, the nodes are found along those paths; otherwise one walk of the tree finds
|
||||
/// them. As for every cached lookup, a second node given an existing id after the cache was
|
||||
/// built is not found while the first one's cached path checks out (see [`id_index`]).
|
||||
pub fn nodes_in_order(&self, ids: impl IntoIterator<Item = NodeId>) -> Vec<&Node> {
|
||||
let want: std::collections::HashSet<NodeId, std::hash::BuildHasherDefault<crate::id_index::IdHasher>> = ids.into_iter().collect();
|
||||
// As in `index_paths`, one walk is quicker than checking the cached paths of a good share
|
||||
// of the document.
|
||||
if let Some(cache) = self.index.get().filter(|c| want.len().saturating_mul(8) < c.len()) {
|
||||
let mut paths = Vec::with_capacity(want.len());
|
||||
let cached = want.iter().all(|id| match cache.get(id) {
|
||||
Some(Some(p)) if self.node_at(&p).is_some_and(|n| n.id == *id) => {
|
||||
paths.push(p);
|
||||
true
|
||||
}
|
||||
_ => false,
|
||||
});
|
||||
if cached {
|
||||
// A node's path sorts after the paths of the nodes before it in tree order, its
|
||||
// ancestors included.
|
||||
paths.sort_unstable();
|
||||
return paths.iter().filter_map(|p| self.node_at(p)).collect();
|
||||
}
|
||||
}
|
||||
let mut out = Vec::new();
|
||||
if !want.is_empty() {
|
||||
crate::id_index::note_tree_walk();
|
||||
self.walk(|n| {
|
||||
if want.contains(&n.id) {
|
||||
out.push(n);
|
||||
}
|
||||
});
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// The node at index path `path` (as [`Document::index_path`] gives it).
|
||||
pub fn node_at(&self, path: &[usize]) -> Option<&Node> {
|
||||
let (first, rest) = path.split_first()?;
|
||||
|
||||
@@ -157,6 +157,58 @@ fn cached_lookups_follow_any_edit_of_the_tree() {
|
||||
}
|
||||
}
|
||||
|
||||
/// Every node whose id is in `ids`, by walking the tree.
|
||||
fn every_node(d: &Document, ids: &[NodeId]) -> Vec<*const Node> {
|
||||
let mut out = vec![];
|
||||
d.walk(|n| {
|
||||
if ids.contains(&n.id) {
|
||||
out.push(n as *const Node);
|
||||
}
|
||||
});
|
||||
out
|
||||
}
|
||||
|
||||
/// [`Document::nodes_in_order`] gives every node with each id in tree order, repeated ids
|
||||
/// included, with the cache built and without it, for a few ids (cached paths) and for many (a
|
||||
/// walk).
|
||||
#[test]
|
||||
fn nodes_in_order_match_a_walk() {
|
||||
for seed in 1..40 {
|
||||
let (d, ids) = tree(seed);
|
||||
let few: Vec<NodeId> = ids.iter().copied().step_by(17).collect();
|
||||
for cold in [true, false] {
|
||||
if cold {
|
||||
d.drop_lookup_cache();
|
||||
} else {
|
||||
d.node(ids[0]);
|
||||
}
|
||||
for list in [&ids[..], &few[..], &ids[ids.len() / 2..ids.len() / 2 + 1], &[]] {
|
||||
let found: Vec<*const Node> = d.nodes_in_order(list.iter().copied()).into_iter().map(|n| n as *const Node).collect();
|
||||
assert_eq!(found, every_node(&d, list), "seed {seed}, cold {cold}, {list:?}");
|
||||
}
|
||||
}
|
||||
// An id that the tree repeats: every node with it.
|
||||
let Some(dup) = ids.iter().enumerate().find(|(i, id)| ids[..*i].contains(id)).map(|(_, id)| *id) else { continue };
|
||||
assert!(d.nodes_in_order([dup]).len() >= 2, "seed {seed}: {dup:?} is in the tree more than once");
|
||||
// A second node given an id once held once, after the cache was built: the lookup finds the
|
||||
// cached node, which has that id; with the cache built afresh, both.
|
||||
let mut d = d;
|
||||
let once = ids.iter().copied().find(|id| every_node(&d, &[*id]).len() == 1 && d.node(*id).is_some_and(|n| !n.is_layer()));
|
||||
let Some(once) = once else { continue };
|
||||
d.node(once);
|
||||
let copy = Arc::new(Node::path(once, shapes::rectangle(Rect::new(0.0, 0.0, 2.0, 2.0)), Appearance::default_art()));
|
||||
if let Some(ch) = Arc::make_mut(&mut d.layers[0]).children_mut() {
|
||||
ch.insert(0, copy);
|
||||
}
|
||||
let found = d.nodes_in_order([once]);
|
||||
assert!(!found.is_empty() && found.iter().all(|n| n.id == once), "seed {seed}: {once:?}");
|
||||
d.drop_lookup_cache();
|
||||
d.node(once);
|
||||
let found: Vec<*const Node> = d.nodes_in_order([once]).into_iter().map(|n| n as *const Node).collect();
|
||||
assert_eq!(found, every_node(&d, &[once]), "seed {seed}: {once:?} cached afresh");
|
||||
}
|
||||
}
|
||||
|
||||
/// Nodes of `d` picked and ordered by `seed`. None lies inside another, and each of them, and each
|
||||
/// node it is in, appears in the tree once.
|
||||
fn picks(d: &Document, seed: u64) -> Vec<NodeId> {
|
||||
|
||||
@@ -274,8 +274,9 @@ impl DocState {
|
||||
/// Whether the selected objects' fills and strokes differ as the proxies show them (a "?"
|
||||
/// proxy; a group whose contents differ counts). `item` (the Appearance panel's active item)
|
||||
/// stands for the proxy of its kind, as in [`Session::proxy_paints`]: that fill or stroke of
|
||||
/// each selected object's own stack is compared. One walk of the document, so callers that ask
|
||||
/// every frame cache it by revision.
|
||||
/// each selected object's own stack is compared. The selected objects are found through the id
|
||||
/// cache ([`vectorcraft_doc::Document::nodes_in_order`]); a large selection takes one walk
|
||||
/// of the document, so callers that ask every frame cache it by revision.
|
||||
pub fn proxy_mixed(&self, item: Option<usize>) -> (bool, bool) {
|
||||
self.proxy_mixed_with(item, &[])
|
||||
}
|
||||
@@ -290,15 +291,17 @@ impl DocState {
|
||||
if self.selection.symbol_part.is_some() {
|
||||
return (false, false);
|
||||
}
|
||||
let ids: std::collections::HashSet<NodeId> = self.selection.objects.iter().copied().collect();
|
||||
let (mut selected, mut nodes) = (vec![], vec![]);
|
||||
self.doc.walk(|n| {
|
||||
if ids.contains(&n.id) {
|
||||
selected.push(n);
|
||||
painted(n, true, &mut nodes);
|
||||
}
|
||||
});
|
||||
// Looking the first object up builds the id cache when there is none.
|
||||
let first = self.selection.objects.first().and_then(|id| self.doc.node(*id));
|
||||
let (mut selected, mut nodes) = (vec![], vec![]);
|
||||
// Every node with a selected id, in tree order: a repeated id (a damaged file) counts at each
|
||||
// place it appears.
|
||||
for n in self.doc.nodes_in_order(self.selection.objects.iter().copied()) {
|
||||
#[cfg(test)]
|
||||
tests::note_gathered();
|
||||
selected.push(n);
|
||||
painted(n, true, &mut nodes);
|
||||
}
|
||||
let differ = |stroke: bool| {
|
||||
let item = first.and_then(|f| f.appearance.item_of_kind(item, !stroke));
|
||||
let set = if item.is_some() { &selected } else { &nodes };
|
||||
@@ -1323,3 +1326,6 @@ fn transparency(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
}
|
||||
s.execute("object.setProps", &Value::Object(q))
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests;
|
||||
|
||||
@@ -0,0 +1,335 @@
|
||||
//! The Fill/Stroke proxies' "?" ([`DocState::proxy_mixed`]) finds the selected objects through the
|
||||
//! id cache: it answers as a walk of the whole document does, and with a few objects selected it
|
||||
//! reads only those.
|
||||
|
||||
use std::cell::Cell;
|
||||
use std::collections::HashSet;
|
||||
use std::sync::Arc;
|
||||
|
||||
use serde_json::json;
|
||||
use vectorcraft_color::{Color, Paint};
|
||||
use vectorcraft_doc::{Appearance, Document, LayerColor, Node, NodeId, NodeKind};
|
||||
use vectorcraft_geom::{Rect, shapes};
|
||||
|
||||
use super::{painted, picked_colors, proxy_paint, same_in_proxy};
|
||||
use crate::{DocState, Session};
|
||||
|
||||
thread_local! {
|
||||
/// [`gathered`] of this thread.
|
||||
static GATHERED: Cell<u64> = const { Cell::new(0) };
|
||||
}
|
||||
|
||||
/// Adds one to [`gathered`]: `proxy_mixed_with` read a node while looking for the selected ones.
|
||||
pub(super) fn note_gathered() {
|
||||
GATHERED.set(GATHERED.get() + 1);
|
||||
}
|
||||
|
||||
/// How many nodes `proxy_mixed_with` has read on this thread while looking for the selected ones.
|
||||
fn gathered() -> u64 {
|
||||
GATHERED.get()
|
||||
}
|
||||
|
||||
/// `proxy_mixed_with` as it was when it found the selected objects by walking the whole document.
|
||||
fn walked(st: &DocState, item: Option<usize>, points: &[(NodeId, Vec<usize>)]) -> (bool, bool) {
|
||||
if st.selection.is_empty() {
|
||||
return (false, false);
|
||||
}
|
||||
if st.selection.symbol_part.is_some() {
|
||||
return (false, false);
|
||||
}
|
||||
let ids: HashSet<NodeId> = st.selection.objects.iter().copied().collect();
|
||||
let (mut selected, mut nodes) = (vec![], vec![]);
|
||||
st.doc.walk(|n| {
|
||||
if ids.contains(&n.id) {
|
||||
selected.push(n);
|
||||
painted(n, true, &mut nodes);
|
||||
}
|
||||
});
|
||||
let first = st.selection.objects.first().and_then(|id| st.doc.node(*id));
|
||||
let differ = |stroke: bool| {
|
||||
let item = first.and_then(|f| f.appearance.item_of_kind(item, !stroke));
|
||||
let set = if item.is_some() { &selected } else { &nodes };
|
||||
let mut paints = set.iter().flat_map(|n| match picked_colors(n, if stroke || item.is_some() { &[] } else { points }) {
|
||||
c if c.is_empty() => vec![proxy_paint(n, stroke, item)],
|
||||
c => c.into_iter().map(Paint::solid).collect(),
|
||||
});
|
||||
let Some(p0) = paints.next() else { return false };
|
||||
paints.any(|p| !same_in_proxy(&p0, &p))
|
||||
};
|
||||
(differ(false), differ(true))
|
||||
}
|
||||
|
||||
/// `proxy_mixed_with` answers as [`walked`] does for `st`'s selection, for every Appearance item
|
||||
/// and with and without `points`, with the id cache built and without it.
|
||||
fn agree(st: &DocState, points: &[(NodeId, Vec<usize>)], what: &str) {
|
||||
for cold in [true, false] {
|
||||
if cold {
|
||||
st.doc.drop_lookup_cache();
|
||||
}
|
||||
for item in [None, Some(0), Some(1), Some(2), Some(3)] {
|
||||
for points in [points, &[]] {
|
||||
assert_eq!(
|
||||
st.proxy_mixed_with(item, points),
|
||||
walked(st, item, points),
|
||||
"{what}: item {item:?}, {} picked points, cold cache {cold}",
|
||||
points.len()
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn id_of(v: &serde_json::Value) -> NodeId {
|
||||
NodeId(v["id"].as_u64().unwrap())
|
||||
}
|
||||
|
||||
fn rect(s: &mut Session, x: f64, fill: &str, stroke: &str) -> NodeId {
|
||||
let id = id_of(&s.execute("shape.rectangle", &json!({"x": x, "y": 10, "width": 20, "height": 20})).unwrap());
|
||||
s.execute("paint.setFill", &json!({"ids": [id.0], "color": fill})).unwrap();
|
||||
s.execute("paint.setStroke", &json!({"ids": [id.0], "color": stroke})).unwrap();
|
||||
id
|
||||
}
|
||||
|
||||
/// Every case of [`DocState::proxy_mixed`]'s rule, each answered as a walk answers it: one object,
|
||||
/// different fills or strokes, a group with different contents, a group with one of its objects,
|
||||
/// objects on two layers, a hidden object, an object with two fills under an Appearance item, a
|
||||
/// gradient mesh with points picked beside another object, ids not in the document and an id that
|
||||
/// appears twice (a damaged file) with different paints.
|
||||
#[test]
|
||||
fn the_question_marks_match_a_walk_of_the_document() {
|
||||
let mut s = Session::new();
|
||||
s.execute("file.new", &json!({"width": 800, "height": 600})).unwrap();
|
||||
let a = rect(&mut s, 10.0, "#ff0000", "#000000");
|
||||
let b = rect(&mut s, 40.0, "#0000ff", "#000000");
|
||||
let c = rect(&mut s, 70.0, "#ff0000", "#00ff00");
|
||||
// Two fills: [Fill, Stroke, Fill].
|
||||
s.execute("select.set", &json!({"ids": [c.0]})).unwrap();
|
||||
s.execute("appearance.addFill", &json!({})).unwrap();
|
||||
s.execute("appearance.setItem", &json!({"index": 2, "color": "#0000ff"})).unwrap();
|
||||
let e = rect(&mut s, 100.0, "#ff0000", "#000000");
|
||||
let f = rect(&mut s, 130.0, "#00ff00", "#000000");
|
||||
let g = id_of(&s.execute("object.group", &json!({"ids": [e.0, f.0]})).unwrap());
|
||||
let mesh = rect(&mut s, 160.0, "#ff0000", "#000000");
|
||||
s.execute("object.mesh.create", &json!({"ids": [mesh.0], "rows": 2, "cols": 2})).unwrap();
|
||||
let hidden = rect(&mut s, 190.0, "#0000ff", "#000000");
|
||||
s.execute("object.hide", &json!({"ids": [hidden.0]})).unwrap();
|
||||
s.execute("layer.new", &json!({})).unwrap();
|
||||
let h = rect(&mut s, 220.0, "#ff0000", "#000000");
|
||||
let missing = NodeId(999_999);
|
||||
let Some(NodeKind::Mesh(m)) = s.doc().unwrap().doc.node(mesh).map(|n| &n.kind) else { panic!("a gradient mesh") };
|
||||
let (p00, p01, p11) = (m.idx(0, 0), m.idx(0, 1), m.idx(1, 1));
|
||||
s.execute("object.mesh.setPointColor", &json!({"id": mesh.0, "index": p00, "color": "#00ff00"})).unwrap();
|
||||
let points = vec![(mesh, vec![p00, p01])];
|
||||
let points_alike = vec![(mesh, vec![p01, p11])];
|
||||
|
||||
let selections = [
|
||||
vec![a],
|
||||
vec![a, b],
|
||||
vec![b, a],
|
||||
vec![a, h],
|
||||
vec![g],
|
||||
vec![g, e],
|
||||
vec![e, g],
|
||||
vec![f, e],
|
||||
vec![c],
|
||||
vec![c, a],
|
||||
vec![a, c],
|
||||
vec![mesh],
|
||||
vec![mesh, a],
|
||||
vec![a, mesh, h],
|
||||
vec![hidden],
|
||||
vec![hidden, b],
|
||||
vec![missing],
|
||||
vec![missing, a],
|
||||
vec![a, missing, b],
|
||||
vec![a, a],
|
||||
];
|
||||
let check = |s: &mut Session, what: &str| {
|
||||
for sel in &selections {
|
||||
let st = s.active_mut().unwrap();
|
||||
st.selection.objects = sel.clone();
|
||||
let st = s.active().unwrap();
|
||||
agree(st, &points, &format!("{what}: {sel:?}"));
|
||||
agree(st, &points_alike, &format!("{what}: {sel:?}, alike points"));
|
||||
}
|
||||
s.execute("select.all", &json!({})).unwrap();
|
||||
agree(s.active().unwrap(), &points, &format!("{what}: Select All"));
|
||||
};
|
||||
check(&mut s, "unique ids");
|
||||
|
||||
// A second node with a's id and another fill, at the end of the tree.
|
||||
let st = s.active_mut().unwrap();
|
||||
let mut copy = st.doc.node(a).unwrap().clone();
|
||||
copy.appearance.set_fill(Paint::solid(Color::rgb(0.0, 0.0, 1.0)));
|
||||
let doc = Arc::make_mut(&mut st.doc);
|
||||
let last = doc.layers.len() - 1;
|
||||
Arc::make_mut(&mut doc.layers[last]).children_mut().unwrap().push(Arc::new(copy));
|
||||
doc.drop_lookup_cache();
|
||||
check(&mut s, "a repeated id");
|
||||
let st = s.active_mut().unwrap();
|
||||
st.selection.objects = vec![a];
|
||||
assert_eq!(st.proxy_mixed_with(None, &[]), (true, false), "the two places of a's id differ in fill");
|
||||
}
|
||||
|
||||
/// A document of `layers` layers, each with `groups` groups of `per_group` rectangles; every other
|
||||
/// rectangle red, the rest blue. Returns it with the rectangles' ids, in tree order.
|
||||
fn big(layers: usize, groups: usize, per_group: usize) -> (Document, Vec<NodeId>) {
|
||||
let mut d = Document::new(612.0, 792.0);
|
||||
d.layers.clear();
|
||||
let mut rects = vec![];
|
||||
for l in 0..layers {
|
||||
let mut layer = Node::layer(d.alloc_id(), &format!("L{l}"), LayerColor::Preset(0));
|
||||
for _ in 0..groups {
|
||||
let children = (0..per_group)
|
||||
.map(|_| {
|
||||
let id = d.alloc_id();
|
||||
let mut ap = Appearance::default_art();
|
||||
let red = rects.len() % 2 == 0;
|
||||
ap.set_fill(Paint::solid(if red { Color::rgb(1.0, 0.0, 0.0) } else { Color::rgb(0.0, 0.0, 1.0) }));
|
||||
rects.push(id);
|
||||
Arc::new(Node::path(id, shapes::rectangle(Rect::new(0.0, 0.0, 5.0, 5.0)), ap))
|
||||
})
|
||||
.collect();
|
||||
let group = Node::group(d.alloc_id(), children);
|
||||
layer.children_mut().unwrap().push(Arc::new(group));
|
||||
}
|
||||
d.layers.push(Arc::new(layer));
|
||||
}
|
||||
(d, rects)
|
||||
}
|
||||
|
||||
fn state(doc: Document) -> Session {
|
||||
let mut s = Session::new();
|
||||
s.execute("file.new", &json!({"width": 612, "height": 792})).unwrap();
|
||||
s.active_mut().unwrap().doc = Arc::new(doc);
|
||||
s
|
||||
}
|
||||
|
||||
/// With one object selected, the "?" reads only that object, not every node of the document, and
|
||||
/// does not walk the tree once the id cache is built; with every object selected it walks the tree
|
||||
/// once.
|
||||
#[test]
|
||||
fn the_question_marks_read_only_the_selected_objects() {
|
||||
let (doc, rects) = big(2, 40, 25);
|
||||
let mut s = state(doc);
|
||||
let st = s.active_mut().unwrap();
|
||||
st.selection.objects = vec![rects[777]];
|
||||
assert_eq!(st.proxy_mixed(None), (false, false));
|
||||
let (read, walks) = (gathered(), vectorcraft_doc::tree_walks());
|
||||
assert_eq!(st.proxy_mixed(None), (false, false));
|
||||
assert_eq!(gathered() - read, 1, "only the selected object is read");
|
||||
assert_eq!(vectorcraft_doc::tree_walks() - walks, 0, "the cached path answers");
|
||||
|
||||
st.selection.objects = vec![rects[3], rects[1500]];
|
||||
let (read, walks) = (gathered(), vectorcraft_doc::tree_walks());
|
||||
assert_eq!(st.proxy_mixed(None), (true, false));
|
||||
assert_eq!((gathered() - read, vectorcraft_doc::tree_walks() - walks), (2, 0));
|
||||
|
||||
st.selection.objects = rects.clone();
|
||||
let (read, walks) = (gathered(), vectorcraft_doc::tree_walks());
|
||||
assert_eq!(st.proxy_mixed(None), (true, false));
|
||||
assert_eq!(gathered() - read, rects.len() as u64);
|
||||
assert!(vectorcraft_doc::tree_walks() - walks <= 1, "one walk for a large selection");
|
||||
}
|
||||
|
||||
/// Random selections of a document with nested groups answer as a walk does.
|
||||
#[test]
|
||||
fn random_selections_match_a_walk_of_the_document() {
|
||||
let (doc, rects) = big(3, 12, 6);
|
||||
let mut s = state(doc);
|
||||
let groups: Vec<NodeId> = s.active().unwrap().doc.layers.iter().flat_map(|l| l.children().unwrap().iter().map(|g| g.id)).collect();
|
||||
let layers: Vec<NodeId> = s.active().unwrap().doc.layers.iter().map(|l| l.id).collect();
|
||||
let all: Vec<NodeId> = rects.iter().chain(&groups).chain(&layers).copied().chain([NodeId(999_999)]).collect();
|
||||
let mut r = 0x2545_f491_4f6c_dd1d_u64;
|
||||
let mut next = |n: usize| {
|
||||
r ^= r << 13;
|
||||
r ^= r >> 7;
|
||||
r ^= r << 17;
|
||||
(r % n as u64) as usize
|
||||
};
|
||||
for round in 0..200 {
|
||||
let count = 1 + next(if round % 10 == 0 { all.len() } else { 6 });
|
||||
let sel: Vec<NodeId> = (0..count).map(|_| all[next(all.len())]).collect();
|
||||
let st = s.active_mut().unwrap();
|
||||
st.selection.objects = sel.clone();
|
||||
agree(s.active().unwrap(), &[], &format!("round {round}: {sel:?}"));
|
||||
}
|
||||
}
|
||||
|
||||
/// The CPU time this thread has used, from Linux's scheduler statistics; `None` elsewhere.
|
||||
fn thread_cpu() -> Option<std::time::Duration> {
|
||||
let stat = std::fs::read_to_string("/proc/thread-self/schedstat").ok()?;
|
||||
stat.split_whitespace().next()?.parse().ok().map(std::time::Duration::from_nanos)
|
||||
}
|
||||
|
||||
/// The time `f` takes: this thread's CPU time where Linux reports it, otherwise the wall clock.
|
||||
fn time(f: impl FnOnce()) -> std::time::Duration {
|
||||
match thread_cpu() {
|
||||
Some(before) => {
|
||||
f();
|
||||
thread_cpu().map_or(std::time::Duration::ZERO, |after| after.saturating_sub(before))
|
||||
}
|
||||
None => {
|
||||
let start = std::time::Instant::now();
|
||||
f();
|
||||
start.elapsed()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// The time of `proxy_mixed` against a walk of the document, on 50,000 rectangles in 500 groups on
|
||||
/// 5 layers: `cargo test --release -p vectorcraft-engine --lib proxy_mixed_timing -- --ignored --nocapture`.
|
||||
#[test]
|
||||
#[ignore = "timing; run by hand"]
|
||||
fn proxy_mixed_timing() {
|
||||
let (doc, rects) = big(5, 100, 100);
|
||||
let mut s = state(doc);
|
||||
let groups: Vec<NodeId> = s.active().unwrap().doc.layers.iter().flat_map(|l| l.children().unwrap().iter().map(|g| g.id)).collect();
|
||||
let cases: [(&str, Vec<NodeId>); 5] = [
|
||||
("1 object", vec![rects[25_000]]),
|
||||
("2 objects, different fills", vec![rects[10], rects[40_001]]),
|
||||
("a group of 100", vec![groups[250]]),
|
||||
("all 500 groups", groups.clone()),
|
||||
("all 50,000 objects", rects.clone()),
|
||||
];
|
||||
const CALLS: usize = 200;
|
||||
let median = |mut v: Vec<f64>| {
|
||||
v.sort_by(f64::total_cmp);
|
||||
v[v.len() / 2]
|
||||
};
|
||||
println!("proxy_mixed_timing: {}", if thread_cpu().is_some() { "thread CPU time" } else { "wall clock" });
|
||||
println!("| Selection | Id cache | Walk (µs/call) | Id cache (µs/call) | Runs (walk / id cache, µs) |");
|
||||
println!("|---|---|---|---|---|");
|
||||
for (name, sel) in &cases {
|
||||
for cold in [false, true] {
|
||||
let st = s.active_mut().unwrap();
|
||||
st.selection.objects = sel.clone();
|
||||
let st = s.active().unwrap();
|
||||
assert_eq!(st.proxy_mixed_with(None, &[]), walked(st, None, &[]), "{name}");
|
||||
let (mut old, mut new) = (vec![], vec![]);
|
||||
let calls = if cold { CALLS / 10 } else { CALLS };
|
||||
for _ in 0..7 {
|
||||
for (times, use_walk) in [(&mut old, true), (&mut new, false)] {
|
||||
let d = time(|| {
|
||||
for _ in 0..calls {
|
||||
if cold {
|
||||
st.doc.drop_lookup_cache();
|
||||
}
|
||||
std::hint::black_box(if use_walk { walked(st, None, &[]) } else { st.proxy_mixed_with(None, &[]) });
|
||||
}
|
||||
});
|
||||
times.push(d.as_secs_f64() * 1e6 / calls as f64);
|
||||
}
|
||||
}
|
||||
let runs = |v: &[f64]| v.iter().map(|x| format!("{x:.1}")).collect::<Vec<_>>().join(" ");
|
||||
println!(
|
||||
"| {name} | {} | {:.1} | {:.1} | {} / {} |",
|
||||
if cold { "dropped before each call" } else { "built" },
|
||||
median(old.clone()),
|
||||
median(new.clone()),
|
||||
runs(&old),
|
||||
runs(&new)
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1830,6 +1830,7 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur
|
||||
A double-click right of an RGB field switches the Color panel's R, G and B between percent and 0 to 255 ([Default keyboard shortcuts](https://helpx.adobe.com/illustrator/using/default-keyboard-shortcuts.html), Color panel). In VectorCraft the color does not change, Web Safe RGB and the hex field stay in 0 to 255, and the panel keeps the choice between sessions (`ui.colorPanel {rgbPercent}`); the color mixer of the Fill and Stroke chips and the gradient stop dialog follow the same setting. Toggle RGB Percent (`ui.colorRgbPercent`) in the command palette and Keyboard Shortcuts switches the units from the keyboard. Tests: `rgb_percent_switches_the_rgb_fields_between_percent_and_0_to_255`, `rgb_percent_does_not_switch_while_the_rows_are_disabled`, `rgb_percent_comes_back_after_a_restart` and `toggle_rgb_percent_switches_the_units_from_the_keyboard` in `crates/ui-egui/src/panels/color/tests.rs`.
|
||||
View › Proof Setup › Color blindness – Tritanopia-type turns Proof Colors on and proofs the canvas with the tritanopia simulation of Brettel, Viénot and Mollon (1997). The Separations Preview panel's Proof Setup list offers the same target (`view.proofSetup {target: "tritanopia"}`). Grays keep their value.
|
||||
The Separations Preview panel's Gamut Check button reports one color outside the CMYK gamut in the singular and more in the plural, in English and in each language's plural forms (`gamut_check_status_takes_the_plural_form` in `crates/ui-egui/src/i18n/tests.rs`).
|
||||
The "?" on the Fill and Stroke proxies finds a few selected objects along their cached places in the document instead of walking every object; a large selection takes one walk, as before. The proxies show the same paints and question marks as before, also for an id that a damaged file repeats. On a document of 50,000 rectangles in 500 groups on 5 layers with one object selected, the check takes under 5 µs of CPU time instead of a median of 995 µs in a release build on Linux, so the gain shows on large documents (seven alternating runs, `cargo test --release -p vectorcraft-engine --lib proxy_mixed_timing -- --ignored --nocapture`).
|
||||
- **Document Color Mode outside the layers:** File › Document Color Mode (in one undo step) and `document.open {colorMode}` also convert the colors of graph designs, graphic styles, opacity-mask art, the tile that pattern editing's Cancel puts back and the art of brushes (with a Hue Shift brush's key color); a tint of a global swatch there becomes the converted swatch's color at its tint, as in the art.
|
||||
- **Segments dragged onto the grid (#3835):** with View › Snap to Grid (or Snap to Pixel) on, a straight segment dragged with Direct Selection or Group Selection lands its anchors on the grid, the box round them putting an edge on a gridline on each axis as a moved object's does (Shift keeps the move on its line), instead of the point it was pressed at landing on an intersection and leaving both anchors off the grid; a dragged anchor still lands on an intersection itself, and drawn points and resize handles already snapped (`direct::tests::a_dragged_segment_lands_its_anchors_on_the_grid`).
|
||||
- **Spinner arrows in the shadow and glow dialogs (#5367, #5368):** Drop Shadow's Opacity, X Offset, Y Offset, Blur and Darkness and the Outer and Inner Glow's Opacity and Blur have up and down arrows beside the field, as the other number fields with arrows do: a click steps by one (a unit for distances; Shift ×10, Ctrl/Cmd ÷10), holding repeats, Opacity and Darkness stop at 0 and 100 % and Blur at 0 (`dialogs::effect` test `drop_shadow_and_outer_glow_fields_have_spinner_arrows`).
|
||||
|
||||
Reference in New Issue
Block a user