diff --git a/crates/doc/src/eval.rs b/crates/doc/src/eval.rs index 1c5b63cba..0ea238841 100644 --- a/crates/doc/src/eval.rs +++ b/crates/doc/src/eval.rs @@ -535,6 +535,10 @@ pub struct ModelState { /// How the pieces a join split off into bodies of their own touched the others (by feature /// id), for its notice. kept_separate: BTreeMap, + /// For a feature saved before format 14 that split a body, a digest of the later features' + /// picks its pieces were named by (by feature id, see [`crate::lineage::order_legacy_lumps`]): + /// the state stands for the feature only while those picks are the same. + legacy_picks: BTreeMap, } /// How a piece a join split off into a body of its own (`Touching::Separate`) touched the @@ -645,7 +649,7 @@ impl ModelState { /// After a feature evaluated to this state from `before` with cache key `key`: bodies it /// made or changed take that key, sketches it made a digest of their solved geometry (see /// [`quantize`]); the rest keep theirs. - fn stamp(&mut self, before: &Arc, f: &Feature, key: u64, mats: Vec) { + fn stamp(&mut self, doc: &Document, before: &Arc, f: &Feature, key: u64, mats: Vec) { let feature = f.id; let depth = before.bodies.iter().filter_map(|b| b.names.depth()).max().unwrap_or(0) + 1; let sheets = if f.kind.is_sheet() { self.sheets.clone() } else { Vec::new() }; @@ -654,7 +658,13 @@ impl ModelState { // the feature was saved when they were named in that order). if !f.shell_piece_order { crate::lineage::order_lumps(&mut self.bodies, &origin); + } else { + crate::lineage::order_legacy_lumps(&mut self.bodies, before, doc, f); } + match crate::lineage::legacy_picks_digest(&self.bodies, before, doc, f) { + 0 => self.legacy_picks.remove(&f.id), + d => self.legacy_picks.insert(f.id, d), + }; // The bodies before the feature by name, in their order (names repeat only in damaged // states): every lookup below is the first match of a linear search, without walking // every earlier body for every body, after every feature. @@ -1328,6 +1338,15 @@ fn context_digest(doc: &Document, vals: &BTreeMap) -> u64 { h.finish() } +/// Whether `after`, a state feature `f` evaluated to from `before` in an earlier evaluation, is +/// still its result in `doc`: a feature saved before format 14 names the pieces it splits a body +/// into as the later features pick them ([`crate::lineage::order_legacy_lumps`]), which neither +/// its fingerprint nor its cache key cover. (A script replays those features after it: the state +/// made before they were there named the pieces otherwise.) +fn legacy_current(doc: &Document, f: &Feature, before: &ModelState, after: &ModelState) -> bool { + !f.shell_piece_order || after.legacy_picks.get(&f.id).copied().unwrap_or(0) == crate::lineage::legacy_picks_digest(&after.bodies, before, doc, f) +} + /// The cache key of a feature evaluation: its own inputs, the document context and the state it /// starts from. Features that replay other features' definitions (patterns and mirrors of /// features) also take the chain fingerprint, which covers every earlier definition. @@ -1860,9 +1879,11 @@ impl Model { if f.suppressed && !rolled_back { reserved.extend(f.body_names.iter().map(|n| n.trim()).filter(|n| !n.is_empty()).map(str::to_string)); } + // A feature that names its pieces as later features pick them (saved before format 14) + // has a result only while those picks are what they were. if reuse && !unkept - && let Some(old) = self.results.get(i).filter(current) + && let Some(old) = self.results.get(i).filter(current).filter(|old| old.skipped || legacy_current(doc, f, &state, &old.state)) { if !old.skipped { state = old.state.clone(); @@ -1898,7 +1919,13 @@ impl Model { cache_key(f, fp, fingerprint(doc, 0, f, &vals, false, &self.step_digests) ^ placement_digest(doc, f, Some(&state)), ctx, &state); let kept = self.kept.0.as_ref().filter(|_| !self.no_cache); if !self.no_cache - && let Some(c) = self.cache.lock().ok().and_then(|mut m| m.get(key)).or_else(|| kept.and_then(|k| k.get(key))) + && let Some(c) = self + .cache + .lock() + .ok() + .and_then(|mut m| m.get(key)) + .or_else(|| kept.and_then(|k| k.get(key))) + .filter(|c| c.error.is_some() || legacy_current(doc, f, &state, &c.state)) { if let Some(k) = kept { k.put(key, &c); @@ -1927,7 +1954,12 @@ impl Model { } // An active result hidden by the marker, or evaluated ahead on these same inputs // (the same chain of definitions from the start). Changed inputs never reuse it. - if let Some(r) = rolled.as_ref().filter(current).or_else(|| primed.as_ref().and_then(|p| p.get(&f.id)).filter(current)) { + if let Some(r) = rolled + .as_ref() + .filter(current) + .or_else(|| primed.as_ref().and_then(|p| p.get(&f.id)).filter(current)) + .filter(|r| r.error.is_some() || legacy_current(doc, f, &state, &r.state)) + { restored += 1; if r.error.is_none() { state = r.state.clone(); @@ -2010,7 +2042,7 @@ impl Model { } _ => mats, }; - next.stamp(&state, f, key, mats); + next.stamp(doc, &state, f, key, mats); for b in &mut next.bodies { if !b.transferred { b.component = match doc.body_components.get(&b.name) { diff --git a/crates/doc/src/lineage.rs b/crates/doc/src/lineage.rs index 5264e8982..60f34d644 100644 --- a/crates/doc/src/lineage.rs +++ b/crates/doc/src/lineage.rs @@ -11,7 +11,7 @@ use std::sync::{Arc, OnceLock}; -use solidcraft_geom::Region2; +use solidcraft_geom::{Region2, Vec3}; use solidcraft_kernel::Body; use solidcraft_kernel::history::{BodyHistory, Change, FaceOrigin, FaceProv, History}; @@ -568,6 +568,150 @@ impl crate::ModelBody { } } +/// The pieces feature `f` (saved before format 14) split a body into, named so the later +/// features of the design find them. Those builds named the pieces in truck's shell order, which +/// SMLib's need not follow, and a later feature names the piece it works on (`body`) and keeps +/// the points it picked on it: each name goes to the piece nearest the points the features +/// naming it picked. Pieces no later feature names keep the order they came in; so do all of +/// them where the picks do not tell the pieces apart. +pub(crate) fn order_legacy_lumps(bodies: &mut [crate::ModelBody], before: &crate::ModelState, doc: &crate::Document, f: &crate::Feature) { + for members in made_families(bodies, before) { + order_legacy_family(bodies, &members, doc, f); + } +} + +/// The families of [`lump_families`] the feature that left `bodies` after `before` made: a family +/// it left as it was keeps its names. +fn made_families(bodies: &[crate::ModelBody], before: &crate::ModelState) -> Vec> { + lump_families(bodies) + .into_iter() + .filter(|members| members.iter().filter_map(|i| bodies.get(*i)).any(|b| !before.bodies.iter().any(|o| o.body.same(&b.body)))) + .collect() +} + +/// What [`order_legacy_lumps`] named the pieces of `bodies` (the state feature `f` left after +/// `before`) by: a digest of each piece name with the points the later features of `doc` naming +/// it picked, 0 where `f` was saved since format 14 or split nothing. Those features come after +/// `f`, so the state is `f`'s only while this is the same: a script replays them after it, and +/// an edit may change what they pick or name. +pub(crate) fn legacy_picks_digest(bodies: &[crate::ModelBody], before: &crate::ModelState, doc: &crate::Document, f: &crate::Feature) -> u64 { + use std::hash::{Hash, Hasher}; + if !f.shell_piece_order { + return 0; + } + let families = made_families(bodies, before); + if families.is_empty() { + return 0; + } + let mut h = std::collections::hash_map::DefaultHasher::new(); + for members in families { + let mut names: Vec = members.iter().filter_map(|i| bodies.get(*i).map(|b| b.name.clone())).collect(); + names.sort(); + for (name, points) in names.iter().zip(later_picks(doc, f, &names)) { + name.hash(&mut h); + for p in points { + [p.x, p.y, p.z].map(f64::to_bits).hash(&mut h); + } + } + } + // 0 means "nothing named so"; a digest that happens to be 0 must not read as that. + h.finish().max(1) +} + +/// The pieces each body a feature cut in two or more came out as (the bodies whose lineage is +/// that one operand), as [`order_lumps`] finds them. +fn lump_families(bodies: &[crate::ModelBody]) -> Vec> { + let mut families: Vec<(*const Operand, Vec)> = Vec::new(); + for (i, b) in bodies.iter().enumerate() { + let Made::Traced(l) = &b.made else { continue }; + let [op] = l.operands.as_slice() else { continue }; + if !matches!(op.as_ref(), Operand::Stage(_)) { + continue; + } + let key = Arc::as_ptr(op); + match families.iter_mut().find(|(k, _)| *k == key) { + Some((_, members)) => members.push(i), + None => families.push((key, vec![i])), + } + } + families.into_iter().map(|(_, m)| m).filter(|m| m.len() > 1).collect() +} + +/// Per name of `names`: the points the features after `f` in `doc` that name that body picked +/// on it. +fn later_picks(doc: &crate::Document, f: &crate::Feature, names: &[String]) -> Vec> { + let later = doc.features.iter().skip_while(|g| g.id != f.id).skip(1); + let mut picks: Vec> = vec![Vec::new(); names.len()]; + for g in later { + let Ok(kind) = serde_json::to_value(&g.kind) else { continue }; + let Some(k) = kind.get("body").and_then(|b| b.as_str()).and_then(|b| names.iter().position(|n| n == b)) else { continue }; + for key in ["edges", "faces", "face", "position"] { + let point = |v: &serde_json::Value| -> Option { + let a = v.as_array().filter(|a| a.len() == 3)?; + Some(Vec3::new(a.first()?.as_f64()?, a.get(1)?.as_f64()?, a.get(2)?.as_f64()?)) + }; + let found: Vec = match kind.get(key) { + Some(v) => { + point(v).map(|p| vec![p]).unwrap_or_else(|| v.as_array().map(|a| a.iter().filter_map(point).collect()).unwrap_or_default()) + } + None => Vec::new(), + }; + if let Some(slot) = picks.get_mut(k) { + slot.extend(found); + } + } + } + picks +} + +fn order_legacy_family(bodies: &mut [crate::ModelBody], members: &[usize], doc: &crate::Document, f: &crate::Feature) { + if members.len() > 64 { + return; + } + let names: Vec = members.iter().filter_map(|i| bodies.get(*i).map(|b| b.name.clone())).collect(); + let picks = later_picks(doc, f, &names); + // How far piece `i` is from the points of name `k` (the mesh's nearest triangle). + let far = |piece: usize, pts: &[Vec3]| -> f64 { + let Some(b) = members.get(piece).and_then(|i| bodies.get(*i)) else { return f64::INFINITY }; + let m = b.mesh(); + pts.iter() + .map(|p| { + m.triangles + .iter() + .filter_map(|t| m.tri(t)) + .map(|[a, b, c]| solidcraft_geom::compare::closest_on_triangle(*p, a, b, c).dist(*p)) + .fold(f64::INFINITY, f64::min) + }) + .fold(0.0, f64::max) + }; + let mut order: Vec> = vec![None; names.len()]; + let mut taken = vec![false; members.len()]; + for (k, pts) in picks.iter().enumerate().filter(|(_, p)| !p.is_empty()) { + let best = + (0..members.len()).filter(|i| !taken.get(*i).copied().unwrap_or(true)).map(|i| (far(i, pts), i)).min_by(|a, b| a.0.total_cmp(&b.0)); + let Some((d, i)) = best else { return }; + // Only a piece the points lie on: a pick off every piece tells nothing. + let size = members.get(i).and_then(|m| bodies.get(*m)).map_or(1.0, |b| b.body.size().max(1.0)); + if d > size * 1e-3 { + return; + } + if let (Some(o), Some(t)) = (order.get_mut(k), taken.get_mut(i)) { + *o = Some(i); + *t = true; + } + } + let mut free = (0..members.len()).filter(|i| !taken.get(*i).copied().unwrap_or(true)); + let order: Vec = order.into_iter().map(|o| o.or_else(|| free.next())).collect::>().unwrap_or_default(); + if order.len() != names.len() { + return; + } + for (name, piece) in names.into_iter().zip(order) { + if let Some(b) = members.get(piece).and_then(|i| bodies.get_mut(*i)) { + b.name = name; + } + } +} + /// Name the pieces a body fell into after their faces: of the bodies in `bodies` that are lumps /// of one body (made in the same step, from one stage), the one whose least face name sorts first /// takes the first of their body names, and so on. The kernel's shell order, which named them diff --git a/crates/doc/src/model_cache.rs b/crates/doc/src/model_cache.rs index 045670cdc..35f9b3329 100644 --- a/crates/doc/src/model_cache.rs +++ b/crates/doc/src/model_cache.rs @@ -364,6 +364,10 @@ impl SavedModel { tapered: serde_json::from_value(field("tapered")?).map_err(invalid)?, // A join's notice is for the evaluation that made it, not kept with the cache. kept_separate: BTreeMap::new(), + // Not kept either: a saved model's states carry no lineage, so the check of a + // legacy split's picks (`lineage::legacy_picks_digest`) finds no pieces in them + // and takes them as the design's evaluation they were saved as. + legacy_picks: BTreeMap::new(), }; held = held.saturating_add(st.bodies.len()).saturating_add(st.sketches.len()).saturating_add(st.sheets.len()); if held > MAX_HELD { diff --git a/docs/compatibility.md b/docs/compatibility.md index 9ecc3a6f0..099cbdb4d 100644 --- a/docs/compatibility.md +++ b/docs/compatibility.md @@ -170,3 +170,12 @@ The #303 draft used `solvecraft-container/1`. `crates/io/src/design.rs` accepts marker alongside `solidcraft-container/1`, and writes only the new marker. Optional old previews are discarded; required document/blob validation is unchanged. The `draft_container_marker_remains_readable` regression covers this shim. + +## Split pieces in designs saved before format 14 + +Builds before format 14 named the pieces a cut splits a body into in the old kernel's shell +order, and the design's later features name the piece they work on by that name (`Body1`, +`Body1 (1)`). SMLib orders pieces otherwise. Such a feature (`shell_piece_order` in the file) +names its pieces so its later features find them: each name goes to the piece the points those +features picked lie on. A name no later feature uses keeps SMLib's order. Designs saved since +format 14 name pieces after their faces and are not affected.