Skip to content

SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.

Model cache: a design with mesh bodies keeps its saved model (#9170) (#9218)

austin62jake0396b2d00ad5
diff --git a/crates/doc/src/model_cache.rs b/crates/doc/src/model_cache.rs
index 569563ea5f..95ab451494 100644
--- a/crates/doc/src/model_cache.rs
+++ b/crates/doc/src/model_cache.rs
@@ -177,9 +177,6 @@ impl Writer {
}
fn model_body(&mut self, b: &ModelBody) -> Option<usize> {
- if b.body.is_mesh() {
- return None;
- }
let key = BodyKey::of(b);
if let Some(i) = self.model_body_index.get(&key) {
return Some(*i);
@@ -261,7 +258,7 @@ impl Writer {
impl Model {
/// The model as a design file keeps it: `None` unless it is `doc`'s evaluation without an
- /// error, holds no mesh bodies, and `doc` keeps no names saved before format 14. Works out
+ /// error and `doc` keeps no names saved before format 14. Works out
/// the face names not asked for yet (a saved model keeps them as worked out).
pub fn saved(&self, doc: &Document) -> Option<SavedModel> {
if self.results.is_empty() || self.results.iter().any(|r| r.error.is_some()) || !self.is_current(doc) || has_legacy_names(doc) {
diff --git a/crates/engine/src/cmd/file.rs b/crates/engine/src/cmd/file.rs
index e6fd8067de..9b47d6b447 100644
--- a/crates/engine/src/cmd/file.rs
+++ b/crates/engine/src/cmd/file.rs
@@ -1477,6 +1477,51 @@ mod tests {
std::fs::remove_file(path).unwrap();
}
+ /// #9170: a design holding a mesh body (an inserted STL) keeps its saved model and opens from
+ /// it. One mesh body left the cache out for the whole model, so every feature, the boxes
+ /// too, was evaluated again on opening.
+ #[test]
+ fn a_design_with_a_mesh_body_keeps_its_saved_model() {
+ let dir = std::env::temp_dir().join(format!("solidcraft-mesh-cache-{}", std::process::id()));
+ std::fs::create_dir_all(&dir).unwrap();
+ let stl = dir.join("tetra.stl");
+ let facets = [
+ [[0, 0, 0], [0, 10, 0], [10, 0, 0]],
+ [[0, 0, 0], [10, 0, 0], [0, 0, 10]],
+ [[0, 0, 0], [0, 0, 10], [0, 10, 0]],
+ [[10, 0, 0], [0, 10, 0], [0, 0, 10]],
+ ];
+ let mut text = String::from("solid tetra\n");
+ for f in facets {
+ text += "facet normal 0 0 0\nouter loop\n";
+ for [x, y, z] in f {
+ text += &format!("vertex {x} {y} {z}\n");
+ }
+ text += "endloop\nendfacet\n";
+ }
+ std::fs::write(&stl, text + "endsolid tetra\n").unwrap();
+ let mut session = Session::new(Document::new("Boxes and a mesh"));
+ for x in [0, 40, 80] {
+ session.execute("solid.box", &json!({"length": 20, "width": 20, "height": 20, "corner": [x, 0, 0], "operation": "new_body"})).unwrap();
+ }
+ session.execute("file.insert_mesh", &json!({"path": stl})).unwrap();
+ let triangles = |s: &Session| s.model.state().bodies.iter().filter_map(|b| b.body.triangle_mesh().map(|(_, t)| t.len())).collect::<Vec<_>>();
+ assert_eq!(triangles(&session), [4], "one mesh body");
+ let bytes = session.design_container(solidcraft_io::DesignCompression::Fast, false, true).unwrap();
+ assert!(solidcraft_io::read_design_geometry(&bytes).is_some(), "the model is saved with the mesh body");
+ let path = dir.join("boxes-mesh.solidcraft");
+ std::fs::write(&path, &bytes).unwrap();
+ let mut reopened = Session::default();
+ reopened.execute("doc.open", &json!({"path": path})).unwrap();
+ std::fs::remove_dir_all(&dir).unwrap();
+ assert_eq!(reopened.model.results.len(), session.model.results.len());
+ assert!(reopened.model.results.iter().zip(&session.model.results).all(|(a, b)| a.ms == b.ms), "taken from the file, not evaluated");
+ assert_eq!(triangles(&reopened), [4]);
+ let volume = |s: &mut Session| s.execute("inspect.measure", &json!({})).unwrap()["total"]["volume_mm3"].as_f64().unwrap();
+ let (saved, opened) = (volume(&mut session), volume(&mut reopened));
+ assert!((opened - saved).abs() < 1e-9 && (saved - (3. * 8000. + 1000. / 6.)).abs() < 1e-6, "{opened} vs {saved}");
+ }
+
/// A sheet-metal design keeps each sheet body once in its saved model, not again with every
/// later feature's state: a design of many features after its sheet metal wrote the sheets
/// over and over, and past the cache's size limit kept only some of its states.
diff --git a/crates/io/src/design.rs b/crates/io/src/design.rs
index 2b3a0b6489..683ed07c9d 100644
--- a/crates/io/src/design.rs
+++ b/crates/io/src/design.rs
@@ -1190,6 +1190,63 @@ mod tests {
}
}
+ /// #9170: a mesh body (an imported STL) is kept in the model cache with the rest of the
+ /// model, as its own triangles, colour and paint. One mesh body left the whole cache out, so
+ /// opening the design evaluated every feature again.
+ #[test]
+ fn model_cache_keeps_mesh_bodies_with_the_rest_of_the_model() {
+ use solidcraft_geom::Vec3;
+ let corners = [Vec3::ZERO, Vec3::new(10., 0., 0.), Vec3::new(0., 10., 0.), Vec3::new(0., 0., 10.)];
+ let tetra = solidcraft_kernel::mesh_body(&corners, &[[0, 2, 1], [0, 1, 3], [0, 3, 2], [1, 2, 3]])
+ .unwrap()
+ .with_color(Some([0.25, 0.5, 0.75]))
+ .with_paint(Some(solidcraft_kernel::Paint { opacity: 0.5, faces: Vec::new() }));
+ let block = solidcraft_kernel::box_solid(Vec3::new(40., 0., 0.), Vec3::new(60., 20., 20.)).unwrap();
+ let model = saved_model(vec![block, tetra.clone()]);
+ let doc = document();
+ let bytes = write_design_container_with_cache(&doc, DesignCompression::Fast, None, Some(&model)).unwrap();
+ let entries = parts(&bytes);
+ let manifest: Value = serde_json::from_slice(&entries["cache/model.json"]).expect("the cache is written");
+ assert_eq!(manifest["slices"].as_array().unwrap().len(), 2);
+ let read = DesignContainerReader::new(Cursor::new(&bytes)).unwrap().geometry().unwrap();
+ assert_eq!(read.records, model.records);
+ assert_eq!(solidcraft_kernel::encode_native_body(&read.bodies[0]).unwrap(), solidcraft_kernel::encode_native_body(&model.bodies[0]).unwrap());
+ let mesh = &read.bodies[1];
+ assert_eq!(mesh.triangle_mesh(), tetra.triangle_mesh());
+ assert_eq!((mesh.color(), mesh.paint()), (tetra.color(), tetra.paint()));
+ // The picture shown while opening draws the mesh body with its own triangles.
+ let preview = read_design_preview(&bytes).unwrap();
+ assert_eq!(preview.meshes.len(), 2);
+ let (positions, triangles) = tetra.triangle_mesh().unwrap();
+ assert_eq!(&*preview.meshes[1].positions, &positions.iter().flat_map(|p| [p.x, p.y, p.z]).collect::<Vec<_>>()[..]);
+ assert_eq!(&*preview.meshes[1].triangles, &triangles.iter().flatten().copied().collect::<Vec<_>>()[..]);
+ assert_eq!(preview.meshes[1].color, tetra.color());
+
+ // A changed or cut-short mesh slice (signed again, so it reaches the slice's reader) is a
+ // cache miss or another mesh, never a crash.
+ let range = |i: usize| manifest["slices"][1][i].as_u64().unwrap() as usize;
+ let (start, length) = (range(0), range(1));
+ let payload = entries["cache/bodies.bin"].clone();
+ assert_eq!(payload.len(), start + length, "the mesh slice is the last");
+ let with = |payload: &[u8], length: usize| {
+ let mut entries = entries.clone();
+ let mut manifest = manifest.clone();
+ manifest["payload"] = json!(digest(payload));
+ manifest["slices"][1][1] = json!(length);
+ entries.insert("cache/model.json".into(), serde_json::to_vec(&manifest).unwrap());
+ entries.insert("cache/bodies.bin".into(), payload.to_vec());
+ package(&entries)
+ };
+ assert!(read_design_geometry(&with(&payload, length)).is_some(), "signed again as it was, it reads");
+ for n in (start..start + length).step_by(5) {
+ let mut changed = payload.clone();
+ changed[n] ^= 0xff;
+ let changed = with(&changed, length);
+ assert!(std::panic::catch_unwind(|| (read_design_geometry(&changed), read_design_preview(&changed))).is_ok(), "byte {n}");
+ assert!(read_design_geometry(&with(&payload[..n], n - start)).is_none(), "cut short at {n}");
+ }
+ }
+
/// A model cache that does not fit the design file is left out: the save succeeds, and the
/// design reads back as saved.
#[test]
diff --git a/crates/io/src/design/native_cache.rs b/crates/io/src/design/native_cache.rs
index 7d85266a36..72b82b732f 100644
--- a/crates/io/src/design/native_cache.rs
+++ b/crates/io/src/design/native_cache.rs
@@ -1,7 +1,8 @@
//! The model cache: a design's evaluated timeline (every feature's result and the state after
//! it, [`SavedModel`]), saved with it so opening need not evaluate it again. Bodies use
-//! SolidCraft's exact native B-rep encoding; the key ties the cache to the exact document, and to
-//! the source and platform that computed it (docs/design-container.md).
+//! SolidCraft's exact native B-rep encoding (a mesh body, its own triangles); the key ties the
+//! cache to the exact document, and to the source and platform that computed it
+//! (docs/design-container.md).
use super::*;
use solidcraft_doc::{ModelState, SavedModel};
@@ -114,6 +115,90 @@ fn same_topology(a: &solidcraft_kernel::Body, b: &solidcraft_kernel::Body) -> bo
counts(a) == counts(b)
}
+/// The start of a mesh body's slice. A mesh body (an imported STL or 3MF) has no B-rep for the
+/// native encoding: its slice is its triangles as they are, with its colour and paint, which is
+/// all a mesh body holds. A B-rep slice starts with the native encoding's own tag.
+const MESH_TAG: &[u8; 8] = b"SCMESH01";
+/// Most bytes of a mesh slice's header (its counts, colour and paint).
+const MAX_MESH_HEADER: usize = 16 << 20;
+
+/// A mesh body's slice: the tag, the header's length (u32) and the header (JSON: the counts,
+/// colour and paint), then each vertex as three f64 and each triangle as three u32, little-endian.
+fn encode_mesh_body(body: &solidcraft_kernel::Body) -> Option<Vec<u8>> {
+ let (positions, triangles) = body.triangle_mesh()?;
+ let header =
+ serde_json::to_vec(&json!({"positions": positions.len(), "triangles": triangles.len(), "color": body.color(), "paint": body.paint()}))
+ .ok()?;
+ if header.len() > MAX_MESH_HEADER {
+ return None;
+ }
+ let size = positions.len().checked_mul(24)?.checked_add(triangles.len().checked_mul(12)?)?.checked_add(12 + header.len())?;
+ let mut out = Vec::with_capacity(size);
+ out.extend_from_slice(MESH_TAG);
+ out.extend_from_slice(&u32::try_from(header.len()).ok()?.to_le_bytes());
+ out.extend_from_slice(&header);
+ for p in positions {
+ for x in [p.x, p.y, p.z] {
+ out.extend_from_slice(&x.to_le_bytes());
+ }
+ }
+ for t in triangles {
+ for i in t {
+ out.extend_from_slice(&i.to_le_bytes());
+ }
+ }
+ Some(out)
+}
+
+/// The mesh body of a slice [`encode_mesh_body`] wrote; `None` for anything else.
+fn decode_mesh_body(bytes: &[u8]) -> Option<solidcraft_kernel::Body> {
+ let rest = bytes.strip_prefix(MESH_TAG.as_slice())?;
+ let (length, rest) = rest.split_first_chunk::<4>()?;
+ let length = usize::try_from(u32::from_le_bytes(*length)).ok().filter(|n| *n <= MAX_MESH_HEADER)?;
+ let (header, data) = rest.split_at_checked(length)?;
+ let header: Value = serde_json::from_slice(header).ok()?;
+ let count = |key: &str| header.get(key).and_then(Value::as_u64).and_then(|n| usize::try_from(n).ok());
+ let (vertices, triangles) = (count("positions")?, count("triangles")?);
+ if triangles > solidcraft_kernel::MAX_TRIANGLES {
+ return None;
+ }
+ // The counts must account for every byte, so nothing is allocated for data that is not there.
+ let split = vertices.checked_mul(24)?;
+ if split.checked_add(triangles.checked_mul(12)?)? != data.len() {
+ return None;
+ }
+ let (coordinates, corners) = data.split_at_checked(split)?;
+ let f64_at = |c: &[u8], at: usize| c.get(at..at + 8)?.try_into().ok().map(f64::from_le_bytes);
+ let u32_at = |c: &[u8], at: usize| c.get(at..at + 4)?.try_into().ok().map(u32::from_le_bytes);
+ let positions: Vec<solidcraft_geom::Vec3> = coordinates
+ .as_chunks::<24>()
+ .0
+ .iter()
+ .map(|c| Some(solidcraft_geom::Vec3::new(f64_at(c, 0)?, f64_at(c, 8)?, f64_at(c, 16)?)))
+ .collect::<Option<_>>()?;
+ let triangles: Vec<[u32; 3]> =
+ corners.as_chunks::<12>().0.iter().map(|c| Some([u32_at(c, 0)?, u32_at(c, 4)?, u32_at(c, 8)?])).collect::<Option<_>>()?;
+ let color: Option<[f32; 3]> = serde_json::from_value(header.get("color").cloned().unwrap_or(Value::Null)).ok()?;
+ let paint: Option<solidcraft_kernel::Paint> = serde_json::from_value(header.get("paint").cloned().unwrap_or(Value::Null)).ok()?;
+ if color.is_some_and(|c| c.iter().any(|x| !x.is_finite())) {
+ return None;
+ }
+ Some(solidcraft_kernel::mesh_body(&positions, &triangles).ok()?.with_color(color).with_paint(paint))
+}
+
+/// A mesh body decoded is the one encoded: the same vertices, bit for bit, the same triangles,
+/// colour and paint.
+fn same_mesh(a: &solidcraft_kernel::Body, b: &solidcraft_kernel::Body) -> bool {
+ let (Some((pa, ta)), Some((pb, tb))) = (a.triangle_mesh(), b.triangle_mesh()) else { return false };
+ let bits = |p: &[solidcraft_geom::Vec3]| p.iter().map(|v| [v.x.to_bits(), v.y.to_bits(), v.z.to_bits()]).collect::<Vec<_>>();
+ ta == tb && bits(pa) == bits(pb) && a.color() == b.color() && a.paint() == b.paint()
+}
+
+/// A body of the cache's payload, mesh or B-rep by the slice's tag.
+fn decode_cached_body(bytes: &[u8]) -> Option<solidcraft_kernel::Body> {
+ if bytes.starts_with(MESH_TAG) { decode_mesh_body(bytes) } else { solidcraft_kernel::decode_native_body(bytes).ok() }
+}
+
impl Encoded {
fn of(model: &SavedModel) -> Result<Self> {
// What to encode: every body, and the part every placed copy shows.
@@ -134,6 +219,10 @@ impl Encoded {
// topology (two loose vertices more on a pattern copy cut by an extrude) would open as
// another body. Then the model isn't kept, and opening the design evaluates it.
let encoded = solidcraft_kernel::map_on_threads(&bodies, 16, |b| {
+ if b.is_mesh() {
+ let bytes = encode_mesh_body(b)?;
+ return decode_mesh_body(&bytes).is_some_and(|back| same_mesh(b, &back)).then_some(bytes);
+ }
let bytes = solidcraft_kernel::encode_native_body(b).ok()?;
let back = solidcraft_kernel::decode_native_body(&bytes).ok()?;
same_topology(b, &back).then_some(bytes)
@@ -272,7 +361,7 @@ pub(super) fn read_geometry_with<R: Read + Seek>(reader: &mut PackageReader<R>,
if end != data.len() {
return Err(invalid("trailing cached data"));
}
- let decoded = solidcraft_kernel::map_on_threads(&parts, 16, |bytes| solidcraft_kernel::decode_native_body(bytes).ok());
+ let decoded = solidcraft_kernel::map_on_threads(&parts, 16, |bytes| decode_cached_body(bytes));
let unique = decoded.into_iter().map(Option::flatten).collect::<Option<Vec<_>>>().ok_or_else(|| invalid("cached body"))?;
let body = |v: Option<&Value>| unique.get(count(v)?).ok_or_else(|| invalid("cached body index"));
let shares = manifest
@@ -330,16 +419,24 @@ pub(super) fn geometry_preview(document: &[u8], model: &SavedModel) -> Result<De
};
let mut work = 1_000_000usize;
for entry in &world.bodies {
- let mesh = solidcraft_kernel::native_preview_mesh(&entry.body, detail, &mut work).map_err(invalid)?;
- triangles = triangles.saturating_add(mesh.triangles.len());
- display_bytes = display_bytes.saturating_add(mesh.positions.len().saturating_mul(24)).saturating_add(mesh.triangles.len().saturating_mul(12));
+ // A mesh body is drawn with its own triangles; a B-rep body with a coarse mesh of it.
+ let made;
+ let (positions, faces) = match entry.body.triangle_mesh() {
+ Some(own) => own,
+ None => {
+ made = solidcraft_kernel::native_preview_mesh(&entry.body, detail, &mut work).map_err(invalid)?;
+ (made.positions.as_slice(), made.triangles.as_slice())
+ }
+ };
+ triangles = triangles.saturating_add(faces.len());
+ display_bytes = display_bytes.saturating_add(positions.len().saturating_mul(24)).saturating_add(faces.len().saturating_mul(12));
if triangles > 1_000_000 || display_bytes > 128 << 20 {
return Err(invalid("regenerated display budget"));
}
let displayed = MeshData {
name: entry.name.clone(),
- positions: mesh.positions.iter().flat_map(|p| [p.x, p.y, p.z]).collect(),
- triangles: mesh.triangles.iter().flatten().copied().collect(),
+ positions: positions.iter().flat_map(|p| [p.x, p.y, p.z]).collect(),
+ triangles: faces.iter().flatten().copied().collect(),
color: entry.body.color(),
};
validate_mesh(&displayed)?;
diff --git a/docs/design-container.md b/docs/design-container.md
index 7b1c9d521b..56afb9a6e0 100644
--- a/docs/design-container.md
+++ b/docs/design-container.md
@@ -118,8 +118,8 @@ Engine Save/Save As write the evaluated model with the design by default
`cache/bodies.bin`. Plain JSON, recovery/autosave and browser downloads do not
carry it. Saving never forces placement, evaluation or tessellation: the model is
the session's own evaluation, and only when it is the evaluation of the document
-being saved (`Model::is_current`). An active sketch, uncaptured moves, feature
-errors or mesh bodies leave the cache out; the design saves as before. A cache
+being saved (`Model::is_current`). An active sketch, uncaptured moves or feature
+errors leave the cache out; the design saves as before. A cache
over its budgets keeps fewer states (below) and is left out only when not even
the final state fits.
@@ -147,6 +147,14 @@ SHA-256 of their encoding), and a placed copy of a repeated part (an instance fr
a STEP assembly) records the part and its matrix, so it shows that part's display
again instead of being meshed on its own.
+A mesh body (an imported STL or 3MF, or a STEP part shown as a mesh of its faces) has no
+B-rep to encode. Its slice starts `SCMESH01`, then the length of a JSON header (u32) and the
+header (its vertex and triangle counts, colour and paint), then each vertex as three f64
+and each triangle as three u32, little-endian: the triangles exactly as the body holds them.
+Before #9170 one mesh body left the cache out for the whole model. As for a B-rep body, a
+mesh body is kept only when its slice reads back as the same vertices, bit for bit, the
+same triangles, colour and paint; the picture shown while opening draws its triangles.
+
`cache/model.json` records `solidcraft-model-cache/5`, the producer revision
`solidcraft-truck-adapter/3`, the application version, the build (source commit,
CPU architecture and OS), the evaluation source (below, with the CPU architecture