Files
solidcraft/crates/kernel/src/native.rs
T
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

464 lines
22 KiB
Rust

//! SolidCraft native, versioned binary geometry. No STEP conversion or display meshes.
//! Exact: a decoded body is the encoded one, number for number, for the same producer.
use crate::{Body, KernelError, Result, guard};
use solidcore_record::native::{self as file, Runtime, Saved};
mod metadata;
mod preview;
pub use preview::native_preview_mesh;
fn invalid(detail: impl std::fmt::Display) -> KernelError {
KernelError::Invalid(format!("native B-rep: {detail}"))
}
/// A refusal of the native file (its own message, "native B-rep: ...").
fn refused(e: file::Error) -> KernelError {
KernelError::Invalid(e.to_string())
}
/// Explicit topology, spatial geometry, construction certificates and history, exactly: the
/// body's own record and what it carries. Failure is a cache miss at the IO boundary, never a
/// failed document save.
pub fn encode_native_body(body: &Body) -> Result<Vec<u8>> {
let _span = solidcraft_profile::span("kernel", "encode_native_body");
guard("encode native B-rep", || {
for source in body.face_sources.iter().flat_map(|s| s.iter()).flatten() {
let mut at = source;
let mut depth = 0usize;
while let crate::FaceSource::ShellPlanar { source, .. } = at {
depth += 1;
if depth > 32 {
return Err(invalid("face-source nesting"));
}
at = source;
}
}
if body.mesh.is_some() {
return Err(invalid("mesh bodies are source blobs, not B-rep"));
}
if body.face_count() > file::MAX_ITEMS || body.edge_count() > file::MAX_ITEMS {
return Err(invalid("native geometry budget"));
}
let runtime = Runtime { size: body.size, coarse_missing: None };
let saved = Saved { solid: body.record().clone(), metadata: metadata::encode(body)?, runtime };
// The record's own checks: no geometric reconstruction.
check(&saved)?;
file::encode(&saved).map_err(refused)
})
}
/// The schema 4 record of a solid body, in canonical order with its pcurves: the body itself.
/// Mesh bodies have none.
pub fn brep_record(body: &Body) -> Result<solidcore_record::brep::Brep> {
let _span = solidcraft_profile::span("kernel", "brep_record");
if body.mesh.is_some() {
return Err(invalid("mesh bodies are source blobs, not B-rep"));
}
Ok(body.record().clone())
}
/// The body in SMLib (see [`Body::smlib`]), as an owned copy.
pub fn smlib_body(body: &Body) -> Result<solidcraft_smlib::Brep> {
let _span = solidcraft_profile::span("kernel", "smlib_body");
body.smlib()?.try_clone().map_err(|e| KernelError::smlib("SMLib", e))
}
/// Decode bounded untrusted data. Validate indices before topology extraction.
/// Only a caller that has checked who produced the data may treat it as evaluated geometry.
pub fn decode_native_body(bytes: &[u8]) -> Result<Body> {
let _span = solidcraft_profile::span("kernel", "decode_native_body");
guard("decode native B-rep", || {
let saved = file::decode(bytes).map_err(refused)?;
check(&saved)?;
let size = saved.runtime.size;
let mut body = Body::from_record(saved.solid)?;
if size > 0.0 {
body.size = size;
}
metadata::apply(&mut body, saved.metadata)?;
Ok(body)
})
}
/// An SMLib body as a kernel body: SMLib's export mapped by `solidcraft_smlib` (canonical order,
/// radians, pcurves) is the body's record ([`Body::from_smlib_record`]).
pub fn body_from_smlib(brep: &solidcraft_smlib::Brep) -> Result<Body> {
let _span = solidcraft_profile::span("kernel", "body_from_smlib");
body_from_smlib_ordered(brep).map(|(body, _)| body)
}
/// [`body_from_smlib`], with where each of SMLib's faces and edges is in the body's face and
/// edge order ([`crate::history`]).
pub(crate) fn body_from_smlib_ordered(brep: &solidcraft_smlib::Brep) -> Result<(Body, Option<solidcraft_smlib::history::Order>)> {
let _span = solidcraft_profile::span("kernel", "body_from_smlib_ordered");
let (record, order) = brep.to_native_ordered().map_err(|e| KernelError::Failed(e.to_string()))?;
Ok((Body::from_smlib_record(record)?, Some(order)))
}
/// `body` in SMLib, with where each of SMLib's faces and edges is in the body's face and edge
/// order: SMLib's export of the imported body, checked to number every face, edge and vertex as
/// the body's record does. `None` where it does not.
pub(crate) fn smlib_body_ordered(body: &Body) -> Result<(solidcraft_smlib::Brep, Option<solidcraft_smlib::history::Order>)> {
let brep = smlib_body(body)?;
Ok((brep.try_clone().map_err(|e| KernelError::smlib("SMLib", e))?, numbering(body.record(), &brep)))
}
/// `record` in SMLib, imported as given (SMLib's own form; a record it refuses is an error that
/// names why), with where each of SMLib's faces and edges is in the record's order.
pub(crate) fn smlib_record_ordered(
record: &solidcore_record::brep::Brep,
) -> Result<(solidcraft_smlib::Brep, Option<solidcraft_smlib::history::Order>)> {
let _span = solidcraft_profile::span("kernel", "smlib_record_ordered");
let brep = solidcraft_smlib::Brep::from_record(record, true).map_err(|e| KernelError::smlib("SMLib", e))?;
let order = numbering(record, &brep);
Ok((brep, order))
}
/// Where SMLib's faces and edges of `brep` (imported from `record`) are in the record's order:
/// `None` where SMLib's export does not number them as the record does.
///
/// SMLib's export is in canonical order, and `order` says where SMLib's own face and edge `i`
/// went in it. Where the canonical record numbers them as `record` does, `order` maps SMLib's
/// to the record's. Otherwise SMLib may still keep the record's own order (an import lists
/// SMLib's faces and edges in the record's order, and canonical order can list them otherwise,
/// a tube's seam edges among them): the export put back in SMLib's order then numbers them as
/// `record` does, and SMLib's face and edge `i` are the record's `i`.
fn numbering(record: &solidcore_record::brep::Brep, brep: &solidcraft_smlib::Brep) -> Option<solidcraft_smlib::history::Order> {
match brep.to_native_ordered() {
Ok((back, order)) => {
if same_numbering(record, &back) {
return Some(order);
}
let in_smlib_order = in_smlib_order(&back, &order)?;
same_numbering(record, &in_smlib_order).then(solidcraft_smlib::history::Order::default)
}
Err(e) => {
log::debug!(target: "smlib", "no order for an operand: {e}");
None
}
}
}
/// The canonical record `back` with its faces and edges in SMLib's own order (`order`: where
/// SMLib's face and edge `i` are in `back`), each loop naming its edges by SMLib's numbers.
/// `None` where `order` is not a renumbering of `back`'s faces and edges (an edge split into
/// pieces where solids touch along it is more than one record edge).
fn in_smlib_order(back: &solidcore_record::brep::Brep, order: &solidcraft_smlib::history::Order) -> Option<solidcore_record::brep::Brep> {
use solidcore_record::brep::Loop;
let permutation = |to: &[usize], n: usize| -> Option<Vec<usize>> {
if to.is_empty() {
return Some((0..n).collect());
}
let mut from = vec![usize::MAX; n];
for (i, &k) in to.iter().enumerate() {
let slot = from.get_mut(k)?;
if *slot != usize::MAX {
return None;
}
*slot = i;
}
(to.len() == n).then_some(from)
};
if !order.pieces.is_empty() {
return None;
}
// `faces_from[k]`: SMLib's number of `back`'s face k; likewise for edges.
let faces_from = permutation(&order.faces, back.faces.len())?;
let edges_from = permutation(&order.edges, back.edges.len())?;
let mut out = back.clone();
for (k, face) in back.faces.iter().enumerate() {
let mut face = face.clone();
for l in &mut face.loops {
if let Loop::Edges { edges } = l {
for e in edges.iter_mut() {
e.edge = u32::try_from(*edges_from.get(usize::try_from(e.edge).ok()?)?).ok()?;
}
}
}
*out.faces.get_mut(*faces_from.get(k)?)? = face;
}
for (k, edge) in back.edges.iter().enumerate() {
*out.edges.get_mut(*edges_from.get(k)?)? = edge.clone();
}
Some(out)
}
/// Whether two records of one body number its faces, edges and vertices alike: the same loops of
/// the same edges, the same edge ends, and each vertex where the other's is.
fn same_numbering(a: &solidcore_record::brep::Brep, b: &solidcore_record::brep::Brep) -> bool {
use solidcore_record::brep::Loop;
if a.faces.len() != b.faces.len() || a.edges.len() != b.edges.len() || a.vertices.len() != b.vertices.len() {
return false;
}
let loops_alike = a.faces.iter().zip(&b.faces).all(|(fa, fb)| {
fa.loops.len() == fb.loops.len()
&& fa.loops.iter().zip(&fb.loops).all(|pair| match pair {
(Loop::Edges { edges: x }, Loop::Edges { edges: y }) => same_cycle(x, y),
(Loop::Vertex { vertex: x }, Loop::Vertex { vertex: y }) => x == y,
_ => false,
})
});
let ends_alike = a.edges.iter().zip(&b.edges).all(|(x, y)| x.vertices == y.vertices);
let at_same_place = a.vertices.iter().zip(&b.vertices).all(|(x, y)| {
let d = (0..3).map(|k| (x.point[k] - y.point[k]).powi(2)).sum::<f64>().sqrt();
d <= x.tolerance + y.tolerance + a.tolerance + b.tolerance
});
loops_alike && ends_alike && at_same_place
}
/// Whether two loops walk the same edges: in the same order from some edge on, or in the
/// opposite order with each edge the other way round. SMLib walks a face whose surface it turned
/// (a hole's wall) the other way, starting where it likes; its faces and edges are numbered
/// alike all the same.
fn same_cycle(x: &[solidcore_record::brep::OrientedEdge], y: &[solidcore_record::brep::OrientedEdge]) -> bool {
let n = x.len();
if n != y.len() {
return false;
}
let Some(first) = x.first() else { return true };
let at = |k: usize| y.get(k % n);
(0..n).filter(|k| at(*k).is_some_and(|e| e.edge == first.edge)).any(|k| {
let ahead = x.iter().enumerate().all(|(i, u)| at(k + i).is_some_and(|w| w.edge == u.edge && w.forward == u.forward));
let back = x.iter().enumerate().all(|(i, u)| at(k + n - i).is_some_and(|w| w.edge == u.edge && w.forward != u.forward));
ahead || back
})
}
/// The kernel's checks of a saved body's record that the file's own structural checks leave to
/// it ([`solidcraft_geom::brep::check::geometry`]: frames, planes, placements).
fn check(saved: &Saved) -> Result<()> {
solidcraft_geom::brep::check::geometry(&saved.solid).map_err(invalid)
}
/// How many values `v` is (a collection and each of its items): [`file::MAX_VALUES`] at most.
#[cfg(test)]
fn value_nodes(v: &serde_json::Value) -> usize {
use serde_json::Value;
match v {
Value::Array(a) => a.iter().fold(1usize, |n, v| n.saturating_add(value_nodes(v))),
Value::Object(o) => o.values().fold(1usize, |n, v| n.saturating_add(value_nodes(v))),
_ => 1,
}
}
#[cfg(test)]
mod smlib_import_tests;
#[cfg(test)]
mod tests {
use super::*;
use serde_json::Value;
use solidcore_record::Vec3;
use solidcraft_geom::prelude::*;
use std::sync::Arc;
fn equal(a: &Body, b: &Body) {
assert_eq!(a.face_count(), b.face_count());
assert_eq!(a.face_sources, b.face_sources);
assert_eq!(a.history, b.history);
assert_eq!(a.paint, b.paint);
assert_eq!(a.color, b.color);
assert_eq!(a.splits, b.splits);
assert_eq!(a.regularization_protected, b.regularization_protected);
assert_eq!(encode_native_body(a).unwrap(), encode_native_body(b).unwrap());
let am = crate::measure(a).unwrap();
let bm = crate::measure(b).unwrap();
assert!((am.volume - bm.volume).abs() < 1e-7);
}
#[test]
fn native_solids_keep_geometry_metadata_and_later_modelling() {
let cube = crate::box_solid(Vec3::ZERO, Vec3::new(40., 30., 10.)).unwrap();
let rounded = crate::fillet(&cube, &[Vec3::new(20., 0., 10.)], 2.).unwrap();
let bore = crate::cylinder(Vec3::new(10., 10., -1.), Vec3::Z, 3., 12.).unwrap();
let cut = crate::boolean(&rounded, &bore, crate::BoolOp::Cut).unwrap().unwrap();
for body in [cube, rounded, cut] {
let body = body.with_color(Some([0.1, 0.5, 0.9]));
let bytes = encode_native_body(&body).unwrap();
assert!(bytes.starts_with(file::MAGIC));
let decoded = decode_native_body(&bytes).unwrap();
equal(&body, &decoded);
let a = crate::boolean(&body, &bore, crate::BoolOp::Cut).unwrap().unwrap();
let b = crate::boolean(&decoded, &bore, crate::BoolOp::Cut).unwrap().unwrap();
assert!((crate::measure(&a).unwrap().volume - crate::measure(&b).unwrap().volume).abs() < 1e-7);
}
}
#[test]
fn native_spheres_tori_and_open_faces_round_trip_without_conversion() {
let cube = crate::box_solid(Vec3::ZERO, Vec3::new(40., 30., 10.)).unwrap();
let surface = crate::copy_faces(&cube, &[Vec3::new(20., 15., 10.)]).unwrap();
let sphere = crate::sphere(Vec3::ZERO, 12.).unwrap();
let torus = crate::torus(Vec3::ZERO, 20., 4.).unwrap();
for body in [surface, sphere, torus] {
let encoded = encode_native_body(&body).unwrap();
let restored = decode_native_body(&encoded).unwrap();
assert_eq!(body.is_surface(), restored.is_surface());
assert_eq!(body.face_count(), restored.face_count());
assert_eq!(encoded, encode_native_body(&restored).unwrap());
if !body.is_surface() {
equal(&body, &restored);
}
}
}
/// The encoding as it was made before the encoder wrote as it serialized: the whole record as
/// a JSON value, checked, then written.
fn encoded_through_a_value(body: &Body) -> Result<Vec<u8>> {
let runtime = Runtime { size: body.size, coarse_missing: None };
let saved = Saved { solid: body.record().clone(), metadata: metadata::encode(body)?, runtime };
check(&saved)?;
file::check(&saved).map_err(refused)?;
let value = serde_json::to_value(saved).map_err(invalid)?;
file::check_value(&value).map_err(refused)?;
if value_nodes(&value) > file::MAX_VALUES {
return Err(invalid("value budget"));
}
let mut out = file::MAGIC.to_vec();
file::write_value(&value, &mut out).map_err(refused)?;
Ok(out)
}
/// Written as it serializes, a body's encoding is the bytes its JSON value gave, byte for
/// byte: plain, blended, cut (history), extruded (face sources), coloured, painted, split
/// along lines, round (spline forms), open, and placed far off.
#[test]
fn the_encoding_is_the_bytes_of_the_record_as_a_json_value() {
use solidcore_record::{Loop2, Plane, Region2, Vec2};
let cube = crate::box_solid(Vec3::ZERO, Vec3::new(40., 30., 10.)).unwrap();
let rounded = crate::fillet(&cube, &[Vec3::new(20., 0., 10.)], 2.).unwrap();
let bore = crate::cylinder(Vec3::new(10., 10., -1.), Vec3::Z, 3., 12.).unwrap();
let cut = crate::boolean(&rounded, &bore, crate::BoolOp::Cut).unwrap().unwrap();
let region = Region2 {
outer: Loop2::polygon(&[Vec2::ZERO, Vec2::new(20., 0.), Vec2::new(20., 20.), Vec2::new(0., 20.)]),
holes: vec![Loop2::circle(Vec2::new(10., 10.), 4.)],
};
let extruded = crate::extrude(&Plane::XY, &[region], 0., 5.).unwrap().remove(0);
assert!(extruded.face_sources().is_some_and(|s| s.iter().any(Option::is_some)), "an extrusion carries its face sources");
assert!(cut.history().is_some(), "a cut carries its history");
let paint = crate::Paint { opacity: 0.5, faces: vec![crate::FacePaint { face: 1, color: [0.9, 0.1, 0.2], opacity: 0.75 }] };
let painted = cube.clone().with_color(Some([0.1, 0.5, 0.9])).with_paint(Some(paint));
let top = (0..cube.face_count()).find(|f| cube.planar_face(*f).is_some_and(|p| p.normal().z > 0.5 && p.origin.z > 9.)).unwrap();
let split =
crate::split_faces(&cube, &[top], &crate::SplitTool::Plane(Plane::from_normal(Vec3::new(20., 0., 0.), Vec3::X).unwrap())).unwrap();
let surface = crate::copy_faces(&cube, &[Vec3::new(20., 15., 10.)]).unwrap();
let far = crate::transform(&cut, Vec3::new(1.0e6, -2.5e5, 3.0e4), Vec3::ZERO, Vec3::Z, 0.7).unwrap();
let bodies = [
cube,
rounded,
cut,
extruded,
painted,
split,
surface,
crate::sphere(Vec3::ZERO, 12.).unwrap(),
crate::torus(Vec3::ZERO, 20., 4.).unwrap(),
far,
];
for (i, body) in bodies.iter().enumerate() {
assert_eq!(encode_native_body(body).unwrap(), encoded_through_a_value(body).unwrap(), "body {i}");
}
}
#[test]
fn box_and_fillet_have_stable_wire_records() {
let cube = crate::box_solid(Vec3::ZERO, Vec3::new(40., 30., 10.)).unwrap();
let rounded = crate::fillet(&cube, &[Vec3::new(20., 0., 10.)], 2.).unwrap();
let records: Vec<_> = [cube, rounded]
.iter()
.map(|body| {
let bytes = encode_native_body(body).unwrap();
assert_eq!(&bytes[..8], b"SCBREP05");
let mut raw = &bytes[8..];
let value = file::read_value(&mut raw, &mut 2_000_000).unwrap();
assert!(raw.is_empty());
value
})
.collect();
let actual = serde_json::json!(records);
// An intended change to the wire records rewrites the fixture with NATIVE_BREP_BLESS=1.
if std::env::var_os("NATIVE_BREP_BLESS").is_some() {
let path = concat!(env!("CARGO_MANIFEST_DIR"), "/src/native/fixtures/box-fillet-v5.json");
std::fs::write(path, serde_json::to_string_pretty(&actual).unwrap() + "\n").unwrap();
}
let expected: Value = serde_json::from_str(include_str!("native/fixtures/box-fillet-v5.json")).unwrap();
compare_wire(&expected, &actual);
}
fn compare_wire(expected: &Value, actual: &Value) {
match (expected, actual) {
(Value::Number(a), Value::Number(b)) if a.is_f64() && b.is_f64() => {
let (a, b) = (a.as_f64().unwrap(), b.as_f64().unwrap());
assert!((a - b).abs() <= 1e-10 * a.abs().max(1.), "wire number changed: {a} vs {b}");
}
(Value::Array(a), Value::Array(b)) => {
assert_eq!(a.len(), b.len());
for (a, b) in a.iter().zip(b) {
compare_wire(a, b);
}
}
(Value::Object(a), Value::Object(b)) => {
assert_eq!(a.keys().collect::<Vec<_>>(), b.keys().collect::<Vec<_>>());
for (key, a) in a {
compare_wire(a, &b[key]);
}
}
_ => assert_eq!(expected, actual),
}
}
#[test]
fn malformed_native_geometry_is_bounded_and_never_panics() {
let body = crate::box_solid(Vec3::ZERO, Vec3::new(10., 20., 30.)).unwrap();
let bytes = encode_native_body(&body).unwrap();
for n in [0, 1, 7, 8, 9, bytes.len() - 1] {
assert!(decode_native_body(&bytes[..n]).is_err());
}
for i in (0..bytes.len()).step_by((bytes.len() / 256).max(1)) {
let mut bad = bytes.clone();
bad[i] ^= 0xff;
assert!(std::panic::catch_unwind(|| decode_native_body(&bad)).is_ok());
}
let mut raw = &bytes[8..];
let value = file::read_value(&mut raw, &mut 2_000_000).unwrap();
for key in ["vertices", "index"] {
let mut v = value.clone();
if key == "vertices" {
v["solid"]["edges"][0]["vertices"] = serde_json::json!([u64::MAX, 0]);
} else {
v["solid"]["faces"][0]["loops"][0]["edges"][0]["edge"] = serde_json::json!(u64::MAX);
}
let mut bad = file::MAGIC.to_vec();
file::write_value(&v, &mut bad).unwrap();
assert!(decode_native_body(&bad).is_err());
}
let mut huge = file::MAGIC.to_vec();
huge.push(7);
huge.extend(u32::MAX.to_le_bytes());
assert!(decode_native_body(&huge).is_err());
}
#[test]
fn a_kernel_body_past_the_file_item_budget_is_taken_and_a_file_of_it_refused() {
// The box with its first edge a polyline of the file item budget's worth of points: a
// record the kernel's own operations may make (#3992), and more than a file may carry.
let body = crate::box_solid(Vec3::ZERO, Vec3::new(10., 20., 30.)).unwrap();
let mut record = body.record().clone();
let [t0, t1] = record.edges[0].interval;
let n = solidcore_record::brep::MAX_ITEMS;
let points = (0..n).map(|i| [i as f64 * 1e-6, 0., 0.]).collect();
record.edges[0].curve = solidcore_record::brep::Curve::Polyline { points };
assert!(t0 >= 0.0 && t1 <= (n - 1) as f64);
Body::from_record(record.clone()).unwrap();
let saved = Saved { solid: record, metadata: metadata::encode(&body).unwrap(), runtime: Runtime { size: 0.0, coarse_missing: None } };
let refused = file::check(&saved).err().map(|e| e.to_string()).unwrap_or_default();
assert!(refused.contains("item budget"), "{refused}");
}
#[test]
fn native_preserves_face_appearance_and_authored_boundaries() {
let mut body = crate::box_solid(Vec3::new(1., 2., 3.), Vec3::new(10., 20., 30.))
.unwrap()
.with_paint(Some(crate::Paint { opacity: 0.7, faces: vec![crate::FacePaint { face: 2, color: [0.25, 0.5, 0.75], opacity: 0.6 }] }));
body.splits = Some(Arc::new(vec![vec![Vec3::new(1., 2., 3.), Vec3::new(11., 2., 3.)]]));
body.regularization_protected = true;
let restored = decode_native_body(&encode_native_body(&body).unwrap()).unwrap();
equal(&body, &restored);
}
}