Files
makeCAD/crates/engine/src/cmd/component_align.rs
T
jyviko dc38349cbf Layer split stage 1: the B-rep record, native body file and Vec/Plane come from solidcore-record (#11496)
* Kernel: the B-rep record and the native body file come from solidcore-record

SolidCraft's portable B-rep record (`solidcraft_geom::brep`: brep.rs, topology, history,
envelope, part, curve2) and the native body file (`solidcraft_kernel::native`: the tagged binary
codec and the container) move to solidcore's `solidcore-record` crate: geometry as data, with
structural validation and no maths (solidcore's docs/layers.md, stage 1). Every caller uses
`solidcore_record::brep` and `solidcore_record::native`; the old copies are deleted.

What computes from coordinates stays with the kernel, in geom's `brep`:
- `brep::check`: the record's geometric checks (orthonormal frames, non-degenerate planes,
  unit revolution axes, non-singular placements). `check::validate` and
  `check::validate_built` are the record's validation and these together, and every caller of
  `Brep::validate` uses them, so what is accepted is unchanged;
- `brep::label`: a surface's natural ranges (a cone's apex), `curve_interval`,
  `edge_curve_interval` and `form_turns`;
- `brep::pcurve::eval`: a pcurve's point;
- `geometry::check`, `placement::moved` and `split_edges` become functions on the record.

The kernel's native module keeps the conversion between a body and its saved record
(metadata.rs) and checks the decoded record's geometry. `native/analytic.rs`, which no module
declared, is deleted.

solidcore-record is pinned to its rev on solidcore's `layer-record` branch.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01NvoxKMbMFSQU8tzRtoJhtT

* Geometry: Vec2, Vec3, Plane and the profile types come from solidcore-record

The plain data of vectors and points, sketch planes and planar profiles (`Seg2`, `Loop2`,
`Region2`) moves to `solidcore-record`, with its constants and component-wise operators only
(owner decision, solidcore layer split). Their geometry stays in geom as traits:
`Vec2Geom`, `Vec3Geom`, `PlaneGeom`, `Seg2Geom`, `Loop2Geom`, `Region2Geom`, `Seg2ArcFit`,
`Loop2ArcFit` and `Region2ArcFit`, in scope with `use solidcraft_geom::prelude::*`. Every caller
names the types from `solidcore_record`; geom no longer defines or re-exports them.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01NvoxKMbMFSQU8tzRtoJhtT

* Kernel: pin solidcore-record to solidcore main f5e8e9a29

