SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Web app: open and insert STEP files over frames, with progress and Cancel (#1376) (#1424)
bherbruck4c7ea34a6810
diff --git a/crates/kernel/src/lib.rs b/crates/kernel/src/lib.rsindex d99415e9d0..3204bc5969 100644--- a/crates/kernel/src/lib.rs+++ b/crates/kernel/src/lib.rs@@ -140,7 +140,9 @@ pub use prism_measure::certified_prism_equivalent;pub use sew::{EdgeSpec, FaceSpec, SurfSpec, sew, sew_touching};pub use splitface::{SplitTool, split_body, split_faces, split_faces_with_map};pub use step::step_export;-pub use step_in::{ImportedBody, StepImport, StepNode, step_cache_alive, step_import, step_import_shared, step_orientation_errors, step_validate};+pub use step_in::{+ ImportedBody, StepImport, StepNode, StepReading, step_cache_alive, step_import, step_import_shared, step_orientation_errors, step_validate,+};pub use step_out::{ExportBody, ExportProduct, StepHeader, step_export_bodies, step_export_products};pub use surface_extend::{ExtendLimit, ExtendMode, ExtendOptions, extend_surface};pub use surface_kind::{EdgeCircle, FaceSurface, edge_circle, face_surface};diff --git a/crates/kernel/src/step_in/mod.rs b/crates/kernel/src/step_in/mod.rsindex 36c9e65846..6bf8a91d9e 100644--- a/crates/kernel/src/step_in/mod.rs+++ b/crates/kernel/src/step_in/mod.rs@@ -88,6 +88,21 @@ pub struct StepImport {pub system: String,}+/// A solid the walk found, converted later.+struct Planned {+ item: u64,+ units: Units,+ batch: usize,+}++/// Where the solids of a batch go: their placement and names.+struct Batch {+ m: mt::Matrix4,+ path: Vec<String>,+ product: String,+ instance: Option<String>,+}+/// Reading context: the file and the units of the representation being read.pub(crate) struct Ctx<'a> {pub ex: &'a Exchange,@@ -228,8 +243,8 @@ fn rigid_inverse(m: &mt::Matrix4) -> mt::Matrix4 {/// faces the file had, and the file face of each kernel face (band faces split into two).type SolidEntry = (mt::Solid, bool, usize, Vec<u64>);-struct Reader<'a> {- ex: &'a Exchange,+struct Reader {+ ex: Arc<Exchange>,units: HashMap<u64, Units>,warnings: BTreeMap<String, usize>,/// Representation → its items and context.@@ -263,6 +278,15 @@ struct Reader<'a> {/// Items whose meshing was checked.unmeshed_checked: HashSet<u64>,bodies: Vec<ImportedBody>,+ /// Solids the walk found, in file order, to be converted into bodies afterwards (so the+ /// conversion, the long part, can be done a piece at a time: [`StepReading`]).+ plan: Vec<Planned>,+ /// What the solids of one batch (consecutive solids of one representation) share.+ batches: Vec<Batch>,+ /// Planned solids converted so far.+ converted: usize,+ /// The body each converted planned solid became (`None`: it failed).+ made: Vec<Option<usize>>,workers: usize,/// Whoever waits for the import (progress, Cancel).watch: Option<Arc<dyn crate::watch::Watch>>,@@ -272,8 +296,8 @@ struct Reader<'a> {cancelled: bool,}-impl<'a> Reader<'a> {- fn new(ex: &'a Exchange, workers: usize) -> Self {+impl Reader {+ fn new(ex: Arc<Exchange>, workers: usize) -> Self {Self {ex,units: HashMap::new(),@@ -293,6 +317,10 @@ impl<'a> Reader<'a> {visits: 0,unmeshed_checked: HashSet::new(),bodies: Vec::new(),+ plan: Vec::new(),+ batches: Vec::new(),+ converted: 0,+ made: Vec::new(),workers,watch: None,solid_items: 0,@@ -310,7 +338,7 @@ impl<'a> Reader<'a> {self.cancelled = true;return true;}- w.progress("converting", self.bodies.len().min(self.solid_items), self.solid_items);+ w.progress("converting", self.converted.min(self.solid_items), self.solid_items);}false}@@ -320,7 +348,8 @@ impl<'a> Reader<'a> {}fn index(&mut self) {- let ex = self.ex;+ let ex = self.ex.clone();+ let ex = &*ex;let mut pds: HashMap<u64, u64> = HashMap::new(); // PDS → definitionlet mut sdrs: Vec<(u64, u64)> = Vec::new(); // (PDS, rep)let mut cdsrs: Vec<(u64, u64)> = Vec::new(); // (relationship, PDS)@@ -522,11 +551,11 @@ impl<'a> Reader<'a> {fn units_of(&mut self, rep: u64) -> Units {let ctx = self.reps.get(&rep).and_then(|r| r.1);- context_units(self.ex, ctx, &mut self.units)+ context_units(&self.ex, ctx, &mut self.units)}fn placement_matrix(&mut self, item: u64, u: Units) -> R<mt::Matrix4> {- let cx = Ctx { ex: self.ex, len: u.len, ang: u.ang, tol: u.tol };+ let cx = Ctx { ex: &self.ex, len: u.len, ang: u.ang, tol: u.tol };let e = geom::entity(&cx, item)?;if e.name() == "CARTESIAN_TRANSFORMATION_OPERATOR_3D" {let p = e.params();@@ -569,7 +598,7 @@ impl<'a> Reader<'a> {if let Some(r) = self.solids.get(&item) {return r.as_ref().ok().cloned();}- let cx = Ctx { ex: self.ex, len: u.len, ang: u.ang, tol: u.tol };+ let cx = Ctx { ex: &self.ex, len: u.len, ang: u.ang, tol: u.tol };let r = match guard("step brep", || brep::read_item(&cx, item).map_err(KernelError::Failed)) {Ok(out) => {let label = self.label(item);@@ -625,7 +654,7 @@ impl<'a> Reader<'a> {// Only batch consecutive solids: mapped items must retain traversal and// first-use unit/cache order. Bound temporary geometry independently of file size.let mut batch = vec![item];- let capacity = MAX_BODIES.saturating_sub(self.bodies.len()).min(64);+ let capacity = MAX_BODIES.saturating_sub(self.bodies_so_far()).min(64);while batch.len() < capacity&& items.peek().is_some_and(|id| {self.ex.get(*id).is_some_and(|e| {@@ -637,84 +666,20 @@ impl<'a> Reader<'a> {batch.push(next);}}- let mut sources = Vec::new();- let mut solids = Vec::new();+ let id = self.batches.len();+ self.batches.push(Batch { m: *m, path: path.to_vec(), product: product.to_string(), instance: instance.map(str::to_string) });for item in batch {self.used_items.insert(item);if !self.node_items.insert(item) {continue;}- if self.bodies.len() >= MAX_BODIES {+ if self.bodies_so_far() >= MAX_BODIES {self.warn(format!("more than {MAX_BODIES} bodies: the rest are left out"));return;}- let Some(entry) = self.item_solid(item, u) else { continue };- // A one-use item is the only reference to its entry, so the solid moves- // out; an item whose conversion is cached for a later instance needs its- // own copy.- let (solid, closed, file_faces, face_origin) = match Arc::try_unwrap(entry) {- Ok(entry) => entry,- Err(shared) => (*shared).clone(),- };- sources.push((item, closed, file_faces, face_origin));- solids.push(parallel::Job { solid, check_mesh: !self.unmeshed_checked.contains(&item) });- }- let prepared = parallel::bodies(&solids, m, self.workers);- for ((item, closed, file_faces, face_origin), body) in sources.into_iter().zip(prepared) {- let Some(e) = self.ex.get(item) else { continue };- match body {- Ok((body, missing)) => {- let own = e.params().first().and_then(Param::as_str).unwrap_or("").trim().to_string();- let name = if own.is_empty() { product.to_string() } else { own };- // Faces the mesher gives up on (or that the budget cut short) are reported.- if self.unmeshed_checked.insert(item) && missing > 0 {- self.warn(format!("solid '{name}': {missing} face(s) could not be meshed and are not shown"));- }- out.push(self.bodies.len());- let color = self.colors.get(&item).copied();- // See-through bodies and faces with colours of their own.- let faces = face_origin- .iter()- .enumerate()- .filter_map(|(i, f)| {- let c = self.colors.get(f)?;- Some(crate::FacePaint { face: i, color: *c, opacity: self.opacity.get(f).copied().unwrap_or(1.0) })- })- .collect();- let paint = crate::Paint { opacity: self.opacity.get(&item).copied().unwrap_or(1.0), faces };- let body = body.with_color(color).with_paint(Some(paint));- let identities = face_origin- .iter()- .map(|face| Some(crate::FaceSource::Imported { item, face: *face, payload_sha256: None, producer: None }))- .collect();- let body = body.with_face_sources(Some(std::sync::Arc::new(identities)));- // A later instance of an item shows its first instance's mesh, placed.- let body = match self.shown.get(&item) {- Some((shared, first)) => body.with_display_of(shared.clone(), to_array(&mat_mul(m, &rigid_inverse(first)))),- None => {- if !self.once.contains(&item) {- self.shown.insert(item, (Arc::new(crate::body::SharedDisplay::new(body.clone())), *m));- }- body- }- };- self.bodies.push(ImportedBody {- name,- body,- color,- path: path.to_vec(),- instance: instance.map(str::to_string),- closed,- file_faces,- source_item: item,- face_origin,- });- }- Err(err) => {- let label = self.label(item);- self.warn(format!("{label}: not imported: {err}"));- }- }+ // The node lists the planned solid; it becomes a body index once converted.+ out.push(self.plan.len());+ self.plan.push(Planned { item, units: u, batch: id });}}"MAPPED_ITEM" => {@@ -742,6 +707,121 @@ impl<'a> Reader<'a> {}}+ /// Bodies made, and planned ones still to convert (the most a failure can leave out).+ fn bodies_so_far(&self) -> usize {+ self.bodies.len() + self.plan.len() - self.converted+ }++ /// Convert the next batch of planned solids into bodies; false once every one is done.+ /// `single`: one solid at a time (the caller wants short steps and has no worker threads).+ fn convert_next(&mut self, single: bool) -> bool {+ if self.converted >= self.plan.len() {+ return false;+ }+ if self.stop() {+ return false;+ }+ let first = self.converted;+ let id = self.plan[first].batch;+ let mut last = first + 1;+ while !single && last < self.plan.len() && self.plan[last].batch == id {+ last += 1;+ }+ self.converted = last;+ let ex = self.ex.clone();+ let mut sources = Vec::new();+ let mut solids = Vec::new();+ for i in first..last {+ let (item, u) = (self.plan[i].item, self.plan[i].units);+ self.made.push(None);+ let Some(entry) = self.item_solid(item, u) else { continue };+ // A one-use item is the only reference to its entry, so the solid moves+ // out; an item whose conversion is cached for a later instance needs its+ // own copy.+ let (solid, closed, file_faces, face_origin) = match Arc::try_unwrap(entry) {+ Ok(entry) => entry,+ Err(shared) => (*shared).clone(),+ };+ sources.push((i, item, closed, file_faces, face_origin));+ solids.push(parallel::Job { solid, check_mesh: !self.unmeshed_checked.contains(&item) });+ }+ let Some(batch) = self.batches.get(id) else { return true };+ let (m, path, product, instance) = (batch.m, batch.path.clone(), batch.product.clone(), batch.instance.clone());+ let prepared = parallel::bodies(&solids, &m, self.workers);+ for ((i, item, closed, file_faces, face_origin), body) in sources.into_iter().zip(prepared) {+ let Some(e) = ex.get(item) else { continue };+ match body {+ Ok((body, missing)) => {+ let own = e.params().first().and_then(Param::as_str).unwrap_or("").trim().to_string();+ let name = if own.is_empty() { product.clone() } else { own };+ // Faces the mesher gives up on (or that the budget cut short) are reported.+ if self.unmeshed_checked.insert(item) && missing > 0 {+ self.warn(format!("solid '{name}': {missing} face(s) could not be meshed and are not shown"));+ }+ if let Some(slot) = self.made.get_mut(i) {+ *slot = Some(self.bodies.len());+ }+ let color = self.colors.get(&item).copied();+ // See-through bodies and faces with colours of their own.+ let faces = face_origin+ .iter()+ .enumerate()+ .filter_map(|(i, f)| {+ let c = self.colors.get(f)?;+ Some(crate::FacePaint { face: i, color: *c, opacity: self.opacity.get(f).copied().unwrap_or(1.0) })+ })+ .collect();+ let paint = crate::Paint { opacity: self.opacity.get(&item).copied().unwrap_or(1.0), faces };+ let body = body.with_color(color).with_paint(Some(paint));+ let identities = face_origin+ .iter()+ .map(|face| Some(crate::FaceSource::Imported { item, face: *face, payload_sha256: None, producer: None }))+ .collect();+ let body = body.with_face_sources(Some(std::sync::Arc::new(identities)));+ // A later instance of an item shows its first instance's mesh, placed.+ let body = match self.shown.get(&item) {+ Some((shared, first)) => body.with_display_of(shared.clone(), to_array(&mat_mul(&m, &rigid_inverse(first)))),+ None => {+ if !self.once.contains(&item) {+ self.shown.insert(item, (Arc::new(crate::body::SharedDisplay::new(body.clone())), m));+ }+ body+ }+ };+ self.bodies.push(ImportedBody {+ name,+ body,+ color,+ path: path.clone(),+ instance: instance.clone(),+ closed,+ file_faces,+ source_item: item,+ face_origin,+ });+ }+ Err(err) => {+ let label = self.label(item);+ self.warn(format!("{label}: not imported: {err}"));+ }+ }+ }+ true+ }++ /// Planned-solid indices (a node's `bodies` after the walk) as body indices, leaving out+ /// the ones that failed.+ fn remap(&self, planned: &[usize]) -> Vec<usize> {+ planned.iter().filter_map(|i| self.made.get(*i).copied().flatten()).collect()+ }++ fn remap_node(&self, n: &mut StepNode) {+ n.bodies = self.remap(&n.bodies);+ for c in &mut n.children {+ self.remap_node(c);+ }+ }+/// The name of an assembly occurrence: the usage's name, else its id.fn occurrence_name(&self, nauo: u64) -> Option<String> {let p = self.ex.get(nauo)?.params();@@ -763,8 +843,9 @@ impl<'a> Reader<'a> {/// Placement of a child occurrence in its parent.fn occurrence_matrix(&mut self, nauo: u64, child_reps: &[u64]) -> mt::Matrix4 {let Some(&rel) = self.placements.get(&nauo) else { return mt::Matrix4::from_scale(1.0) };+ let ex = self.ex.clone();let r = (|| -> R<mt::Matrix4> {- let e = self.ex.get(rel).ok_or("missing placement")?;+ let e = ex.get(rel).ok_or("missing placement")?;let rr = e.record("REPRESENTATION_RELATIONSHIP").ok_or("placement without representations")?;let (r1, r2) =(rr.get(2).and_then(Param::as_ref_id).ok_or("bad placement")?, rr.get(3).and_then(Param::as_ref_id).ok_or("bad placement")?);@@ -773,7 +854,7 @@ impl<'a> Reader<'a> {.and_then(|x| x.first()).and_then(Param::as_ref_id).ok_or("placement without transformation")?;- let ope = self.ex.get(op).ok_or("missing transformation")?;+ let ope = ex.get(op).ok_or("missing transformation")?;let (u1, u2) = (self.units_of(r1), self.units_of(r2));if ope.name() == "ITEM_DEFINED_TRANSFORMATION" {let p = ope.params();@@ -1019,25 +1100,34 @@ const KEEP_SMALL_BYTES: usize = 1 << 20;/// [`step_import`] through a small cache of recent results (keyed by the text). Keep the result/// while the same text is still to be read elsewhere (in the timeline): that read reuses it.pub fn step_import_shared(text: &str) -> Result<std::sync::Arc<StepImport>> {- use std::hash::{Hash, Hasher};- let mut h = std::collections::hash_map::DefaultHasher::new();- text.hash(&mut h);- let key = (h.finish(), text.len());+ let key = text_key(text);if let Ok(cache) = RECENT.lock()&& let Some(imp) = cache.iter().filter(|r| r.key == key).find_map(|r| r.import.upgrade()){return Ok(imp);}let imp = std::sync::Arc::new(step_import(text)?);+ remember(key, &imp, text.len() <= KEEP_SMALL_BYTES);+ Ok(imp)+}++/// The cache key of a STEP text: its hash and length.+fn text_key(text: &str) -> (u64, usize) {+ use std::hash::{Hash, Hasher};+ let mut h = std::collections::hash_map::DefaultHasher::new();+ text.hash(&mut h);+ (h.finish(), text.len())+}++/// Keep `imp` in the recent imports (strongly only when `small`).+fn remember(key: (u64, usize), imp: &Arc<StepImport>, small: bool) {if let Ok(mut cache) = RECENT.lock() {cache.retain(|r| r.key != key && r.import.strong_count() > 0);- let small = (text.len() <= KEEP_SMALL_BYTES).then(|| imp.clone());- cache.push(Recent { key, import: Arc::downgrade(&imp), _small: small });+ cache.push(Recent { key, import: Arc::downgrade(imp), _small: small.then(|| imp.clone()) });while cache.len() > 4 {cache.remove(0);}}- Ok(imp)}/// Imports the cache still holds alive, and how many STEP bytes they came from (tests and@@ -1052,72 +1142,130 @@ pub fn step_import(text: &str) -> Result<StepImport> {}fn step_import_with_workers(text: &str, workers: usize) -> Result<StepImport> {- let watch = crate::watch::current();- let cancelled = || watch.as_ref().is_some_and(|w| w.cancelled());- let ex = match p21::parse(text) {- Ok(ex) => ex,- Err(_) if cancelled() => return Err(crate::watch::cancelled_error("STEP import")),- Err(e) => return Err(KernelError::Invalid(e)),- };- let mut rd = Reader::new(&ex, workers);- rd.solid_items = ex- .entities- .values()- .filter(|e| matches!(e.name(), "MANIFOLD_SOLID_BREP" | "BREP_WITH_VOIDS" | "FACETED_BREP" | "SHELL_BASED_SURFACE_MODEL"))- .count();- rd.watch = watch.clone();- rd.index();- // Roots: product definitions that are nobody's component.- let child_pds: HashSet<u64> =- rd.children.values().flatten().filter_map(|n| ex.get(*n).and_then(|e| e.params().get(4)).and_then(Param::as_ref_id)).collect();- let mut roots: Vec<u64> =- ex.entities.iter().filter(|(id, e)| e.name() == "PRODUCT_DEFINITION" && !child_pds.contains(id)).map(|(id, _)| *id).collect();- roots.sort();- let identity = mt::Matrix4::from_scale(1.0);- let mut tree = Vec::new();- for pd in roots {- let n = rd.node(pd, identity, identity, &[], None, 0, &mut Vec::new());- if !n.bodies.is_empty() || !n.children.is_empty() {- tree.push(n);- }+ let mut reading = StepReading::with_workers(text, workers)?;+ while reading.step() {}+ reading.finish()+}++/// A STEP file being read a piece at a time, for a caller that can't wait for the whole read+/// in one go (the web app, which has one thread and must keep drawing): [`StepReading::new`]+/// parses the file and walks its structure, each [`StepReading::step`] converts the next few+/// solids into bodies, and [`StepReading::finish_shared`] gives the import, cached as+/// [`step_import_shared`] would, so a command reading the same text next finds it read.+pub struct StepReading {+ rd: Reader,+ tree: Vec<StepNode>,+ key: (u64, usize),+ small: bool,+ /// One solid per step (no worker threads to share a batch between).+ single: bool,+}++impl StepReading {+ /// Parse `text` and walk it; the solids are converted by [`Self::step`].+ pub fn new(text: &str) -> Result<StepReading> {+ Self::with_workers(text, parallel::workers())}- // Solids outside any product structure (bare geometry files).- let mut loose: Vec<u64> = rd- .reps- .iter()- .flat_map(|(r, (items, _))| items.iter().map(move |i| (*r, *i)))- .filter(|(_, i)| !rd.used_items.contains(i))- .filter(|(_, i)| {- ex.get(*i).is_some_and(|e| matches!(e.name(), "MANIFOLD_SOLID_BREP" | "BREP_WITH_VOIDS" | "FACETED_BREP" | "SHELL_BASED_SURFACE_MODEL"))- })- .map(|(r, _)| r)- .collect();- loose.sort();- loose.dedup();- if !loose.is_empty() {- let mut bodies = Vec::new();- rd.node_items = rd.used_items.clone();- rd.visits = 0;- for r in loose {- rd.rep_bodies(r, &identity, &[], "Import", None, &mut bodies, 0);++ fn with_workers(text: &str, workers: usize) -> Result<StepReading> {+ let key = text_key(text);+ let watch = crate::watch::current();+ let cancelled = || watch.as_ref().is_some_and(|w| w.cancelled());+ let ex = match p21::parse(text) {+ Ok(ex) => Arc::new(ex),+ Err(_) if cancelled() => return Err(crate::watch::cancelled_error("STEP import")),+ Err(e) => return Err(KernelError::Invalid(e)),+ };+ let mut rd = Reader::new(ex.clone(), workers);+ rd.solid_items = ex+ .entities+ .values()+ .filter(|e| matches!(e.name(), "MANIFOLD_SOLID_BREP" | "BREP_WITH_VOIDS" | "FACETED_BREP" | "SHELL_BASED_SURFACE_MODEL"))+ .count();+ rd.watch = watch.clone();+ rd.index();+ // Roots: product definitions that are nobody's component.+ let child_pds: HashSet<u64> =+ rd.children.values().flatten().filter_map(|n| ex.get(*n).and_then(|e| e.params().get(4)).and_then(Param::as_ref_id)).collect();+ let mut roots: Vec<u64> =+ ex.entities.iter().filter(|(id, e)| e.name() == "PRODUCT_DEFINITION" && !child_pds.contains(id)).map(|(id, _)| *id).collect();+ roots.sort();+ let identity = mt::Matrix4::from_scale(1.0);+ let mut tree = Vec::new();+ for pd in roots {+ tree.push(rd.node(pd, identity, identity, &[], None, 0, &mut Vec::new()));}- if !bodies.is_empty() {+ // Solids outside any product structure (bare geometry files).+ let mut loose: Vec<u64> = rd+ .reps+ .iter()+ .flat_map(|(r, (items, _))| items.iter().map(move |i| (*r, *i)))+ .filter(|(_, i)| !rd.used_items.contains(i))+ .filter(|(_, i)| {+ ex.get(*i)+ .is_some_and(|e| matches!(e.name(), "MANIFOLD_SOLID_BREP" | "BREP_WITH_VOIDS" | "FACETED_BREP" | "SHELL_BASED_SURFACE_MODEL"))+ })+ .map(|(r, _)| r)+ .collect();+ loose.sort();+ loose.dedup();+ if !loose.is_empty() {+ let mut bodies = Vec::new();+ rd.node_items = rd.used_items.clone();+ rd.visits = 0;+ for r in loose {+ rd.rep_bodies(r, &identity, &[], "Import", None, &mut bodies, 0);+ }tree.push(StepNode { name: "Import".into(), transform: to_array(&identity), bodies, children: Vec::new() });}+ let single = workers <= 1;+ Ok(StepReading { rd, tree, key, small: text.len() <= KEEP_SMALL_BYTES, single })+ }++ /// Convert the next solid (or batch of solids); false once all are converted (or the+ /// watch cancelled the import).+ pub fn step(&mut self) -> bool {+ self.rd.convert_next(self.single)}- // Cancelled: what was read so far is dropped here, not cached.- if rd.cancelled || cancelled() {- return Err(crate::watch::cancelled_error("STEP import"));++ /// Solids converted, of the solids to convert.+ pub fn progress(&self) -> (usize, usize) {+ (self.rd.converted, self.rd.plan.len())}- if let Some(first) = ex.duplicates.first() {- rd.warn(format!("{} entity ids are defined twice (first #{first}); the first definitions were used", ex.duplicates.len()));++ /// The import, once [`Self::step`] has converted every solid.+ pub fn finish(mut self) -> Result<StepImport> {+ while self.step() {}+ let rd = &mut self.rd;+ // Cancelled: what was read so far is dropped here, not cached.+ if rd.cancelled || rd.watch.as_ref().is_some_and(|w| w.cancelled()) {+ return Err(crate::watch::cancelled_error("STEP import"));+ }+ let mut tree = std::mem::take(&mut self.tree);+ for n in &mut tree {+ rd.remap_node(n);+ }+ tree.retain(|n| !n.bodies.is_empty() || !n.children.is_empty());+ let ex = rd.ex.clone();+ if let Some(first) = ex.duplicates.first() {+ rd.warn(format!("{} entity ids are defined twice (first #{first}); the first definitions were used", ex.duplicates.len()));+ }+ let warnings: Vec<String> = rd.warnings.iter().map(|(m, n)| if *n > 1 { format!("{m} (×{n})") } else { m.clone() }).collect();+ if rd.bodies.is_empty() {+ let why = warnings.first().cloned().unwrap_or_else(|| "the file has no solids".into());+ return Err(KernelError::Failed(format!("STEP import: no bodies ({why})")));+ }+ let bodies = std::mem::take(&mut rd.bodies);+ Ok(StepImport { bodies, tree, warnings, schema: ex.schemas.join(", "), system: ex.originating_system.clone() })}- let warnings: Vec<String> = rd.warnings.iter().map(|(m, n)| if *n > 1 { format!("{m} (×{n})") } else { m.clone() }).collect();- if rd.bodies.is_empty() {- let why = warnings.first().cloned().unwrap_or_else(|| "the file has no solids".into());- return Err(KernelError::Failed(format!("STEP import: no bodies ({why})")));++ /// [`Self::finish`], and the import is cached for the next read of the same text.+ pub fn finish_shared(self) -> Result<Arc<StepImport>> {+ let (key, small) = (self.key, self.small);+ let imp = Arc::new(self.finish()?);+ remember(key, &imp, small);+ Ok(imp)}- Ok(StepImport { bodies: rd.bodies, tree, warnings, schema: ex.schemas.join(", "), system: ex.originating_system.clone() })}#[cfg(test)]diff --git a/crates/kernel/src/step_in/tests.rs b/crates/kernel/src/step_in/tests.rsindex 1ff99f9361..9bad51c6fd 100644--- a/crates/kernel/src/step_in/tests.rs+++ b/crates/kernel/src/step_in/tests.rs@@ -175,16 +175,19 @@ fn parallel_import_does_not_prepare_past_body_budget_with_duplicates_or_mapped_i"{HEAD}{}#2000=MANIFOLD_SOLID_BREP('Duplicate',#100);\n#2001=MANIFOLD_SOLID_BREP('First',#100);\n#2002=MANIFOLD_SOLID_BREP('Second',#100);\n#2003=MANIFOLD_SOLID_BREP('Beyond budget',#999999);\n#3000=MAPPED_ITEM('',#999998,#999997);\n#60=SHAPE_REPRESENTATION('',(#2000,#2000,#2001,#3000,#2002,#2003),$);\n{TAIL}",cube_entities());- let ex = p21::parse(&text).unwrap();+ let ex = std::sync::Arc::new(p21::parse(&text).unwrap());let seed =step_import_with_workers(&format!("{HEAD}{}#60=SHAPE_REPRESENTATION('',(#101),$);\n{TAIL}", cube_entities()), 1).unwrap().bodies.remove(0);for workers in [1, 8] {- let mut reader = Reader::new(&ex, workers);+ let mut reader = Reader::new(ex.clone(), workers);reader.index();reader.bodies = vec![seed.clone(); MAX_BODIES - 2];reader.node_items.insert(2000);let mut out = Vec::new();reader.rep_bodies(60, &mt::Matrix4::from_scale(1.0), &[], "Budget", None, &mut out, 0);+ assert!(reader.solids.is_empty(), "the walk only plans the solids");+ while reader.convert_next(workers == 1) {}+ let out = reader.remap(&out);assert_eq!(reader.bodies.len(), MAX_BODIES);assert_eq!(out, vec![MAX_BODIES - 2, MAX_BODIES - 1]);assert_eq!(reader.bodies.last().unwrap().name, "Second");@@ -598,8 +601,8 @@ fn repeated_items_are_shared_and_one_use_items_are_not() {let a = box_solid(Vec3::ZERO, Vec3::new(10.0, 10.0, 10.0)).unwrap();let b = box_solid(Vec3::new(20.0, 0.0, 0.0), Vec3::new(30.0, 10.0, 10.0)).unwrap();let flat = step_export(&[&a, &b], "test").unwrap();- let ex = p21::parse(&flat).unwrap();- let mut rd = Reader::new(&ex, 1);+ let ex = std::sync::Arc::new(p21::parse(&flat).unwrap());+ let mut rd = Reader::new(ex.clone(), 1);rd.index();assert_eq!(rd.once.len(), 2, "each solid of a flat file is converted once");let imp = step_import(&flat).unwrap();@@ -609,8 +612,8 @@ fn repeated_items_are_shared_and_one_use_items_are_not() {assert!(rel(vol, 2000.0) < 1e-6, "{vol}");let assembly = two_instance_assembly();- let ex = p21::parse(&assembly).unwrap();- let mut rd = Reader::new(&ex, 1);+ let ex = std::sync::Arc::new(p21::parse(&assembly).unwrap());+ let mut rd = Reader::new(ex.clone(), 1);rd.index();assert!(rd.once.is_empty(), "an assembly may convert an item again for the second instance");let imp = step_import(&assembly).unwrap();diff --git a/crates/ui-egui/src/file_load.rs b/crates/ui-egui/src/file_load.rsindex 7f88cd2aaa..1beeac50c7 100644--- a/crates/ui-egui/src/file_load.rs+++ b/crates/ui-egui/src/file_load.rs@@ -95,6 +95,41 @@ struct Running {partial_rx: Option<Receiver<(egui::ColorImage, usize)>>,/// The picture shown is of the first this many features (`None`: the saved preview).built: Option<usize>,+ /// A STEP file read a piece per frame on this thread (the web app), instead of on a worker.+ staged: Option<Staged>,+}++/// A STEP import done a piece per frame, for the web app: it has one thread, which must keep+/// drawing (and offer Cancel) while a large file comes in. The file is parsed in one frame,+/// then its solids are converted a few at a time, each frame for about [`STAGED_FRAME_MS`];+/// the import is then cached, and the command that inserts or opens the file finds it read.+struct Staged {+ tx: Sender<Job>,+ session: Option<Session>,+ command: &'static str,+ params: Value,+ reading: Option<solidcraft_engine::kernel::StepReading>,+ /// The command's result once it has run; then the bodies' meshes are made, a few a frame,+ /// so the first frame that draws the design doesn't make them all at once.+ ran: Option<Value>,+ /// Bodies meshed so far, and their triangles.+ warmed: usize,+ triangles: usize,+ /// The overlay has been drawn once (the first frame does no work, so it shows at once).+ shown: bool,+}++/// Designs up to this many triangles get a thumbnail (a picture of more takes a while).+const STAGED_THUMBNAIL_TRIANGLES: usize = 1_000_000;++/// How long a frame spends on a staged STEP import.+const STAGED_FRAME_MS: f64 = 30.0;++/// Files read in stages: STEP (not IGES, which is first restated as STEP) to insert or open.+#[cfg_attr(not(target_arch = "wasm32"), allow(dead_code))]+fn staged_kind(request: &Request) -> bool {+ let p = &request.path;+ matches!(request.kind, Kind::Insert | Kind::Open) && solidcraft_engine::io::is_step_path(p) && !solidcraft_engine::io::is_iges_path(p)}impl Running {@@ -147,6 +182,11 @@ pub fn begin(app: &mut SolveApp, path: &str, insert: bool) {pub fn begin_request(app: &mut SolveApp, request: Request) -> Result<(), String> {#[cfg(target_arch = "wasm32")]{+ if staged_kind(&request) {+ app.file_load.queued.push_back(request);+ start_staged(app);+ return Ok(());+ }let r = match &request.kind {Kind::Insert => {app.insert_path(&request.path);@@ -332,6 +372,7 @@ fn start(app: &mut SolveApp) {preview: None,partial_rx,built: None,+ staged: None,})}Err(e) => {@@ -342,6 +383,139 @@ fn start(app: &mut SolveApp) {}}+/// Start the next queued STEP file as a [`Staged`] import (see [`step_staged`]).+#[cfg_attr(not(target_arch = "wasm32"), allow(dead_code))]+fn start_staged(app: &mut SolveApp) {+ if app.file_load.running.is_some() {+ return;+ }+ let Some(request) = app.file_load.queued.pop_front() else { return };+ let insert = request.insert();+ let before = if insert { app.session.world_state().bodies.iter().map(|b| b.name.clone()).collect() } else { Vec::new() };+ let mut session = if insert { app.session.scratch() } else { Session::default() };+ if insert {+ session.selection = app.session.selection.clone();+ }+ let (command, params) = request.command();+ let (tx, rx) = std::sync::mpsc::channel();+ let progress = Arc::new(Progress::default());+ #[cfg(test)]+ if let Some(i) = app.file_load.hold_at.take() {+ progress.hold_at(i);+ }+ app.file_load.running = Some(Running {+ base: app.session.doc.clone(),+ base_revision: app.session.revision,+ before,+ rx,+ phase: Arc::new(AtomicU8::new(0)),+ progress,+ preview_rx: None,+ preview: None,+ partial_rx: None,+ built: None,+ staged: Some(Staged { tx, session: Some(session), command, params, reading: None, ran: None, warmed: 0, triangles: 0, shown: false }),+ request,+ });+}++/// One frame of a staged STEP import: parse the file, or convert solids for a frame's worth of+/// time, or, once every solid is in, run the command (which finds the file read) and hand its+/// result to [`tick`] as a worker would.+fn step_staged(running: &mut Running) {+ let Some(staged) = running.staged.as_mut() else { return };+ let progress = running.progress.clone();+ let scope = running.request.scope.clone();+ let path = running.request.path.clone();+ let send = |staged: &mut Staged, job: Job| {+ let _ = staged.tx.send(job);+ staged.session = None;+ staged.reading = None;+ };+ if staged.session.is_none() {+ return;+ }+ if progress.is_cancelled() {+ send(staged, Err("file operation cancelled".into()));+ return;+ }+ if !staged.shown {+ staged.shown = true;+ return;+ }+ let began = web_time::Instant::now();+ let in_budget = || began.elapsed().as_secs_f64() * 1000.0 < STAGED_FRAME_MS;+ if staged.ran.is_some() {+ let Some(session) = staged.session.as_ref() else { return };+ let world = session.world_state();+ while staged.warmed < world.bodies.len() && in_budget() {+ if let Some(body) = world.bodies.get(staged.warmed) {+ staged.triangles += body.mesh().triangles.len();+ }+ staged.warmed += 1;+ }+ if staged.warmed < world.bodies.len() {+ return;+ }+ let (Some(session), Some(result)) = (staged.session.take(), staged.ran.take()) else { return };+ let thumbnail = staged.command == "doc.open" && staged.triangles <= STAGED_THUMBNAIL_TRIANGLES;+ let image = if thumbnail { crate::home::remember(&session) } else { None };+ send(staged, Ok(Made { session, result, image }));+ return;+ }+ let Some(reading) = staged.reading.as_mut() else {+ // Parse and walk the file. The reading keeps the watch: its steps report progress and+ // stop on Cancel.+ let read = solidcraft_engine::io::vfs::scoped(scope, || {+ let bytes = solidcraft_engine::io::vfs::read(&path, solidcraft_engine::io::MAX_STEP_BYTES).map_err(|e| format!("{path}: {e}"))?;+ // The same text the import command makes of the bytes, so it finds this reading.+ let text = String::from_utf8_lossy(&bytes).into_owned();+ solidcraft_engine::doc::progress::watch(progress.clone(), || solidcraft_engine::kernel::StepReading::new(&text))+ .map_err(|e| format!("{path}: {e}"))+ });+ match read {+ Ok(reading) => staged.reading = Some(reading),+ Err(e) => send(staged, Err(e)),+ }+ return;+ };+ while in_budget() {+ if !reading.step() {+ break;+ }+ }+ let (done, total) = reading.progress();+ if done < total && !progress.is_cancelled() {+ return;+ }+ let Some(reading) = staged.reading.take() else { return };+ // Held until the command has read the file from the cache.+ let import = reading.finish_shared();+ let import = match import {+ _ if progress.is_cancelled() => Err("file operation cancelled".to_string()),+ Ok(import) => Ok(import),+ Err(e) => Err(format!("{path}: {e}")),+ };+ let (Some(mut session), Ok(import)) = (staged.session.take(), import.clone()) else {+ send(staged, Err(import.err().unwrap_or_else(|| "file operation cancelled".into())));+ return;+ };+ let (command, params) = (staged.command, staged.params.clone());+ let result = solidcraft_engine::io::vfs::scoped(running.request.scope.clone(), || {+ solidcraft_engine::doc::progress::watch(progress.clone(), || session.execute(command, ¶ms))+ });+ drop(import);+ match result {+ Ok(result) => {+ // Next frames: the meshes ("Preparing the view").+ running.phase.store(1, Ordering::Relaxed);+ staged.session = Some(session);+ staged.ran = Some(result);+ }+ Err(e) => send(staged, Err(e.to_string())),+ }+}+/// A small picture of the bodies built so far (their display meshes, made here and kept for/// the finished model), or `None` when there is nothing to show yet, too much to draw, or the/// load ended meanwhile (`stop`).@@ -520,6 +694,9 @@ fn compute(}pub fn tick(app: &mut SolveApp, ctx: &egui::Context) {+ if let Some(running) = &mut app.file_load.running {+ step_staged(running);+ }if let Some(running) = &mut app.file_load.running {if !running.cancelled() && running.matches(&app.session) {if let Some(image) = running.preview_rx.as_ref().and_then(|rx| rx.try_recv().ok()) {@@ -598,6 +775,8 @@ pub fn tick(app: &mut SolveApp, ctx: &egui::Context) {}#[cfg(not(target_arch = "wasm32"))]start(app);+ #[cfg(target_arch = "wasm32")]+ start_staged(app);if app.file_load.busy() {ctx.request_repaint_after(std::time::Duration::from_millis(16));}@@ -746,6 +925,7 @@ mod tests {preview: None,partial_rx: None,built: None,+ staged: None,});if change_document {app.session.execute("file.new", &serde_json::json!({"name":"Newer design"})).unwrap();@@ -810,6 +990,7 @@ mod tests {preview: None,partial_rx: None,built: None,+ staged: None,});tick(&mut app, &egui::Context::default());assert!(Arc::ptr_eq(&app.session.doc, &old));@@ -835,6 +1016,7 @@ mod tests {preview: None,partial_rx: None,built: None,+ staged: None,});assert!(!app.file_load.busy());assert!(app.file_load.running.is_some());@@ -845,4 +1027,61 @@ mod tests {assert!(app.file_load.running.is_none());assert!(Arc::ptr_eq(&old, &app.session.doc));}++ /// #1376: the web app reads a STEP file a piece per frame. The first frame only shows the+ /// overlay, the next parses, and the solids follow, frame by frame, until the insert+ /// lands as a worker's would; Cancel between frames leaves the design as it was.+ #[test]+ fn a_staged_step_import_lands_over_frames_and_cancels_between_them() {+ let dir = std::env::temp_dir().join(format!("solidcraft-staged-step-{}", std::process::id()));+ std::fs::create_dir_all(&dir).unwrap();+ let path = dir.join("boxes.step").to_string_lossy().into_owned();+ let mut part = Session::default();+ for i in 0..6 {+ part.execute("solid.box", &serde_json::json!({"length": 10, "width": 10, "height": 10, "corner": [i * 20, 0, 0]})).unwrap();+ }+ part.execute("file.export", &serde_json::json!({"path": path})).unwrap();+ let ctx = egui::Context::default();+ let mut app = SolveApp::new(Session::default(), Default::default());+ let bodies = |app: &SolveApp| app.session.world_state().bodies.len();+ assert!(staged_kind(&Request::new(&path, Kind::Insert)) && staged_kind(&Request::new(&path, Kind::Open)));+ assert!(!staged_kind(&Request::new("part.igs", Kind::Insert)) && !staged_kind(&Request::new("part.solidcraft", Kind::Open)));+ app.file_load.queued.push_back(Request::new(&path, Kind::Insert));+ start_staged(&mut app);+ tick(&mut app, &ctx);+ assert!(app.file_load.busy() && bodies(&app) == 0, "the first frame only shows the overlay");+ tick(&mut app, &ctx);+ let reading = app.file_load.running.as_ref().and_then(|r| r.staged.as_ref()).is_some_and(|s| s.reading.is_some());+ assert!(reading, "the next frame parses the file");+ let mut frames = 2;+ while app.file_load.running.is_some() && frames < 1000 {+ tick(&mut app, &ctx);+ frames += 1;+ }+ assert_eq!(bodies(&app), 6, "{:?}", app.status);+ assert!(app.status.as_ref().is_some_and(|s| s.0.contains("Insert done")), "{:?}", app.status);+ // Cancelled after the parse: nothing is inserted, and nothing waits.+ let before = app.session.doc.clone();+ app.file_load.queued.push_back(Request::new(&path, Kind::Insert));+ start_staged(&mut app);+ tick(&mut app, &ctx);+ tick(&mut app, &ctx);+ app.file_load.cancel();+ tick(&mut app, &ctx);+ assert!(app.file_load.running.is_none() && !app.file_load.busy());+ assert!(Arc::ptr_eq(&before, &app.session.doc));+ assert_eq!(bodies(&app), 6);+ // A file that isn't STEP fails like the worker's would, and the design stays.+ let junk = dir.join("junk.step").to_string_lossy().into_owned();+ std::fs::write(&junk, "not a step file").unwrap();+ app.file_load.queued.push_back(Request::new(&junk, Kind::Insert));+ start_staged(&mut app);+ for _ in 0..4 {+ tick(&mut app, &ctx);+ }+ assert!(app.file_load.running.is_none());+ assert!(app.status.as_ref().is_some_and(|s| s.2 && s.0.contains("junk.step")), "{:?}", app.status);+ assert!(Arc::ptr_eq(&before, &app.session.doc));+ let _ = std::fs::remove_dir_all(&dir);+ }}