dc38349cbf
* 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>
64 lines
3.6 KiB
Rust
64 lines
3.6 KiB
Rust
use super::*;
|
|
use solidcore_record::Plane;
|
|
|
|
fn stamped_stock() -> Body {
|
|
crate::box_solid(Vec3::new(-20., -15., 0.), Vec3::new(20., 15., 24.)).unwrap().with_box_certificate(7).unwrap()
|
|
}
|
|
|
|
fn cup(stock: &Body) -> Body {
|
|
crate::shell(stock, &[Vec3::new(0., 0., 24.)], 1.).unwrap().with_shell_certificate(9).unwrap()
|
|
}
|
|
|
|
#[test]
|
|
fn stamped_shell_keeps_authored_painted_and_split_boundaries() {
|
|
let stock = stamped_stock();
|
|
let ordinary = cup(&stock);
|
|
assert!(!ordinary.regularization_protected);
|
|
let painted = stock.clone().with_paint(Some(Paint { opacity: 1., faces: vec![FacePaint { face: 0, color: [1., 0., 0.], opacity: 1. }] }));
|
|
let side = (0..stock.face_count()).find(|i| stock.planar_face(*i).is_some_and(|p| p.normal().dot(Vec3::X) > 0.999 && p.origin.x == 20.)).unwrap();
|
|
let split = crate::split_faces(&stock, &[side], &crate::SplitTool::Plane(Plane { origin: Vec3::new(0., 0., 8.), ..Plane::XY })).unwrap();
|
|
assert!(split.split_lines().is_some());
|
|
// SMLib's shell makes no section strips: the ordinary cup is the stock's five kept faces,
|
|
// their five linings and the rim (11). A paint over a whole face authors no boundary inside
|
|
// it, so the painted cup has those same faces; the split side's line stays an edge on both
|
|
// walls (13).
|
|
for (protected, faces) in [(painted, ordinary.face_count()), (split, ordinary.face_count() + 2)] {
|
|
let result = cup(&protected);
|
|
assert!(result.regularization_protected);
|
|
assert_eq!(result.face_count(), faces, "authored boundaries must survive Shell");
|
|
assert_eq!(result.split_lines(), protected.split_lines());
|
|
assert!(result.validity().is_empty());
|
|
let expected = 40. * 30. * 24. - 38. * 28. * 23.;
|
|
let mesh = result.mesh(&crate::MeshTolerance::chord(1e-5)).unwrap();
|
|
assert!((mesh.measure().volume - expected).abs() < 1e-6);
|
|
assert!(mesh.contains(Vec3::new(19.5, 0., 12.)));
|
|
assert!(!mesh.contains(Vec3::new(0., 0., 12.)));
|
|
let count = result.face_count();
|
|
assert_eq!(result.clone().regularize_certified_planar_faces().unwrap().face_count(), count);
|
|
let placed = crate::transform(&result, Vec3::new(30., -40., 7.), Vec3::ZERO, Vec3::Z, 0.3).unwrap();
|
|
assert!(placed.regularization_protected);
|
|
for lump in placed.lumps().unwrap() {
|
|
assert!(lump.regularization_protected);
|
|
}
|
|
let cleared = result.clone().with_paint(None).with_split_lines(None);
|
|
assert!(cleared.regularization_protected, "cleared appearance must not erase inherited boundary protection");
|
|
assert_eq!(cleared.regularize_certified_planar_faces().unwrap().face_count(), count);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn protection_is_identity_and_survives_tool_operand_and_compounds() {
|
|
let a = stamped_stock();
|
|
let protected = a.clone().with_paint(Some(Paint { opacity: 1., faces: vec![FacePaint { face: 0, color: [0., 1., 0.], opacity: 1. }] }));
|
|
let cleared = protected.with_paint(None);
|
|
assert!(!a.same(&cleared));
|
|
let tool = crate::box_solid(Vec3::new(-5., -5., 23.), Vec3::new(5., 5., 30.)).unwrap().inherit_regularization_protection(&cleared);
|
|
let cut = crate::boolean(&a, &tool, crate::BoolOp::Cut).unwrap().unwrap();
|
|
assert!(cut.regularization_protected);
|
|
let remote = crate::box_solid(Vec3::new(100., 0., 0.), Vec3::new(110., 10., 10.)).unwrap();
|
|
let joined = crate::ops::join_pieces(vec![cleared, remote]).unwrap().unwrap();
|
|
assert!(joined.regularization_protected);
|
|
assert_eq!(joined.lumps().unwrap().len(), 2);
|
|
assert!(joined.lumps().unwrap().iter().all(|body| body.regularization_protected));
|
|
}
|