SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Wave 158/509: solidcraft-smlib: Brep::split_faces and Brep::split_body on the fork's split shims (and 1 more)
jyvikob885929d8a93
diff --git a/crates/kernel/src/body.rs b/crates/kernel/src/body.rsindex 233fb281e9..4d3803cdaf 100644--- a/crates/kernel/src/body.rs+++ b/crates/kernel/src/body.rs@@ -358,10 +358,11 @@ fn same_shared<T: PartialEq>(a: &Option<std::sync::Arc<T>>, b: &Option<std::sync}/// `record`, checked to be a body's: valid structure (budgets, references, loops, regions,-/// canonical order) and some bounded material.+/// canonical order) and at least one face. A solid's faces bound material; a surface body's lie+/// in open shells.fn solid_record(record: Brep) -> Result<Brep> {record.validate().map_err(|e| KernelError::Invalid(e.to_string()))?;- if record.faces.is_empty() || record.material_regions().is_empty() {+ if record.faces.is_empty() {return Err(KernelError::Failed("empty result".into()));}Ok(record)@@ -405,8 +406,9 @@ impl Body {}}- /// The solid body of a schema 4 record: checked for structure (budgets, references, loops,- /// regions, canonical order) and for bounding material. Its faces face as the record says.+ /// The body of a schema 4 record (a solid, or a surface body of open shells): checked for+ /// structure (budgets, references, loops, regions, canonical order). Its faces face as the+ /// record says.pub(crate) fn from_record(record: Brep) -> Result<Body> {Ok(Body::bare(solid_record(record)?, None, None))}diff --git a/crates/smlib/src/ffi.rs b/crates/smlib/src/ffi.rsindex 17c1f66e84..1254d7c04c 100644--- a/crates/smlib/src/ffi.rs+++ b/crates/smlib/src/ffi.rs@@ -191,6 +191,7 @@ pub mod flat;pub mod history;pub mod measure;pub mod ops;+pub mod split;pub mod ssi;pub mod sweeps;pub mod trim;diff --git a/crates/smlib/src/ffi/split.rs b/crates/smlib/src/ffi/split.rsnew file mode 100644index 0000000000..6e07ae3aed--- /dev/null+++ b/crates/smlib/src/ffi/split.rs@@ -0,0 +1,76 @@+//! The split block of `capi/include/smlib.h` (`smlib_split_faces`, `smlib_split_body`; the+//! fork's `capi/src/smlib_split.cpp`), declared by hand. Part of the FFI boundary, like its+//! parent: called only through [`crate::split`].++#![allow(unsafe_code)]++use super::Handle;+#[cfg(not(feature = "native"))]+use super::NOT_BUILT;+use super::ssi::SurfaceHandle;+#[cfg(feature = "native")]+use super::{ERR_ARG, ERR_EMPTY, OK, RawBrep, new_brep, ssi::RawSurface};++/// `SMLIB_SPLIT_MAX_FACES`, `SMLIB_SPLIT_MAX_TOOLS`.+pub const MAX_FACES: usize = 100_000;+pub const MAX_TOOLS: usize = 4096;++#[cfg(feature = "native")]+unsafe extern "C" {+ fn smlib_split_faces(+ body: *const RawBrep,+ faces: *const i64,+ n_faces: i64,+ tools: *const *const RawSurface,+ n_tools: i64,+ out: *mut *mut RawBrep,+ made: *mut i64,+ ) -> i32;+ fn smlib_split_body(body: *const RawBrep, tool: *const RawSurface, back: *mut *mut RawBrep, front: *mut *mut RawBrep) -> i32;+}++/// `body` with `faces` cut by `tools` in turn, and per face how many faces it became besides+/// itself.+#[cfg(feature = "native")]+pub fn split_faces(body: &Handle, faces: &[i64], tools: &[&SurfaceHandle]) -> Result<(Handle, Vec<i64>), i32> {+ if faces.is_empty() || faces.len() > MAX_FACES || tools.is_empty() || tools.len() > MAX_TOOLS {+ return Err(ERR_ARG);+ }+ let raw: Vec<*const RawSurface> = tools.iter().map(|t| t.raw()).collect();+ let mut made = vec![0i64; faces.len()];+ let n = i64::try_from(faces.len()).map_err(|_| ERR_ARG)?;+ let m = i64::try_from(raw.len()).map_err(|_| ERR_ARG)?;+ // SAFETY: the arrays outlive the call and hold `n` and `m` entries; the handles are live.+ let h = new_brep(|out| unsafe { smlib_split_faces(body.raw(), faces.as_ptr(), n, raw.as_ptr(), m, out, made.as_mut_ptr()) })?;+ Ok((h, made))+}++/// The parts of `body` behind and in front of `tool`.+#[cfg(feature = "native")]+pub fn split_body(body: &Handle, tool: &SurfaceHandle) -> Result<(Handle, Handle), i32> {+ let mut back: *mut RawBrep = std::ptr::null_mut();+ let mut front: *mut RawBrep = std::ptr::null_mut();+ // SAFETY: the handles are live; the out-pointers are written only on success.+ let s = unsafe { smlib_split_body(body.raw(), tool.raw(), &mut back, &mut front) };+ let (b, f) = (std::ptr::NonNull::new(back), std::ptr::NonNull::new(front));+ match (s, b, f) {+ (OK, Some(b), Some(f)) => Ok((Handle(b), Handle(f))),+ (OK, b, f) => {+ // Free whichever came back alone.+ drop(b.map(Handle));+ drop(f.map(Handle));+ Err(ERR_EMPTY)+ }+ (s, _, _) => Err(s),+ }+}++#[cfg(not(feature = "native"))]+pub fn split_faces(_: &Handle, _: &[i64], _: &[&SurfaceHandle]) -> Result<(Handle, Vec<i64>), i32> {+ Err(NOT_BUILT)+}++#[cfg(not(feature = "native"))]+pub fn split_body(_: &Handle, _: &SurfaceHandle) -> Result<(Handle, Handle), i32> {+ Err(NOT_BUILT)+}diff --git a/crates/smlib/src/ffi/ssi.rs b/crates/smlib/src/ffi/ssi.rsindex f02533bcea..fb9b576297 100644--- a/crates/smlib/src/ffi/ssi.rs+++ b/crates/smlib/src/ffi/ssi.rs@@ -110,6 +110,13 @@ unsafe impl Sync for SurfaceHandle {}unsafe impl Send for ResultHandle {}unsafe impl Sync for ResultHandle {}+impl SurfaceHandle {+ #[cfg_attr(not(feature = "native"), allow(dead_code))]+ pub(crate) fn raw(&self) -> *const RawSurface {+ self.0.as_ptr()+ }+}+impl Drop for SurfaceHandle {fn drop(&mut self) {#[cfg(feature = "native")]diff --git a/crates/smlib/src/lib.rs b/crates/smlib/src/lib.rsindex b2903e2ca1..91f2b98c13 100644--- a/crates/smlib/src/lib.rs+++ b/crates/smlib/src/lib.rs@@ -23,6 +23,7 @@ pub mod history;pub mod import;mod measure;mod ops;+mod split;pub mod ssi;pub mod sweeps;pub mod trim;diff --git a/crates/smlib/src/split.rs b/crates/smlib/src/split.rsnew file mode 100644index 0000000000..9a818f87d8--- /dev/null+++ b/crates/smlib/src/split.rs@@ -0,0 +1,40 @@+//! Split Face and Split Body (`capi/include/smlib.h`, "Split"): faces cut where tool surfaces+//! meet them, and a solid cut in two by a surface. Tools are [`crate::ssi::Surface`]s, each+//! taken over its whole domain.++use crate::ssi::Surface;+use crate::{Brep, Error, Result, error, ffi, init};++impl Brep {+ /// `self` with faces `faces` (indices in SMLib's face order, distinct) cut where each of+ /// `tools` meets them, the tools in turn, each cutting the pieces the earlier ones left; and+ /// for each face how many faces it became besides itself (0: no tool split it). `None` when+ /// no face is split. Tagged operands ([`Brep::tagged`]) give the pieces' history.+ pub fn split_faces(&self, faces: &[usize], tools: &[&Surface]) -> Result<Option<(Brep, Vec<usize>)>> {+ init()?;+ if faces.is_empty() || faces.len() > ffi::split::MAX_FACES || tools.is_empty() || tools.len() > ffi::split::MAX_TOOLS {+ return Err(Error::Argument);+ }+ let faces: Vec<i64> = faces.iter().map(|f| i64::try_from(*f).map_err(|_| Error::Argument)).collect::<Result<_>>()?;+ let handles: Vec<&ffi::ssi::SurfaceHandle> = tools.iter().map(|t| t.handle()).collect();+ match ffi::split::split_faces(&self.0, &faces, &handles) {+ Ok((h, made)) => Ok(Some((Brep(h), made.into_iter().map(|m| usize::try_from(m).unwrap_or(0)).collect()))),+ Err(ffi::ops::ERR_NO_CUT) => Ok(None),+ Err(s) => Err(error(s)),+ }+ }++ /// The manifold solid `self` cut in two by `tool` (whose domain must reach past it): the+ /// part behind the surface (its normal points away) and the part in front, each closed by+ /// the tool's piece inside the body and each possibly several solids. A tool that misses+ /// leaves both parts the whole body, with no face from the tool (tag `self` to tell); `None`+ /// when a side is left empty.+ pub fn split_body(&self, tool: &Surface) -> Result<Option<(Brep, Brep)>> {+ init()?;+ match ffi::split::split_body(&self.0, tool.handle()) {+ Ok((b, f)) => Ok(Some((Brep(b), Brep(f)))),+ Err(ffi::ops::ERR_NO_CUT) => Ok(None),+ Err(s) => Err(error(s)),+ }+ }+}diff --git a/crates/smlib/src/ssi.rs b/crates/smlib/src/ssi.rsindex e05078b874..628b6dece7 100644--- a/crates/smlib/src/ssi.rs+++ b/crates/smlib/src/ssi.rs@@ -25,6 +25,10 @@ fn int(n: usize) -> Result<i32> {}impl Surface {+ pub(crate) fn handle(&self) -> &ffi::ssi::SurfaceHandle {+ &self.0+ }+/// `origin + u*x + v*y` (x, y the axes made unit), for u in `u`, v in `v`.pub fn plane(origin: [f64; 3], xaxis: [f64; 3], yaxis: [f64; 3], u: [f64; 2], v: [f64; 2]) -> Result<Surface> {init()?;