* Add timeline.cut and refactor timeline.paste to allow cutting and pasting features Co-Authored-By: Claude <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01FyPtTd9nt3T9mHihfHkCcZ * Updated test for new grounded behaviour Co-Authored-By: Claude <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01FyPtTd9nt3T9mHihfHkCcZ * Resolved conflicts with #3390 Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com> * Fixed failing test Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com> * Resolved conflicts with #3512 Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com> --------- Co-authored-by: Claude <noreply@anthropic.com>
144 lines
7.1 KiB
Rust
144 lines
7.1 KiB
Rust
//! Moving timeline features (sketches included) into another component.
|
|
//!
|
|
//! It is an organisational change: ids, names and timeline positions stay, nothing is copied, and
|
|
//! the geometry stays where it is in the world (a moved feature's picks, planes and directions are
|
|
//! re-expressed in the new component's frame). Bodies follow the feature that made them. The move
|
|
//! is made on a scratch copy and the whole timeline is evaluated; the result is adopted only when
|
|
//! no feature, moved or left behind, gained an error. Otherwise nothing changes.
|
|
|
|
use std::collections::{BTreeMap, BTreeSet};
|
|
|
|
use solidcraft_doc::{Feature, FeatureKind, is_identity, mat_inverse, mat_mul};
|
|
|
|
use super::super::clipboard::explicit_planes;
|
|
use super::*;
|
|
use crate::params::name_or_id_list;
|
|
|
|
pub(super) fn move_features(s: &mut Session, p: &Value) -> Result<Value> {
|
|
let cmd = "component.move_features";
|
|
let dest = if p.get("component").is_some() { component(s, p, "component", cmd)? } else { s.active_component };
|
|
let keys = name_or_id_list(cmd, p, "features")?;
|
|
if keys.is_empty() || keys.len() > 1000 {
|
|
return Err(bad(cmd, "`features` must list 1…1000 features"));
|
|
}
|
|
if s.doc.marker.is_some() {
|
|
return Err(bad(cmd, "finish timeline rollback before moving features"));
|
|
}
|
|
if !s.pending_moves.is_empty() {
|
|
return Err(bad(cmd, "finish the component move in progress first"));
|
|
}
|
|
let mut ids = BTreeSet::new();
|
|
for k in &keys {
|
|
ids.insert(s.doc.find_feature(k).map(|f| f.id).ok_or_else(|| bad(cmd, format!("no feature `{k}`")))?);
|
|
}
|
|
let moving: BTreeSet<u64> = ids.into_iter().filter(|id| s.doc.feature(*id).is_some_and(|f| f.component != dest)).collect();
|
|
if moving.is_empty() {
|
|
return Err(bad(cmd, "already in that component"));
|
|
}
|
|
let moved: Vec<Feature> = s.doc.features.iter().filter(|f| moving.contains(&f.id)).cloned().collect();
|
|
// One placement each: a component placed twice has no single frame to keep the geometry in.
|
|
let placements = |c: u64| s.doc.occurrences.iter().filter(|o| o.component == c).count();
|
|
let sources: BTreeSet<u64> = moved.iter().map(|f| f.component).collect();
|
|
if sources.iter().chain([&dest]).any(|c| *c != 0 && placements(*c) > 1) {
|
|
return Err(bad(cmd, "a component placed more than once can't take part in this move"));
|
|
}
|
|
if moved.iter().any(|f| matches!(f.kind, FeatureKind::BodyTransfer { .. })) {
|
|
return Err(bad(cmd, "a recorded body transfer can't be moved"));
|
|
}
|
|
// The bodies that move with the features: those they are the origin of.
|
|
let moved_bodies: BTreeSet<String> = s.body_origins().into_iter().filter(|(_, f)| moving.contains(f)).map(|(body, _)| body).collect();
|
|
if moved_bodies.iter().any(|b| s.doc.body_components.contains_key(b) || s.doc.body_offsets.contains_key(b)) {
|
|
return Err(bad(cmd, "a body that was transferred between components can't be moved with its features"));
|
|
}
|
|
// A join or boolean whose inputs would end up in two components.
|
|
for f in &s.doc.features {
|
|
let mut inputs: BTreeSet<String> = f.kind.input_bodies().into_iter().collect();
|
|
inputs.extend(f.participants.iter().cloned());
|
|
let (inside, outside) =
|
|
(inputs.iter().filter(|b| moved_bodies.contains(*b)).count(), inputs.iter().filter(|b| !moved_bodies.contains(*b)).count());
|
|
if inside > 0 && outside > 0 && inputs.len() > 1 {
|
|
return Err(bad(cmd, format!("{} works on bodies that would be split between components", f.name)));
|
|
}
|
|
}
|
|
let to_dest = mat_inverse(&s.doc.component_transform(dest)).ok_or_else(|| bad(cmd, "the target component's frame is not invertible"))?;
|
|
let dest_path = s.doc.first_path(dest);
|
|
let before_errors: BTreeMap<u64, bool> = s.doc.features.iter().map(|f| (f.id, s.model.result(f.id).is_some_and(|r| r.error.is_some()))).collect();
|
|
|
|
let mut scratch = s.scratch();
|
|
let doc = scratch.doc_mut();
|
|
for old in &moved {
|
|
let delta = mat_mul(&to_dest, &s.doc.component_transform(old.component));
|
|
let Some(f) = doc.feature_mut(old.id) else { continue };
|
|
f.component = dest;
|
|
if !is_identity(&delta) {
|
|
if let FeatureKind::Sketch { plane, .. } | FeatureKind::ConstructionPlane { plane } = &mut f.kind {
|
|
explicit_planes(plane);
|
|
}
|
|
f.kind.transform_geometry(&delta);
|
|
}
|
|
}
|
|
// Attached sketches and embossed faces carry the placement of the body they sit on and of
|
|
// the component they were authored in: those that moved are rewritten, nothing else changes.
|
|
for f in &mut doc.features {
|
|
let authored_here = moving.contains(&f.id);
|
|
let rewrite = |body: &str, path: &mut Vec<u64>, author_path: &mut Vec<u64>| {
|
|
if moved_bodies.contains(body) {
|
|
*path = dest_path.clone();
|
|
}
|
|
if authored_here {
|
|
*author_path = dest_path.clone();
|
|
}
|
|
};
|
|
match &mut f.kind {
|
|
FeatureKind::Sketch { plane, .. } => {
|
|
if let Some(anchor) = crate::cmd::sketch::face::anchor_mut(plane) {
|
|
let moved_body = moved_bodies.contains(&anchor.target.body);
|
|
rewrite(&anchor.target.body, &mut anchor.path, &mut anchor.author_path);
|
|
if moved_body {
|
|
anchor.component = dest;
|
|
}
|
|
}
|
|
}
|
|
FeatureKind::Emboss { face: Some(face), .. } => {
|
|
let body = face.body.as_ref().to_string();
|
|
rewrite(&body, &mut face.path, &mut face.author_path);
|
|
}
|
|
_ => {}
|
|
}
|
|
}
|
|
scratch.refresh();
|
|
// Any feature that gains an error, moved or left behind, stops the move.
|
|
let broken = scratch
|
|
.doc
|
|
.features
|
|
.iter()
|
|
.filter(|f| !before_errors.get(&f.id).copied().unwrap_or(false))
|
|
.find_map(|f| scratch.model.result(f.id).and_then(|r| r.error.clone()).map(|e| (f.name.clone(), e)));
|
|
if let Some((name, error)) = broken {
|
|
return Err(bad(cmd, format!("moving would break {name}: {error}")));
|
|
}
|
|
s.accept_computed(scratch);
|
|
let names: Vec<&str> = moved.iter().map(|f| f.name.as_str()).collect();
|
|
Ok(json!({"moved": names, "component": dest, "bodies": moved_bodies}))
|
|
}
|
|
|
|
impl Session {
|
|
/// The feature each body depends on first, by body name: the earliest feature whose own result
|
|
/// holds a body of that name (a converted mesh keeps its import), else the creator the body
|
|
/// carries (the pieces of a split). Moving that feature moves the body.
|
|
pub fn body_origins(&self) -> BTreeMap<String, u64> {
|
|
let mut origins = BTreeMap::new();
|
|
for f in &self.doc.features {
|
|
if let Some(r) = self.model.result(f.id) {
|
|
for b in r.state.bodies.iter().filter(|b| b.feature == f.id) {
|
|
origins.entry(b.name.clone()).or_insert(f.id);
|
|
}
|
|
}
|
|
}
|
|
for b in &self.model.state().bodies {
|
|
origins.entry(b.name.clone()).or_insert(b.feature);
|
|
}
|
|
origins
|
|
}
|
|
}
|