3MF export: a component's bodies as one object with parts (#8139) (#8187)

* claim: #8139

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_019FAWPuFoh9qxn2uS2j53QZ

* 3MF export: a component's bodies as one object with parts (#8139)

file.export and file.save_mesh wrote every body as its own 3MF object and
build item, so a slicer loaded a multi-body part as separate objects and
could arrange them apart on the bed. With objects: "component", each placed
component that holds two or more bodies is written as one object whose
<components> are its bodies' meshes, built once, so PrusaSlicer, OrcaSlicer,
Bambu Studio and Cura load it as one object with a part per body, each of
which can take its own filament. The design's own bodies, and a component
with a single body, stay objects of their own. The default (objects: "body")
writes the same file as before.

- io: model_xml_parts and write_3mf_parts write the parts; export_with_parts
  maps body names to them. model_xml_with and export_with_quality give the
  same output as before.
- engine: mesh_parts reads `objects` (component is refused for formats
  other than 3MF); component_parts groups the placed bodies by placement,
  each part named after its occurrence (Bracket:1, Bracket:2).
- file.save_mesh passes the parts on when it also sends the file to a slicer;
  file.send_to_slicer's own folder export is unchanged.

Fixes #8139.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_019FAWPuFoh9qxn2uS2j53QZ

---------

Co-authored-by: Claude <noreply@anthropic.com>
This commit is contained in:
austin62jakeandClaude Opus 5.5 authored and GitHub committed 2026-10-29 03:35:38 +00:00
1 parent 40ff251e5f
commit d8d22cd52a
5 files changed
+215 -12

No files matched your search

