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))
}
pub fn geometry_to_obj(g: &BufferGeometry) -> String {
let Some((verts, normals, indices)) = tri_data(g) else {
return String::new();
};
let mut s = String::from("# threers OBJ export\no model\n");
for v in &verts {
s.push_str(&format!("v {} {} {}\n", v[0], v[1], v[2]));
}
if let Some(n) = &normals {
for v in n {
s.push_str(&format!("vn {} {} {}\n", v[0], v[1], v[2]));
}
}
for t in indices.chunks_exact(3) {
let (a, b, c) = (t[0] + 1, t[1] + 1, t[2] + 1); if normals.is_some() {
s.push_str(&format!("f {a}//{a} {b}//{b} {c}//{c}\n"));
} else {
s.push_str(&format!("f {a} {b} {c}\n"));
}
}
s
}
pub fn geometry_to_off(g: &BufferGeometry) -> String {
let Some((verts, _, indices)) = tri_data(g) else {
return String::from("OFF\n0 0 0\n");
};
let nf = indices.len() / 3;
let mut s = format!("OFF\n{} {} 0\n", verts.len(), nf);
for v in &verts {
s.push_str(&format!("{} {} {}\n", v[0], v[1], v[2]));
}
for t in indices.chunks_exact(3) {
s.push_str(&format!("3 {} {} {}\n", t[0], t[1], t[2]));
}
s
}
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()
}
struct Zip {
out: Vec<u8>,
dir: Vec<u8>,
count: u16,
}
impl Zip {
fn new() -> Self {
Self {
out: Vec::new(),
dir: Vec::new(),
count: 0,
}
}
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;
}
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
}
}
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");
}
#[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]);
assert_eq!(
off.lines().filter(|l| l.starts_with("3 ")).count(),
nf,
"face count"
);
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");
}
}