diff --git a/crates/doc/src/model_cache.rs b/crates/doc/src/model_cache.rs index 569563ea5..95ab45149 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 { - 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 { 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 e6fd8067d..9b47d6b44 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::>(); + 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 2b3a0b648..683ed07c9 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::>()[..]); + assert_eq!(&*preview.meshes[1].triangles, &triangles.iter().flatten().copied().collect::>()[..]); + 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 7d85266a3..72b82b732 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> { + 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 { + 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 = 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::>()?; + 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::>()?; + let color: Option<[f32; 3]> = serde_json::from_value(header.get("color").cloned().unwrap_or(Value::Null)).ok()?; + let paint: Option = 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::>(); + 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 { + 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 { // 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(reader: &mut PackageReader, 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::>>().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 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 7b1c9d521..56afb9a6e 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