use super::*;
use crate::core::ObjectKind;
use crate::materials::Material;
const PLAIN: &[u8] = include_bytes!("../testdata/sphere_plain.glb");
const MESHOPT: &[u8] = include_bytes!("../testdata/sphere_meshopt.glb");
const DRACO: &[u8] = include_bytes!("../testdata/sphere_draco.glb");
const FEATURES_GLTF: &str = include_str!("../testdata/gltf/features.gltf");
const FEATURES_GLB: &[u8] = include_bytes!("../testdata/gltf/features.glb");
const EXTERNAL_GLTF: &str = include_str!("../testdata/gltf/external.gltf");
const EXTERNAL_BIN: &[u8] = include_bytes!("../testdata/gltf/external.bin");
const CHECKER_PNG: &[u8] = include_bytes!("../testdata/gltf/checker.png");
fn parse(bytes: &[u8]) -> (GltfParser, ObjectArena) {
let doc = Document::from_bytes(bytes).expect("container");
let mut parser = GltfParser::new(doc, GltfOptions { refuse_unknown_required: false, ..Default::default() })
.expect("parser");
supply_images(&mut parser, &GltfImages::new()).expect("images");
let mut arena = ObjectArena::new();
parser.parse(&mut arena).expect("parse");
(parser, arena)
}
fn dump(p: &GltfParser, arena: &ObjectArena, o: usize, depth: usize, out: &mut String) {
let obj = &p.objects[o];
let ty = match obj.ty {
ObjectType::InstancedMesh => "Mesh",
t => t.name(),
};
out.push_str(&format!("{}{} \"{}\"", " ".repeat(depth), ty, obj.name));
if let Some(m) = obj.material {
out.push_str(&format!(" mat={}:{}", p.materials[m].ty.name(), p.materials[m].name));
}
if let Some(inf) = &obj.morph_influences {
let v: Vec<String> = inf.iter().map(|x| format!("{x}")).collect();
out.push_str(&format!(" inf=[{}]", v.join(",")));
}
out.push('\n');
for c in &arena.get(obj.id).unwrap().children {
dump(p, arena, p.object_index(*c).unwrap(), depth + 1, out);
}
}
fn find(p: &GltfParser, name: &str) -> usize {
p.objects.iter().position(|o| o.name == name).unwrap_or_else(|| panic!("no object {name}"))
}
const THREE_OUTLINE: &str = r#"Group "Main_Scene"
Object3D "Parent"
Mesh "Child" mat=MeshStandardMaterial:Textured
Mesh "Dup" mat=MeshStandardMaterial:Blend
Group "Dup_1"
Mesh "Multi" mat=MeshBasicMaterial:Unlit
Mesh "Multi_1" mat=MeshStandardMaterial:
Mesh "Multi_2" mat=MeshStandardMaterial:
Mesh "Shared_A" mat=MeshStandardMaterial:Plain
Mesh "Shared_B" mat=MeshStandardMaterial:Plain
Mesh "mesh_4" mat=MeshStandardMaterial:Blend
PerspectiveCamera "CamPersp"
OrthographicCamera "Cam_Ortho"
PerspectiveCamera "CamShared"
DirectionalLight "Lit"
Object3D ""
PointLight "light_1"
SpotLight "SpotA"
Object3D ""
Group "SpotB"
Group "_instance_1"
Mesh "Multi" mat=MeshBasicMaterial:Unlit
Mesh "Multi_1" mat=MeshStandardMaterial:
Mesh "Multi_2" mat=MeshStandardMaterial:
SpotLight "Spot_Light_instance_1"
Object3D ""
SkinnedMesh "Skinned" mat=MeshStandardMaterial:Plain
Mesh "Morph" mat=MeshStandardMaterial:Plain inf=[0.1,0.2,0.3]
Mesh "Instanced" mat=MeshStandardMaterial:Plain
Group "Modes"
Points "Modes_1" mat=PointsMaterial:Blend
LineSegments "Modes_2" mat=LineBasicMaterial:Blend
LineLoop "Modes_3" mat=LineBasicMaterial:
Line "Modes_4" mat=LineBasicMaterial:Lines
Mesh "Modes_5" mat=MeshStandardMaterial:Plain
Mesh "Modes_6" mat=MeshStandardMaterial:Plain
Object3D "Skeleton"
Bone "Bone_Root"
Bone "Bone_Tip"
Mesh "Quantized" mat=MeshStandardMaterial:Textured
Group "Multi_Morph"
Mesh "MultiMorph" mat=MeshStandardMaterial: inf=[1]
Mesh "MultiMorph_1" mat=MeshStandardMaterial: inf=[1]
Group "Physical"
Mesh "PhysicalMesh" mat=MeshPhysicalMaterial:Clearcoat & co
Mesh "PhysicalMesh_1" mat=MeshPhysicalMaterial:Glass
Mesh "PhysicalMesh_2" mat=MeshPhysicalMaterial:Brushed
"#;
#[test]
fn the_feature_file_has_three_js_structure_and_names() {
for bytes in [FEATURES_GLTF.as_bytes(), FEATURES_GLB] {
let (p, arena) = parse(bytes);
let mut out = String::new();
dump(&p, &arena, p.default_scene().unwrap(), 0, &mut out);
assert_eq!(out, THREE_OUTLINE);
let tracks: Vec<Vec<String>> = p
.clips
.iter()
.map(|c| c.tracks.iter().map(|t| format!("{}.{}", p.objects[t.target].name, t.property)).collect())
.collect();
assert_eq!(
tracks,
vec![
vec![
"Parent.position",
"Bone_Tip.quaternion",
"Shared_A.scale",
"Morph.morphTargetInfluences",
"Animated_Only.position"
],
vec!["MultiMorph.morphTargetInfluences", "MultiMorph_1.morphTargetInfluences"],
]
);
assert_eq!(p.clips[0].name, "Move");
assert_eq!(p.clips[1].name, "animation_1");
let cams: Vec<String> = p.cameras.iter().map(|c| p.objects[c.unwrap()].name.clone()).collect();
assert_eq!(cams, ["Lens", "Cam_Ortho", "Unused"]);
}
}
#[test]
fn every_node_is_the_kind_of_rust_node_it_says() {
let (p, arena) = parse(FEATURES_GLTF.as_bytes());
for o in &p.objects {
let node = arena.get(o.id).expect("node in the arena");
assert_eq!(node.name, o.name);
let ok = match (o.ty, &node.kind) {
(ObjectType::Mesh, ObjectKind::Mesh(_)) => true,
(ObjectType::SkinnedMesh, ObjectKind::SkinnedMesh(_)) => true,
(ObjectType::InstancedMesh, ObjectKind::InstancedMesh(im)) => im.transforms.len() == 3,
(ObjectType::Points, ObjectKind::Points(_)) => true,
(ObjectType::LineSegments, ObjectKind::LineSegments(l)) => l.strip.is_none(),
(ObjectType::Line, ObjectKind::LineSegments(l)) => l.strip.as_ref().is_some_and(|s| !s.closed),
(ObjectType::LineLoop, ObjectKind::LineSegments(l)) => l.strip.as_ref().is_some_and(|s| s.closed),
(ObjectType::DirectionalLight | ObjectType::PointLight | ObjectType::SpotLight, ObjectKind::Light(_)) => true,
(ObjectType::Group, ObjectKind::Group) => node.is_group,
(
ObjectType::Object3D | ObjectType::Bone | ObjectType::PerspectiveCamera | ObjectType::OrthographicCamera,
ObjectKind::Group,
) => !node.is_group,
_ => false,
};
assert!(ok, "{:?} {:?} became {:?}", o.ty, o.name, std::mem::discriminant(&node.kind));
}
}
#[test]
fn transforms_follow_trs_and_matrix() {
let (p, arena) = parse(FEATURES_GLTF.as_bytes());
let parent = arena.get(p.objects[find(&p, "Parent")].id).unwrap();
assert_eq!(parent.position, Vector3::new(1.0, 2.0, 3.0));
assert!((parent.quaternion.y - 0.382_683_4).abs() < 1e-6);
assert_eq!(parent.scale, Vector3::new(2.0, 2.0, 2.0));
let child = arena.get(p.objects[find(&p, "Child")].id).unwrap();
assert_eq!(child.position, Vector3::new(5.0, 6.0, 7.0));
assert!((child.quaternion.x + std::f32::consts::FRAC_1_SQRT_2).abs() < 1e-6, "{:?}", child.quaternion);
assert!((child.scale.x - 1.0).abs() < 1e-6);
}
#[test]
fn attributes_are_read_as_three_reads_them() {
let (p, _) = parse(FEATURES_GLTF.as_bytes());
let geo = |name: &str| &p.geometries[p.objects[find(&p, name)].geometry.unwrap()];
let q = geo("Quantized");
assert_eq!(q.attribute_order, ["position", "normal", "uv", "color"]);
let pos = &q.get().get_attribute("position").unwrap().array;
assert_eq!(pos, &[0.0, 0.0, 0.0, 100.0, 0.0, 0.0, 50.0, 0.0, 100.0, 0.0, 0.0, 0.0]);
let n = &q.get().get_attribute("normal").unwrap().array;
assert_eq!(n[2], 1.0);
assert_eq!(n[8], -1.0);
let uv = &q.get().get_attribute("uv").unwrap().array;
assert_eq!(uv[7], 32768.0 / 65535.0);
let c = q.get().get_attribute("color").unwrap();
assert_eq!(c.item_size, 4);
assert_eq!(c.array[7], 128.0 / 255.0);
assert_eq!(q.get().index.as_ref().unwrap(), &vec![0, 1, 2, 2, 1, 3]);
let multi = find(&p, "Multi_1");
let g = p.geometries[p.objects[multi].geometry.unwrap()].get();
assert_eq!(g.get_attribute("position").unwrap().array, vec![0.0, 0.0, 0.0, 2.0, 0.0, 0.0, 0.0, 0.0, 2.0]);
assert_eq!(g.get_attribute("normal").unwrap().array, vec![0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0]);
let sp = geo("mesh_4");
assert_eq!(sp.get().get_attribute("position").unwrap().array[3..6], [0.5, 0.5, 0.5]);
let bb = geo("Child").get().bounding_box.unwrap();
assert_eq!((bb.min, bb.max), (Vector3::ZERO, Vector3::new(1.0, 1.0, 0.0)));
}
#[test]
fn morph_targets_skins_and_instances() {
let (p, arena) = parse(FEATURES_GLTF.as_bytes());
let m = &p.objects[find(&p, "Morph")];
let geo = &p.geometries[m.geometry.unwrap()];
assert!(geo.get().morph_targets_relative);
assert_eq!(geo.morph_order, ["position", "normal"]);
let pos = &geo.get().morph_attributes["position"];
assert_eq!(pos[1].array, vec![0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.25, 0.5, 0.0, 0.0, 0.0, 0.0]);
assert_eq!(pos[2].array, geo.get().get_attribute("position").unwrap().array);
assert_eq!(m.morph_dictionary, [("bulge".into(), 0), ("sparse".into(), 1), ("tilt".into(), 2)]);
let s = &p.objects[find(&p, "Skinned")];
let sk = &p.skeletons[s.skeleton.unwrap()];
assert_eq!(sk.bones.iter().map(|b| p.objects[*b].name.as_str()).collect::<Vec<_>>(), ["Bone_Root", "Bone_Tip"]);
assert_eq!(sk.inverses[1][12..15], [-0.5, -1.0, 0.0]);
let w = &p.geometries[s.geometry.unwrap()].get().get_attribute("skinWeight").unwrap().array;
let bytes: Vec<f32> = w.iter().map(|v| (v * 255.0).round()).collect();
assert_eq!(bytes, [200.0, 55.0, 0.0, 0.0, 127.0, 127.0, 0.0, 0.0, 255.0, 0.0, 0.0, 0.0, 255.0, 0.0, 0.0, 0.0]);
let ObjectKind::SkinnedMesh(sm) = &arena.get(s.id).unwrap().kind else { panic!() };
assert_eq!(sm.skeleton.bones.len(), 2);
assert!(sm.geometry.get_attribute("joint").is_some() && sm.geometry.get_attribute("weight").is_some());
let inst = &p.objects[find(&p, "Instanced")];
let i = inst.instances.as_ref().unwrap();
assert_eq!(i.count, 3);
assert_eq!(i.matrices[16 + 12..16 + 15], [2.0, 0.0, 0.0]);
assert_eq!(i.colors.as_ref().unwrap().0[..3], [1.0, 0.0, 0.0]);
assert!(p.geometries[inst.geometry.unwrap()].attribute_order.contains(&"_ID".to_string()));
}
#[test]
fn materials_carry_three_js_parameters() {
let (p, _) = parse(FEATURES_GLTF.as_bytes());
let mat = |name: &str| p.materials.iter().find(|m| m.name == name && m.params.contains_key("color")).unwrap();
let textured = mat("Textured");
assert_eq!(textured.params["color"], Param::Color([1.0, 0.5, 0.25]));
assert_eq!(textured.num("opacity"), Some(0.75));
assert_eq!(textured.num("alphaTest"), Some(0.3));
assert_eq!(textured.num("side"), Some(2.0));
assert_eq!(textured.num("aoMapIntensity"), Some(0.6));
let map = &p.textures[textured.texture("map").unwrap()];
assert_eq!((map.offset, map.repeat, map.rotation), ([0.5, 0.25], [2.0, 3.0], 0.3));
assert!(map.srgb);
let ao = &p.textures[textured.texture("aoMap").unwrap()];
assert_eq!(ao.channel, 1);
assert_eq!(ao.min_filter, 1008);
let glass = mat("Glass");
assert_eq!(glass.ty, MaterialType::MeshPhysicalMaterial);
assert_eq!(glass.num("attenuationDistance"), Some(2.0));
assert_eq!(glass.params["iridescenceThicknessRange"], Param::Range([100.0, 500.0]));
assert_eq!(mat("Brushed").num("attenuationDistance"), Some(f64::INFINITY));
let unlit = mat("Unlit");
assert_eq!(unlit.ty, MaterialType::MeshBasicMaterial);
assert!(unlit.texture("normalMap").is_none());
let Some(Material::Physical(ph)) = mat("Clearcoat & co").rust.as_deref() else { panic!() };
assert_eq!((ph.clearcoat, ph.ior, ph.emissive_intensity), (0.8, 1.8, 4.0));
assert!(!ph.map.as_ref().unwrap().flip_y);
}
#[test]
fn external_resources_are_supplied_by_the_caller() {
let doc = Document::from_bytes(EXTERNAL_GLTF.as_bytes()).unwrap();
assert_eq!(doc.external_buffers(), vec![(0, "external.bin".to_string())]);
let mut doc = doc;
doc.set_buffer(0, EXTERNAL_BIN.to_vec());
let mut parser = GltfParser::new(doc, GltfOptions::default()).unwrap();
let pending = parser.pending_images().unwrap();
assert_eq!(pending.len(), 1);
assert_eq!(pending[0].source.uri.as_deref(), Some("checker.png"));
assert!(parser.set_image_bytes(0, CHECKER_PNG));
assert!(parser.pending_images().unwrap().is_empty());
let mut arena = ObjectArena::new();
parser.parse(&mut arena).unwrap();
let m = &parser.materials[parser.objects[find(&parser, "Ext")].material.unwrap()];
let t = &parser.textures[m.texture("map").unwrap()];
assert_eq!(t.image_data.size(), (4, 4));
assert_eq!(t.name, "checker.png");
}
fn mesh(bytes: &[u8]) -> (Vec<f32>, Option<Vec<f32>>, Option<Vec<u32>>) {
let scene = GltfLoader::parse_glb(bytes).expect("parses");
let (_, object) = scene
.arena
.nodes
.iter()
.find(|(_, o)| matches!(o.kind, ObjectKind::Mesh(_)))
.expect("a mesh");
let ObjectKind::Mesh(m) = &object.kind else { unreachable!() };
(
m.geometry.get_attribute("position").unwrap().array.clone(),
m.geometry.get_attribute("normal").map(|a| a.array.clone()),
m.geometry.index.clone(),
)
}
#[test]
fn a_meshopt_file_reads_as_the_same_mesh() {
let (plain, _, plain_index) = mesh(PLAIN);
let (ours, normals, index) = mesh(MESHOPT);
assert_eq!(ours.len(), plain.len(), "same vertex count");
assert_eq!(index.as_ref().map(Vec::len), plain_index.as_ref().map(Vec::len), "same index count");
assert!(normals.is_some(), "normals survived the filter");
let tolerance = 2.0 / 32767.0 * 4.0;
for v in ours.chunks_exact(3) {
let nearest = plain
.chunks_exact(3)
.map(|p| ((p[0] - v[0]).powi(2) + (p[1] - v[1]).powi(2) + (p[2] - v[2]).powi(2)).sqrt())
.fold(f32::MAX, f32::min);
assert!(nearest < tolerance, "decoded vertex {v:?} is {nearest} from anything in the original");
}
for v in ours.chunks_exact(3) {
let r = (v[0] * v[0] + v[1] * v[1] + v[2] * v[2]).sqrt();
assert!((r - 1.0).abs() < 1e-3, "{v:?} is at radius {r}, not 1");
}
}
#[test]
fn meshopt_indices_are_a_valid_triangle_list() {
let (positions, _, index) = mesh(MESHOPT);
let index = index.expect("indices");
let vertices = positions.len() / 3;
assert_eq!(index.len() % 3, 0, "whole triangles");
for &i in &index {
assert!((i as usize) < vertices, "index {i} past {vertices} vertices");
}
for t in index.chunks_exact(3) {
assert!(t[0] != t[1] && t[1] != t[2] && t[0] != t[2], "degenerate {t:?}");
}
}
#[test]
fn a_file_requiring_an_unimplemented_extension_is_refused() {
let json = r#"{"asset":{"version":"2.0"},
"extensionsRequired":["EXT_not_a_real_extension"],
"scene":0,"scenes":[{"nodes":[]}],"nodes":[]}"#;
let root = crate::loaders::json::parse(json).expect("parses");
match GltfLoader::build_for_test(&root) {
Err(GltfError::UnsupportedExtension(name)) => assert_eq!(name, "EXT_not_a_real_extension"),
Err(other) => panic!("expected a named refusal, got {other:?}"),
Ok(_) => panic!("a file requiring an unknown extension must not load"),
}
}
#[test]
fn an_unknown_required_extension_is_a_warning_in_three_mode() {
let json = r#"{"asset":{"version":"2.0"},
"extensionsUsed":["EXT_not_a_real_extension"],
"extensionsRequired":["EXT_not_a_real_extension"],
"scene":0,"scenes":[{"nodes":[]}],"nodes":[]}"#;
let doc = Document::from_bytes(json.as_bytes()).unwrap();
let p = GltfParser::new(doc, GltfOptions { refuse_unknown_required: false, ..Default::default() }).unwrap();
assert_eq!(p.warnings, ["THREE.GLTFLoader: Unknown extension \"EXT_not_a_real_extension\"."]);
}
#[test]
fn an_extension_only_used_is_not_fatal() {
let json = r#"{"asset":{"version":"2.0"},
"extensionsUsed":["KHR_materials_variants","SOMETHING_INVENTED"],
"scene":0,"scenes":[{"nodes":[]}],"nodes":[]}"#;
let root = crate::loaders::json::parse(json).expect("parses");
assert!(GltfLoader::build_for_test(&root).is_ok());
}
#[test]
fn a_required_extension_that_is_implemented_loads() {
assert!(GltfLoader::parse_glb(MESHOPT).is_ok());
}
#[test]
fn a_version_one_asset_is_refused() {
let doc = Document::from_bytes(br#"{"asset":{"version":"1.0"}}"#);
assert!(matches!(doc, Err(GltfError::UnsupportedVersion)));
}
#[test]
fn a_draco_primitive_decodes_to_the_same_mesh_as_its_plain_twin() {
let (dp, dn, di) = mesh(DRACO);
let (pp, pn, pi) = mesh(PLAIN);
assert_eq!(dp.len(), pp.len(), "the same number of position floats");
assert_eq!(dp.len() / 3, 423);
assert_eq!(di.as_ref().map(|i| i.len()), Some(2160));
assert_eq!(pi.as_ref().map(|i| i.len()), Some(2160));
assert!(dn.is_some() && pn.is_some(), "both carry normals");
let dedup = |v: &[f32]| -> Vec<[f32; 3]> {
let mut out: Vec<[f32; 3]> = Vec::new();
for p in v.chunks(3) {
let p = [p[0], p[1], p[2]];
if !out.contains(&p) {
out.push(p);
}
}
out
};
let plain_unique = dedup(&pp);
assert_eq!(plain_unique.len(), 362, "distinct positions in the plain file");
assert_eq!(dedup(&dp).len(), 362, "distinct decoded positions");
let nearest = |p: &[f32]| -> (usize, f32) {
let mut best = (0usize, f32::MAX);
for (i, q) in plain_unique.iter().enumerate() {
let d = (p[0] - q[0]).powi(2) + (p[1] - q[1]).powi(2) + (p[2] - q[2]).powi(2);
if d < best.1 {
best = (i, d);
}
}
(best.0, best.1.sqrt())
};
let mut worst = 0.0f32;
let mut canonical = Vec::with_capacity(dp.len() / 3);
for p in dp.chunks(3) {
let (i, d) = nearest(p);
worst = worst.max(d);
canonical.push(i);
}
assert!(worst < 2e-3, "a decoded position is {worst} from the nearest in the plain file");
let hit: std::collections::BTreeSet<usize> = canonical.iter().copied().collect();
assert_eq!(hit.len(), 362, "the decode does not cover every position");
let plain_canonical: Vec<usize> = pp.chunks(3).map(|p| nearest(p).0).collect();
let faces = |idx: &[u32], canon: &[usize]| -> std::collections::BTreeSet<[usize; 3]> {
idx.chunks(3)
.map(|t| {
let mut k = [canon[t[0] as usize], canon[t[1] as usize], canon[t[2] as usize]];
k.sort();
k
})
.collect()
};
let df = faces(di.as_ref().unwrap(), &canonical);
let pf = faces(pi.as_ref().unwrap(), &plain_canonical);
assert_eq!(df.len(), 720, "720 distinct triangles decoded");
assert_eq!(df, pf, "the decoded faces are not the plain file's faces");
}
#[test]
fn draco_attributes_are_matched_by_id_not_order() {
let (positions, normals, _) = mesh(DRACO);
let normals = normals.expect("normals");
assert_eq!(normals.len(), positions.len());
let mut worst = 0.0f32;
for (p, n) in positions.chunks(3).zip(normals.chunks(3)) {
let dot = p[0] * n[0] + p[1] * n[1] + p[2] * n[2];
worst = worst.max((dot - 1.0).abs());
}
assert!(worst < 0.05, "normals disagree with positions by {worst} — attributes are crossed");
}
#[test]
fn the_plain_file_still_reads() {
let (positions, normals, index) = mesh(PLAIN);
assert_eq!(positions.len() / 3, 423);
assert!(normals.is_some());
assert_eq!(index.map(|i| i.len()), Some(2160));
}
#[test]
fn truncated_files_do_not_panic() {
for file in [MESHOPT, DRACO, PLAIN, FEATURES_GLB, FEATURES_GLTF.as_bytes()] {
for cut in [4, 11, 16, 64, 256, 1024, 4096, 7000, 12000] {
if cut < file.len() {
let _ = GltfLoader::parse_glb(&file[..cut]);
let doc = Document::from_bytes(&file[..cut]);
if let Ok(doc) = doc {
if let Ok(mut p) = GltfParser::new(doc, GltfOptions::default()) {
let _ = supply_images(&mut p, &GltfImages::new());
let _ = p.parse(&mut ObjectArena::new());
}
}
}
}
}
}
#[test]
fn morph_targets_load_as_three() {
let src = include_str!("../testdata/morph_sparse.gltf");
let scene = GltfLoader::parse_gltf(src, &HashMap::new()).expect("parses");
let id = scene.roots[0];
let ObjectKind::Mesh(mesh) = &scene.arena.get(id).unwrap().kind else {
panic!("a mesh node");
};
let g = &mesh.geometry;
assert!(g.morph_targets_relative);
let targets: Vec<Vec<f32>> = g.morph_attributes["position"].iter().map(|a| a.array.clone()).collect();
assert_eq!(
targets,
vec![vec![0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0], vec![0.5, 0.0, 0.0, 0.5, 0.0, 0.0, 0.0, 0.5, 0.0]]
);
assert_eq!(mesh.morph_influences, vec![0.25, 0.5]);
assert_eq!(mesh.morph_target_dictionary.get("up"), Some(&0));
assert_eq!(mesh.morph_target_dictionary.get("wide"), Some(&1));
let tracks = &scene.animations[0].tracks;
assert_eq!(tracks.len(), 2);
for (t, want) in tracks.iter().zip([[0.0, 1.0], [1.0, 0.0]]) {
assert_eq!(t.object, id);
assert_eq!(t.times, vec![0.0, 1.0]);
assert_eq!(t.sample_scalar(0.0), Some(want[0]));
assert_eq!(t.sample_scalar(1.0), Some(want[1]));
}
}