use crate::core::BufferGeometry;
type TriData = (Vec<[f32; 3]>, Option<Vec<[f32; 3]>>, Vec<u32>);
fn tri_data(g: &BufferGeometry) -> Option<TriData> {
let pos = &g.get_attribute("position")?.array;
let verts: Vec<[f32; 3]> = pos.chunks_exact(3).map(|c| [c[0], c[1], c[2]]).collect();
if verts.len() < 3 {
return None;
}
let normals = g
.get_attribute("normal")
.map(|a| {
a.array
.chunks_exact(3)
.map(|c| [c[0], c[1], c[2]])
.collect::<Vec<_>>()
})
.filter(|n: &Vec<[f32; 3]>| n.len() == verts.len());
let indices = g
.index
.clone()
.unwrap_or_else(|| (0..verts.len() as u32).collect());
Some((verts, normals, indices))
}
fn faces(g: &BufferGeometry) -> Vec<Vec<u32>> {
g.faces().collect()
}
pub fn geometry_to_obj(g: &BufferGeometry) -> String {
if tri_data(g).is_none() {
return String::new();
}
let mut s = String::from("# threers OBJ export\n");
s.push_str(&crate::exporters::write_obj(
&[crate::exporters::ExportObject::mesh("model", g.clone())],
&crate::exporters::ObjOptions {
polygons: true,
numbers: crate::exporters::NumberFormat::Float32,
},
));
s
}
pub fn geometry_to_off(g: &BufferGeometry) -> String {
let Some((verts, _, _)) = tri_data(g) else {
return String::from("OFF\n0 0 0\n");
};
let faces = faces(g);
let mut s = format!("OFF\n{} {} 0\n", verts.len(), faces.len());
for v in &verts {
s.push_str(&format!("{} {} {}\n", v[0], v[1], v[2]));
}
for face in &faces {
s.push_str(&face.len().to_string());
for i in face {
s.push_str(&format!(" {i}"));
}
s.push('\n');
}
s
}
pub fn geometry_to_ply(g: &BufferGeometry) -> String {
let bytes = crate::exporters::write_ply(
&[crate::exporters::ExportObject::mesh("model", g.clone())],
&crate::exporters::PlyOptions {
polygons: true,
numbers: crate::exporters::NumberFormat::Float32,
comment: Some("threers PLY export".into()),
..Default::default()
},
);
let bytes = bytes.or_else(|| {
crate::exporters::write_ply(
&[crate::exporters::ExportObject::mesh("model", g.clone())],
&crate::exporters::PlyOptions {
exclude_attributes: vec!["index".into()],
numbers: crate::exporters::NumberFormat::Float32,
comment: Some("threers PLY export".into()),
..Default::default()
},
)
});
String::from_utf8(bytes.unwrap_or_default()).expect("ASCII PLY is UTF-8")
}
pub fn geometry_to_3mf(g: &BufferGeometry) -> Vec<u8> {
let (verts, _, indices) = tri_data(g).unwrap_or_default();
let mut model = String::from(
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n\
<model unit=\"millimeter\" xml:lang=\"en-US\" \
xmlns=\"http://schemas.microsoft.com/3dmanufacturing/core/2015/02\">\n\
<resources><object id=\"1\" type=\"model\"><mesh><vertices>",
);
for v in &verts {
model.push_str(&format!(
"<vertex x=\"{}\" y=\"{}\" z=\"{}\"/>",
v[0], v[1], v[2]
));
}
model.push_str("</vertices><triangles>");
for t in indices.chunks_exact(3) {
model.push_str(&format!(
"<triangle v1=\"{}\" v2=\"{}\" v3=\"{}\"/>",
t[0], t[1], t[2]
));
}
model.push_str(
"</triangles></mesh></object></resources><build><item objectid=\"1\"/></build></model>",
);
let content_types = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n\
<Types xmlns=\"http://schemas.openxmlformats.org/package/2006/content-types\">\
<Default Extension=\"rels\" ContentType=\"application/vnd.openxmlformats-package.relationships+xml\"/>\
<Default Extension=\"model\" ContentType=\"application/vnd.ms-package.3dmanufacturing-3dmodel+xml\"/>\
</Types>";
let rels = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n\
<Relationships xmlns=\"http://schemas.openxmlformats.org/package/2006/relationships\">\
<Relationship Target=\"/3D/3dmodel.model\" Id=\"rel0\" \
Type=\"http://schemas.microsoft.com/3dmanufacturing/2013/01/3dmodel\"/></Relationships>";
let mut zip = Zip::new();
zip.add("[Content_Types].xml", content_types.as_bytes());
zip.add("_rels/.rels", rels.as_bytes());
zip.add("3D/3dmodel.model", model.as_bytes());
zip.finish()
}
pub(crate) struct Zip {
out: Vec<u8>,
dir: Vec<u8>,
count: u16,
}
impl Zip {
pub(crate) fn new() -> Self {
Self {
out: Vec::new(),
dir: Vec::new(),
count: 0,
}
}
pub(crate) fn add(&mut self, name: &str, data: &[u8]) {
let crc = crc32(data);
let (nl, dl) = (name.len() as u16, data.len() as u32);
let offset = self.out.len() as u32;
self.out.extend_from_slice(b"PK\x03\x04");
self.out.extend_from_slice(&[20, 0, 0, 0, 0, 0]); self.out.extend_from_slice(&[0, 0, 0, 0]); self.out.extend_from_slice(&crc.to_le_bytes());
self.out.extend_from_slice(&dl.to_le_bytes());
self.out.extend_from_slice(&dl.to_le_bytes());
self.out.extend_from_slice(&nl.to_le_bytes());
self.out.extend_from_slice(&[0, 0]); self.out.extend_from_slice(name.as_bytes());
self.out.extend_from_slice(data);
self.dir.extend_from_slice(b"PK\x01\x02");
self.dir.extend_from_slice(&[20, 0, 20, 0, 0, 0, 0, 0]); self.dir.extend_from_slice(&[0, 0, 0, 0]); self.dir.extend_from_slice(&crc.to_le_bytes());
self.dir.extend_from_slice(&dl.to_le_bytes());
self.dir.extend_from_slice(&dl.to_le_bytes());
self.dir.extend_from_slice(&nl.to_le_bytes());
self.dir.extend_from_slice(&[0, 0, 0, 0, 0, 0]); self.dir.extend_from_slice(&[0, 0, 0, 0, 0, 0]); self.dir.extend_from_slice(&offset.to_le_bytes());
self.dir.extend_from_slice(name.as_bytes());
self.count += 1;
}
pub(crate) fn finish(mut self) -> Vec<u8> {
let cd_off = self.out.len() as u32;
let cd_size = self.dir.len() as u32;
self.out.extend_from_slice(&self.dir);
self.out.extend_from_slice(b"PK\x05\x06");
self.out.extend_from_slice(&[0, 0, 0, 0]); self.out.extend_from_slice(&self.count.to_le_bytes());
self.out.extend_from_slice(&self.count.to_le_bytes());
self.out.extend_from_slice(&cd_size.to_le_bytes());
self.out.extend_from_slice(&cd_off.to_le_bytes());
self.out.extend_from_slice(&[0, 0]); self.out
}
}
pub(crate) fn crc32(data: &[u8]) -> u32 {
let mut crc = 0xFFFF_FFFFu32;
for &b in data {
crc ^= b as u32;
for _ in 0..8 {
crc = if crc & 1 != 0 {
(crc >> 1) ^ 0xEDB8_8320
} else {
crc >> 1
};
}
}
!crc
}
pub fn geometry_to_glb(g: &BufferGeometry) -> Vec<u8> {
let Some((verts, normals, indices)) = tri_data(g) else {
return Vec::new();
};
let mut bin = Vec::new();
for &i in &indices {
bin.extend_from_slice(&i.to_le_bytes());
}
let idx_len = bin.len();
let pos_off = bin.len();
for v in &verts {
for c in v {
bin.extend_from_slice(&c.to_le_bytes());
}
}
let pos_len = bin.len() - pos_off;
let (nrm_off, nrm_len) = match &normals {
Some(n) => {
let off = bin.len();
for v in n {
for c in v {
bin.extend_from_slice(&c.to_le_bytes());
}
}
(off, bin.len() - off)
}
None => (0, 0),
};
let buf_len = bin.len();
let (mut mn, mut mx) = ([f32::MAX; 3], [f32::MIN; 3]);
for v in &verts {
for k in 0..3 {
mn[k] = mn[k].min(v[k]);
mx[k] = mx[k].max(v[k]);
}
}
let arr = |a: [f32; 3]| format!("[{},{},{}]", a[0], a[1], a[2]);
let mut views = format!(
"{{\"buffer\":0,\"byteOffset\":0,\"byteLength\":{idx_len},\"target\":34963}},\
{{\"buffer\":0,\"byteOffset\":{pos_off},\"byteLength\":{pos_len},\"target\":34962}}"
);
let mut accessors = format!(
"{{\"bufferView\":0,\"componentType\":5125,\"count\":{},\"type\":\"SCALAR\"}},\
{{\"bufferView\":1,\"componentType\":5126,\"count\":{},\"type\":\"VEC3\",\"min\":{},\"max\":{}}}",
indices.len(),
verts.len(),
arr(mn),
arr(mx),
);
let attributes = if normals.is_some() {
views.push_str(&format!(
",{{\"buffer\":0,\"byteOffset\":{nrm_off},\"byteLength\":{nrm_len},\"target\":34962}}"
));
accessors.push_str(&format!(
",{{\"bufferView\":2,\"componentType\":5126,\"count\":{},\"type\":\"VEC3\"}}",
verts.len()
));
"\"POSITION\":1,\"NORMAL\":2"
} else {
"\"POSITION\":1"
};
let json = format!(
"{{\"asset\":{{\"version\":\"2.0\",\"generator\":\"threers\"}},\
\"scene\":0,\"scenes\":[{{\"nodes\":[0]}}],\"nodes\":[{{\"mesh\":0}}],\
\"meshes\":[{{\"primitives\":[{{\"attributes\":{{{attributes}}},\"indices\":0,\"mode\":4}}]}}],\
\"buffers\":[{{\"byteLength\":{buf_len}}}],\
\"bufferViews\":[{views}],\"accessors\":[{accessors}]}}"
);
let mut json_bytes = json.into_bytes();
while !json_bytes.len().is_multiple_of(4) {
json_bytes.push(b' ');
}
while !bin.len().is_multiple_of(4) {
bin.push(0);
}
let total = 12 + 8 + json_bytes.len() + 8 + bin.len();
let mut glb = Vec::with_capacity(total);
glb.extend_from_slice(b"glTF"); glb.extend_from_slice(&2u32.to_le_bytes()); glb.extend_from_slice(&(total as u32).to_le_bytes());
glb.extend_from_slice(&(json_bytes.len() as u32).to_le_bytes());
glb.extend_from_slice(b"JSON");
glb.extend_from_slice(&json_bytes);
glb.extend_from_slice(&(bin.len() as u32).to_le_bytes());
glb.extend_from_slice(b"BIN\0");
glb.extend_from_slice(&bin);
glb
}
pub fn parts_to_glb(parts: &[crate::openscad::ScadPart]) -> Vec<u8> {
use crate::openscad::ScadPart;
let mut bin: Vec<u8> = Vec::new();
let mut buffer_views: Vec<String> = Vec::new();
let mut accessors: Vec<String> = Vec::new();
let mut meshes: Vec<String> = Vec::new();
let mut nodes: Vec<String> = Vec::new();
let mut materials: Vec<String> = Vec::new();
let mut mat_map: Vec<(u32, u32, u32, u32)> = Vec::new();
let default_rgba = [0.91_f32, 0.93, 0.95, 1.0];
let pbr = |rgba: [f32; 4]| -> (f32, f32) {
let (r, g, b) = (rgba[0], rgba[1], rgba[2]);
if r > 0.85 && g > 0.75 && b < 0.55 {
return (0.55, 0.06);
}
if r < 0.08 && g < 0.08 && b < 0.12 {
return (0.08, 0.32);
}
if r < 0.15 && g < 0.16 && b < 0.20 {
return (0.12, 0.74);
}
if r > 0.65 && g < 0.20 && b < 0.25 {
return (0.55, 0.35);
}
if r < 0.15 && g > 0.22 && b > 0.55 {
return (0.55, 0.35);
}
if r > 0.65 && g > 0.55 && b < 0.45 {
return (0.90, 0.24);
}
if r > 0.85 && g > 0.82 && b < 0.92 && r - b > 0.02 {
return (0.04, 0.86);
}
if r > 0.92 && g > 0.92 && b > 0.92 {
return (0.32, 0.48);
}
if b > r + 0.03 && b > g && r > 0.55 {
return (0.82, 0.18);
}
(0.32, 0.48)
};
let mut mat_idx = |rgba: [f32; 4]| -> usize {
let key = (
(rgba[0] * 255.0).round() as u32,
(rgba[1] * 255.0).round() as u32,
(rgba[2] * 255.0).round() as u32,
(rgba[3] * 255.0).round() as u32,
);
if let Some(i) = mat_map.iter().position(|k| *k == key) {
return i;
}
let i = materials.len();
mat_map.push(key);
let (metal, rough) = pbr(rgba);
materials.push(format!(
"{{\"pbrMetallicRoughness\":{{\"baseColorFactor\":[{},{},{},{}],\"metallicFactor\":{},\"roughnessFactor\":{}}}}}",
rgba[0], rgba[1], rgba[2], rgba[3], metal, rough
));
i
};
let arr3 = |a: [f32; 3]| format!("[{},{},{}]", a[0], a[1], a[2]);
for part in parts {
let ScadPart { geometry, color } = part;
let Some((verts, normals, indices)) = tri_data(geometry) else {
continue;
};
if indices.is_empty() {
continue;
}
let rgba = color.unwrap_or(default_rgba);
let mi = mat_idx(rgba);
let idx_off = bin.len();
for &i in &indices {
bin.extend_from_slice(&i.to_le_bytes());
}
let idx_len = bin.len() - idx_off;
let idx_bv = buffer_views.len();
buffer_views.push(format!(
"{{\"buffer\":0,\"byteOffset\":{idx_off},\"byteLength\":{idx_len},\"target\":34963}}"
));
let idx_acc = accessors.len();
accessors.push(format!(
"{{\"bufferView\":{idx_bv},\"componentType\":5125,\"count\":{},\"type\":\"SCALAR\"}}",
indices.len()
));
let pos_off = bin.len();
for v in &verts {
for c in v {
bin.extend_from_slice(&c.to_le_bytes());
}
}
let pos_len = bin.len() - pos_off;
let pos_bv = buffer_views.len();
buffer_views.push(format!(
"{{\"buffer\":0,\"byteOffset\":{pos_off},\"byteLength\":{pos_len},\"target\":34962}}"
));
let (mut mn, mut mx) = ([f32::MAX; 3], [f32::MIN; 3]);
for v in &verts {
for k in 0..3 {
mn[k] = mn[k].min(v[k]);
mx[k] = mx[k].max(v[k]);
}
}
let pos_acc = accessors.len();
accessors.push(format!(
"{{\"bufferView\":{pos_bv},\"componentType\":5126,\"count\":{},\"type\":\"VEC3\",\"min\":{},\"max\":{}}}",
verts.len(),
arr3(mn),
arr3(mx)
));
let nrm_acc = if let Some(n) = &normals {
let nrm_off = bin.len();
for v in n {
for c in v {
bin.extend_from_slice(&c.to_le_bytes());
}
}
let nrm_len = bin.len() - nrm_off;
let nrm_bv = buffer_views.len();
buffer_views.push(format!(
"{{\"buffer\":0,\"byteOffset\":{nrm_off},\"byteLength\":{nrm_len},\"target\":34962}}"
));
let acc = accessors.len();
accessors.push(format!(
"{{\"bufferView\":{nrm_bv},\"componentType\":5126,\"count\":{},\"type\":\"VEC3\"}}",
n.len()
));
Some(acc)
} else {
None
};
let attrs = if let Some(na) = nrm_acc {
format!("\"POSITION\":{pos_acc},\"NORMAL\":{na}")
} else {
format!("\"POSITION\":{pos_acc}")
};
let mesh_idx = meshes.len();
meshes.push(format!(
"{{\"primitives\":[{{\"attributes\":{{{attrs}}},\"indices\":{idx_acc},\"material\":{mi},\"mode\":4}}]}}"
));
nodes.push(format!("{{\"mesh\":{mesh_idx}}}"));
}
if meshes.is_empty() {
return Vec::new();
}
let node_list: String = (0..nodes.len()).map(|i| i.to_string()).collect::<Vec<_>>().join(",");
let json = format!(
"{{\"asset\":{{\"version\":\"2.0\",\"generator\":\"threers\"}},\
\"scene\":0,\"scenes\":[{{\"nodes\":[{node_list}]}}],\
\"nodes\":[{}],\"meshes\":[{}],\"materials\":[{}],\
\"buffers\":[{{\"byteLength\":{}}}],\"bufferViews\":[{}],\"accessors\":[{}]}}",
nodes.join(","),
meshes.join(","),
materials.join(","),
bin.len(),
buffer_views.join(","),
accessors.join(","),
);
let mut json_bytes = json.into_bytes();
while !json_bytes.len().is_multiple_of(4) {
json_bytes.push(b' ');
}
while !bin.len().is_multiple_of(4) {
bin.push(0);
}
let total = 12 + 8 + json_bytes.len() + 8 + bin.len();
let mut glb = Vec::with_capacity(total);
glb.extend_from_slice(b"glTF");
glb.extend_from_slice(&2u32.to_le_bytes());
glb.extend_from_slice(&(total as u32).to_le_bytes());
glb.extend_from_slice(&(json_bytes.len() as u32).to_le_bytes());
glb.extend_from_slice(b"JSON");
glb.extend_from_slice(&json_bytes);
glb.extend_from_slice(&(bin.len() as u32).to_le_bytes());
glb.extend_from_slice(b"BIN\0");
glb.extend_from_slice(&bin);
glb
}
#[cfg(test)]
mod tests {
use super::*;
use crate::{cube, geometry_to_obj as _reexport_check};
fn tetra() -> BufferGeometry {
cube([10.0, 10.0, 10.0]).to_geometry_exact()
}
#[test]
fn obj_roundtrips_through_objloader() {
let _ = _reexport_check; let g = tetra();
let obj = geometry_to_obj(&g);
let vlines = obj.lines().filter(|l| l.starts_with("v ")).count();
let flines = obj.lines().filter(|l| l.starts_with("f ")).count();
assert!(vlines > 0 && flines > 0, "obj empty");
let back = crate::ObjLoader::parse(&obj);
let n_in = g.index.as_ref().map(|i| i.len() / 3).unwrap_or(vlines / 3);
let n_out = back.index.as_ref().map(|i| i.len() / 3).unwrap_or_else(|| {
back.get_attribute("position")
.map(|a| a.count() / 3)
.unwrap_or(0)
});
assert_eq!(n_out, n_in, "obj triangle count changed on round-trip");
}
fn from_faces(points: &[[f32; 3]], faces: &[&[u32]]) -> BufferGeometry {
let mut index = Vec::new();
let mut counts = Vec::new();
for f in faces {
for k in 1..f.len() - 1 {
index.extend_from_slice(&[f[0], f[k], f[k + 1]]);
}
counts.push(f.len() as u32 - 2);
}
let mut g = BufferGeometry::new();
g.set_attribute(
"position",
crate::core::BufferAttribute::new(points.iter().flatten().copied().collect(), 3),
);
g.set_index(index);
g.set_polygons(counts);
g
}
fn unit_quad() -> BufferGeometry {
from_faces(
&[[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [1.0, 1.0, 0.0], [0.0, 1.0, 0.0]],
&[&[0, 1, 2, 3]],
)
}
fn mixed() -> BufferGeometry {
from_faces(
&[
[0.0, 0.0, 0.0],
[1.0, 0.0, 0.0],
[1.0, 1.0, 0.0],
[0.0, 1.0, 0.0],
[2.0, 0.5, 0.0],
[0.5, -1.0, 0.0],
[-0.5, -0.8, 0.0],
[-0.7, 0.0, 0.0],
],
&[&[1, 4, 2], &[0, 1, 2, 3], &[0, 7, 6, 5, 1]],
)
}
fn polygon_positions(g: &BufferGeometry) -> Vec<Vec<[u32; 3]>> {
let p = &g.get_attribute("position").unwrap().array;
g.faces()
.map(|f| {
f.iter()
.map(|&i| {
let at = i as usize * 3;
[p[at].to_bits(), p[at + 1].to_bits(), p[at + 2].to_bits()]
})
.collect()
})
.collect()
}
fn assert_same_polygons(back: &BufferGeometry, g: &BufferGeometry, what: &str) {
assert_eq!(back.polygon_counts(), g.polygon_counts(), "{what}: grouping");
assert_eq!(polygon_positions(back), polygon_positions(g), "{what}: corners");
}
fn face_corner_counts(lines: impl Iterator<Item = usize>) -> Vec<usize> {
lines.collect()
}
#[test]
fn obj_writes_a_quad_as_one_face_and_reads_back() {
let g = unit_quad();
let obj = geometry_to_obj(&g);
let faces: Vec<&str> = obj.lines().filter(|l| l.starts_with("f ")).collect();
assert_eq!(faces, vec!["f 1 2 3 4"]);
assert_same_polygons(&crate::ObjLoader::parse(&obj), &g, "obj quad");
}
#[test]
fn obj_ply_off_keep_triangles_quads_and_pentagons() {
let g = mixed();
let obj = geometry_to_obj(&g);
let corners = face_corner_counts(
obj.lines()
.filter(|l| l.starts_with("f "))
.map(|l| l.split_whitespace().count() - 1),
);
assert_eq!(corners, vec![3, 4, 5]);
assert_same_polygons(&crate::ObjLoader::parse(&obj), &g, "obj mixed");
let ply = geometry_to_ply(&g);
assert_same_polygons(&crate::PlyLoader::parse(ply.as_bytes()), &g, "ply mixed");
let off = geometry_to_off(&g);
let mut lines = off.lines().skip(1);
let header: Vec<usize> = lines
.next()
.unwrap()
.split_whitespace()
.map(|s| s.parse().unwrap())
.collect();
assert_eq!(header, vec![8, 3, 0]);
let corners = face_corner_counts(
off.lines()
.skip(2 + 8)
.map(|l| l.split_whitespace().next().unwrap().parse().unwrap()),
);
assert_eq!(corners, vec![3, 4, 5]);
}
#[test]
fn a_box_round_trips_as_six_quads() {
let g = crate::BoxGeometry::new(1.0, 2.0, 3.0);
assert_eq!(g.polygon_counts(), Some(&[2u32; 6][..]));
let obj = geometry_to_obj(&g);
assert_eq!(obj.lines().filter(|l| l.starts_with("f ")).count(), 6);
assert!(obj.lines().any(|l| l.starts_with("vt ")), "uvs written");
let ply = geometry_to_ply(&g);
for (back, what) in [
(crate::ObjLoader::parse(&obj), "obj box"),
(crate::PlyLoader::parse(ply.as_bytes()), "ply box"),
] {
assert_same_polygons(&back, &g, what);
for name in ["normal", "uv"] {
let per_corner = |geo: &BufferGeometry| -> Vec<Vec<u32>> {
let a = geo.get_attribute(name).unwrap();
geo.faces()
.map(|f| {
f.iter()
.flat_map(|&i| {
let at = i as usize * a.item_size;
a.array[at..at + a.item_size].iter().map(|x| x.to_bits())
})
.collect()
})
.collect()
};
assert_eq!(per_corner(&back), per_corner(&g), "{what}: {name}");
}
}
}
#[test]
fn ungrouped_and_unrecoverable_polygons_fall_back_to_triangles() {
let mut g = unit_quad();
g.polygons = None;
let obj = geometry_to_obj(&g);
assert_eq!(obj.lines().filter(|l| l.starts_with("f ")).count(), 2);
let back = crate::ObjLoader::parse(&obj);
assert_eq!(back.polygon_counts(), Some(&[1u32, 1][..]));
let mut bow = from_faces(
&[
[0.0, 0.0, 0.0],
[1.0, 0.0, 0.0],
[0.0, 1.0, 0.0],
[-1.0, 0.0, 0.0],
[0.0, -1.0, 0.0],
],
&[&[0, 1, 2], &[0, 3, 4]],
);
bow.set_polygons(vec![2]);
let obj = geometry_to_obj(&bow);
assert_eq!(obj.lines().filter(|l| l.starts_with("f ")).count(), 2);
}
#[test]
fn assimp_reads_the_quads() {
let Ok(probe) = std::process::Command::new("assimp").arg("version").output() else {
eprintln!("assimp not installed; skipping the reference check");
return;
};
if !probe.status.success() {
eprintln!("assimp not runnable; skipping the reference check");
return;
}
let g = mixed();
let dir = std::env::temp_dir().join(format!("threers-quad-export-{}", std::process::id()));
std::fs::create_dir_all(&dir).unwrap();
for (ext, text) in [("obj", geometry_to_obj(&g)), ("ply", geometry_to_ply(&g))] {
let path = dir.join(format!("mixed.{ext}"));
std::fs::write(&path, text).unwrap();
let out = std::process::Command::new("assimp")
.arg("info")
.arg(&path)
.arg("--raw")
.output()
.unwrap();
let report = String::from_utf8_lossy(&out.stdout);
let faces = report
.lines()
.find(|l| l.trim_start().starts_with("Faces:"))
.and_then(|l| l.split(':').nth(1))
.map(|n| n.trim().parse::<usize>().unwrap())
.unwrap_or_else(|| panic!("no face count in assimp's report:\n{report}"));
assert_eq!(faces, 3, "{ext}: assimp should read 3 faces\n{report}");
let vertices = report
.lines()
.find(|l| l.trim_start().starts_with("Vertices:"))
.and_then(|l| l.split(':').nth(1))
.map(|n| n.trim().parse::<usize>().unwrap())
.unwrap();
let expected = if ext == "obj" { 12 } else { 8 };
assert_eq!(vertices, expected, "{ext}: vertices\n{report}");
assert!(report.contains("n-polygons"), "{ext}: polygons\n{report}");
}
let _ = std::fs::remove_dir_all(&dir);
}
#[test]
fn off_has_matching_counts() {
let g = tetra();
let off = geometry_to_off(&g);
let mut lines = off.lines();
assert_eq!(lines.next(), Some("OFF"));
let counts: Vec<usize> = lines
.next()
.unwrap()
.split_whitespace()
.map(|s| s.parse().unwrap())
.collect();
let (nv, nf) = (counts[0], counts[1]);
let face_lines: Vec<&str> = off.lines().skip(2 + nv).collect();
assert_eq!(face_lines.len(), nf, "face count");
for f in &face_lines {
let n: usize = f.split_whitespace().next().unwrap().parse().unwrap();
assert_eq!(f.split_whitespace().count(), n + 1, "{f}");
}
assert_eq!(off.lines().count() - 2 - nf, nv, "vertex count");
}
#[test]
fn threemf_is_valid_zip_with_the_mesh() {
let g = tetra();
let bytes = geometry_to_3mf(&g);
assert!(bytes.starts_with(b"PK\x03\x04"), "not a zip");
assert!(bytes.windows(4).any(|w| w == b"PK\x05\x06"), "no EOCD");
let text = String::from_utf8_lossy(&bytes);
assert!(text.contains("3dmodel.model"), "missing model part name");
let n_v = g.get_attribute("position").unwrap().count(); assert_eq!(text.matches("<vertex ").count(), n_v, "3mf vertex count");
}
#[test]
fn glb_header_and_json_are_wellformed() {
let g = tetra();
let glb = geometry_to_glb(&g);
assert!(glb.starts_with(b"glTF"), "bad magic");
let total = u32::from_le_bytes(glb[8..12].try_into().unwrap()) as usize;
assert_eq!(total, glb.len(), "declared length != actual");
let jlen = u32::from_le_bytes(glb[12..16].try_into().unwrap()) as usize;
assert_eq!(&glb[16..20], b"JSON");
let json = std::str::from_utf8(&glb[20..20 + jlen]).unwrap();
assert!(json.contains("\"version\":\"2.0\""));
assert!(json.contains("\"POSITION\":1"));
let n_v = g.get_attribute("position").unwrap().count(); assert!(
json.contains(&format!("\"count\":{n_v}")),
"position accessor count"
);
assert_eq!(jlen % 4, 0);
let bin_hdr = 20 + jlen;
assert_eq!(&glb[bin_hdr + 4..bin_hdr + 8], b"BIN\0");
}
}