* 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>
198 lines
7.7 KiB
Rust
198 lines
7.7 KiB
Rust
//! Mesh bodies: triangles without a B-rep (imported 3MF/STL). They render, measure, move and
|
||
//! export; B-rep features refuse them.
|
||
|
||
use solidcraft_geom::prelude::*;
|
||
use std::collections::HashMap;
|
||
|
||
use solidcore_record::Vec3;
|
||
use solidcraft_geom::Mesh;
|
||
|
||
use crate::body::Body;
|
||
use crate::{KernelError, Result};
|
||
|
||
/// Most triangles in one mesh body.
|
||
pub const MAX_TRIANGLES: usize = 20_000_000;
|
||
|
||
/// Indexed triangles with shared vertices, wound counter-clockwise seen from outside.
|
||
#[derive(Clone, Debug, Default)]
|
||
pub struct TriMesh {
|
||
pub positions: Vec<Vec3>,
|
||
pub triangles: Vec<[u32; 3]>,
|
||
}
|
||
|
||
impl TriMesh {
|
||
/// Display/measure mesh: corners split per triangle so normals stay flat.
|
||
pub(crate) fn to_mesh(&self) -> Mesh {
|
||
let mut out = Mesh::default();
|
||
out.positions.reserve(self.triangles.len() * 3);
|
||
for t in &self.triangles {
|
||
let (Some(a), Some(b), Some(c)) =
|
||
(self.positions.get(t[0] as usize), self.positions.get(t[1] as usize), self.positions.get(t[2] as usize))
|
||
else {
|
||
continue;
|
||
};
|
||
let n = (*b - *a).cross(*c - *a).normalized().unwrap_or(Vec3::Z);
|
||
let base = u32::try_from(out.positions.len()).unwrap_or(u32::MAX);
|
||
out.positions.extend([*a, *b, *c]);
|
||
out.normals.extend([n, n, n]);
|
||
out.triangles.push([base, base.saturating_add(1), base.saturating_add(2)]);
|
||
out.tri_face.push(0);
|
||
}
|
||
out
|
||
}
|
||
|
||
/// Distinct undirected triangle sides.
|
||
pub(crate) fn edge_count(&self) -> usize {
|
||
let mut set = std::collections::HashSet::new();
|
||
for t in &self.triangles {
|
||
for (a, b) in [(t[0], t[1]), (t[1], t[2]), (t[2], t[0])] {
|
||
set.insert((a.min(b), a.max(b)));
|
||
}
|
||
}
|
||
set.len()
|
||
}
|
||
|
||
/// Signed volume ×6.
|
||
fn volume6(&self) -> f64 {
|
||
self.triangles
|
||
.iter()
|
||
.filter_map(|t| Some((self.positions.get(t[0] as usize)?, self.positions.get(t[1] as usize)?, self.positions.get(t[2] as usize)?)))
|
||
.map(|(a, b, c)| a.dot(b.cross(*c)))
|
||
.sum()
|
||
}
|
||
}
|
||
|
||
/// A mesh body from triangles (`positions` in mm). Coincident vertices are merged, degenerate
|
||
/// triangles dropped, and a closed mesh with inward winding is turned outward.
|
||
pub fn mesh_body(positions: &[Vec3], triangles: &[[u32; 3]]) -> Result<Body> {
|
||
let _span = solidcraft_profile::span("kernel", "mesh_body");
|
||
if triangles.len() > MAX_TRIANGLES {
|
||
return Err(KernelError::Invalid(format!("mesh with {} triangles (limit {MAX_TRIANGLES})", triangles.len())));
|
||
}
|
||
if positions.iter().any(|p| !(p.is_finite() && p.x.abs() < 1e9 && p.y.abs() < 1e9 && p.z.abs() < 1e9)) {
|
||
return Err(KernelError::Invalid("mesh with non-finite or huge coordinates".into()));
|
||
}
|
||
// Merge vertices that are exactly equal (bit pattern of the coordinates).
|
||
let mut map: HashMap<[u64; 3], u32> = HashMap::new();
|
||
let mut remap: Vec<u32> = Vec::with_capacity(positions.len());
|
||
let mut out = TriMesh::default();
|
||
for p in positions {
|
||
let key = [(p.x + 0.0).to_bits(), (p.y + 0.0).to_bits(), (p.z + 0.0).to_bits()];
|
||
let next = u32::try_from(out.positions.len()).map_err(|_| KernelError::Invalid("too many vertices".into()))?;
|
||
let i = *map.entry(key).or_insert_with(|| {
|
||
out.positions.push(*p);
|
||
next
|
||
});
|
||
remap.push(i);
|
||
}
|
||
for t in triangles {
|
||
let (Some(&a), Some(&b), Some(&c)) = (remap.get(t[0] as usize), remap.get(t[1] as usize), remap.get(t[2] as usize)) else {
|
||
return Err(KernelError::Invalid("mesh triangle refers to a missing vertex".into()));
|
||
};
|
||
if a == b || b == c || c == a {
|
||
continue;
|
||
}
|
||
out.triangles.push([a, b, c]);
|
||
}
|
||
if out.triangles.is_empty() {
|
||
return Err(KernelError::Invalid("mesh has no triangles".into()));
|
||
}
|
||
unify_winding(&mut out);
|
||
if out.volume6() < 0.0 && is_closed(&out) {
|
||
for t in &mut out.triangles {
|
||
t.swap(1, 2);
|
||
}
|
||
}
|
||
Ok(Body::of_mesh(out))
|
||
}
|
||
|
||
/// Wind every connected piece one way: a triangle that runs a side in the same direction as
|
||
/// its neighbour is turned over (files with stray inverted facets). Sides shared by more than
|
||
/// two triangles are left alone.
|
||
fn unify_winding(m: &mut TriMesh) {
|
||
let mut sides: HashMap<(u32, u32), Vec<usize>> = HashMap::new();
|
||
for (i, t) in m.triangles.iter().enumerate() {
|
||
for (a, b) in [(t[0], t[1]), (t[1], t[2]), (t[2], t[0])] {
|
||
sides.entry((a.min(b), a.max(b))).or_default().push(i);
|
||
}
|
||
}
|
||
let runs = |t: &[u32; 3], a: u32, b: u32| [(t[0], t[1]), (t[1], t[2]), (t[2], t[0])].contains(&(a, b));
|
||
let mut done = vec![false; m.triangles.len()];
|
||
for start in 0..m.triangles.len() {
|
||
if done[start] {
|
||
continue;
|
||
}
|
||
done[start] = true;
|
||
let mut stack = vec![start];
|
||
while let Some(i) = stack.pop() {
|
||
let Some(t) = m.triangles.get(i).copied() else { continue };
|
||
for (a, b) in [(t[0], t[1]), (t[1], t[2]), (t[2], t[0])] {
|
||
let Some(list) = sides.get(&(a.min(b), a.max(b))) else { continue };
|
||
if list.len() != 2 {
|
||
continue;
|
||
}
|
||
for &j in list {
|
||
if j == i || done[j] {
|
||
continue;
|
||
}
|
||
done[j] = true;
|
||
if let Some(u) = m.triangles.get_mut(j)
|
||
&& runs(u, a, b)
|
||
{
|
||
u.swap(1, 2);
|
||
}
|
||
stack.push(j);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
/// Every triangle side is shared by exactly two triangles in opposite directions.
|
||
pub(crate) fn is_closed(m: &TriMesh) -> bool {
|
||
let mut count: HashMap<(u32, u32), i32> = HashMap::new();
|
||
for t in &m.triangles {
|
||
for (a, b) in [(t[0], t[1]), (t[1], t[2]), (t[2], t[0])] {
|
||
*count.entry((a, b)).or_default() += 1;
|
||
}
|
||
}
|
||
count.iter().all(|(&(a, b), &n)| n == 1 && count.get(&(b, a)) == Some(&1))
|
||
}
|
||
|
||
impl Body {
|
||
/// Shared-vertex triangles of a mesh body.
|
||
pub fn triangle_mesh(&self) -> Option<(&[Vec3], &[[u32; 3]])> {
|
||
self.mesh.as_ref().map(|m| (m.positions.as_slice(), m.triangles.as_slice()))
|
||
}
|
||
/// Does a mesh body enclose a volume (every side shared by two triangles)?
|
||
pub fn is_closed_mesh(&self) -> bool {
|
||
self.mesh.as_ref().is_some_and(|m| is_closed(m))
|
||
}
|
||
|
||
/// A mesh body moved by a column-major affine matrix (reflections keep outward winding).
|
||
pub(crate) fn mesh_transformed(&self, m: &[[f64; 4]; 4]) -> Option<Body> {
|
||
let tm = self.mesh.as_ref()?;
|
||
let f = |p: Vec3| {
|
||
Vec3::new(
|
||
m[0][0] * p.x + m[1][0] * p.y + m[2][0] * p.z + m[3][0],
|
||
m[0][1] * p.x + m[1][1] * p.y + m[2][1] * p.z + m[3][1],
|
||
m[0][2] * p.x + m[1][2] * p.y + m[2][2] * p.z + m[3][2],
|
||
)
|
||
};
|
||
let det = m[0][0] * (m[1][1] * m[2][2] - m[2][1] * m[1][2]) - m[1][0] * (m[0][1] * m[2][2] - m[2][1] * m[0][2])
|
||
+ m[2][0] * (m[0][1] * m[1][2] - m[1][1] * m[0][2]);
|
||
let mut out = TriMesh { positions: tm.positions.iter().map(|p| f(*p)).collect(), triangles: tm.triangles.clone() };
|
||
if det < 0.0 {
|
||
for t in &mut out.triangles {
|
||
t.swap(1, 2);
|
||
}
|
||
}
|
||
let mut placed = Body::of_mesh(out);
|
||
placed.color = self.color;
|
||
placed.paint = self.paint.clone();
|
||
placed.splits = self.splits.clone();
|
||
placed.regularization_protected = self.regularization_protected;
|
||
Some(placed)
|
||
}
|
||
}
|