solidcore-record is merged on solidcore main (tangency-labs/solidcore#2519); its crate there is
identical to the rev pinned before but for its clippy configuration. The lock is regenerated
against the merged rev.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01NvoxKMbMFSQU8tzRtoJhtT

---------

Co-authored-by: jyviko <2501648+jyviko@users.noreply.github.com>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-03 09:04:26 -05:00

246 lines
11 KiB
Rust

//! Aligning component occurrences (`occurrence.align`): moves only the chosen occurrence
//! placements in world coordinates using the same `from` / `to` / `flip` rules as `solid.align`,
//! without modifying shared component geometry across other instances.
use serde_json::{Value, json};
use solidcore_record::Vec3;
use solidcraft_doc::{IDENTITY, mat_inverse, mat_mul, rigid};
use solidcraft_geom::prelude::*;
use super::{occurrence, occurrence_path, valid_position};
use crate::params::{bad, vec3};
use crate::{Result, Session};
const MAX_ALIGNED: usize = 64;
fn opt_bool(p: &Value, key: &str, default: bool, cmd: &str) -> Result<bool> {
match p.get(key) {
None => Ok(default),
Some(Value::Bool(b)) => Ok(*b),
_ => Err(bad(cmd, format!("`{key}` must be a boolean"))),
}
}
fn parse_path(v: &Value, key: &str, cmd: &str) -> Result<Vec<u64>> {
v.as_array()
.filter(|a| !a.is_empty() && a.len() <= 64)
.and_then(|a| a.iter().map(Value::as_u64).collect::<Option<Vec<_>>>())
.ok_or_else(|| bad(cmd, format!("`{key}` must list 1..64 occurrence ids")))
}
fn resolve_paths(s: &Session, p: &Value, cmd: &str) -> Result<Vec<Vec<u64>>> {
let raw: Vec<Vec<u64>> = if let Some(v) = p.get("paths") {
if ["occurrences", "occurrence", "path"].into_iter().any(|k| p.get(k).is_some()) {
return Err(bad(cmd, "give `paths`, `occurrences`, or `occurrence`/`path`, not more than one"));
}
let items = v
.as_array()
.filter(|a| !a.is_empty() && a.len() <= MAX_ALIGNED)
.ok_or_else(|| bad(cmd, format!("`paths` must list 1..{MAX_ALIGNED} occurrence paths")))?;
let mut out = Vec::with_capacity(items.len());
for item in items {
let path = parse_path(item, "paths", cmd)?;
s.occurrence_placement(&path).map_err(|e| bad(cmd, e.to_string()))?;
out.push(path);
}
out
} else if let Some(v) = p.get("occurrences") {
if p.get("occurrence").is_some() || p.get("path").is_some() {
return Err(bad(cmd, "give `occurrences` or `occurrence`/`path`, not both"));
}
let items: Vec<&Value> = match v {
Value::Number(_) | Value::String(_) => vec![v],
Value::Array(a) if !a.is_empty() && a.len() <= MAX_ALIGNED => a.iter().collect(),
_ => return Err(bad(cmd, format!("`occurrences` must be an occurrence id/name or a list of 1..{MAX_ALIGNED} ids/names"))),
};
let mut out = Vec::with_capacity(items.len());
for item in items {
let q = json!({ "occurrence": item });
let id = occurrence(s, &q, cmd)?;
out.push(occurrence_path(s, &json!({}), id, cmd)?);
}
out
} else if p.get("occurrence").is_some() {
let id = occurrence(s, p, cmd)?;
vec![occurrence_path(s, p, id, cmd)?]
} else if let Some(v) = p.get("path") {
let path = parse_path(v, "path", cmd)?;
s.occurrence_placement(&path).map_err(|e| bad(cmd, e.to_string()))?;
vec![path]
} else {
return Err(bad(cmd, "give `occurrence`, `occurrences`, `path` or `paths`"));
};
let mut deduped: Vec<Vec<u64>> = Vec::with_capacity(raw.len());
for path in raw {
if !deduped.contains(&path) {
deduped.push(path);
}
}
// If both an ancestor placement and a placement under it were selected, moving the ancestor
// already carries the descendant along; skip the descendant so it moves once. Only a path
// prefix means "under it": another placement of the same component does not carry it.
let all = deduped.clone();
deduped.retain(|cand| !all.iter().any(|other| other.len() < cand.len() && cand.starts_with(other)));
// Two distinct paths ending in the same nested occurrence id share one definition transform.
for (i, a) in deduped.iter().enumerate() {
if deduped[..i].iter().any(|b| b.last() == a.last()) {
return Err(bad(cmd, "cannot align two placements of the same shared child occurrence at once; align their parent occurrences instead"));
}
}
Ok(deduped)
}
fn world_pick(
s: &Session,
p: &Value,
pk: &str,
fk: &str,
plane: &Option<solidcraft_doc::PlaneRef>,
vals: &std::collections::BTreeMap<String, solidcraft_doc::expr::Value>,
cmd: &str,
) -> Result<(Vec3, Option<Vec3>)> {
if let Some(pl_ref) = plane {
if p.get(pk).is_some() || p.get(fk).is_some() {
return Err(bad(cmd, format!("give `{pk}_plane` or `{pk}`/`{fk}`, not both")));
}
let world = s.world_state()?;
let pl = s.placed_document().resolve_plane_in(vals, pl_ref, 0, Some(&*world)).map_err(|e| bad(cmd, e.to_string()))?;
return Ok((pl.origin, Some(pl.normal())));
}
if let Some(fv) = p.get(fk) {
if p.get(pk).is_some() {
return Err(bad(cmd, format!("give `{pk}` or `{fk}`, not both")));
}
let fp = vec3(fv).ok_or_else(|| bad(cmd, format!("`{fk}` must be [x, y, z]")))?;
let n = super::super::face::face_normal_world(s, fp).ok_or_else(|| bad(cmd, format!("`{fk}` must be on a planar face")))?;
return Ok((fp, Some(n)));
}
if p.get(pk).and_then(Value::as_str).is_some_and(|o| o.eq_ignore_ascii_case("origin")) {
return Ok((Vec3::ZERO, None));
}
if let Some(o) = p.get(pk).and_then(Value::as_object)
&& (o.contains_key("at") || o.contains_key("snap"))
{
let at = o.get("at").and_then(vec3).ok_or_else(|| bad(cmd, format!("`{pk}.at` must be [x, y, z]")))?;
let kind = match o.get("snap") {
None => "vertex",
Some(Value::String(k)) if matches!(k.as_str(), "vertex" | "edge_mid" | "face_center" | "circle_center") => k.as_str(),
_ => return Err(bad(cmd, format!("`{pk}.snap` must be vertex, edge_mid, face_center or circle_center"))),
};
return super::super::features_more::snap_point(&*s.world_state()?, kind, at)
.map(|q| (q, None))
.ok_or_else(|| bad(cmd, format!("no {kind} to snap to near `{pk}`")));
}
p.get(pk)
.and_then(vec3)
.map(|v| (v, None))
.ok_or_else(|| bad(cmd, format!("give `{pk}`, `{fk}` or `{pk}_plane` ([x, y, z], \"origin\", or a plane)")))
}
pub(super) fn align(s: &mut Session, p: &Value) -> Result<Value> {
let cmd = "occurrence.align";
let paths = resolve_paths(s, p, cmd)?;
let flip = opt_bool(p, "flip", false, cmd)?;
let capture = opt_bool(p, "capture", true, cmd)?;
let move_grounded = opt_bool(p, "move_grounded", false, cmd)?;
for path in &paths {
let Some(&id) = path.last() else {
return Err(bad(cmd, "occurrence path is empty"));
};
let o = s.doc.occurrences.iter().find(|o| o.id == id).ok_or_else(|| bad(cmd, "no occurrence"))?;
if o.grounded && !move_grounded {
return Err(bad(
cmd,
format!("{} is grounded: unground it first (occurrence.ground; a design's first part is grounded when it is made)", o.name),
));
}
if let Some(mut group) = s.held_by_rigid_group(id) {
for _ in 0..64 {
match s.doc.occurrence_of(group).and_then(|occ| s.held_by_rigid_group(occ.id)) {
Some(up) => group = up,
None => break,
}
}
let name = s.doc.components.iter().find(|c| c.id == group).map(|c| c.name.clone()).unwrap_or_default();
return Err(bad(cmd, format!("{} is held in {name} by a rigid group: move {name}, or Unlock Contents (component.unlock) first", o.name)));
}
}
let plane = |key: &str| -> Result<Option<solidcraft_doc::PlaneRef>> {
p.get(key).map(|v| super::super::features::plane_param(s, Some(v), cmd)).transpose()
};
let (from_plane, to_plane) = (plane("from_plane")?, plane("to_plane")?);
let (vals, _) = s.doc.param_values();
let (from, from_normal) = world_pick(s, p, "from", "from_face", &from_plane, &vals, cmd)?;
let (to, to_normal) = world_pick(s, p, "to", "to_face", &to_plane, &vals, cmd)?;
let (mut axis, mut ang) = (Vec3::Z, 0.0);
if let (Some(a), Some(b)) = (from_normal.and_then(Vec3::normalized), to_normal.and_then(Vec3::normalized)) {
let want = if flip { b } else { b * -1.0 };
let cross = a.cross(want);
let theta = cross.len().atan2(a.dot(want));
if theta.abs() > 1e-12 {
axis = cross.normalized().unwrap_or_else(|| a.any_perp());
ang = theta;
}
}
let d = match (&to_plane, to_normal.and_then(Vec3::normalized)) {
(Some(_), Some(n)) => n * (to - from).dot(n),
_ => to - from,
};
if !(d.is_finite() && from.is_finite() && axis.is_finite() && ang.is_finite()) {
return Err(bad(cmd, "non-finite alignment transform"));
}
let world_move = rigid(d, from, axis, ang);
// Compute every new local placement from the current placements before mutating anything.
let mut updates = Vec::with_capacity(paths.len());
for path in &paths {
let placement = s.occurrence_placement(path).map_err(|e| bad(cmd, e.to_string()))?;
let inverse = mat_inverse(&placement.parent_world).ok_or_else(|| bad(cmd, "parent frame is singular"))?;
let local_delta = mat_mul(&mat_mul(&inverse, &world_move), &placement.parent_world);
let next = mat_mul(&local_delta, &placement.local);
if !valid_position(&next) {
return Err(bad(cmd, "alignment transform exceeds supported numeric range"));
}
updates.push((placement.occurrence, next));
}
let moved: Vec<u64> = updates.iter().map(|(id, _)| *id).collect();
// Placements inside a component placed more than once move in every placement of it: the
// command still runs (as occurrence.move does), and says so for the dialog's warning.
let shared: Vec<&Vec<u64>> = paths.iter().filter(|path| s.occurrence_shared(path)).collect();
if capture {
if world_move != IDENTITY || updates.iter().any(|(id, _)| s.pending_moves.contains_key(id)) {
for (id, next) in updates {
s.pending_moves.remove(&id);
if let Some(x) = s.doc_mut().occurrences.iter_mut().find(|x| x.id == id) {
x.transform = next;
}
}
}
} else {
for (id, next) in updates {
s.pending_moves.insert(id, next);
}
s.revision += 1;
}
let mut reply = json!({
"occurrences": moved,
"paths": paths,
"world_transform": world_move,
"pending": !capture,
});
if !shared.is_empty()
&& let Some(o) = reply.as_object_mut()
{
o.insert("shared".into(), json!(shared));
}
Ok(reply)
}