463 lines
21 KiB
Rust
463 lines
21 KiB
Rust
//! glTF import tests. Every file here is built by the tests themselves.
|
|
|
|
use serde_json::{Value, json};
|
|
|
|
use super::*;
|
|
|
|
/// A glTF file under construction: one binary buffer, meshes, nodes and materials.
|
|
#[derive(Default)]
|
|
pub(crate) struct Fixture {
|
|
pub bin: Vec<u8>,
|
|
pub views: Vec<Value>,
|
|
pub accessors: Vec<Value>,
|
|
pub meshes: Vec<Value>,
|
|
pub nodes: Vec<Value>,
|
|
pub materials: Vec<Value>,
|
|
pub roots: Vec<usize>,
|
|
}
|
|
|
|
/// A cube of side `s` (metres) with its corner at the origin, outward facing.
|
|
pub(crate) fn cube(s: f32) -> (Vec<[f32; 3]>, Vec<u16>) {
|
|
let p = (0..8).map(|i| [(i & 1) as f32 * s, ((i >> 1) & 1) as f32 * s, ((i >> 2) & 1) as f32 * s]).collect();
|
|
let t = vec![0, 2, 1, 1, 2, 3, 4, 5, 6, 5, 7, 6, 0, 1, 4, 1, 5, 4, 2, 6, 3, 3, 6, 7, 0, 4, 2, 2, 4, 6, 1, 3, 5, 3, 7, 5];
|
|
(p, t)
|
|
}
|
|
|
|
impl Fixture {
|
|
fn view(&mut self, bytes: &[u8]) -> usize {
|
|
while !self.bin.len().is_multiple_of(4) {
|
|
self.bin.push(0);
|
|
}
|
|
self.views.push(json!({"buffer": 0, "byteOffset": self.bin.len(), "byteLength": bytes.len()}));
|
|
self.bin.extend_from_slice(bytes);
|
|
self.views.len() - 1
|
|
}
|
|
|
|
/// A mesh of one primitive per (positions, indices, material).
|
|
pub fn mesh(&mut self, name: &str, prims: &[(&[[f32; 3]], &[u16], Option<usize>)]) -> usize {
|
|
let mut out = Vec::new();
|
|
for (positions, indices, material) in prims {
|
|
let bytes: Vec<u8> = positions.iter().flatten().flat_map(|v| v.to_le_bytes()).collect();
|
|
let v = self.view(&bytes);
|
|
let lo = (0..3).map(|k| positions.iter().map(|p| p[k]).fold(f32::INFINITY, f32::min)).collect::<Vec<_>>();
|
|
let hi = (0..3).map(|k| positions.iter().map(|p| p[k]).fold(f32::NEG_INFINITY, f32::max)).collect::<Vec<_>>();
|
|
self.accessors.push(json!({"bufferView": v, "componentType": 5126, "count": positions.len(), "type": "VEC3", "min": lo, "max": hi}));
|
|
let pa = self.accessors.len() - 1;
|
|
let bytes: Vec<u8> = indices.iter().flat_map(|v| v.to_le_bytes()).collect();
|
|
let v = self.view(&bytes);
|
|
self.accessors.push(json!({"bufferView": v, "componentType": 5123, "count": indices.len(), "type": "SCALAR"}));
|
|
let mut p = json!({"attributes": {"POSITION": pa}, "indices": self.accessors.len() - 1});
|
|
if let Some(m) = material {
|
|
p["material"] = json!(m);
|
|
}
|
|
out.push(p);
|
|
}
|
|
self.meshes.push(json!({"name": name, "primitives": out}));
|
|
self.meshes.len() - 1
|
|
}
|
|
|
|
pub fn cube_mesh(&mut self, name: &str, s: f32) -> usize {
|
|
let (p, t) = cube(s);
|
|
self.mesh(name, &[(&p, &t, None)])
|
|
}
|
|
|
|
pub fn node(&mut self, node: Value) -> usize {
|
|
self.nodes.push(node);
|
|
self.nodes.len() - 1
|
|
}
|
|
|
|
pub fn json(&self, uri: Option<&str>) -> Value {
|
|
let mut buffer = json!({"byteLength": self.bin.len()});
|
|
if let Some(u) = uri {
|
|
buffer["uri"] = json!(u);
|
|
}
|
|
let mut j = json!({
|
|
"asset": {"version": "2.0", "generator": "solidcraft tests"},
|
|
"scene": 0,
|
|
"scenes": [{"nodes": self.roots}],
|
|
"nodes": self.nodes,
|
|
"meshes": self.meshes,
|
|
"accessors": self.accessors,
|
|
"bufferViews": self.views,
|
|
"buffers": [buffer],
|
|
});
|
|
if !self.materials.is_empty() {
|
|
j["materials"] = json!(self.materials);
|
|
}
|
|
j
|
|
}
|
|
|
|
pub fn glb(&self) -> Vec<u8> {
|
|
glb_container(self.json(None).to_string().as_bytes(), &self.bin)
|
|
}
|
|
}
|
|
|
|
fn no_files(name: &str) -> std::result::Result<Vec<u8>, String> {
|
|
Err(format!("no file `{name}`"))
|
|
}
|
|
|
|
fn read(bytes: &[u8]) -> Result<GltfImport> {
|
|
read_gltf(bytes, "model.glb", &mut no_files)
|
|
}
|
|
|
|
fn meshes(g: &GltfImport) -> &[MeshData] {
|
|
match &g.feature.kind {
|
|
solidcraft_doc::FeatureKind::MeshImport { meshes, .. } => meshes,
|
|
_ => &[],
|
|
}
|
|
}
|
|
|
|
fn bounds(m: &MeshData) -> ([f64; 3], [f64; 3]) {
|
|
let mut lo = [f64::INFINITY; 3];
|
|
let mut hi = [f64::NEG_INFINITY; 3];
|
|
for p in m.positions.as_chunks::<3>().0 {
|
|
for k in 0..3 {
|
|
lo[k] = lo[k].min(p[k]);
|
|
hi[k] = hi[k].max(p[k]);
|
|
}
|
|
}
|
|
(lo, hi)
|
|
}
|
|
|
|
/// Signed volume (positive for outward-facing triangles).
|
|
fn volume(m: &MeshData) -> f64 {
|
|
let p = |i: u32| {
|
|
let i = i as usize * 3;
|
|
Vec3::new(m.positions[i], m.positions[i + 1], m.positions[i + 2])
|
|
};
|
|
m.triangles.as_chunks::<3>().0.iter().map(|t| p(t[0]).dot(p(t[1]).cross(p(t[2]))) / 6.0).sum()
|
|
}
|
|
|
|
fn close(a: f64, b: f64) -> bool {
|
|
(a - b).abs() < 1e-6 * (1.0 + b.abs())
|
|
}
|
|
|
|
#[test]
|
|
fn single_mesh_in_millimetres() {
|
|
let mut f = Fixture::default();
|
|
let m = f.cube_mesh("Cube", 0.01);
|
|
let n = f.node(json!({"name": "Cube node", "mesh": m}));
|
|
f.roots = vec![n];
|
|
let g = read(&f.glb()).unwrap();
|
|
assert!(g.feature.warnings.is_empty(), "{:?}", g.feature.warnings);
|
|
assert_eq!(g.feature.name, "Cube");
|
|
let ms = meshes(&g);
|
|
assert_eq!(ms.len(), 1);
|
|
assert_eq!(ms[0].triangles.len(), 36);
|
|
let (lo, hi) = bounds(&ms[0]);
|
|
assert!(lo.iter().all(|v| close(*v, 0.0)) && hi.iter().all(|v| close(*v, 10.0)), "{lo:?} {hi:?}");
|
|
assert!(close(volume(&ms[0]), 1000.0), "{}", volume(&ms[0]));
|
|
// One root node is the import's own component.
|
|
assert!(g.plan.slots.is_empty() && g.plan.places.is_empty());
|
|
assert_eq!(g.plan.bodies, vec![None]);
|
|
assert_eq!(g.looks, vec![None]);
|
|
// The axes are the file's: Y up stays Y here (the caller turns the component).
|
|
let mut f = Fixture::default();
|
|
let (p, t) = cube(0.01);
|
|
let tall: Vec<[f32; 3]> = p.iter().map(|q| [q[0], q[1] * 3.0, q[2]]).collect();
|
|
let m = f.mesh("Tall", &[(&tall, &t, None)]);
|
|
let n = f.node(json!({"mesh": m}));
|
|
f.roots = vec![n];
|
|
let g = read(&f.glb()).unwrap();
|
|
let (_, hi) = bounds(&meshes(&g)[0]);
|
|
assert!(close(hi[1], 30.0) && close(hi[2], 10.0), "{hi:?}");
|
|
}
|
|
|
|
#[test]
|
|
fn node_hierarchy_becomes_components() {
|
|
let mut f = Fixture::default();
|
|
let m = f.cube_mesh("Block", 0.01);
|
|
let arm = f.node(json!({"name": "Arm", "mesh": m, "translation": [0.0, 0.05, 0.0], "rotation": [0.0, 0.0, 0.70710677, 0.70710677]}));
|
|
let base = f.node(json!({"name": "Base", "mesh": m, "translation": [0.1, 0.0, 0.0], "children": [arm]}));
|
|
let block = f.cube_mesh("Other block", 0.01);
|
|
let other = f.node(json!({"name": "Other", "mesh": block, "translation": [0.0, 0.0, 0.2]}));
|
|
f.roots = vec![base, other];
|
|
let g = read(&f.glb()).unwrap();
|
|
assert_eq!(g.plan.slots, vec!["Base", "Arm", "Other"]);
|
|
assert_eq!(g.plan.places.len(), 3);
|
|
let base_place = &g.plan.places[0];
|
|
assert_eq!((base_place.slot, base_place.parent), (0, None));
|
|
assert!(close(base_place.transform[3][0], 100.0));
|
|
let arm_place = &g.plan.places[1];
|
|
assert_eq!((arm_place.slot, arm_place.parent), (1, Some(0)));
|
|
assert!(close(arm_place.transform[3][1], 50.0));
|
|
// A quarter turn about Z: X goes to Y.
|
|
assert!(close(arm_place.transform[0][1], 1.0) && arm_place.transform[0][0].abs() < 1e-6, "{:?}", arm_place.transform);
|
|
assert_eq!(g.plan.bodies, vec![Some(0), Some(1), Some(2)]);
|
|
// Bodies are in their component's frame.
|
|
for m in meshes(&g) {
|
|
let (lo, hi) = bounds(m);
|
|
assert!(lo.iter().all(|v| close(*v, 0.0)) && hi.iter().all(|v| close(*v, 10.0)), "{} {lo:?} {hi:?}", m.name);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn repeated_meshes_are_instances() {
|
|
let mut f = Fixture::default();
|
|
let m = f.cube_mesh("Bolt", 0.005);
|
|
f.roots = (0..4).map(|k| f.node(json!({"name": format!("Bolt.{k}"), "mesh": m, "translation": [k as f32 * 0.02, 0.0, 0.0]}))).collect();
|
|
let g = read(&f.glb()).unwrap();
|
|
assert_eq!(g.plan.slots, vec!["Bolt"], "named after the mesh: the nodes' names differ");
|
|
assert_eq!(g.plan.places.len(), 4);
|
|
assert!(g.plan.places.iter().all(|p| p.slot == 0 && p.parent.is_none()));
|
|
assert!(close(g.plan.places[3].transform[3][0], 60.0));
|
|
assert_eq!(meshes(&g).len(), 1, "the mesh is built once");
|
|
// The same mesh scaled differently is not the same part.
|
|
f.nodes[3]["scale"] = json!([2.0, 2.0, 2.0]);
|
|
let g = read(&f.glb()).unwrap();
|
|
assert_eq!(g.plan.slots.len(), 2);
|
|
assert_eq!(meshes(&g).len(), 2);
|
|
}
|
|
|
|
#[test]
|
|
fn scale_and_mirror_are_baked_and_the_tree_kept() {
|
|
let mut f = Fixture::default();
|
|
let m = f.cube_mesh("Cube", 0.01);
|
|
let child = f.node(json!({"name": "Child", "mesh": m, "translation": [0.1, 0.0, 0.0]}));
|
|
let mirrored = f.node(json!({"name": "Mirror", "mesh": m, "scale": [-1.0, 1.0, 1.0]}));
|
|
let scaled = f.node(json!({"name": "Half", "scale": [0.5, 0.5, 0.5], "children": [child]}));
|
|
f.roots = vec![scaled, mirrored];
|
|
let g = read(&f.glb()).unwrap();
|
|
assert_eq!(g.plan.slots, vec!["Half", "Child", "Mirror"]);
|
|
// The child sits half as far out, and is half the size.
|
|
assert!(close(g.plan.places[1].transform[3][0], 50.0), "{:?}", g.plan.places[1].transform);
|
|
let ms = meshes(&g);
|
|
assert!(close(volume(&ms[0]), 125.0), "{}", volume(&ms[0]));
|
|
// A mirrored mesh still faces out.
|
|
assert!(close(volume(&ms[1]), 1000.0), "{}", volume(&ms[1]));
|
|
// Placed, it lies on the other side of the origin.
|
|
let place = &g.plan.places[2].transform;
|
|
let xs: Vec<f64> = ms[1].positions.as_chunks::<3>().0.iter().map(|p| solidcraft_doc::apply_point(place, Vec3::new(p[0], p[1], p[2])).x).collect();
|
|
assert!(
|
|
close(xs.iter().copied().fold(f64::INFINITY, f64::min), -10.0) && close(xs.iter().copied().fold(f64::NEG_INFINITY, f64::max), 0.0),
|
|
"{xs:?}"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn materials_give_looks() {
|
|
let mut f = Fixture {
|
|
materials: vec![
|
|
json!({"name": "Red metal", "pbrMetallicRoughness": {"baseColorFactor": [1.0, 0.0, 0.0, 1.0], "metallicFactor": 1.0, "roughnessFactor": 0.25}}),
|
|
json!({"name": "Glass", "alphaMode": "BLEND", "pbrMetallicRoughness": {"baseColorFactor": [0.214, 0.214, 0.214, 0.5]}}),
|
|
],
|
|
..Default::default()
|
|
};
|
|
let (p, t) = cube(0.01);
|
|
let q: Vec<[f32; 3]> = p.iter().map(|v| [v[0] + 0.02, v[1], v[2]]).collect();
|
|
let m = f.mesh("Two", &[(&p, &t, Some(0)), (&q, &t, Some(1))]);
|
|
let n = f.node(json!({"mesh": m}));
|
|
f.roots = vec![n];
|
|
let g = read(&f.glb()).unwrap();
|
|
let ms = meshes(&g);
|
|
assert_eq!(ms.iter().map(|m| m.name.as_str()).collect::<Vec<_>>(), ["Two (Red metal)", "Two (Glass)"]);
|
|
let red = g.looks[0].as_ref().unwrap();
|
|
assert_eq!((red.name.as_str(), red.color, red.opacity), ("Red metal", [255, 0, 0], 1.0));
|
|
let pbr = red.pbr.unwrap();
|
|
assert!(close(pbr.metallic(), 1.0) && close(pbr.roughness(), 0.25));
|
|
assert_eq!(ms[0].color, Some([1.0, 0.0, 0.0]));
|
|
// Linear 0.214 is sRGB 128; a blended material is see-through and not PBR.
|
|
let glass = g.looks[1].as_ref().unwrap();
|
|
assert!((i32::from(glass.color[0]) - 128).abs() <= 1, "{:?}", glass.color);
|
|
assert!(close(glass.opacity, 0.5) && glass.pbr.is_none());
|
|
}
|
|
|
|
#[test]
|
|
fn gltf_with_external_and_embedded_buffers() {
|
|
let mut f = Fixture::default();
|
|
let m = f.cube_mesh("Cube", 0.01);
|
|
let n = f.node(json!({"mesh": m}));
|
|
f.roots = vec![n];
|
|
let text = f.json(Some("cube%20data.bin")).to_string();
|
|
let bin = f.bin.clone();
|
|
let mut asked = Vec::new();
|
|
let mut load = |name: &str| {
|
|
asked.push(name.to_string());
|
|
Ok(bin.clone())
|
|
};
|
|
let g = read_gltf(text.as_bytes(), "dir/model.gltf", &mut load).unwrap();
|
|
assert_eq!(meshes(&g).len(), 1);
|
|
assert_eq!(asked, ["cube data.bin"]);
|
|
// Missing: a clear error naming the file.
|
|
let e = read_gltf(text.as_bytes(), "model.gltf", &mut no_files).err().unwrap().to_string();
|
|
assert!(e.contains("cube data.bin"), "{e}");
|
|
// Outside the file's folder: refused before anything is read.
|
|
for uri in ["../secret.bin", "/etc/passwd", "C:/x.bin", "file:///x.bin", "a/%2e%2e/../b.bin"] {
|
|
let text = f.json(Some(uri)).to_string();
|
|
let mut called = false;
|
|
let mut load = |_: &str| {
|
|
called = true;
|
|
Ok(Vec::new())
|
|
};
|
|
let r = read_gltf(text.as_bytes(), "model.gltf", &mut load);
|
|
assert!(r.is_err() && !called, "{uri}");
|
|
}
|
|
// Embedded as a data URI.
|
|
let b64 = {
|
|
const A: &[u8] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
|
|
let mut s = String::new();
|
|
for c in f.bin.chunks(3) {
|
|
let n = (u32::from(c[0]) << 16) | (u32::from(*c.get(1).unwrap_or(&0)) << 8) | u32::from(*c.get(2).unwrap_or(&0));
|
|
for k in 0..4 {
|
|
s.push(if k <= c.len() { A[((n >> (18 - 6 * k)) & 63) as usize] as char } else { '=' });
|
|
}
|
|
}
|
|
s
|
|
};
|
|
let text = f.json(Some(&format!("data:application/octet-stream;base64,{b64}"))).to_string();
|
|
let g = read_gltf(text.as_bytes(), "model.gltf", &mut no_files).unwrap();
|
|
assert!(close(volume(&meshes(&g)[0]), 1000.0));
|
|
// The GLB route through mesh_import_feature builds every body where it is.
|
|
let mut f2 = Fixture::default();
|
|
let m = f2.cube_mesh("Cube", 0.01);
|
|
f2.roots = vec![f2.node(json!({"mesh": m, "translation": [1.0, 0.0, 0.0]})), f2.node(json!({"mesh": m, "translation": [2.0, 0.0, 0.0]}))];
|
|
let mf = crate::mesh_import_feature(&f2.glb(), "two.glb").unwrap();
|
|
let solidcraft_doc::FeatureKind::MeshImport { meshes, .. } = &mf.kind else { panic!() };
|
|
assert_eq!(meshes.len(), 1);
|
|
assert!(close(bounds(&meshes[0]).0[0], 1000.0));
|
|
assert!(crate::is_mesh_path("a.GLB") && crate::is_mesh_path("b.gltf") && is_gltf_path("c.Gltf") && !is_gltf_path("d.obj"));
|
|
}
|
|
|
|
#[test]
|
|
fn strips_fans_and_unsupported_parts() {
|
|
let mut f = Fixture::default();
|
|
// A square as a strip and as a fan, and a line primitive that is skipped.
|
|
let sq: Vec<[f32; 3]> = vec![[0.0, 0.0, 0.0], [0.01, 0.0, 0.0], [0.0, 0.01, 0.0], [0.01, 0.01, 0.0]];
|
|
let m = f.mesh("Sheet", &[(&sq, &[0, 1, 2, 3], None)]);
|
|
f.meshes[m]["primitives"][0]["mode"] = json!(5);
|
|
let n = f.node(json!({"mesh": m}));
|
|
f.roots = vec![n];
|
|
let g = read(&f.glb()).unwrap();
|
|
assert_eq!(meshes(&g)[0].triangles.len(), 6);
|
|
f.meshes[m]["primitives"][0]["mode"] = json!(1);
|
|
let e = read(&f.glb()).err().unwrap().to_string();
|
|
assert!(e.contains("no triangle meshes"), "{e}");
|
|
}
|
|
|
|
/// The plan makes each component at its first placement, inside one made before (never inside
|
|
/// itself), and puts bodies only in components it makes.
|
|
fn plan_ok(p: &MeshPlan) -> bool {
|
|
let mut made = 0;
|
|
for place in &p.places {
|
|
if place.slot > made || place.parent.is_some_and(|q| q >= made || q == place.slot) {
|
|
return false;
|
|
}
|
|
made += usize::from(place.slot == made);
|
|
}
|
|
made == p.slots.len() && p.bodies.iter().flatten().all(|b| *b < made)
|
|
}
|
|
|
|
fn assert_no_panic(bytes: &[u8], what: &str) {
|
|
let r = std::panic::catch_unwind(|| read(bytes).map(|g| (meshes(&g).len(), plan_ok(&g.plan), g.looks.len() == meshes(&g).len())));
|
|
assert!(r.is_ok(), "panicked on {what}");
|
|
if let Ok(Ok((_, plan, looks))) = r {
|
|
assert!(plan && looks, "inconsistent plan on {what}");
|
|
}
|
|
}
|
|
|
|
/// A primitive whose POSITION names an accessor the file lacks is refused before the glTF crate
|
|
/// sees it: the crate's own check indexes the accessors unchecked and panics, which the guard
|
|
/// catches on the desktop but which aborts the app in the browser (#469, found by mutation).
|
|
#[test]
|
|
fn a_position_naming_a_missing_accessor_is_refused_before_the_gltf_crate() {
|
|
let mut f = Fixture::default();
|
|
let m = f.cube_mesh("Cube", 0.01);
|
|
let n = f.node(json!({"mesh": m}));
|
|
f.roots = vec![n];
|
|
let mut j = f.json(None);
|
|
j["meshes"][0]["primitives"][0]["attributes"]["POSITION"] = json!(99);
|
|
let glb = glb_container(j.to_string().as_bytes(), &f.bin);
|
|
let e = read(&glb).err().map(|e| e.to_string()).unwrap_or_default();
|
|
assert!(e.contains("POSITION names accessor 99, but the file has 2"), "{e}");
|
|
assert!(!solidcraft_kernel::guarded(), "no guard left open");
|
|
}
|
|
|
|
#[test]
|
|
fn hostile_gltf_never_panics() {
|
|
let mut f = Fixture::default();
|
|
let m = f.cube_mesh("Cube", 0.01);
|
|
let child = f.node(json!({"name": "C", "mesh": m, "translation": [0.0, 0.1, 0.0]}));
|
|
let n = f.node(json!({"mesh": m, "children": [child], "scale": [2.0, 1.0, 1.0]}));
|
|
f.roots = vec![n, child];
|
|
let glb = f.glb();
|
|
assert!(read(&glb).is_ok());
|
|
// Every truncation is an error, never a panic.
|
|
for k in 0..glb.len() {
|
|
assert_no_panic(&glb[..k], &format!("truncated to {k}"));
|
|
assert!(read(&glb[..k]).is_err(), "truncated to {k}");
|
|
}
|
|
// Flipped bytes anywhere.
|
|
for k in 0..glb.len() {
|
|
let mut bad = glb.clone();
|
|
bad[k] ^= 0xA5;
|
|
assert_no_panic(&bad, &format!("byte {k} flipped"));
|
|
}
|
|
// Lengths in the container that lie.
|
|
for (at, v) in [(8, 0u32), (8, 5), (8, u32::MAX), (12, 0), (12, u32::MAX), (4, 1)] {
|
|
let mut bad = glb.clone();
|
|
bad[at..at + 4].copy_from_slice(&v.to_le_bytes());
|
|
assert_no_panic(&bad, &format!("{v} at {at}"));
|
|
assert!(read(&bad).is_err(), "{v} at {at}");
|
|
}
|
|
// Documents that lie.
|
|
let base = f.json(None);
|
|
let cases: Vec<(&str, Box<dyn Fn(&mut Value)>)> = vec![
|
|
("huge count", Box::new(|j| j["accessors"][0]["count"] = json!(u32::MAX))),
|
|
("past the view", Box::new(|j| j["accessors"][0]["byteOffset"] = json!(1000))),
|
|
("view past buffer", Box::new(|j| j["bufferViews"][0]["byteLength"] = json!(1 << 20))),
|
|
("buffer longer than chunk", Box::new(|j| j["buffers"][0]["byteLength"] = json!(1 << 20))),
|
|
("bad accessor index", Box::new(|j| j["meshes"][0]["primitives"][0]["attributes"]["POSITION"] = json!(99))),
|
|
("bad mesh index", Box::new(|j| j["nodes"][0]["mesh"] = json!(99))),
|
|
("bad child", Box::new(|j| j["nodes"][1]["children"] = json!([99]))),
|
|
("loop", Box::new(|j| j["nodes"][0]["children"] = json!([1, 0]))),
|
|
("two-node loop", Box::new(|j| j["nodes"][0]["children"] = json!([1]))),
|
|
("index past vertices", Box::new(|j| j["accessors"][1]["componentType"] = json!(5125))),
|
|
("float indices", Box::new(|j| j["accessors"][1]["componentType"] = json!(5126))),
|
|
("stride too small", Box::new(|j| j["bufferViews"][0]["byteStride"] = json!(4))),
|
|
("nan transform", Box::new(|j| j["nodes"][1]["matrix"] = json!([f32::MAX, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1e30, 0, 0, 1]))),
|
|
("zero scale", Box::new(|j| j["nodes"][1]["scale"] = json!([0.0, 0.0, 0.0]))),
|
|
("draco", Box::new(|j| j["extensionsRequired"] = json!(["KHR_draco_mesh_compression"]))),
|
|
("version 1", Box::new(|j| j["asset"]["version"] = json!("1.0"))),
|
|
("no scenes", Box::new(|j| j.as_object_mut().unwrap().retain(|k, _| k != "scenes" && k != "scene"))),
|
|
(
|
|
"sparse",
|
|
Box::new(|j| {
|
|
j["accessors"][0]["sparse"] = json!({"count": 1, "indices": {"bufferView": 1, "componentType": 5123}, "values": {"bufferView": 0}})
|
|
}),
|
|
),
|
|
("no buffer", Box::new(|j| j["buffers"] = json!([]))),
|
|
("not json", Box::new(|j| *j = json!("nope"))),
|
|
];
|
|
for (what, edit) in &cases {
|
|
let mut j = base.clone();
|
|
edit(&mut j);
|
|
let bytes = glb_container(j.to_string().as_bytes(), &f.bin);
|
|
assert_no_panic(&bytes, what);
|
|
let text = j.to_string();
|
|
let r = std::panic::catch_unwind(|| read_gltf(text.as_bytes(), "x.gltf", &mut no_files).map(|g| meshes(&g).len()));
|
|
assert!(r.is_ok(), "panicked on {what} (gltf)");
|
|
}
|
|
let mut j = base.clone();
|
|
j["extensionsRequired"] = json!(["KHR_draco_mesh_compression"]);
|
|
let e = read(&glb_container(j.to_string().as_bytes(), &f.bin)).err().unwrap().to_string();
|
|
assert!(e.contains("KHR_draco_mesh_compression") && e.contains("uncompressed"), "{e}");
|
|
// Looks-only extensions don't stop a file.
|
|
j["extensionsRequired"] = json!(["KHR_texture_transform", "KHR_materials_emissive_strength"]);
|
|
assert!(read(&glb_container(j.to_string().as_bytes(), &f.bin)).is_ok());
|
|
// A deep chain is cut off or flattened, not followed forever.
|
|
let mut f = Fixture::default();
|
|
let m = f.cube_mesh("Cube", 0.01);
|
|
let mut last = f.node(json!({"mesh": m}));
|
|
for _ in 0..200 {
|
|
last = f.node(json!({"mesh": m, "translation": [0.0, 0.0, 0.01], "children": [last]}));
|
|
}
|
|
f.roots = vec![last, 0];
|
|
let g = read(&f.glb()).unwrap();
|
|
assert!(g.plan.slots.len() <= MAX_COMPONENTS);
|
|
assert!(g.feature.warnings.iter().any(|w| w.contains("too large or too deep")), "{:?}", g.feature.warnings);
|
|
for junk in [&b""[..], b"glTF", b"glTF\x02\0\0\0", b"{", b"\xff\xfe", b"[]", b"{\"asset\":{\"version\":\"2.0\"}}"] {
|
|
assert_no_panic(junk, &format!("{junk:?}"));
|
|
assert!(read(junk).is_err());
|
|
}
|
|
}
|