diff --git a/crates/kernel/src/lib.rs b/crates/kernel/src/lib.rs index 77436d8dd..75bf79663 100644 --- a/crates/kernel/src/lib.rs +++ b/crates/kernel/src/lib.rs @@ -188,7 +188,7 @@ pub use meshbody::{MAX_TRIANGLES, mesh_body}; pub use native::{body_from_smlib, smlib_body}; pub use native::{brep_record, decode_native_body, encode_native_body, native_preview_mesh}; pub use offset::with_same_surface; -pub use ops::{BoolOp, boolean, half_space, join_apart, place_matrix, split_by_plane, transform, transform_matrix, union_apart}; +pub use ops::{BoolOp, boolean, half_space, join_apart, place_matrix, split_by_plane, transform, transform_matrix, union_all, union_apart}; pub use point_path::{ PathPiece, PointPath, SpaceBezier, curve_path, edge_path, face_section_along, iso_curves, project_onto_face, sketch_record_curve, sweep_point_path_with, diff --git a/crates/kernel/src/ops.rs b/crates/kernel/src/ops.rs index 676a5de70..1f1ce9832 100644 --- a/crates/kernel/src/ops.rs +++ b/crates/kernel/src/ops.rs @@ -29,16 +29,31 @@ pub fn boolean(a: &Body, b: &Body, op: BoolOp) -> Result> { }) } +/// The union of `bodies` (at least one) in one SMLib call, each body taking part in about +/// log2(n) of its unions, the result checked once. A result SMLib's check refuses is an error. +/// +/// The result carries its exact history over `bodies` in order, as [`boolean`]'s does, and +/// what the operands' faces stood for (their regularization protection and the planar roles on +/// supports it kept). +pub fn union_all(bodies: &[&Body]) -> Result { + crate::profile::timed(crate::profile::Kind::Boolean, || { + if bodies.is_empty() { + return Err(KernelError::Invalid("a union of no bodies".into())); + } + guard("SMLib union", || crate::smlib_boolean::smlib_union_all(bodies))?.with_preserved_union_planar_sources(bodies) + }) +} + /// A boolean's result with what its operands' faces stood for carried over: regularization /// protection and the planar construction and shell roles on supports it kept. fn with_operand_roles(a: &Body, b: &Body, op: BoolOp, r: Result>) -> Result> { let r = r.map(|result| result.map(|body| body.inherit_regularization_protection(a).inherit_regularization_protection(b))); match op { BoolOp::Cut => r.and_then(|result| result.map(|body| body.with_preserved_boolean_planar_sources(a, b, true)).transpose()), - BoolOp::Union => r.and_then(|result| result.map(|body| body.with_preserved_union_planar_sources(a, b)).transpose()), + BoolOp::Union => r.and_then(|result| result.map(|body| body.with_preserved_union_planar_sources(&[a, b])).transpose()), // Every face of an intersection lies on one operand's face, as a union's does: the same // roles carry over (#565). - BoolOp::Intersect => r.and_then(|result| result.map(|body| body.with_preserved_union_planar_sources(a, b)).transpose()), + BoolOp::Intersect => r.and_then(|result| result.map(|body| body.with_preserved_union_planar_sources(&[a, b])).transpose()), } } diff --git a/crates/kernel/src/planar_sources.rs b/crates/kernel/src/planar_sources.rs index 61ad9722d..af081a1f5 100644 --- a/crates/kernel/src/planar_sources.rs +++ b/crates/kernel/src/planar_sources.rs @@ -151,15 +151,15 @@ impl Body { self_.map_planar_sources(&[input], None, Some(tool), &[], constructed) } - /// Retain exact construction and shell roles through a Union from both operands, only on - /// unchanged supports. Coplanar supports of the two operands carry distinct identities, so - /// a face merged from both stays without a role. - pub(crate) fn with_preserved_union_planar_sources(self, a: &Body, b: &Body) -> Result { - let self_ = self.inherit_regularization_protection(a).inherit_regularization_protection(b); - if ![a, b].iter().any(|input| input.face_sources().is_some_and(|sources| sources.iter().flatten().any(|s| boolean_source(s, true)))) { + /// Retain exact construction and shell roles through a Union from every operand, only on + /// unchanged supports. Coplanar supports of different operands carry distinct identities, so + /// a face merged from several stays without a role. + pub(crate) fn with_preserved_union_planar_sources(self, operands: &[&Body]) -> Result { + let self_ = operands.iter().fold(self, |body, operand| body.inherit_regularization_protection(operand)); + if !operands.iter().any(|input| input.face_sources().is_some_and(|sources| sources.iter().flatten().any(|s| boolean_source(s, true)))) { return Ok(self_); } - self_.map_planar_sources(&[a, b], None, None, &[], true) + self_.map_planar_sources(operands, None, None, &[], true) } fn map_planar_sources(mut self, inputs: &[&Body], shell: Option, blocker: Option<&Body>, open: &[Vec3], constructed: bool) -> Result { @@ -172,7 +172,8 @@ impl Body { if inputs.iter().all(|input| input.face_sources().is_none()) { return Ok(self); } - if inputs.len() > 2 + // Each body at most 16 384 faces, and the inputs together at most two such bodies' worth. + if inputs.iter().fold(0usize, |n, input| n.saturating_add(input.face_count())) > 2 * 16_384 || inputs.iter().any(|input| input.face_count() > 16_384) || self.face_count() > 16_384 || blocker.is_some_and(|b| b.face_count() > 16_384) diff --git a/crates/kernel/src/smlib_boolean.rs b/crates/kernel/src/smlib_boolean.rs index 719cacca5..87f41d0d3 100644 --- a/crates/kernel/src/smlib_boolean.rs +++ b/crates/kernel/src/smlib_boolean.rs @@ -4,7 +4,7 @@ //! ([`crate::history::History`]'s contract). A result SMLib's own check or the record's geometry //! check refuses is an error, never a body. -pub(crate) use smlib::boolean as smlib_boolean; +pub(crate) use smlib::{boolean as smlib_boolean, union_all as smlib_union_all}; mod smlib { use solidcraft_smlib::{BooleanOp, CheckLevel}; @@ -34,6 +34,54 @@ mod smlib { BoolOp::Intersect => BooleanOp::Intersect, }; let Some(r) = ta.boolean(&tb, kind).map_err(|e| failed("operation", e))? else { return Ok(None) }; + checked(&r, &[&sa, &sb])?; + let (body, or) = body_from_smlib_ordered(&r)?; + let history = match (oa, ob, or) { + (Some(oa), Some(ob), Some(or)) => r.history().map_err(|e| failed("history", e))?.history(&[oa, ob], &or).map(Some).unwrap_or_else(|e| { + log::debug!(target: "smlib", "boolean history: {e}"); + None + }), + _ => None, + }; + Ok(Some(with_history(body, history, a, b))) + } + + /// The union of `bodies` in one SMLib call, each tagged as its own operand, checked once: + /// the result's history is over `bodies` in order. At least one body. + pub(crate) fn union_all(bodies: &[&Body]) -> Result { + if bodies.len() > solidcraft_smlib::MAX_UNION_BREPS { + return Err(KernelError::Invalid(format!("a union takes at most {} bodies", solidcraft_smlib::MAX_UNION_BREPS))); + } + let mut operands = Vec::with_capacity(bodies.len()); + let mut tagged = Vec::with_capacity(bodies.len()); + let mut orders = Some(Vec::with_capacity(bodies.len())); + for (i, body) in bodies.iter().enumerate() { + body.require_brep("a union")?; + let (s, order) = smlib_body_ordered(body)?; + tagged.push(s.tagged(i).map_err(|e| failed("tag", e))?); + operands.push(s); + orders = orders.zip(order).map(|(mut v, o)| { + v.push(o); + v + }); + } + let refs: Vec<&solidcraft_smlib::Brep> = tagged.iter().collect(); + let r = solidcraft_smlib::Brep::union_all(&refs).map_err(|e| failed("operation", e))?; + let operand_refs: Vec<&solidcraft_smlib::Brep> = operands.iter().collect(); + checked(&r, &operand_refs)?; + let (body, or) = body_from_smlib_ordered(&r)?; + let history = match (orders, or) { + (Some(orders), Some(or)) => r.history().map_err(|e| failed("history", e))?.history(&orders, &or).map(Some).unwrap_or_else(|e| { + log::debug!(target: "smlib", "union history: {e}"); + None + }), + _ => None, + }; + Ok(body.with_checked_history(history, &record::counts(bodies))) + } + + /// An error unless SMLib's check accepts `r`, the result of combining `operands`. + fn checked(r: &solidcraft_smlib::Brep, operands: &[&solidcraft_smlib::Brep]) -> Result<()> { // Solids touching each other along an edge or at a vertex come back as one non-manifold // body, which the export splits into separate solids: SMLib's check is of those, imported // as given (its check of the touching arrangement itself refuses the radial order of @@ -46,29 +94,26 @@ mod smlib { let split = solidcraft_smlib::Brep::from_record(&record, true).map_err(|e| failed("the separate solids", e))?; split.check(CheckLevel::All).map_err(|e| failed("check", e))? }; - if !check.is_valid() { - // Whether an operand failed it already says whose the fault is. - let operands: Vec<&str> = [("the first operand", &sa), ("the second operand", &sb)] - .into_iter() - .filter(|(_, s)| s.check(CheckLevel::All).is_ok_and(|c| !c.is_valid())) - .map(|(name, _)| name) - .collect(); - let what = if operands.is_empty() { - "SMLib's check refuses the result".to_string() - } else { - format!("SMLib's check refuses the result ({} already fails it)", operands.join(" and ")) - }; - return Err(failed(&what, check)); + if check.is_valid() { + return Ok(()); } - let (body, or) = body_from_smlib_ordered(&r)?; - let history = match (oa, ob, or) { - (Some(oa), Some(ob), Some(or)) => r.history().map_err(|e| failed("history", e))?.history(&[oa, ob], &or).map(Some).unwrap_or_else(|e| { - log::debug!(target: "smlib", "boolean history: {e}"); - None - }), - _ => None, + // Whether an operand failed it already says whose the fault is. + let failing: Vec = operands + .iter() + .enumerate() + .filter(|(_, s)| s.check(CheckLevel::All).is_ok_and(|c| !c.is_valid())) + .map(|(i, _)| match (operands.len(), i) { + (2, 0) => "the first operand".to_string(), + (2, _) => "the second operand".to_string(), + _ => format!("operand {i}"), + }) + .collect(); + let what = if failing.is_empty() { + "SMLib's check refuses the result".to_string() + } else { + format!("SMLib's check refuses the result ({} already fails it)", failing.join(" and ")) }; - Ok(Some(with_history(body, history, a, b))) + Err(failed(&what, check)) } /// `body` with `history` where it describes `body` made from `a` and `b`.