+112 -7
View File
@@ -56,12 +56,12 @@ pub static COMMANDS: &[CommandSpec] = &[
CommandSpec::new("file.export", "Export", export)
.icon("export")
.noundo()
.params("path; format?: stl|stla|obj|step|3mf|3mf-tagged|urdf|json (default from extension; 3mf-tagged: 3MF whose triangles carry their B-rep face, at full precision, for meshing and analysis tools; docs/formats/3mf-face-tags.md; obj: the colours of the bodies go in a material library (`.mtl`) written next to the mesh file; urdf: the whole assembly as a robot, with STL meshes written next to it; docs/urdf.md); bodies?: [names] (JSON and URDF export the complete design); urdf only: mesh_prefix? (before each mesh file name, e.g. package://robot/meshes/), effort? (default 1000), velocity? (default 10); quality?: standard|fine|finest (STL, OBJ and 3MF: how closely the mesh follows curved faces, a chord tolerance of 2e-4, 5e-5 or 1e-5 of each body's size; default standard)"),
.params("path; format?: stl|stla|obj|step|3mf|3mf-tagged|urdf|json (default from extension; 3mf-tagged: 3MF whose triangles carry their B-rep face, at full precision, for meshing and analysis tools; docs/formats/3mf-face-tags.md; obj: the colours of the bodies go in a material library (`.mtl`) written next to the mesh file; urdf: the whole assembly as a robot, with STL meshes written next to it; docs/urdf.md); bodies?: [names] (JSON and URDF export the complete design); urdf only: mesh_prefix? (before each mesh file name, e.g. package://robot/meshes/), effort? (default 1000), velocity? (default 10); quality?: standard|fine|finest (STL, OBJ and 3MF: how closely the mesh follows curved faces, a chord tolerance of 2e-4, 5e-5 or 1e-5 of each body's size; default standard); objects?: body|component (3MF only: one object per body, the default, or one object for each placed component with two or more bodies, with those bodies as its parts, so a slicer loads them as one object with parts)"),
CommandSpec::new("file.save_mesh", "Save As Mesh", save_mesh)
.at("INSERT", "FILES")
.icon("mesh_export")
.noundo()
.params("path; format?: stl|3mf|3mf-tagged (default from the extension, else stl; 3mf-tagged: docs/formats/3mf-face-tags.md); bodies?: [names] (default: all); ascii?: bool (STL); slicer?: id or name from file.slicers, the program path it lists, or a program the user added under Custom… (send the saved file there, through the same steps as file.send_to_slicer: a slicer that has to be started first is waited for; may be deprecated later in favour of file.send_to_slicer or a Send to App workflow, kept for scripts); single_instance?: bool (default true; see file.send_to_slicer); quality?: standard|fine|finest (STL, OBJ and 3MF: how closely the mesh follows curved faces, a chord tolerance of 2e-4, 5e-5 or 1e-5 of each body's size; default standard)"),
.params("path; format?: stl|3mf|3mf-tagged (default from the extension, else stl; 3mf-tagged: docs/formats/3mf-face-tags.md); bodies?: [names] (default: all); ascii?: bool (STL); slicer?: id or name from file.slicers, the program path it lists, or a program the user added under Custom… (send the saved file there, through the same steps as file.send_to_slicer: a slicer that has to be started first is waited for; may be deprecated later in favour of file.send_to_slicer or a Send to App workflow, kept for scripts); single_instance?: bool (default true; see file.send_to_slicer); quality?: standard|fine|finest (STL, OBJ and 3MF: how closely the mesh follows curved faces, a chord tolerance of 2e-4, 5e-5 or 1e-5 of each body's size; default standard); objects?: body|component (3MF only: one object per body, the default, or one object for each placed component with two or more bodies, with those bodies as its parts, so a slicer loads them as one object with parts)"),
CommandSpec::new("file.send_to_slicer", "Send to Slicer", send_to_slicer)
.enabled(starts_programs)
.at("INSERT", "FILES")
@@ -618,7 +618,52 @@ fn mesh_quality(p: &Value, cmd: &str) -> Result<solidcraft_io::MeshQuality> {
}
}
fn export_to(s: &Session, path: &str, format: Format, bodies: &[String], quality: solidcraft_io::MeshQuality) -> Result<Value> {
/// The 3MF parts a mesh export's `objects` asks for (#8139): none for `body` (the default, one
/// object per body), or for `component` one part per placement of a component with two or more
/// bodies ([`component_parts`]). Other formats have no parts, so `component` is refused there.
pub(super) fn mesh_parts(s: &Session, p: &Value, cmd: &str, format: Format) -> Result<Vec<(String, Vec<String>)>> {
match p.get("objects") {
None | Some(Value::Null) => Ok(Vec::new()),
Some(v) => match v.as_str() {
Some("body") => Ok(Vec::new()),
Some("component") if matches!(format, Format::ThreeMf | Format::ThreeMfTagged) => Ok(component_parts(s)),
Some("component") => Err(bad(cmd, "`objects: component` is for 3MF: other formats have no parts")),
_ => Err(bad(cmd, format!("`objects` must be body or component, not {v}"))),
},
}
}
/// Each placement of a component that holds two or more bodies, by its occurrence's name, with
/// the names its bodies have where they are placed (as the export names them). The design's own
/// bodies and a component's single body are left out: they stay objects of their own.
fn component_parts(s: &Session) -> Vec<(String, Vec<String>)> {
let doc = &s.doc;
if doc.occurrences.is_empty() {
return Vec::new();
}
let st = s.model.state();
let owners = doc.model_body_components(&st);
let names = solidcraft_doc::WorldNames::new(doc, &st);
doc.placements()
.into_iter()
.filter(|(comp, _, _)| *comp != 0)
.filter_map(|(comp, path, _)| {
let bodies: Vec<String> =
st.bodies.iter().zip(&owners).filter(|(_, owner)| **owner == comp).map(|(b, _)| names.name(&b.name, comp, &path)).collect();
let name = path.last().and_then(|id| doc.occurrences.iter().find(|o| o.id == *id)).map(|o| o.name.clone()).unwrap_or_default();
(bodies.len() >= 2).then_some((name, bodies))
})
.collect()
}
fn export_to(
s: &Session,
path: &str,
format: Format,
bodies: &[String],
parts: &[(String, Vec<String>)],
quality: solidcraft_io::MeshQuality,
) -> Result<Value> {
if format == Format::Obj {
// The colours of the bodies go in a material library beside the mesh file.
return export_obj(s, path, bodies, quality);
@@ -635,7 +680,7 @@ fn export_to(s: &Session, path: &str, format: Format, bodies: &[String], quality
} else {
// Bodies carry the colour they are shown in (appearance, material or imported), and the
// file the design's properties where the format has a place for them.
solidcraft_io::export_with_quality(&s.doc.painted(&s.world_state()), bodies, format, &name, &s.doc.metadata, quality)?
solidcraft_io::export_with_parts(&s.doc.painted(&s.world_state()), bodies, parts, format, &name, &s.doc.metadata, quality)?
};
solidcraft_io::vfs::write(path, &bytes).map_err(|e| EngineError::Other(format!("{path}: {e}")))?;
Ok(json!({"path": path, "bytes": bytes.len(), "format": format!("{format:?}")}))
@@ -649,7 +694,8 @@ fn export(s: &mut Session, p: &Value) -> Result<Value> {
return export_urdf(s, path, p);
}
let quality = mesh_quality(p, cmd)?;
export_to(s, path, format, &string_list(cmd, p, "bodies")?, quality)
let parts = mesh_parts(s, p, cmd, format)?;
export_to(s, path, format, &string_list(cmd, p, "bodies")?, &parts, quality)
}
/// The OBJ export: the mesh file and the material library beside it, with the colours of the
@@ -755,10 +801,11 @@ fn save_mesh(s: &mut Session, p: &Value) -> Result<Value> {
// and may be deprecated later in favour of `file.send_to_slicer` or a Send to App workflow; that is
// a possibility, not a plan.
let quality = mesh_quality(p, cmd)?;
let parts = mesh_parts(s, p, cmd, format)?;
if let Some(spec) = str_(p, "slicer") {
#[cfg(target_arch = "wasm32")]
{
let _ = spec;
let _ = (spec, parts);
return Err(bad(cmd, "a slicer can't be started from the browser"));
}
#[cfg(not(target_arch = "wasm32"))]
@@ -769,6 +816,7 @@ fn save_mesh(s: &mut Session, p: &Value) -> Result<Value> {
kind: crate::slicers::TargetKind::Slicer,
spec,
bodies: string_list(cmd, p, "bodies")?,
parts,
format,
quality,
dest: send::Dest::Path(path),
@@ -777,7 +825,7 @@ fn save_mesh(s: &mut Session, p: &Value) -> Result<Value> {
},
);
}
export_to(s, path, format, &string_list(cmd, p, "bodies")?, quality)
export_to(s, path, format, &string_list(cmd, p, "bodies")?, &parts, quality)
}
/// The browser build can't start a program.
@@ -811,6 +859,7 @@ fn send_to_slicer(s: &mut Session, p: &Value) -> Result<Value> {
kind: crate::slicers::TargetKind::Slicer,
spec,
bodies: string_list(cmd, p, "bodies")?,
parts: Vec::new(),
format,
quality: Default::default(),
dest: send::Dest::Folder,
@@ -883,6 +932,62 @@ mod urdf_tests;
mod tests {
use super::*;
/// #8139: with `objects: "component"` a 3MF has one object for each placement of a component
/// with two or more bodies, its bodies the object's parts; the design's own bodies stay objects
/// of their own. The default (and `objects: "body"`) is one object per body, as before. Read
/// back, an object with parts is one mesh with all its parts' triangles.
#[test]
fn a_components_bodies_export_to_3mf_as_one_object_with_parts() {
let dir = std::env::temp_dir().join(format!("solidcraft-3mf-parts-{}", std::process::id()));
std::fs::create_dir_all(&dir).unwrap();
let path = |n: &str| dir.join(n).to_string_lossy().to_string();
let read = |p: &str| -> Vec<(String, usize)> {
let (objects, warnings) = solidcraft_io::read_3mf(&std::fs::read(p).unwrap()).unwrap();
assert!(warnings.is_empty(), "{warnings:?}");
objects.iter().map(|o| (o.name.clone(), o.triangles.len())).collect()
};
let mut s = Session::default();
s.execute("solid.box", &json!({"length": 10, "width": 10, "height": 10, "corner": [-30, 0, 0], "body_name": "Loose"})).unwrap();
s.execute("component.create", &json!({"name": "Bracket"})).unwrap();
s.execute("solid.box", &json!({"length": 20, "width": 20, "height": 10, "body_name": "Base"})).unwrap();
s.execute("solid.cylinder", &json!({"radius": 5, "height": 10, "base": [10, 10, 10], "operation": "new", "body_name": "Boss"})).unwrap();
s.execute("component.activate", &json!({"component": "root"})).unwrap();
s.execute("file.export", &json!({"path": path("bodies.3mf")})).unwrap();
let bodies = read(&path("bodies.3mf"));
assert_eq!(bodies.len(), 3, "one object per body: {bodies:?}");
s.execute("file.export", &json!({"path": path("body.3mf"), "objects": "body"})).unwrap();
assert_eq!(read(&path("body.3mf")), bodies);
let loose = bodies.iter().find(|(n, _)| n == "Loose").map(|(_, t)| *t).unwrap_or(0);
let bracket: usize = bodies.iter().filter(|(n, _)| n != "Loose").map(|(_, t)| t).sum();
s.execute("file.export", &json!({"path": path("parts.3mf"), "objects": "component"})).unwrap();
let parts = read(&path("parts.3mf"));
assert_eq!(parts, [("Loose".to_string(), loose), ("Bracket:1".to_string(), bracket)], "{bodies:?}");
s.execute("file.save_mesh", &json!({"path": path("saved.3mf"), "objects": "component"})).unwrap();
assert_eq!(read(&path("saved.3mf")), parts);
s.execute("file.export", &json!({"path": path("tagged.3mf"), "format": "3mf-tagged", "objects": "component"})).unwrap();
assert_eq!(read(&path("tagged.3mf")), parts);
// Placed again, each placement is an object of its own.
s.execute("occurrence.copy", &json!({"component": "Bracket", "translate": [0, 40, 0]})).unwrap();
s.execute("file.export", &json!({"path": path("two.3mf"), "objects": "component"})).unwrap();
let two = read(&path("two.3mf"));
assert_eq!(two, [("Loose".to_string(), loose), ("Bracket:1".to_string(), bracket), ("Bracket:2".to_string(), bracket)]);
// Other formats have no parts, and `objects` is body or component.
let e = s.execute("file.export", &json!({"path": path("parts.stl"), "objects": "component"})).unwrap_err().to_string();
assert!(e.contains("`objects: component` is for 3MF"), "{e}");
let e = s.execute("file.save_mesh", &json!({"path": path("parts.stl"), "objects": "component"})).unwrap_err().to_string();
assert!(e.contains("`objects: component` is for 3MF"), "{e}");
for bad in [json!("parts"), json!(true), json!(2)] {
let e = s.execute("file.export", &json!({"path": path("bad.3mf"), "objects": bad})).unwrap_err().to_string();
assert!(e.contains("`objects` must be body or component"), "{bad}: {e}");
}
assert!(!std::path::Path::new(&path("parts.stl")).exists() && !std::path::Path::new(&path("bad.3mf")).exists());
let _ = std::fs::remove_dir_all(&dir);
}
/// #4747: a mesh export's `quality` follows curved faces more closely. A 3 mm hole in a
/// 200 mm plate gets more triangles at fine and more again at finest, in STL and 3MF alike
/// (Save As Mesh too); standard is what the export always gave; anything else is refused.
+3 -1
View File
@@ -53,6 +53,8 @@ pub(super) struct Send<'a> {
/// The target as the caller named it: an id, a name, or a program path.
pub spec: &'a str,
pub bodies: Vec<String>,
/// 3MF objects with parts (`objects: "component"`, #8139). Only for [`Dest::Path`].
pub parts: Vec<(String, Vec<String>)>,
pub format: Format,
/// Only for [`Dest::Path`]; the slicer folder's file is always standard.
pub quality: solidcraft_io::MeshQuality,
@@ -79,7 +81,7 @@ pub(super) fn send(s: &mut Session, r: Send<'_>) -> Result<Value> {
return Err(bad(r.cmd, format!("{} does not take {}", target.name, format_name(r.format))));
}
let mut out = match r.dest {
Dest::Path(path) => export_to(s, path, r.format, &r.bodies, r.quality)?,
Dest::Path(path) => export_to(s, path, r.format, &r.bodies, &r.parts, r.quality)?,
Dest::Folder => write_in_folder(s, &r)?,
};
let path = out.get("path").and_then(Value::as_str).unwrap_or_default().to_string();
+21 -2
View File
@@ -48,7 +48,9 @@ mod gltf_in;
pub use gltf_in::{GltfImport, Loader, MAX_GLTF_BYTES, MeshPlan, PlanPlace, glb_container, is_gltf_path, read_gltf};
mod obj;
pub use obj::read_obj;
pub use threemf::{MAX_3MF_BYTES, MeshObject, model_xml, model_xml_with, read_3mf, weld, write_3mf, write_3mf_with};
pub use threemf::{
MAX_3MF_BYTES, MeshObject, model_xml, model_xml_parts, model_xml_with, read_3mf, weld, write_3mf, write_3mf_parts, write_3mf_with,
};
pub use urdf::{UrdfOptions, UrdfPackage, urdf};
use solidcraft_doc::{Document, Metadata, ModelState};
@@ -682,6 +684,21 @@ pub fn export_with_quality(
name: &str,
meta: &Metadata,
quality: MeshQuality,
) -> Result<Vec<u8>> {
export_with_parts(state, bodies, &[], format, name, meta, quality)
}
/// [`export_with_quality`], and in 3MF each of `parts` (a name and the names of its bodies)
/// written as one object with those bodies as its parts ([`model_xml_parts`], #8139).
/// Bodies of a part that are not exported are left out of it. Other formats have no parts.
pub fn export_with_parts(
state: &ModelState,
bodies: &[String],
parts: &[(String, Vec<String>)],
format: Format,
name: &str,
meta: &Metadata,
quality: MeshQuality,
) -> Result<Vec<u8>> {
let sel = selected(state, bodies)?;
Ok(match format {
@@ -716,7 +733,9 @@ pub fn export_with_quality(
}
Format::ThreeMf | Format::ThreeMfTagged => {
let objs: Vec<MeshObject> = sel.iter().map(|b| mesh_object(b, format == Format::ThreeMfTagged, quality)).collect::<Result<_>>()?;
write_3mf_with(&objs, &threemf_metadata(meta))?
let index = |n: &String| sel.iter().position(|b| &b.name == n);
let parts: Vec<(String, Vec<usize>)> = parts.iter().map(|(p, names)| (p.clone(), names.iter().filter_map(index).collect())).collect();
write_3mf_parts(&objs, &parts, &threemf_metadata(meta))?
}
Format::Design => return Err(IoError::Format("sc (save the document instead)".into())),
Format::Urdf => return Err(IoError::Format("urdf (an assembly package; use file.export)".into())),
+72 -2
View File
@@ -251,6 +251,15 @@ pub fn model_xml(objects: &[MeshObject]) -> String {
/// The model part's XML with model metadata after `Application`: (3MF metadata name, such as
/// `Title` or `Designer`, and its text).
pub fn model_xml_with(objects: &[MeshObject], metadata: &[(&str, &str)]) -> String {
model_xml_parts(objects, &[], metadata)
}
/// [`model_xml_with`], with `parts`: each a name and the indices of two or more `objects` written
/// as one object whose `<components>` are their meshes, built once, so a slicer loads them as
/// one object with parts (#8139). An index out of range or already in an earlier part is left
/// out of it, and a part left with fewer than two objects is not made: those objects are built
/// on their own, as every object not in a part is.
pub fn model_xml_parts(objects: &[MeshObject], parts: &[(String, Vec<usize>)], metadata: &[(&str, &str)]) -> String {
let mut x = String::new();
x.push_str("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
let ft = if objects.iter().any(MeshObject::tagged) { format!(" xmlns:ft=\"{FACE_TAGS_NS}\"") } else { String::new() };
@@ -314,10 +323,37 @@ pub fn model_xml_with(objects: &[MeshObject], metadata: &[(&str, &str)]) -> Stri
}
x.push_str(" </triangles>\n </mesh>\n </object>\n");
}
// Each part an object after the meshes it names (a component refers back), built in their
// place; the meshes in it are not built on their own.
let mut in_part = vec![false; objects.len()];
let mut built: Vec<usize> = Vec::new();
for (name, members) in parts {
let mut kept: Vec<usize> = Vec::new();
for &k in members {
if k < objects.len() && !in_part[k] && !kept.contains(&k) {
kept.push(k);
}
}
if kept.len() < 2 {
continue;
}
let id = objects.len() + 2 + built.len();
let _ = writeln!(x, " <object id=\"{id}\" type=\"model\" name=\"{}\">", esc(name));
x.push_str(" <components>\n");
for &k in &kept {
in_part[k] = true;
let _ = writeln!(x, " <component objectid=\"{}\"/>", k + 2);
}
x.push_str(" </components>\n </object>\n");
built.push(id);
}
x.push_str(" </resources>\n <build>\n");
for k in 0..objects.len() {
for k in (0..objects.len()).filter(|&k| !in_part[k]) {
let _ = writeln!(x, " <item objectid=\"{}\"/>", k + 2);
}
for id in built {
let _ = writeln!(x, " <item objectid=\"{id}\"/>");
}
x.push_str(" </build>\n</model>\n");
x
}
@@ -329,6 +365,11 @@ pub fn write_3mf(objects: &[MeshObject]) -> Result<Vec<u8>> {
/// A 3MF package of meshes with model metadata (see [`model_xml_with`]).
pub fn write_3mf_with(objects: &[MeshObject], metadata: &[(&str, &str)]) -> Result<Vec<u8>> {
write_3mf_parts(objects, &[], metadata)
}
/// A 3MF package of meshes, some of them written as objects with parts (see [`model_xml_parts`]).
pub fn write_3mf_parts(objects: &[MeshObject], parts: &[(String, Vec<usize>)], metadata: &[(&str, &str)]) -> Result<Vec<u8>> {
if objects.is_empty() {
return Err(IoError::Empty);
}
@@ -336,7 +377,7 @@ pub fn write_3mf_with(objects: &[MeshObject], metadata: &[(&str, &str)]) -> Resu
let rels = format!(
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<Relationships xmlns=\"http://schemas.openxmlformats.org/package/2006/relationships\">\n <Relationship Target=\"/3D/3dmodel.model\" Id=\"rel0\" Type=\"{MODEL_REL}\"/>\n</Relationships>\n"
);
let model = model_xml_with(objects, metadata);
let model = model_xml_parts(objects, parts, metadata);
let mut zip = zip::ZipWriter::new(Cursor::new(Vec::new()));
for (name, data) in [("[Content_Types].xml", content_types.as_bytes()), ("_rels/.rels", rels.as_bytes()), ("3D/3dmodel.model", model.as_bytes())]
{
@@ -965,6 +1006,35 @@ pub(crate) mod tests {
}
}
/// #8139: objects in a part are written once as meshes and built once, as one object whose
/// components are those meshes; the others are built on their own, as before. Read back, the
/// part is one object named after it, with every triangle of its meshes.
#[test]
fn a_part_is_one_object_whose_components_are_its_meshes() {
let objects = [tetra("Cube"), tetra("Dome"), tetra("Loose")];
let x = model_xml_parts(&objects, &[("Bracket:1".into(), vec![0, 1])], &[]);
assert_eq!(x.matches("<mesh>").count(), 3, "{x}");
assert!(x.contains("<object id=\"5\" type=\"model\" name=\"Bracket:1\">"), "{x}");
assert!(x.contains("<component objectid=\"2\"/>") && x.contains("<component objectid=\"3\"/>"), "{x}");
let build = x.split("<build>").nth(1).unwrap_or_default();
assert_eq!(build.matches("<item ").count(), 2, "{x}");
assert!(build.contains("objectid=\"4\"") && build.contains("objectid=\"5\""), "{x}");
let (read, warnings) = read_3mf(&write_3mf_parts(&objects, &[("Bracket:1".into(), vec![0, 1])], &[]).unwrap()).unwrap();
assert!(warnings.is_empty(), "{warnings:?}");
let names: Vec<&str> = read.iter().map(|o| o.name.as_str()).collect();
assert_eq!(names, ["Loose", "Bracket:1"]);
assert_eq!(read[1].triangles.len(), 8);
// Without parts the file is as before: one built object per mesh.
assert_eq!(model_xml_parts(&objects, &[], &[]), model_xml_with(&objects, &[]));
assert_eq!(model_xml_with(&objects, &[]).split("<build>").nth(1).unwrap_or_default().matches("<item ").count(), 3);
// A part of one object, an index out of range, or one already in a part makes nothing new.
for parts in [vec![("One".to_string(), vec![2])], vec![("Out".to_string(), vec![0, 7])]] {
assert_eq!(model_xml_parts(&objects, &parts, &[]), model_xml_with(&objects, &[]), "{parts:?}");
}
let x = model_xml_parts(&objects, &[("A".into(), vec![0, 1]), ("B".into(), vec![1, 2])], &[]);
assert!(x.contains("name=\"A\"") && !x.contains("name=\"B\""), "{x}");
}
/// A see-through object writes its alpha; triangles of faces with colours of their own
/// point at their entries.
#[test]
+7
View File
@@ -47,6 +47,13 @@ panel, and in the right-click menu of a body) open the same dialog with that for
the selected bodies as STL, 3MF or 3MF with face tags (below) to a file you name, and you can change
the format there.
A 3MF has one object per body, so a slicer arranges the bodies of a multi-body part apart on the
bed. Scripts and the control channel can keep each component together: `file.export` or
`file.save_mesh` with `objects: "component"` writes every placed component that holds two or more
bodies as one 3MF object whose parts are those bodies. PrusaSlicer, OrcaSlicer, Bambu Studio and
Cura then load it as one object with a part per body, and each part can take its own filament. The
design's own bodies, and a component with a single body, stay objects of their own.
**File → Send to Slicer** (also on the Insert tab's Files panel, and in the right-click menu of a
body) is the short way: it saves the selected bodies as a 3MF in millimetres, without face tags,
and sends it to a slicer. It always asks which one and pre-selects the slicer you used last time,