use crate::{
Interpolation, OwnedArgument, OwnedData, ResolveError, Sampled, Scene,
};
use core::mem;
use nsi_ffi_wrap::nsi_sys::NSIParamFlags;
use nsi_trait::Type;
fn translate(x: f64, y: f64, z: f64) -> OwnedArgument {
#[rustfmt::skip]
let m = vec![
1.0, 0.0, 0.0, 0.0,
0.0, 1.0, 0.0, 0.0,
0.0, 0.0, 1.0, 0.0,
x, y, z, 1.0,
];
OwnedArgument {
name: "transformationmatrix".to_string(),
type_tag: Type::MatrixF64,
array_length: 1,
flags: 0,
data: OwnedData::F64(m),
}
}
fn scale(s: f64) -> OwnedArgument {
#[rustfmt::skip]
let m = vec![
s, 0.0, 0.0, 0.0,
0.0, s, 0.0, 0.0,
0.0, 0.0, s, 0.0,
0.0, 0.0, 0.0, 1.0,
];
OwnedArgument {
name: "transformationmatrix".to_string(),
type_tag: Type::MatrixF64,
array_length: 1,
flags: 0,
data: OwnedData::F64(m),
}
}
#[test]
fn a_node_with_no_transforms_is_identity() {
let mut scene = Scene::default();
scene.create("mesh", "mesh").unwrap();
scene.connect("mesh", None, ".root", "objects").unwrap();
assert_eq!(scene.world_transform("mesh").unwrap(), super::IDENTITY);
}
#[test]
fn a_detached_node_is_an_error_not_identity() {
let mut scene = Scene::default();
scene.create("mesh", "mesh").unwrap();
assert_eq!(
scene.world_transform("mesh"),
Err(ResolveError::Detached {
handle: "mesh".to_string()
})
);
}
#[test]
fn detachment_is_reported_at_the_node_that_fails_to_reach_root() {
let mut scene = Scene::default();
scene.create("grp", "transform").unwrap();
scene.create("mesh", "mesh").unwrap();
scene.connect("mesh", None, "grp", "objects").unwrap();
assert_eq!(
scene.world_transform("mesh"),
Err(ResolveError::Detached {
handle: "grp".to_string()
})
);
}
#[test]
fn a_single_transform_applies_to_its_child() {
let mut scene = Scene::default();
scene.create("xf", "transform").unwrap();
scene
.set_attribute("xf", vec![translate(1.0, 2.0, 3.0)])
.unwrap();
scene.create("mesh", "mesh").unwrap();
scene.connect("mesh", None, "xf", "objects").unwrap();
scene.connect("xf", None, ".root", "objects").unwrap();
let m = scene.world_transform("mesh").unwrap();
assert_eq!(&m[12..15], &[1.0, 2.0, 3.0]);
}
#[test]
fn nested_transforms_compose() {
let mut scene = Scene::default();
scene.create("outer", "transform").unwrap();
scene
.set_attribute("outer", vec![translate(10.0, 0.0, 0.0)])
.unwrap();
scene.create("inner", "transform").unwrap();
scene
.set_attribute("inner", vec![translate(1.0, 0.0, 0.0)])
.unwrap();
scene.create("mesh", "mesh").unwrap();
scene.connect("mesh", None, "inner", "objects").unwrap();
scene.connect("inner", None, "outer", "objects").unwrap();
scene.connect("outer", None, ".root", "objects").unwrap();
let m = scene.world_transform("mesh").unwrap();
assert_eq!(m[12], 11.0);
}
#[test]
fn child_transform_applies_before_parent() {
let mut scene = Scene::default();
scene.create("outer", "transform").unwrap();
scene
.set_attribute("outer", vec![translate(10.0, 0.0, 0.0)])
.unwrap();
scene.create("inner", "transform").unwrap();
scene.set_attribute("inner", vec![scale(2.0)]).unwrap();
scene.create("mesh", "mesh").unwrap();
scene.connect("mesh", None, "inner", "objects").unwrap();
scene.connect("inner", None, "outer", "objects").unwrap();
scene.connect("outer", None, ".root", "objects").unwrap();
let m = scene.world_transform("mesh").unwrap();
assert_eq!(m[0], 2.0, "scale survives");
assert_eq!(m[12], 10.0, "translation is not scaled");
}
#[test]
fn a_transforms_own_matrix_is_included() {
let mut scene = Scene::default();
scene.create("xf", "transform").unwrap();
scene
.set_attribute("xf", vec![translate(5.0, 0.0, 0.0)])
.unwrap();
scene.connect("xf", None, ".root", "objects").unwrap();
assert_eq!(scene.world_transform("xf").unwrap()[12], 5.0);
}
#[test]
fn a_cycle_is_an_error() {
let mut scene = Scene::default();
scene.create("a", "transform").unwrap();
scene.create("b", "transform").unwrap();
scene.connect("a", None, "b", "objects").unwrap();
scene.connect("b", None, "a", "objects").unwrap();
assert_eq!(
scene.world_transform("a"),
Err(ResolveError::Cycle {
handle: "a".to_string()
})
);
}
#[test]
fn more_than_one_parent_is_an_error() {
let mut scene = Scene::default();
scene.create("left", "transform").unwrap();
scene
.set_attribute("left", vec![translate(1.0, 0.0, 0.0)])
.unwrap();
scene.create("right", "transform").unwrap();
scene
.set_attribute("right", vec![translate(9.0, 0.0, 0.0)])
.unwrap();
scene.create("mesh", "mesh").unwrap();
scene.connect("mesh", None, "left", "objects").unwrap();
scene.connect("mesh", None, "right", "objects").unwrap();
assert_eq!(
scene.world_transform("mesh"),
Err(ResolveError::MultipleParents {
handle: "mesh".to_string(),
parents: vec!["left".to_string(), "right".to_string()],
})
);
}
#[test]
fn a_motion_sampled_transform_is_an_error() {
let mut scene = Scene::default();
scene.create("xf", "transform").unwrap();
scene
.set_attribute_at_time("xf", 0.0, vec![translate(0.0, 0.0, 0.0)])
.unwrap();
scene
.set_attribute_at_time("xf", 1.0, vec![translate(5.0, 0.0, 0.0)])
.unwrap();
scene.create("mesh", "mesh").unwrap();
scene.connect("mesh", None, "xf", "objects").unwrap();
scene.connect("xf", None, ".root", "objects").unwrap();
assert_eq!(
scene.world_transform("mesh"),
Err(ResolveError::MotionSampledTransform {
handle: "xf".to_string()
})
);
}
#[test]
fn motion_samples_of_other_attributes_do_not_block_resolution() {
let mut scene = Scene::default();
scene.create("xf", "transform").unwrap();
scene
.set_attribute("xf", vec![translate(5.0, 0.0, 0.0)])
.unwrap();
scene
.set_attribute_at_time(
"xf",
0.5,
vec![OwnedArgument {
name: "unrelated".to_string(),
type_tag: Type::F64,
array_length: 1,
flags: 0,
data: OwnedData::F64(vec![1.0]),
}],
)
.unwrap();
scene.connect("xf", None, ".root", "objects").unwrap();
assert_eq!(scene.world_transform("xf").unwrap()[12], 5.0);
}
#[test]
fn a_sampled_chain_resolves_per_sample() {
let mut scene = Scene::default();
scene.create("xf", "transform").unwrap();
scene
.set_attribute_at_time("xf", 0.0, vec![translate(0.0, 0.0, 0.0)])
.unwrap();
scene
.set_attribute_at_time("xf", 1.0, vec![translate(5.0, 0.0, 0.0)])
.unwrap();
scene.create("mesh", "mesh").unwrap();
scene.connect("mesh", None, "xf", "objects").unwrap();
scene.connect("xf", None, ".root", "objects").unwrap();
assert_eq!(scene.world_transform_at("mesh", 0.0).unwrap()[12], 0.0);
assert_eq!(scene.world_transform_at("mesh", 1.0).unwrap()[12], 5.0);
}
#[test]
fn a_static_parent_composes_with_a_sampled_child() {
let mut scene = Scene::default();
scene.create("grp", "transform").unwrap();
scene
.set_attribute("grp", vec![translate(100.0, 0.0, 0.0)])
.unwrap();
scene.create("xf", "transform").unwrap();
scene
.set_attribute_at_time("xf", 0.0, vec![translate(0.0, 0.0, 0.0)])
.unwrap();
scene
.set_attribute_at_time("xf", 1.0, vec![translate(5.0, 0.0, 0.0)])
.unwrap();
scene.connect("xf", None, "grp", "objects").unwrap();
scene.connect("grp", None, ".root", "objects").unwrap();
assert_eq!(scene.world_transform_at("xf", 0.0).unwrap()[12], 100.0);
assert_eq!(scene.world_transform_at("xf", 1.0).unwrap()[12], 105.0);
}
#[test]
fn motion_times_are_the_union_of_the_chain() {
let mut scene = Scene::default();
scene.create("outer", "transform").unwrap();
scene
.set_attribute_at_time("outer", 0.5, vec![translate(1.0, 0.0, 0.0)])
.unwrap();
scene
.set_attribute_at_time("outer", 0.0, vec![translate(0.0, 0.0, 0.0)])
.unwrap();
scene.create("inner", "transform").unwrap();
scene
.set_attribute_at_time("inner", 2.0, vec![translate(0.0, 0.0, 0.0)])
.unwrap();
scene
.set_attribute_at_time("inner", 0.0, vec![translate(0.0, 0.0, 0.0)])
.unwrap();
scene.connect("inner", None, "outer", "objects").unwrap();
scene.connect("outer", None, ".root", "objects").unwrap();
assert_eq!(scene.motion_times("inner").unwrap(), vec![0.0, 0.5, 2.0]);
}
#[test]
fn a_static_chain_has_no_motion_times() {
let mut scene = Scene::default();
scene.create("xf", "transform").unwrap();
scene
.set_attribute("xf", vec![translate(5.0, 0.0, 0.0)])
.unwrap();
scene
.set_attribute_at_time(
"xf",
0.5,
vec![OwnedArgument {
name: "unrelated".to_string(),
type_tag: Type::F64,
array_length: 1,
flags: 0,
data: OwnedData::F64(vec![1.0]),
}],
)
.unwrap();
scene.connect("xf", None, ".root", "objects").unwrap();
assert!(scene.motion_times("xf").unwrap().is_empty());
assert_eq!(
scene.world_transform_at("xf", 0.25).unwrap(),
scene.world_transform("xf").unwrap()
);
}
#[test]
fn samples_pair_every_time_with_its_matrix() {
let mut scene = Scene::default();
scene.create("xf", "transform").unwrap();
scene
.set_attribute_at_time("xf", 0.0, vec![translate(0.0, 0.0, 0.0)])
.unwrap();
scene
.set_attribute_at_time("xf", 0.5, vec![translate(2.0, 0.0, 0.0)])
.unwrap();
scene.connect("xf", None, ".root", "objects").unwrap();
let samples = scene.world_transform_samples("xf").unwrap();
assert_eq!(samples.len(), 2);
assert_eq!(samples[0].0, 0.0);
assert_eq!(samples[0].1[12], 0.0);
assert_eq!(samples[1].0, 0.5);
assert_eq!(samples[1].1[12], 2.0);
}
#[test]
fn a_time_between_samples_is_an_error_not_an_interpolation() {
let mut scene = Scene::default();
scene.create("xf", "transform").unwrap();
scene
.set_attribute_at_time("xf", 0.0, vec![translate(0.0, 0.0, 0.0)])
.unwrap();
scene
.set_attribute_at_time("xf", 1.0, vec![translate(5.0, 0.0, 0.0)])
.unwrap();
scene.connect("xf", None, ".root", "objects").unwrap();
assert_eq!(
scene.world_transform_at("xf", 0.5),
Err(ResolveError::MissingSampleAtTime {
handle: "xf".to_string(),
time: 0.5,
available: vec![0.0, 1.0],
})
);
}
#[test]
fn a_chain_sampled_at_different_times_resolves() {
let mut scene = Scene::default();
scene.create("outer", "transform").unwrap();
scene
.set_attribute_at_time("outer", 0.0, vec![translate(0.0, 0.0, 0.0)])
.unwrap();
scene
.set_attribute_at_time("outer", 0.5, vec![translate(2.0, 0.0, 0.0)])
.unwrap();
scene.create("inner", "transform").unwrap();
scene
.set_attribute_at_time("inner", 0.25, vec![translate(0.0, 0.0, 0.0)])
.unwrap();
scene
.set_attribute_at_time("inner", 0.75, vec![translate(4.0, 0.0, 0.0)])
.unwrap();
scene.connect("inner", None, "outer", "objects").unwrap();
scene.connect("outer", None, ".root", "objects").unwrap();
let times = scene.motion_times("inner").unwrap();
assert_eq!(times, vec![0.0, 0.25, 0.5, 0.75], "the union of both");
let samples = scene.world_transform_samples("inner").unwrap();
assert_eq!(samples.len(), 4);
for (time, matrix) in &samples {
assert_eq!(
*matrix,
scene
.world_transform_interpolated_at("inner", *time)
.unwrap(),
"the sweep agrees with the interpolating accessor at {time}",
);
}
assert_eq!(samples[2].1[12], 4.0);
}
#[test]
fn a_non_f64_matrix_is_skipped_not_reinterpreted() {
let mut scene = Scene::default();
scene.create("xf", "transform").unwrap();
#[rustfmt::skip]
let m = vec![
1.0f32, 0.0, 0.0, 0.0,
0.0, 1.0, 0.0, 0.0,
0.0, 0.0, 1.0, 0.0,
7.0, 0.0, 0.0, 1.0,
];
scene
.set_attribute(
"xf",
vec![OwnedArgument {
name: "transformationmatrix".to_string(),
type_tag: Type::MatrixF32,
array_length: 1,
flags: 0,
data: OwnedData::F32(m),
}],
)
.unwrap();
scene.connect("xf", None, ".root", "objects").unwrap();
assert_eq!(scene.world_transform("xf").unwrap(), super::IDENTITY);
}
fn index_arg(value: i32) -> OwnedArgument {
OwnedArgument {
name: "index".to_string(),
..priority(value)
}
}
fn priority(value: i32) -> OwnedArgument {
OwnedArgument {
name: "priority".to_string(),
type_tag: Type::I32,
array_length: 1,
flags: 0,
data: OwnedData::I32(vec![value]),
}
}
fn scene_with_material() -> Scene {
let mut scene = Scene::default();
scene.create("mesh", "mesh").unwrap();
scene.create("attr", "attributes").unwrap();
scene.create("shader", "shader").unwrap();
scene.connect("mesh", None, ".root", "objects").unwrap();
scene
.connect("attr", None, "mesh", "geometryattributes")
.unwrap();
scene
.connect("shader", None, "attr", "surfaceshader")
.unwrap();
scene
}
#[test]
fn dissolves_attributes_to_a_shader() {
let scene = scene_with_material();
let binding = scene.geometry_binding("mesh").unwrap().expect("bound");
assert_eq!(binding.attributes, vec!["attr".to_string()]);
assert_eq!(binding.surface_shader.as_deref(), Some("shader"));
}
#[test]
fn unbound_geometry_has_no_binding() {
let mut scene = Scene::default();
scene.create("mesh", "mesh").unwrap();
scene.connect("mesh", None, ".root", "objects").unwrap();
assert!(scene.geometry_binding("mesh").unwrap().is_none());
}
#[test]
fn attributes_without_a_shader_still_bind() {
let mut scene = Scene::default();
scene.create("mesh", "mesh").unwrap();
scene.create("attr", "attributes").unwrap();
scene.connect("mesh", None, ".root", "objects").unwrap();
scene
.connect("attr", None, "mesh", "geometryattributes")
.unwrap();
let binding = scene.geometry_binding("mesh").unwrap().expect("bound");
assert_eq!(binding.attributes, vec!["attr".to_string()]);
assert!(binding.surface_shader.is_none());
}
#[test]
fn one_attributes_node_fans_out_to_every_shape() {
let mut scene = Scene::default();
scene.create("attr", "attributes").unwrap();
scene.create("shader", "shader").unwrap();
scene
.connect("shader", None, "attr", "surfaceshader")
.unwrap();
for mesh in ["a", "b", "c"] {
scene.create(mesh, "mesh").unwrap();
scene.connect(mesh, None, ".root", "objects").unwrap();
scene
.connect("attr", None, mesh, "geometryattributes")
.unwrap();
}
for mesh in ["a", "b", "c"] {
let binding = scene.geometry_binding(mesh).unwrap().expect("bound");
assert_eq!(binding.surface_shader.as_deref(), Some("shader"));
}
}
#[test]
fn a_binding_on_an_ancestor_transform_is_inherited() {
let mut scene = Scene::default();
scene.create("grp", "transform").unwrap();
scene.create("mesh", "mesh").unwrap();
scene.create("attr", "attributes").unwrap();
scene.create("shader", "shader").unwrap();
scene.connect("mesh", None, "grp", "objects").unwrap();
scene.connect("grp", None, ".root", "objects").unwrap();
scene
.connect("attr", None, "grp", "geometryattributes")
.unwrap();
scene
.connect("shader", None, "attr", "surfaceshader")
.unwrap();
let binding = scene.geometry_binding("mesh").unwrap().expect("bound");
assert_eq!(binding.attributes, vec!["attr".to_string()]);
assert_eq!(binding.surface_shader.as_deref(), Some("shader"));
}
#[test]
fn a_binding_on_the_root_is_gathered() {
let mut scene = Scene::default();
scene.create("mesh", "mesh").unwrap();
scene.create("global_attr", "attributes").unwrap();
scene.create("shader", "shader").unwrap();
scene.connect("mesh", None, ".root", "objects").unwrap();
scene
.connect("global_attr", None, ".root", "geometryattributes")
.unwrap();
scene
.connect("shader", None, "global_attr", "surfaceshader")
.unwrap();
let binding = scene.geometry_binding("mesh").unwrap().expect("bound");
assert_eq!(binding.attributes, vec!["global_attr".to_string()]);
assert_eq!(binding.surface_shader.as_deref(), Some("shader"));
}
#[test]
fn every_attributes_node_on_the_path_is_gathered() {
let mut scene = Scene::default();
scene.create("grp", "transform").unwrap();
scene.create("mesh", "mesh").unwrap();
scene.create("shaded", "attributes").unwrap();
scene.create("visibility", "attributes").unwrap();
scene.create("metal", "shader").unwrap();
scene.connect("mesh", None, "grp", "objects").unwrap();
scene.connect("grp", None, ".root", "objects").unwrap();
scene
.connect("shaded", None, "grp", "geometryattributes")
.unwrap();
scene
.connect("metal", None, "shaded", "surfaceshader")
.unwrap();
scene
.connect("visibility", None, "mesh", "geometryattributes")
.unwrap();
let binding = scene.geometry_binding("mesh").unwrap().expect("bound");
assert_eq!(
binding.attributes,
vec!["visibility".to_string(), "shaded".to_string()],
"both nodes gathered, nearest first"
);
assert_eq!(
binding.surface_shader.as_deref(),
Some("metal"),
"the shader survives being on the farther node"
);
}
#[test]
fn the_nearest_binding_wins_at_equal_priority() {
let mut scene = Scene::default();
scene.create("grp", "transform").unwrap();
scene.create("mesh", "mesh").unwrap();
scene.create("outer", "attributes").unwrap();
scene.create("own", "attributes").unwrap();
scene.connect("mesh", None, "grp", "objects").unwrap();
scene.connect("grp", None, ".root", "objects").unwrap();
scene
.connect("outer", None, "grp", "geometryattributes")
.unwrap();
scene
.connect("own", None, "mesh", "geometryattributes")
.unwrap();
let binding = scene.geometry_binding("mesh").unwrap().expect("bound");
assert_eq!(binding.attributes[0], "own");
}
#[test]
fn a_geometryattributes_connection_priority_does_not_reorder() {
let mut scene = Scene::default();
scene.create("grp", "transform").unwrap();
scene.create("mesh", "mesh").unwrap();
scene.create("outer", "attributes").unwrap();
scene.create("own", "attributes").unwrap();
scene.connect("mesh", None, "grp", "objects").unwrap();
scene.connect("grp", None, ".root", "objects").unwrap();
scene
.connect_with_arguments(
"outer",
None,
"grp",
"geometryattributes",
vec![priority(10)],
)
.unwrap();
scene
.connect("own", None, "mesh", "geometryattributes")
.unwrap();
let binding = scene.geometry_binding("mesh").unwrap().expect("bound");
assert_eq!(
binding.attributes[0], "own",
"proximity decides; the connection priority is inert",
);
}
#[test]
fn a_surfaceshader_connection_priority_wins() {
let mut scene = Scene::default();
scene.create("grp", "transform").unwrap();
scene.create("mesh", "mesh").unwrap();
scene.create("outer", "attributes").unwrap();
scene.create("own", "attributes").unwrap();
scene.create("far_shader", "shader").unwrap();
scene.create("near_shader", "shader").unwrap();
scene.connect("mesh", None, "grp", "objects").unwrap();
scene.connect("grp", None, ".root", "objects").unwrap();
scene
.connect("outer", None, "grp", "geometryattributes")
.unwrap();
scene
.connect("own", None, "mesh", "geometryattributes")
.unwrap();
scene
.connect("near_shader", None, "own", "surfaceshader")
.unwrap();
scene
.connect_with_arguments(
"far_shader",
None,
"outer",
"surfaceshader",
vec![priority(5)],
)
.unwrap();
let binding = scene.geometry_binding("mesh").unwrap().expect("bound");
assert_eq!(binding.surface_shader.as_deref(), Some("far_shader"));
}
#[test]
fn an_instancing_prototype_is_not_detached() {
let mut scene = Scene::default();
scene.create("inst", "instances").unwrap();
scene.create("proto", "mesh").unwrap();
scene.create("attr", "attributes").unwrap();
scene.create("metal", "shader").unwrap();
scene.connect("inst", None, ".root", "objects").unwrap();
scene
.connect("proto", None, "inst", "sourcemodels")
.unwrap();
scene
.connect("attr", None, "proto", "geometryattributes")
.unwrap();
scene
.connect("metal", None, "attr", "surfaceshader")
.unwrap();
let binding = scene.geometry_binding("proto").unwrap().expect("bound");
assert_eq!(binding.surface_shader.as_deref(), Some("metal"));
}
#[test]
fn a_prototype_has_no_single_world_transform() {
let mut scene = Scene::default();
scene.create("xf", "transform").unwrap();
scene.create("inst", "instances").unwrap();
scene.create("proto", "mesh").unwrap();
scene.connect("xf", None, ".root", "objects").unwrap();
scene.connect("inst", None, "xf", "objects").unwrap();
scene
.connect("proto", None, "inst", "sourcemodels")
.unwrap();
assert_eq!(
scene.world_transform("proto"),
Err(crate::ResolveError::Instanced {
instancer: "inst".to_string()
})
);
}
#[test]
fn a_prototype_placed_directly_resolves_by_that_path() {
let mut scene = Scene::default();
scene.create("xf", "transform").unwrap();
scene
.set_attribute("xf", vec![translate(4.0, 0.0, 0.0)])
.unwrap();
scene.create("inst", "instances").unwrap();
scene.create("proto", "mesh").unwrap();
scene.connect("xf", None, ".root", "objects").unwrap();
scene.connect("inst", None, ".root", "objects").unwrap();
scene.connect("proto", None, "xf", "objects").unwrap();
scene
.connect("proto", None, "inst", "sourcemodels")
.unwrap();
assert_eq!(
scene.world_transform("proto").unwrap()[12],
4.0,
"the direct placement is the answer"
);
assert!(scene.geometry_binding("proto").is_ok());
}
#[test]
fn a_prototype_of_two_instancers_is_ambiguous() {
let mut scene = Scene::default();
scene.create("proto", "mesh").unwrap();
for inst in ["one", "two"] {
scene.create(inst, "instances").unwrap();
scene.connect(inst, None, ".root", "objects").unwrap();
scene.connect("proto", None, inst, "sourcemodels").unwrap();
}
assert!(matches!(
scene.geometry_binding("proto"),
Err(crate::ResolveError::MultipleParents { .. })
));
}
#[test]
fn instance_sources_are_ordered_by_their_index_attribute() {
let mut scene = Scene::default();
scene.create("inst", "instances").unwrap();
for (handle, index) in [("third", 2), ("first", 0), ("second", 1)] {
scene.create(handle, "mesh").unwrap();
scene
.connect_with_arguments(
handle,
None,
"inst",
"sourcemodels",
vec![priority(0), index_arg(index)],
)
.unwrap();
}
assert_eq!(
scene.instance_sources("inst"),
vec!["first", "second", "third"],
"connection order was third, first, second"
);
}
#[test]
fn the_shader_agrees_with_the_gathered_order() {
let mut scene = Scene::default();
scene.create("mesh", "mesh").unwrap();
scene.create("first", "attributes").unwrap();
scene.create("second", "attributes").unwrap();
scene.create("wanted", "shader").unwrap();
scene.create("loser", "shader").unwrap();
scene.connect("mesh", None, ".root", "objects").unwrap();
scene
.connect("first", None, "mesh", "geometryattributes")
.unwrap();
scene
.connect("second", None, "mesh", "geometryattributes")
.unwrap();
scene
.connect("wanted", None, "first", "surfaceshader")
.unwrap();
scene
.connect("loser", None, "second", "surfaceshader")
.unwrap();
let binding = scene.geometry_binding("mesh").unwrap().expect("bound");
assert_eq!(binding.attributes[0], "first");
assert_eq!(
binding.surface_shader.as_deref(),
Some("wanted"),
"the shader must come from attributes[0], not the last match"
);
}
#[test]
fn displacement_and_volume_shaders_resolve_too() {
let mut scene = Scene::default();
scene.create("mesh", "mesh").unwrap();
scene.create("attr", "attributes").unwrap();
scene.create("surf", "shader").unwrap();
scene.create("disp", "shader").unwrap();
scene.create("vol", "shader").unwrap();
scene.connect("mesh", None, ".root", "objects").unwrap();
scene
.connect("attr", None, "mesh", "geometryattributes")
.unwrap();
scene
.connect("surf", None, "attr", "surfaceshader")
.unwrap();
scene
.connect("disp", None, "attr", "displacementshader")
.unwrap();
scene.connect("vol", None, "attr", "volumeshader").unwrap();
let binding = scene.geometry_binding("mesh").unwrap().expect("bound");
assert_eq!(binding.surface_shader.as_deref(), Some("surf"));
assert_eq!(binding.displacement_shader.as_deref(), Some("disp"));
assert_eq!(binding.volume_shader.as_deref(), Some("vol"));
}
#[test]
fn a_prototype_subtree_resolves_relative_to_the_prototype() {
let mut scene = Scene::default();
scene.create("inst", "instances").unwrap();
scene.create("proto", "transform").unwrap();
scene
.set_attribute("proto", vec![translate(1.0, 0.0, 0.0)])
.unwrap();
scene.create("part", "transform").unwrap();
scene
.set_attribute("part", vec![translate(0.0, 2.0, 0.0)])
.unwrap();
scene.connect("inst", None, ".root", "objects").unwrap();
scene
.connect("proto", None, "inst", "sourcemodels")
.unwrap();
scene.connect("part", None, "proto", "objects").unwrap();
assert!(scene.world_transform("part").is_err());
let m = scene.relative_transform("part", "inst").unwrap();
assert_eq!(&m[12..15], &[1.0, 2.0, 0.0]);
let m = scene.relative_transform("part", "proto").unwrap();
assert_eq!(&m[12..15], &[0.0, 2.0, 0.0]);
}
#[test]
fn relative_transform_refuses_to_cross_an_instancer() {
let mut scene = Scene::default();
scene.create("placer", "transform").unwrap();
scene
.set_attribute("placer", vec![translate(100.0, 0.0, 0.0)])
.unwrap();
scene.create("inst", "instances").unwrap();
scene
.set_attribute("inst", vec![translate(1000.0, 0.0, 0.0)])
.unwrap();
scene.create("proto", "transform").unwrap();
scene
.set_attribute("proto", vec![translate(10.0, 0.0, 0.0)])
.unwrap();
scene.create("leaf", "mesh").unwrap();
scene.connect("placer", None, ".root", "objects").unwrap();
scene.connect("inst", None, "placer", "objects").unwrap();
scene
.connect("proto", None, "inst", "sourcemodels")
.unwrap();
scene.connect("leaf", None, "proto", "objects").unwrap();
for ancestor in [".root", "placer"] {
assert!(
matches!(
scene.relative_transform("leaf", ancestor),
Err(ResolveError::Instanced { .. })
),
"composing past the instancer to {ancestor} must refuse"
);
}
assert_eq!(scene.relative_transform("leaf", "inst").unwrap()[12], 10.0);
}
#[test]
fn relative_transform_rejects_a_node_off_the_chain() {
let mut scene = Scene::default();
scene.create("a", "transform").unwrap();
scene.create("elsewhere", "transform").unwrap();
scene.connect("a", None, ".root", "objects").unwrap();
scene
.connect("elsewhere", None, ".root", "objects")
.unwrap();
assert_eq!(
scene.relative_transform("a", "elsewhere"),
Err(crate::ResolveError::NotAnAncestor {
handle: "a".to_string(),
ancestor: "elsewhere".to_string(),
})
);
}
#[test]
fn a_cycle_is_an_error_for_bindings_too() {
let mut scene = Scene::default();
scene.create("a", "transform").unwrap();
scene.create("b", "transform").unwrap();
scene.connect("a", None, "b", "objects").unwrap();
scene.connect("b", None, "a", "objects").unwrap();
assert!(scene.geometry_binding("a").is_err());
}
fn scene_with_output() -> Scene {
let mut scene = Scene::default();
scene.create("cam", "perspectivecamera").unwrap();
scene.create("scr", "screen").unwrap();
scene.create("beauty", "outputlayer").unwrap();
scene.create("drv", "outputdriver").unwrap();
scene.connect("scr", None, "cam", "screens").unwrap();
scene
.connect("beauty", None, "scr", "outputlayers")
.unwrap();
scene
.connect("drv", None, "beauty", "outputdrivers")
.unwrap();
scene
}
#[test]
fn resolves_the_whole_output_chain() {
let scene = scene_with_output();
let outputs = scene.render_outputs();
assert_eq!(outputs.len(), 1);
assert_eq!(outputs[0].camera, "cam");
assert_eq!(outputs[0].screen, "scr");
assert_eq!(outputs[0].layers.len(), 1);
assert_eq!(outputs[0].layers[0].handle, "beauty");
assert_eq!(outputs[0].layers[0].drivers, vec!["drv".to_string()]);
}
#[test]
fn a_screen_without_layers_still_resolves() {
let mut scene = Scene::default();
scene.create("cam", "perspectivecamera").unwrap();
scene.create("scr", "screen").unwrap();
scene.connect("scr", None, "cam", "screens").unwrap();
let outputs = scene.render_outputs();
assert_eq!(outputs.len(), 1);
assert!(outputs[0].layers.is_empty());
}
#[test]
fn multiple_layers_keep_connection_order() {
let mut scene = scene_with_output();
scene.create("depth", "outputlayer").unwrap();
scene.connect("depth", None, "scr", "outputlayers").unwrap();
let outputs = scene.render_outputs();
let names: Vec<&str> = outputs[0]
.layers
.iter()
.map(|l| l.handle.as_str())
.collect();
assert_eq!(names, vec!["beauty", "depth"]);
}
#[test]
fn a_layer_may_have_several_drivers() {
let mut scene = scene_with_output();
scene.create("drv2", "outputdriver").unwrap();
scene
.connect("drv2", None, "beauty", "outputdrivers")
.unwrap();
let outputs = scene.render_outputs();
assert_eq!(outputs[0].layers[0].drivers, vec!["drv", "drv2"]);
}
#[test]
fn no_screen_means_no_outputs() {
let mut scene = Scene::default();
scene.create("cam", "perspectivecamera").unwrap();
assert!(scene.render_outputs().is_empty());
}
#[test]
fn multiple_screens_yield_one_output_each() {
let mut scene = Scene::default();
for (cam, scr, layer) in [
("cam_a", "scr_a", "beauty_a"),
("cam_b", "scr_b", "beauty_b"),
] {
scene.create(cam, "perspectivecamera").unwrap();
scene.create(scr, "screen").unwrap();
scene.create(layer, "outputlayer").unwrap();
scene.connect(scr, None, cam, "screens").unwrap();
scene.connect(layer, None, scr, "outputlayers").unwrap();
}
let outputs = scene.render_outputs();
assert_eq!(outputs.len(), 2);
assert_eq!(outputs[0].camera, "cam_a");
assert_eq!(outputs[0].screen, "scr_a");
assert_eq!(outputs[0].layers[0].handle, "beauty_a");
assert_eq!(outputs[1].camera, "cam_b");
assert_eq!(outputs[1].screen, "scr_b");
assert_eq!(outputs[1].layers[0].handle, "beauty_b");
}
fn doubles(name: &str, values: Vec<f64>) -> OwnedArgument {
OwnedArgument {
name: name.to_string(),
type_tag: Type::MatrixF64,
array_length: 1,
flags: 0,
data: OwnedData::F64(values),
}
}
fn integers(name: &str, values: Vec<i32>) -> OwnedArgument {
OwnedArgument {
name: name.to_string(),
type_tag: Type::I32,
array_length: 1,
flags: 0,
data: OwnedData::I32(values),
}
}
fn instance_matrix(x: f64) -> Vec<f64> {
vec![
1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, x, 0.0,
0.0, 1.0,
]
}
#[test]
fn instances_pair_their_matrix_with_their_prototype() {
let mut scene = Scene::default();
scene.create("inst", "instances").unwrap();
for (handle, index) in [("five", 5), ("nine", 9)] {
scene.create(handle, "mesh").unwrap();
scene
.connect_with_arguments(
handle,
None,
"inst",
"sourcemodels",
vec![integers("index", vec![index])],
)
.unwrap();
}
let mut matrices = instance_matrix(10.0);
matrices.extend(instance_matrix(20.0));
scene
.set_attribute(
"inst",
vec![
doubles("transformationmatrices", matrices),
integers("modelindices", vec![9, 5]),
],
)
.unwrap();
assert_eq!(scene.instance_sources("inst"), vec!["five", "nine"]);
let placed = scene.instance_transforms("inst").unwrap();
assert_eq!(placed.len(), 2);
assert_eq!(placed[0].source, 1, "index 9 is `nine`, at position 1");
assert_eq!(placed[0].transform[12], 10.0);
assert_eq!(placed[1].source, 0, "index 5 is `five`, at position 0");
assert_eq!(placed[1].transform[12], 20.0);
}
#[test]
fn a_negative_model_index_is_not_rendered() {
let mut scene = Scene::default();
scene.create("inst", "instances").unwrap();
scene.create("hidden", "mesh").unwrap();
scene
.connect_with_arguments(
"hidden",
None,
"inst",
"sourcemodels",
vec![integers("index", vec![-1])],
)
.unwrap();
scene
.set_attribute(
"inst",
vec![
doubles("transformationmatrices", instance_matrix(1.0)),
integers("modelindices", vec![-1]),
],
)
.unwrap();
assert!(
scene.instance_transforms("inst").unwrap().is_empty(),
"a negative index is not a lookup key"
);
}
#[test]
fn disabled_instances_are_omitted() {
let mut scene = Scene::default();
scene.create("inst", "instances").unwrap();
scene.create("a", "mesh").unwrap();
scene.connect("a", None, "inst", "sourcemodels").unwrap();
let mut matrices = instance_matrix(1.0);
matrices.extend(instance_matrix(2.0));
scene
.set_attribute(
"inst",
vec![
doubles("transformationmatrices", matrices),
integers("disabledinstances", vec![0]),
],
)
.unwrap();
let placed = scene.instance_transforms("inst").unwrap();
assert_eq!(placed.len(), 1);
assert_eq!(placed[0].transform[12], 2.0);
}
#[test]
fn an_instances_node_without_matrices_places_nothing() {
let mut scene = Scene::default();
scene.create("inst", "instances").unwrap();
assert!(scene.instance_transforms("inst").unwrap().is_empty());
}
#[test]
fn resolves_instance_source_models() {
let mut scene = Scene::default();
scene.create("inst", "instances").unwrap();
scene.create("proto_a", "mesh").unwrap();
scene.create("proto_b", "mesh").unwrap();
scene
.connect("proto_a", None, "inst", "sourcemodels")
.unwrap();
scene
.connect("proto_b", None, "inst", "sourcemodels")
.unwrap();
assert_eq!(scene.instance_sources("inst"), vec!["proto_a", "proto_b"]);
}
#[test]
fn an_instances_node_with_no_sources_is_empty() {
let mut scene = Scene::default();
scene.create("inst", "instances").unwrap();
assert!(scene.instance_sources("inst").is_empty());
}
#[test]
fn a_ragged_matrix_buffer_is_an_error() {
let mut scene = Scene::default();
scene.create("inst", "instances").unwrap();
scene.create("a", "mesh").unwrap();
scene.connect("a", None, "inst", "sourcemodels").unwrap();
let mut ragged = instance_matrix(1.0);
ragged.push(0.0);
scene
.set_attribute("inst", vec![doubles("transformationmatrices", ragged)])
.unwrap();
assert!(matches!(
scene.instance_transforms("inst"),
Err(ResolveError::MalformedInstanceMatrices { values: 17, .. })
));
}
#[test]
fn a_model_index_matching_no_prototype_is_an_error() {
let mut scene = Scene::default();
scene.create("inst", "instances").unwrap();
scene.create("a", "mesh").unwrap();
scene.connect("a", None, "inst", "sourcemodels").unwrap();
scene
.set_attribute(
"inst",
vec![
doubles("transformationmatrices", instance_matrix(1.0)),
integers("modelindices", vec![7]),
],
)
.unwrap();
assert!(matches!(
scene.instance_transforms("inst"),
Err(ResolveError::UnknownModelIndex { model: 7, .. })
));
}
#[test]
fn a_shader_network_port_does_not_resolve_as_its_namesake_class() {
let mut scene = Scene::default();
scene.create("mesh", "mesh").unwrap();
scene.create("attr", "attributes").unwrap();
scene.create("tex", "shader").unwrap();
scene.connect("mesh", None, ".root", "objects").unwrap();
scene
.connect("attr", None, "mesh", "geometryattributes")
.unwrap();
scene
.connect("tex", Some("outColor"), "attr", "surfaceshader")
.unwrap();
let binding = scene.geometry_binding("mesh").unwrap().expect("bound");
assert_eq!(
binding.surface_shader, None,
"a port edge is carried, not resolved as the material"
);
}
#[test]
fn a_port_named_like_a_binding_does_not_bind() {
let mut scene = Scene::default();
scene.create("mesh", "mesh").unwrap();
scene.create("tex", "shader").unwrap();
scene.connect("mesh", None, ".root", "objects").unwrap();
scene
.connect("tex", Some("outColor"), "mesh", "geometryattributes")
.unwrap();
assert!(
scene.geometry_binding("mesh").unwrap().is_none(),
"a port edge must not become an attributes node"
);
}
#[test]
fn duplicate_model_indices_are_refused() {
let mut scene = Scene::default();
scene.create("inst", "instances").unwrap();
for handle in ["a", "b"] {
scene.create(handle, "mesh").unwrap();
scene
.connect_with_arguments(
handle,
None,
"inst",
"sourcemodels",
vec![index_arg(0)],
)
.unwrap();
}
scene
.set_attribute(
"inst",
vec![doubles("transformationmatrices", instance_matrix(1.0))],
)
.unwrap();
assert!(matches!(
scene.instance_transforms("inst"),
Err(crate::ResolveError::DuplicateModelIndex { index: 0, .. })
));
}
fn scene_with_two_attribute_levels() -> Scene {
let mut scene = Scene::default();
scene.create("mesh", "mesh").unwrap();
scene.create("xf", "transform").unwrap();
scene.create("near", "attributes").unwrap();
scene.create("far", "attributes").unwrap();
scene.connect("xf", None, ".root", "objects").unwrap();
scene.connect("mesh", None, "xf", "objects").unwrap();
scene
.connect("near", None, "mesh", "geometryattributes")
.unwrap();
scene
.connect("far", None, "xf", "geometryattributes")
.unwrap();
scene
}
#[test]
fn at_equal_priority_the_nearest_definition_wins() {
let mut scene = scene_with_two_attribute_levels();
scene
.set_attribute("near", vec![integers("visibility", vec![0])])
.unwrap();
scene
.set_attribute("far", vec![integers("visibility", vec![1])])
.unwrap();
let value = scene.attribute_value("mesh", "visibility").unwrap();
let value = value.expect("defined on the path");
assert_eq!(value.node, "near");
assert_eq!(
value.arg.expect("a recorded value").data,
OwnedData::I32(vec![0])
);
}
#[test]
fn attr_priority_beats_proximity() {
let mut scene = scene_with_two_attribute_levels();
scene
.set_attribute("near", vec![integers("visibility", vec![0])])
.unwrap();
scene
.set_attribute(
"far",
vec![
integers("visibility", vec![1]),
integers("visibility.priority", vec![10]),
],
)
.unwrap();
let value = scene.attribute_value("mesh", "visibility").unwrap();
let value = value.expect("defined on the path");
assert_eq!(value.node, "far", "priority 10 outranks proximity");
assert_eq!(value.priority, 10);
assert_eq!(
value.arg.expect("a recorded value").data,
OwnedData::I32(vec![1])
);
}
#[test]
fn attr_priority_lifts_only_its_own_attribute() {
let mut scene = scene_with_two_attribute_levels();
scene
.set_attribute(
"near",
vec![integers("visibility", vec![0]), integers("matte", vec![0])],
)
.unwrap();
scene
.set_attribute(
"far",
vec![
integers("visibility", vec![1]),
integers("visibility.priority", vec![10]),
integers("matte", vec![1]),
],
)
.unwrap();
assert_eq!(
scene
.attribute_value("mesh", "visibility")
.unwrap()
.unwrap()
.node,
"far",
);
assert_eq!(
scene
.attribute_value("mesh", "matte")
.unwrap()
.unwrap()
.node,
"near",
"`matte` has no priority of its own, so proximity decides it",
);
}
#[test]
fn a_per_ray_visibility_beats_the_default() {
let mut scene = scene_with_two_attribute_levels();
scene
.set_attribute(
"near",
vec![
integers("visibility", vec![1]),
integers("visibility.camera", vec![0]),
],
)
.unwrap();
let value = scene.attribute_value("mesh", "visibility.camera").unwrap();
let value = value.expect("defined on the path");
assert_eq!(value.name, "visibility.camera");
assert_eq!(
value.arg.expect("a recorded value").data,
OwnedData::I32(vec![0])
);
}
#[test]
fn the_default_visibility_answers_a_per_ray_query() {
let mut scene = scene_with_two_attribute_levels();
scene
.set_attribute("near", vec![integers("visibility", vec![0])])
.unwrap();
let value = scene.attribute_value("mesh", "visibility.shadow").unwrap();
let value = value.expect("the default covers every ray type");
assert_eq!(value.name, "visibility");
assert_eq!(
value.arg.expect("a recorded value").data,
OwnedData::I32(vec![0])
);
}
#[test]
fn a_prioritised_default_beats_a_per_ray_visibility() {
let mut scene = scene_with_two_attribute_levels();
scene
.set_attribute(
"near",
vec![
integers("visibility", vec![1]),
integers("visibility.priority", vec![5]),
integers("visibility.camera", vec![0]),
],
)
.unwrap();
let value = scene.attribute_value("mesh", "visibility.camera").unwrap();
let value = value.expect("defined on the path");
assert_eq!(value.name, "visibility", "priority 5 beats specificity");
assert_eq!(value.priority, 5);
}
#[test]
fn visibility_set_subsurface_is_not_a_ray_type() {
let mut scene = scene_with_two_attribute_levels();
scene
.set_attribute("near", vec![integers("visibility", vec![1])])
.unwrap();
assert!(
scene
.attribute_value("mesh", "visibility.set.subsurface")
.unwrap()
.is_none(),
"`set.subsurface` is not one of ɴsɪ's ray types",
);
}
#[test]
fn a_non_integer_priority_is_ignored() {
let mut scene = scene_with_two_attribute_levels();
scene
.set_attribute("near", vec![integers("visibility", vec![0])])
.unwrap();
scene
.set_attribute(
"far",
vec![
integers("visibility", vec![1]),
OwnedArgument {
name: "visibility.priority".to_string(),
type_tag: Type::F32,
array_length: 1,
flags: 0,
data: OwnedData::F32(vec![10.0]),
},
],
)
.unwrap();
let value = scene.attribute_value("mesh", "visibility").unwrap();
let value = value.expect("defined on the path");
assert_eq!(value.node, "near", "the float priority does not count");
assert_eq!(value.priority, 0);
}
#[test]
fn an_undefined_attribute_resolves_to_none() {
let mut scene = scene_with_two_attribute_levels();
scene
.set_attribute("near", vec![integers("visibility", vec![0])])
.unwrap();
assert!(scene.attribute_value("mesh", "matte").unwrap().is_none());
}
#[test]
fn attribute_value_propagates_a_detached_path() {
let mut scene = Scene::default();
scene.create("mesh", "mesh").unwrap();
assert!(matches!(
scene.attribute_value("mesh", "visibility"),
Err(ResolveError::Detached { .. })
));
}
#[test]
fn specificity_is_compared_before_proximity() {
let mut scene = scene_with_two_attribute_levels();
scene
.set_attribute("near", vec![integers("visibility", vec![1])])
.unwrap();
scene
.set_attribute("far", vec![integers("visibility.camera", vec![0])])
.unwrap();
let value = scene.attribute_value("mesh", "visibility.camera").unwrap();
let value = value.expect("defined on the path");
assert_eq!(
value.node, "far",
"the per-ray value outranks the nearer default"
);
assert_eq!(value.name, "visibility.camera");
}
#[test]
fn an_int64_priority_is_ignored() {
let mut scene = scene_with_two_attribute_levels();
scene
.set_attribute("near", vec![integers("visibility", vec![0])])
.unwrap();
scene
.set_attribute(
"far",
vec![
integers("visibility", vec![1]),
OwnedArgument {
name: "visibility.priority".to_string(),
type_tag: Type::I64,
array_length: 1,
flags: 0,
data: OwnedData::I64(vec![10]),
},
],
)
.unwrap();
let value = scene.attribute_value("mesh", "visibility").unwrap();
let value = value.expect("defined on the path");
assert_eq!(value.node, "near", "an int64 priority does not count");
assert_eq!(value.priority, 0);
}
#[test]
fn a_priority_without_its_attribute_is_a_definition() {
let mut scene = scene_with_two_attribute_levels();
scene
.set_attribute("near", vec![integers("visibility.priority", vec![10])])
.unwrap();
scene
.set_attribute("far", vec![integers("visibility", vec![0])])
.unwrap();
let value = scene.attribute_value("mesh", "visibility").unwrap();
let value = value.expect("`near` defines it at the default");
assert_eq!(value.node, "near");
assert_eq!(value.name, "visibility");
assert_eq!(value.arg, None, "the default is the backend's to supply");
assert_eq!(value.priority, 10);
}
#[test]
fn a_defaulted_definition_outranks_a_nearer_value() {
let mut scene = scene_with_two_attribute_levels();
scene
.set_attribute("near", vec![integers("visibility", vec![0])])
.unwrap();
scene
.set_attribute("far", vec![integers("visibility.priority", vec![10])])
.unwrap();
let value = scene.attribute_value("mesh", "visibility").unwrap();
let value = value.expect("`far` defines it at the default");
assert_eq!(value.node, "far", "priority 10 outranks proximity");
assert_eq!(value.arg, None);
assert_eq!(value.priority, 10);
}
#[test]
fn a_higher_priority_value_beats_a_defaulted_definition() {
let mut scene = scene_with_two_attribute_levels();
scene
.set_attribute("near", vec![integers("visibility.priority", vec![10])])
.unwrap();
scene
.set_attribute(
"far",
vec![
integers("visibility", vec![0]),
integers("visibility.priority", vec![20]),
],
)
.unwrap();
let value = scene.attribute_value("mesh", "visibility").unwrap();
let value = value.expect("`far` defines it");
assert_eq!(value.node, "far");
assert_eq!(
value.arg.expect("a recorded value").data,
OwnedData::I32(vec![0])
);
assert_eq!(value.priority, 20);
}
#[test]
fn a_multi_valued_priority_is_ignored() {
let mut scene = scene_with_two_attribute_levels();
scene
.set_attribute("near", vec![integers("visibility", vec![0])])
.unwrap();
scene
.set_attribute(
"far",
vec![
integers("visibility", vec![1]),
integers("visibility.priority", vec![10, 10]),
],
)
.unwrap();
let value = scene.attribute_value("mesh", "visibility").unwrap();
let value = value.expect("defined on the path");
assert_eq!(value.node, "near", "two ints are not a priority");
assert_eq!(value.priority, 0);
}
#[test]
fn a_lone_priority_answers_a_per_ray_query_through_the_fallback() {
let mut scene = scene_with_two_attribute_levels();
scene
.set_attribute("near", vec![integers("visibility.priority", vec![10])])
.unwrap();
scene
.set_attribute("far", vec![integers("visibility.camera", vec![0])])
.unwrap();
let value = scene.attribute_value("mesh", "visibility.camera").unwrap();
let value = value.expect("the lone priority defines the default");
assert_eq!(value.node, "near");
assert_eq!(value.name, "visibility", "the less specific key won");
assert_eq!(value.arg, None);
assert_eq!(value.priority, 10);
}
#[test]
fn an_unreadable_priority_alone_is_not_a_definition() {
let mut scene = scene_with_two_attribute_levels();
scene
.set_attribute(
"near",
vec![OwnedArgument {
name: "visibility.priority".to_string(),
type_tag: Type::I64,
array_length: 1,
flags: 0,
data: OwnedData::I64(vec![10]),
}],
)
.unwrap();
scene
.set_attribute("far", vec![integers("visibility", vec![0])])
.unwrap();
let value = scene.attribute_value("mesh", "visibility").unwrap();
let value = value.expect("`far` defines it");
assert_eq!(value.node, "far", "an int64 priority defines nothing");
assert_eq!(
value.arg.expect("a recorded value").data,
OwnedData::I32(vec![0])
);
}
#[test]
fn an_empty_attributes_node_is_not_a_definition() {
let mut scene = scene_with_two_attribute_levels();
scene
.set_attribute("far", vec![integers("visibility", vec![0])])
.unwrap();
let value = scene.attribute_value("mesh", "visibility").unwrap();
let value = value.expect("`far` defines it");
assert_eq!(value.node, "far");
}
#[test]
fn a_per_ray_priority_alone_defines_the_per_ray_attribute() {
let mut scene = scene_with_two_attribute_levels();
scene
.set_attribute(
"near",
vec![integers("visibility.camera.priority", vec![10])],
)
.unwrap();
scene
.set_attribute("far", vec![integers("visibility.camera", vec![0])])
.unwrap();
let value = scene.attribute_value("mesh", "visibility.camera").unwrap();
let value = value.expect("`near` defines it at the default");
assert_eq!(value.node, "near");
assert_eq!(value.name, "visibility.camera");
assert_eq!(value.arg, None);
}
#[test]
fn a_defaulted_definition_is_ranked_by_specificity() {
let mut scene = scene_with_two_attribute_levels();
scene
.set_attribute("near", vec![integers("visibility.priority", vec![0])])
.unwrap();
scene
.set_attribute("far", vec![integers("visibility.camera", vec![0])])
.unwrap();
let value = scene.attribute_value("mesh", "visibility.camera").unwrap();
let value = value.expect("`far` defines it");
assert_eq!(value.node, "far", "the per-ray value is more specific");
assert_eq!(value.name, "visibility.camera");
assert_eq!(
value.arg.expect("a recorded value").data,
OwnedData::I32(vec![0])
);
}
fn scene_with_shader_attributes() -> Scene {
let mut scene = Scene::default();
scene.create("mesh", "mesh").unwrap();
scene.create("xf", "transform").unwrap();
scene.create("near", "attributes").unwrap();
scene.create("far", "attributes").unwrap();
scene.connect("xf", None, ".root", "objects").unwrap();
scene.connect("mesh", None, "xf", "objects").unwrap();
scene
.connect("near", None, "mesh", "shaderattributes")
.unwrap();
scene
.connect("far", None, "xf", "shaderattributes")
.unwrap();
scene
}
#[test]
fn the_nearest_shader_attribute_wins() {
let mut scene = scene_with_shader_attributes();
scene
.set_attribute("near", vec![integers("tint", vec![1])])
.unwrap();
scene
.set_attribute("far", vec![integers("tint", vec![2])])
.unwrap();
let value = scene.shader_attribute_value("mesh", "tint").unwrap();
let value = value.expect("defined on the path");
assert_eq!(value.node, "near");
assert_eq!(
value.arg.expect("a recorded value").data,
OwnedData::I32(vec![1])
);
}
#[test]
fn an_ancestor_shader_attribute_is_inherited() {
let mut scene = scene_with_shader_attributes();
scene
.set_attribute("far", vec![integers("tint", vec![2])])
.unwrap();
let value = scene.shader_attribute_value("mesh", "tint").unwrap();
assert_eq!(value.expect("inherited").node, "far");
}
#[test]
fn a_shader_attribute_ignores_attr_priority() {
let mut scene = scene_with_shader_attributes();
scene
.set_attribute("near", vec![integers("tint", vec![1])])
.unwrap();
scene
.set_attribute(
"far",
vec![
integers("tint", vec![2]),
integers("tint.priority", vec![10]),
],
)
.unwrap();
let value = scene.shader_attribute_value("mesh", "tint").unwrap();
let value = value.expect("defined on the path");
assert_eq!(value.node, "near", "proximity only; no priority here");
assert_eq!(value.priority, 0);
}
#[test]
fn the_two_attribute_containers_do_not_cross() {
let mut scene = Scene::default();
scene.create("mesh", "mesh").unwrap();
scene.create("geom", "attributes").unwrap();
scene.create("shade", "attributes").unwrap();
scene.connect("mesh", None, ".root", "objects").unwrap();
scene
.connect("geom", None, "mesh", "geometryattributes")
.unwrap();
scene
.connect("shade", None, "mesh", "shaderattributes")
.unwrap();
scene
.set_attribute("geom", vec![integers("only_geom", vec![1])])
.unwrap();
scene
.set_attribute("shade", vec![integers("only_shade", vec![1])])
.unwrap();
assert!(
scene
.shader_attribute_value("mesh", "only_geom")
.unwrap()
.is_none(),
"a geometryattributes node is not a shader-attribute source",
);
assert!(
scene
.attribute_value("mesh", "only_shade")
.unwrap()
.is_none(),
"a shaderattributes node is not a geometry-attribute source",
);
assert_eq!(
scene.shader_attributes("mesh").unwrap(),
vec!["mesh".to_string(), "shade".to_string()],
);
}
#[test]
fn an_undefined_shader_attribute_resolves_to_none() {
let scene = scene_with_shader_attributes();
assert!(
scene
.shader_attribute_value("mesh", "tint")
.unwrap()
.is_none()
);
}
#[test]
fn the_geometrys_own_shader_attribute_outranks_every_container() {
let mut scene = scene_with_shader_attributes();
scene
.set_attribute("mesh", vec![integers("tint", vec![1])])
.unwrap();
scene
.set_attribute(
"near",
vec![
integers("tint", vec![2]),
integers("tint.priority", vec![10]),
],
)
.unwrap();
let value = scene.shader_attribute_value("mesh", "tint").unwrap();
let value = value.expect("set on the primitive");
assert_eq!(value.node, "mesh");
assert_eq!(
value.arg.expect("a recorded value").data,
OwnedData::I32(vec![1])
);
}
#[test]
fn a_shader_attribute_on_the_primitive_needs_no_container() {
let mut scene = Scene::default();
scene.create("mesh", "mesh").unwrap();
scene.connect("mesh", None, ".root", "objects").unwrap();
scene
.set_attribute("mesh", vec![integers("tint", vec![7])])
.unwrap();
let value = scene.shader_attribute_value("mesh", "tint").unwrap();
assert_eq!(value.expect("set on the primitive").node, "mesh");
}
#[test]
fn shader_attribute_sources_are_in_precedence_order() {
let mut scene = Scene::default();
scene.create("mesh", "mesh").unwrap();
scene.create("xf", "transform").unwrap();
for handle in ["near", "near2", "mid", "root_attrs"] {
scene.create(handle, "attributes").unwrap();
}
scene.connect("xf", None, ".root", "objects").unwrap();
scene.connect("mesh", None, "xf", "objects").unwrap();
scene
.connect("near", None, "mesh", "shaderattributes")
.unwrap();
scene
.connect("near2", None, "mesh", "shaderattributes")
.unwrap();
scene
.connect("mid", None, "xf", "shaderattributes")
.unwrap();
scene
.connect("root_attrs", None, ".root", "shaderattributes")
.unwrap();
assert_eq!(
scene.shader_attributes("mesh").unwrap(),
vec![
"mesh".to_string(),
"near".to_string(),
"near2".to_string(),
"mid".to_string(),
"root_attrs".to_string(),
],
);
}
#[test]
fn the_first_connected_shader_attribute_wins_at_one_level() {
let mut scene = Scene::default();
scene.create("mesh", "mesh").unwrap();
scene.create("first", "attributes").unwrap();
scene.create("second", "attributes").unwrap();
scene.create("root_attrs", "attributes").unwrap();
scene.connect("mesh", None, ".root", "objects").unwrap();
scene
.connect("first", None, "mesh", "shaderattributes")
.unwrap();
scene
.connect("second", None, "mesh", "shaderattributes")
.unwrap();
scene
.connect("root_attrs", None, ".root", "shaderattributes")
.unwrap();
scene
.set_attribute("first", vec![integers("tint", vec![1])])
.unwrap();
scene
.set_attribute("second", vec![integers("tint", vec![2])])
.unwrap();
scene
.set_attribute("root_attrs", vec![integers("other", vec![9])])
.unwrap();
assert_eq!(
scene
.shader_attribute_value("mesh", "tint")
.unwrap()
.unwrap()
.node,
"first",
);
assert_eq!(
scene
.shader_attribute_value("mesh", "other")
.unwrap()
.unwrap()
.node,
"root_attrs",
"a node on `.root` is still a source",
);
}
fn scene_with_a_set() -> Scene {
let mut scene = Scene::default();
scene.create("mesh", "mesh").unwrap();
scene.create("xf", "transform").unwrap();
scene.create("s", "set").unwrap();
scene.connect("xf", None, ".root", "objects").unwrap();
scene.connect("mesh", None, "xf", "objects").unwrap();
scene.connect("mesh", None, "s", "members").unwrap();
scene
}
#[test]
fn an_attributes_node_on_a_set_binds() {
let mut scene = scene_with_a_set();
scene.create("sa", "attributes").unwrap();
scene
.connect("sa", None, "s", "geometryattributes")
.unwrap();
let binding = scene.geometry_binding("mesh").unwrap().expect("bound");
assert_eq!(binding.attributes, vec!["sa".to_string()]);
}
#[test]
fn the_geometrys_own_container_outranks_its_set() {
let mut scene = scene_with_a_set();
scene.create("near", "attributes").unwrap();
scene.create("sa", "attributes").unwrap();
scene
.connect("near", None, "mesh", "geometryattributes")
.unwrap();
scene
.connect("sa", None, "s", "geometryattributes")
.unwrap();
scene
.set_attribute("near", vec![integers("visibility", vec![0])])
.unwrap();
scene
.set_attribute("sa", vec![integers("visibility", vec![1])])
.unwrap();
let value = scene.attribute_value("mesh", "visibility").unwrap();
assert_eq!(value.expect("defined").node, "near");
}
#[test]
fn a_set_outranks_the_transform_above_it() {
let mut scene = scene_with_a_set();
scene.create("far", "attributes").unwrap();
scene.create("sa", "attributes").unwrap();
scene
.connect("far", None, "xf", "geometryattributes")
.unwrap();
scene
.connect("sa", None, "s", "geometryattributes")
.unwrap();
scene
.set_attribute("far", vec![integers("visibility", vec![0])])
.unwrap();
scene
.set_attribute("sa", vec![integers("visibility", vec![1])])
.unwrap();
let value = scene.attribute_value("mesh", "visibility").unwrap();
let value = value.expect("defined");
assert_eq!(value.node, "sa");
assert_eq!(
value.arg.expect("a recorded value").data,
OwnedData::I32(vec![1])
);
}
#[test]
fn the_first_set_membership_wins() {
let mut scene = scene_with_a_set();
scene.create("s2", "set").unwrap();
scene.connect("mesh", None, "s2", "members").unwrap();
scene.create("sa", "attributes").unwrap();
scene.create("sa2", "attributes").unwrap();
scene
.connect("sa", None, "s", "geometryattributes")
.unwrap();
scene
.connect("sa2", None, "s2", "geometryattributes")
.unwrap();
scene
.set_attribute("sa", vec![integers("visibility", vec![0])])
.unwrap();
scene
.set_attribute("sa2", vec![integers("visibility", vec![1])])
.unwrap();
let value = scene.attribute_value("mesh", "visibility").unwrap();
assert_eq!(value.expect("defined").node, "sa");
}
#[test]
fn a_nested_sets_attributes_are_not_inherited() {
let mut scene = scene_with_a_set();
scene.create("s2", "set").unwrap();
scene.connect("s", None, "s2", "members").unwrap();
scene.create("sa2", "attributes").unwrap();
scene
.connect("sa2", None, "s2", "geometryattributes")
.unwrap();
scene
.set_attribute("sa2", vec![integers("visibility", vec![0])])
.unwrap();
assert!(
scene
.attribute_value("mesh", "visibility")
.unwrap()
.is_none(),
"the outer set is not a source for this geometry",
);
}
#[test]
fn an_attr_priority_on_a_set_beats_the_geometrys_own() {
let mut scene = scene_with_a_set();
scene.create("near", "attributes").unwrap();
scene.create("sa", "attributes").unwrap();
scene
.connect("near", None, "mesh", "geometryattributes")
.unwrap();
scene
.connect("sa", None, "s", "geometryattributes")
.unwrap();
scene
.set_attribute("near", vec![integers("visibility", vec![0])])
.unwrap();
scene
.set_attribute(
"sa",
vec![
integers("visibility", vec![1]),
integers("visibility.priority", vec![10]),
],
)
.unwrap();
let value = scene.attribute_value("mesh", "visibility").unwrap();
let value = value.expect("defined");
assert_eq!(value.node, "sa");
assert_eq!(value.priority, 10);
}
#[test]
fn a_set_provides_shader_attributes_below_the_geometry() {
let mut scene = scene_with_a_set();
scene.create("sa", "attributes").unwrap();
scene.create("far", "attributes").unwrap();
scene.connect("sa", None, "s", "shaderattributes").unwrap();
scene
.connect("far", None, "xf", "shaderattributes")
.unwrap();
scene
.set_attribute("sa", vec![integers("tint", vec![1])])
.unwrap();
scene
.set_attribute("far", vec![integers("tint", vec![2])])
.unwrap();
let value = scene.shader_attribute_value("mesh", "tint").unwrap();
assert_eq!(value.expect("defined").node, "sa");
assert_eq!(
scene.shader_attributes("mesh").unwrap(),
vec!["mesh".to_string(), "sa".to_string(), "far".to_string()],
);
}
fn points(values: Vec<f32>) -> OwnedArgument {
OwnedArgument {
name: "P".to_string(),
type_tag: Type::Point,
array_length: 1,
flags: 0,
data: OwnedData::F32(values),
}
}
#[test]
fn a_deforming_mesh_reports_its_sample_times() {
let mut scene = Scene::default();
scene.create("mesh", "mesh").unwrap();
scene.connect("mesh", None, ".root", "objects").unwrap();
scene
.set_attribute_at_time("mesh", 0.0, vec![points(vec![0.0, 0.0, 0.0])])
.unwrap();
scene
.set_attribute_at_time("mesh", 1.0, vec![points(vec![1.0, 0.0, 0.0])])
.unwrap();
assert!(
scene.motion_times("mesh").unwrap().is_empty(),
"the transform really is static",
);
assert_eq!(scene.attribute_times("mesh", "P").unwrap(), vec![0.0, 1.0]);
let samples = scene.attribute_samples("mesh", "P").unwrap();
assert_eq!(samples.len(), 2);
assert_eq!(samples[0].0, 0.0);
assert_eq!(samples[1].1.data, OwnedData::F32(vec![1.0, 0.0, 0.0]));
}
#[test]
fn attribute_times_are_per_attribute() {
let mut scene = Scene::default();
scene.create("mesh", "mesh").unwrap();
scene
.set_attribute_at_time("mesh", 0.0, vec![points(vec![0.0])])
.unwrap();
scene
.set_attribute_at_time("mesh", 1.0, vec![integers("N", vec![1])])
.unwrap();
assert_eq!(scene.attribute_times("mesh", "P").unwrap(), vec![0.0]);
assert_eq!(scene.attribute_times("mesh", "N").unwrap(), vec![1.0]);
assert!(scene.attribute_times("mesh", "absent").unwrap().is_empty());
}
#[test]
fn a_static_attribute_has_no_sample_times() {
let mut scene = Scene::default();
scene.create("mesh", "mesh").unwrap();
scene
.set_attribute("mesh", vec![points(vec![0.0, 0.0, 0.0])])
.unwrap();
assert!(scene.attribute_times("mesh", "P").unwrap().is_empty());
assert!(scene.attribute_samples("mesh", "P").unwrap().is_empty());
}
#[test]
fn attribute_times_refuses_an_unknown_handle() {
let scene = Scene::default();
assert!(matches!(
scene.attribute_times("nope", "P"),
Err(ResolveError::UnknownHandle { .. })
));
assert!(matches!(
scene.attribute_samples("nope", "P"),
Err(ResolveError::UnknownHandle { .. })
));
}
#[test]
fn attribute_samples_are_time_ordered() {
let mut scene = Scene::default();
scene.create("mesh", "mesh").unwrap();
for time in [2.0, 0.0, 1.0] {
scene
.set_attribute_at_time(
"mesh",
time,
vec![points(vec![time as f32])],
)
.unwrap();
}
assert_eq!(
scene.attribute_times("mesh", "P").unwrap(),
vec![0.0, 1.0, 2.0],
);
let samples = scene.attribute_samples("mesh", "P").unwrap();
let times: Vec<f64> = samples.iter().map(|(time, _)| *time).collect();
assert_eq!(times, vec![0.0, 1.0, 2.0]);
assert_eq!(samples[0].1.data, OwnedData::F32(vec![0.0]));
}
#[test]
fn a_set_on_a_transform_in_the_chain_is_gathered() {
let mut scene = Scene::default();
scene.create("mesh", "mesh").unwrap();
scene.create("xf", "transform").unwrap();
scene.create("s", "set").unwrap();
scene.create("sa", "attributes").unwrap();
scene.connect("xf", None, ".root", "objects").unwrap();
scene.connect("mesh", None, "xf", "objects").unwrap();
scene.connect("xf", None, "s", "members").unwrap();
scene
.connect("sa", None, "s", "geometryattributes")
.unwrap();
scene
.set_attribute("sa", vec![integers("visibility", vec![0])])
.unwrap();
let binding = scene.geometry_binding("mesh").unwrap().expect("bound");
assert_eq!(binding.attributes, vec!["sa".to_string()]);
let value = scene.attribute_value("mesh", "visibility").unwrap();
assert_eq!(value.expect("defined").node, "sa");
}
#[test]
fn a_set_of_the_geometry_outranks_a_set_of_its_transform() {
let mut scene = Scene::default();
scene.create("mesh", "mesh").unwrap();
scene.create("xf", "transform").unwrap();
scene.create("sm", "set").unwrap();
scene.create("sx", "set").unwrap();
scene.create("am", "attributes").unwrap();
scene.create("ax", "attributes").unwrap();
scene.connect("xf", None, ".root", "objects").unwrap();
scene.connect("mesh", None, "xf", "objects").unwrap();
scene.connect("mesh", None, "sm", "members").unwrap();
scene.connect("xf", None, "sx", "members").unwrap();
scene
.connect("am", None, "sm", "geometryattributes")
.unwrap();
scene
.connect("ax", None, "sx", "geometryattributes")
.unwrap();
scene
.set_attribute("am", vec![integers("visibility", vec![1])])
.unwrap();
scene
.set_attribute("ax", vec![integers("visibility", vec![0])])
.unwrap();
let value = scene.attribute_value("mesh", "visibility").unwrap();
let value = value.expect("defined");
assert_eq!(value.node, "am");
assert_eq!(
value.arg.expect("a recorded value").data,
OwnedData::I32(vec![1])
);
}
#[test]
fn a_transforms_own_container_outranks_its_set() {
let mut scene = Scene::default();
scene.create("mesh", "mesh").unwrap();
scene.create("xf", "transform").unwrap();
scene.create("s", "set").unwrap();
scene.create("own", "attributes").unwrap();
scene.create("sa", "attributes").unwrap();
scene.connect("xf", None, ".root", "objects").unwrap();
scene.connect("mesh", None, "xf", "objects").unwrap();
scene.connect("xf", None, "s", "members").unwrap();
scene
.connect("own", None, "xf", "geometryattributes")
.unwrap();
scene
.connect("sa", None, "s", "geometryattributes")
.unwrap();
assert_eq!(
scene
.geometry_binding("mesh")
.unwrap()
.expect("bound")
.attributes,
vec!["own".to_string(), "sa".to_string()],
);
}
#[test]
fn a_set_holding_two_chain_nodes_is_one_source() {
let mut scene = Scene::default();
scene.create("mesh", "mesh").unwrap();
scene.create("xf", "transform").unwrap();
scene.create("s", "set").unwrap();
scene.create("sa", "attributes").unwrap();
scene.create("xa", "attributes").unwrap();
scene.connect("xf", None, ".root", "objects").unwrap();
scene.connect("mesh", None, "xf", "objects").unwrap();
scene.connect("mesh", None, "s", "members").unwrap();
scene.connect("xf", None, "s", "members").unwrap();
scene
.connect("sa", None, "s", "geometryattributes")
.unwrap();
scene
.connect("xa", None, "xf", "geometryattributes")
.unwrap();
assert_eq!(
scene
.geometry_binding("mesh")
.unwrap()
.expect("bound")
.attributes,
vec!["sa".to_string(), "xa".to_string()],
);
}
#[test]
fn a_reserved_handle_has_no_samples_rather_than_being_unknown() {
let mut scene = Scene::default();
assert_eq!(scene.attribute_times(".root", "P").unwrap(), Vec::new());
assert!(scene.attribute_samples(".global", "P").unwrap().is_empty());
scene
.set_attribute(".root", vec![integers("unrelated", vec![1])])
.unwrap();
assert_eq!(scene.attribute_times(".root", "P").unwrap(), Vec::new());
}
#[test]
fn a_transform_interpolates_between_its_samples() {
let mut scene = Scene::default();
scene.create("xf", "transform").unwrap();
scene.create("mesh", "mesh").unwrap();
scene.connect("xf", None, ".root", "objects").unwrap();
scene.connect("mesh", None, "xf", "objects").unwrap();
scene
.set_attribute_at_time("xf", 0.0, vec![translate(0.0, 0.0, 0.0)])
.unwrap();
scene
.set_attribute_at_time("xf", 1.0, vec![translate(10.0, 0.0, 0.0)])
.unwrap();
let half = scene.world_transform_interpolated_at("mesh", 0.5).unwrap();
assert_eq!(half[12], 5.0);
let quarter = scene.world_transform_interpolated_at("mesh", 0.25).unwrap();
assert_eq!(quarter[12], 2.5);
}
#[test]
fn interpolating_at_a_sample_returns_the_sample() {
let mut scene = Scene::default();
scene.create("xf", "transform").unwrap();
scene.create("mesh", "mesh").unwrap();
scene.connect("xf", None, ".root", "objects").unwrap();
scene.connect("mesh", None, "xf", "objects").unwrap();
scene
.set_attribute_at_time("xf", 0.0, vec![translate(0.0, 0.0, 0.0)])
.unwrap();
scene
.set_attribute_at_time("xf", 1.0, vec![translate(10.0, 0.0, 0.0)])
.unwrap();
assert_eq!(
scene.world_transform_interpolated_at("mesh", 1.0).unwrap(),
scene.world_transform_at("mesh", 1.0).unwrap(),
);
}
#[test]
fn interpolating_outside_the_sampled_range_holds_the_end_sample() {
let mut scene = Scene::default();
scene.create("xf", "transform").unwrap();
scene.create("mesh", "mesh").unwrap();
scene.connect("xf", None, ".root", "objects").unwrap();
scene.connect("mesh", None, "xf", "objects").unwrap();
scene
.set_attribute_at_time("xf", 0.0, vec![translate(0.0, 0.0, 0.0)])
.unwrap();
scene
.set_attribute_at_time("xf", 1.0, vec![translate(10.0, 0.0, 0.0)])
.unwrap();
assert_eq!(
scene.world_transform_interpolated_at("mesh", -0.5).unwrap()[12],
0.0,
);
assert_eq!(
scene.world_transform_interpolated_at("mesh", 1.5).unwrap()[12],
10.0,
);
assert_eq!(
scene.world_transform_interpolated_at("mesh", -0.0).unwrap()[12],
0.0,
);
let error = scene
.world_transform_interpolated_at("mesh", f64::NAN)
.unwrap_err();
let ResolveError::MissingSampleAtTime { available, .. } = &error else {
panic!("a NaN names no sample: {error:?}");
};
assert_eq!(available, &vec![0.0, 1.0]);
}
#[test]
fn each_node_interpolates_from_its_own_samples() {
let mut scene = Scene::default();
scene.create("outer", "transform").unwrap();
scene.create("inner", "transform").unwrap();
scene.create("mesh", "mesh").unwrap();
scene.connect("outer", None, ".root", "objects").unwrap();
scene.connect("inner", None, "outer", "objects").unwrap();
scene.connect("mesh", None, "inner", "objects").unwrap();
scene
.set_attribute_at_time("outer", 0.0, vec![scale(1.0)])
.unwrap();
scene
.set_attribute_at_time("outer", 1.0, vec![scale(3.0)])
.unwrap();
scene
.set_attribute_at_time("inner", 0.0, vec![translate(0.0, 0.0, 0.0)])
.unwrap();
scene
.set_attribute_at_time("inner", 1.0, vec![translate(4.0, 0.0, 0.0)])
.unwrap();
let half = scene.world_transform_interpolated_at("mesh", 0.5).unwrap();
assert_eq!(half[12], 4.0);
}
#[test]
fn interpolation_keeps_the_static_nodes_of_a_chain() {
let mut scene = Scene::default();
scene.create("outer", "transform").unwrap();
scene.create("mid", "transform").unwrap();
scene.create("inner", "transform").unwrap();
scene.create("mesh", "mesh").unwrap();
scene.connect("outer", None, ".root", "objects").unwrap();
scene.connect("mid", None, "outer", "objects").unwrap();
scene.connect("inner", None, "mid", "objects").unwrap();
scene.connect("mesh", None, "inner", "objects").unwrap();
scene
.set_attribute_at_time("outer", 0.0, vec![scale(1.0)])
.unwrap();
scene
.set_attribute_at_time("outer", 1.0, vec![scale(3.0)])
.unwrap();
scene
.set_attribute("mid", vec![translate(1.0, 0.0, 0.0)])
.unwrap();
scene
.set_attribute_at_time("inner", 0.0, vec![translate(0.0, 0.0, 0.0)])
.unwrap();
scene
.set_attribute_at_time("inner", 1.0, vec![translate(4.0, 0.0, 0.0)])
.unwrap();
let half = scene.world_transform_interpolated_at("mesh", 0.5).unwrap();
assert_eq!(half[12], 6.0);
for time in [0.0, 1.0] {
assert_eq!(
scene.world_transform_interpolated_at("mesh", time).unwrap(),
scene.world_transform_at("mesh", time).unwrap(),
"the two accessors disagree at sample {time}",
);
}
}
#[test]
fn a_single_sample_node_is_constant() {
let mut scene = Scene::default();
scene.create("xf", "transform").unwrap();
scene.create("mesh", "mesh").unwrap();
scene.connect("xf", None, ".root", "objects").unwrap();
scene.connect("mesh", None, "xf", "objects").unwrap();
scene
.set_attribute_at_time("xf", 0.25, vec![translate(7.0, 0.0, 0.0)])
.unwrap();
for time in [0.0, 0.25, 9.0] {
assert_eq!(
scene.world_transform_interpolated_at("mesh", time).unwrap()[12],
7.0,
"one sample applies at every time, including {time}",
);
}
}
#[test]
fn a_two_parent_geometry_has_two_placements() {
let mut scene = Scene::default();
scene.create("q", "mesh").unwrap();
scene.create("xfA", "transform").unwrap();
scene.create("xfB", "transform").unwrap();
scene.connect("xfA", None, ".root", "objects").unwrap();
scene.connect("xfB", None, ".root", "objects").unwrap();
scene
.set_attribute("xfA", vec![translate(-2.0, 0.0, 0.0)])
.unwrap();
scene
.set_attribute("xfB", vec![translate(2.0, 0.0, 0.0)])
.unwrap();
scene.connect("q", None, "xfA", "objects").unwrap();
scene.connect("q", None, "xfB", "objects").unwrap();
let placements = scene.placements("q").unwrap();
assert_eq!(placements.len(), 2);
assert_eq!(placements[0].transform[12], -2.0);
assert_eq!(placements[1].transform[12], 2.0);
assert_eq!(placements[0].path, vec!["q", "xfA", ".root"]);
assert_eq!(placements[1].path, vec!["q", "xfB", ".root"]);
assert!(matches!(
scene.world_transform("q"),
Err(ResolveError::MultipleParents { .. })
));
}
#[test]
fn each_placement_binds_along_its_own_path() {
let mut scene = Scene::default();
scene.create("q", "mesh").unwrap();
scene.create("xfA", "transform").unwrap();
scene.create("xfB", "transform").unwrap();
scene.create("visA", "attributes").unwrap();
scene.create("visB", "attributes").unwrap();
scene.connect("xfA", None, ".root", "objects").unwrap();
scene.connect("xfB", None, ".root", "objects").unwrap();
scene
.connect("visA", None, "xfA", "geometryattributes")
.unwrap();
scene
.connect("visB", None, "xfB", "geometryattributes")
.unwrap();
scene.connect("q", None, "xfA", "objects").unwrap();
scene.connect("q", None, "xfB", "objects").unwrap();
let placements = scene.placements("q").unwrap();
assert_eq!(
placements[0].binding.as_ref().unwrap().attributes,
vec!["visA".to_string()],
);
assert_eq!(
placements[1].binding.as_ref().unwrap().attributes,
vec!["visB".to_string()],
);
}
#[test]
fn a_single_placement_agrees_with_the_single_answer_accessors() {
let scene = scene_with_material();
let placements = scene.placements("mesh").unwrap();
assert_eq!(placements.len(), 1);
assert_eq!(
placements[0].transform,
scene.world_transform("mesh").unwrap()
);
assert_eq!(
placements[0].binding,
scene.geometry_binding("mesh").unwrap(),
);
}
#[test]
fn a_detached_geometry_has_no_placements() {
let mut scene = Scene::default();
scene.create("q", "mesh").unwrap();
assert!(matches!(
scene.placements("q"),
Err(ResolveError::Detached { .. })
));
}
#[test]
fn a_cyclic_placement_path_is_refused() {
let mut scene = Scene::default();
scene.create("a", "transform").unwrap();
scene.create("b", "transform").unwrap();
scene.connect("a", None, "b", "objects").unwrap();
scene.connect("b", None, "a", "objects").unwrap();
assert!(matches!(
scene.placements("a"),
Err(ResolveError::Cycle { .. })
));
}
#[test]
fn an_instancer_only_prototype_has_no_direct_placements() {
let mut scene = Scene::default();
scene.create("inst", "instances").unwrap();
scene.create("q", "mesh").unwrap();
scene.connect("inst", None, ".root", "objects").unwrap();
scene.connect("q", None, "inst", "sourcemodels").unwrap();
assert_eq!(
scene.placements("q").unwrap(),
Vec::new(),
"no direct placements; the instancer carries them",
);
scene.create("orphan", "mesh").unwrap();
assert!(matches!(
scene.placements("orphan"),
Err(ResolveError::Detached { .. })
));
}
#[test]
fn a_directly_placed_prototype_keeps_its_placement() {
let mut scene = Scene::default();
scene.create("inst", "instances").unwrap();
scene.create("q", "mesh").unwrap();
scene.create("xf", "transform").unwrap();
scene.connect("inst", None, ".root", "objects").unwrap();
scene.connect("xf", None, ".root", "objects").unwrap();
scene.connect("q", None, "inst", "sourcemodels").unwrap();
scene.connect("q", None, "xf", "objects").unwrap();
scene
.set_attribute("xf", vec![translate(3.0, 0.0, 0.0)])
.unwrap();
let placements = scene.placements("q").unwrap();
assert_eq!(placements.len(), 1);
assert_eq!(placements[0].path, vec!["q", "xf", ".root"]);
assert_eq!(placements[0].transform[12], 3.0);
}
#[test]
fn placement_composition_order_matches_world_transform() {
let mut scene = Scene::default();
scene.create("q", "mesh").unwrap();
scene.create("outer", "transform").unwrap();
scene.create("inner", "transform").unwrap();
scene.connect("outer", None, ".root", "objects").unwrap();
scene.connect("inner", None, "outer", "objects").unwrap();
scene.connect("q", None, "inner", "objects").unwrap();
scene.set_attribute("outer", vec![scale(2.0)]).unwrap();
scene
.set_attribute("inner", vec![translate(5.0, 0.0, 0.0)])
.unwrap();
let placements = scene.placements("q").unwrap();
assert_eq!(placements[0].transform[12], 10.0);
assert_eq!(
placements[0].transform,
scene.world_transform("q").unwrap(),
"one composition, so the two cannot disagree",
);
}
#[test]
fn a_placement_includes_the_nodes_own_matrix() {
let mut scene = Scene::default();
scene.create("xf", "transform").unwrap();
scene.create("parent", "transform").unwrap();
scene.connect("parent", None, ".root", "objects").unwrap();
scene.connect("xf", None, "parent", "objects").unwrap();
scene
.set_attribute("xf", vec![translate(4.0, 0.0, 0.0)])
.unwrap();
scene
.set_attribute("parent", vec![translate(1.0, 0.0, 0.0)])
.unwrap();
let placements = scene.placements("xf").unwrap();
assert_eq!(placements[0].transform[12], 5.0);
assert_eq!(
placements[0].transform,
scene.world_transform("xf").unwrap(),
);
}
#[test]
fn a_sampled_transform_refuses_a_placement() {
let mut scene = Scene::default();
scene.create("q", "mesh").unwrap();
scene.create("xf", "transform").unwrap();
scene.connect("xf", None, ".root", "objects").unwrap();
scene.connect("q", None, "xf", "objects").unwrap();
scene
.set_attribute_at_time("xf", 0.0, vec![translate(0.0, 0.0, 0.0)])
.unwrap();
scene
.set_attribute_at_time("xf", 1.0, vec![translate(9.0, 0.0, 0.0)])
.unwrap();
assert!(matches!(
scene.placements("q"),
Err(ResolveError::MotionSampledTransform { .. })
));
}
#[test]
fn the_placement_walk_does_not_follow_an_instancer() {
let mut scene = Scene::default();
scene.create("inst", "instances").unwrap();
scene.create("q", "mesh").unwrap();
scene.create("xf", "transform").unwrap();
scene.connect("xf", None, ".root", "objects").unwrap();
scene.connect("inst", None, "xf", "objects").unwrap();
scene.connect("q", None, "inst", "sourcemodels").unwrap();
scene
.set_attribute("xf", vec![translate(7.0, 0.0, 0.0)])
.unwrap();
assert_eq!(
scene.placements("q").unwrap(),
Vec::new(),
"reached only through the instancer, so no direct placement",
);
}
#[test]
fn a_deep_chain_does_not_overflow_the_stack() {
const DEPTH: usize = 12_000;
let mut scene = Scene::default();
scene.create("q", "mesh").unwrap();
for level in 0..DEPTH {
scene.create(&format!("xf{level}"), "transform").unwrap();
}
scene.connect("xf0", None, ".root", "objects").unwrap();
for level in 1..DEPTH {
scene
.connect(
&format!("xf{level}"),
None,
&format!("xf{}", level - 1),
"objects",
)
.unwrap();
}
scene
.connect("q", None, &format!("xf{}", DEPTH - 1), "objects")
.unwrap();
let placements = scene.placements("q").unwrap();
assert_eq!(placements.len(), 1);
assert_eq!(placements[0].path.len(), DEPTH + 2);
}
#[test]
fn a_moving_instanced_geometry_resolves_per_path() {
let mut scene = Scene::default();
scene.create("q", "mesh").unwrap();
scene.create("xfA", "transform").unwrap();
scene.create("xfB", "transform").unwrap();
scene.connect("xfA", None, ".root", "objects").unwrap();
scene.connect("xfB", None, ".root", "objects").unwrap();
scene.connect("q", None, "xfA", "objects").unwrap();
scene.connect("q", None, "xfB", "objects").unwrap();
scene
.set_attribute_at_time("xfA", 0.0, vec![translate(0.0, 0.0, 0.0)])
.unwrap();
scene
.set_attribute_at_time("xfA", 1.0, vec![translate(10.0, 0.0, 0.0)])
.unwrap();
scene
.set_attribute_at_time("xfB", 0.0, vec![translate(0.0, 0.0, 0.0)])
.unwrap();
scene
.set_attribute_at_time("xfB", 1.0, vec![translate(-4.0, 0.0, 0.0)])
.unwrap();
assert!(matches!(
scene.placements("q"),
Err(ResolveError::MotionSampledTransform { .. })
));
assert!(matches!(
scene.world_transform_interpolated_at("q", 0.5),
Err(ResolveError::MultipleParents { .. })
));
let half = scene.placements_at("q", 0.5).unwrap();
assert_eq!(half.len(), 2);
assert_eq!(half[0].transform[12], 5.0);
assert_eq!(half[1].transform[12], -2.0);
let after = scene.placements_at("q", 9.0).unwrap();
assert_eq!(after[0].transform[12], 10.0);
}
#[test]
fn placements_at_agrees_with_placements_on_a_static_scene() {
let scene = scene_with_material();
assert_eq!(
scene.placements_at("mesh", 0.25).unwrap(),
scene.placements("mesh").unwrap(),
);
}
#[test]
fn attribute_rules_apply_along_a_placement_path() {
let mut scene = Scene::default();
scene.create("q", "mesh").unwrap();
scene.create("xfA", "transform").unwrap();
scene.create("xfB", "transform").unwrap();
scene.create("attrA", "attributes").unwrap();
scene.create("attrB", "attributes").unwrap();
scene.connect("xfA", None, ".root", "objects").unwrap();
scene.connect("xfB", None, ".root", "objects").unwrap();
scene.connect("q", None, "xfA", "objects").unwrap();
scene.connect("q", None, "xfB", "objects").unwrap();
scene
.connect("attrA", None, "xfA", "geometryattributes")
.unwrap();
scene
.connect("attrB", None, "xfB", "geometryattributes")
.unwrap();
scene
.set_attribute(
"attrA",
vec![
integers("visibility", vec![1]),
integers("visibility.camera", vec![0]),
],
)
.unwrap();
scene
.set_attribute("attrB", vec![integers("visibility", vec![1])])
.unwrap();
assert!(matches!(
scene.attribute_value("q", "visibility.camera"),
Err(ResolveError::MultipleParents { .. })
));
let placements = scene.placements("q").unwrap();
let a = scene
.attribute_value_along(&placements[0].path, "visibility.camera")
.expect("defined");
assert_eq!(a.node, "attrA");
assert_eq!(a.name, "visibility.camera", "specificity still applies");
let b = scene
.attribute_value_along(&placements[1].path, "visibility.camera")
.expect("defined");
assert_eq!(b.node, "attrB");
assert_eq!(b.name, "visibility", "falls back to the default");
}
#[test]
fn shader_attributes_resolve_along_a_placement_path() {
let mut scene = Scene::default();
scene.create("q", "mesh").unwrap();
scene.create("xfA", "transform").unwrap();
scene.create("xfB", "transform").unwrap();
scene.create("saA", "attributes").unwrap();
scene.connect("xfA", None, ".root", "objects").unwrap();
scene.connect("xfB", None, ".root", "objects").unwrap();
scene.connect("q", None, "xfA", "objects").unwrap();
scene.connect("q", None, "xfB", "objects").unwrap();
scene
.connect("saA", None, "xfA", "shaderattributes")
.unwrap();
scene
.set_attribute("saA", vec![integers("tint", vec![3])])
.unwrap();
let placements = scene.placements("q").unwrap();
assert_eq!(
scene
.shader_attribute_value_along(&placements[0].path, "tint")
.expect("on the A path")
.node,
"saA",
);
assert!(
scene
.shader_attribute_value_along(&placements[1].path, "tint")
.is_none(),
"nothing on the B path provides it",
);
scene
.set_attribute("q", vec![integers("tint", vec![9])])
.unwrap();
let placements = scene.placements("q").unwrap();
assert_eq!(
scene
.shader_attribute_value_along(&placements[0].path, "tint")
.expect("on the primitive")
.node,
"q",
);
}
#[test]
fn interpolated_composition_order_is_pinned() {
let mut scene = Scene::default();
scene.create("q", "mesh").unwrap();
scene.create("outer", "transform").unwrap();
scene.create("inner", "transform").unwrap();
scene.connect("outer", None, ".root", "objects").unwrap();
scene.connect("inner", None, "outer", "objects").unwrap();
scene.connect("q", None, "inner", "objects").unwrap();
scene.set_attribute("outer", vec![scale(2.0)]).unwrap();
scene
.set_attribute_at_time("inner", 0.0, vec![translate(0.0, 0.0, 0.0)])
.unwrap();
scene
.set_attribute_at_time("inner", 1.0, vec![translate(6.0, 0.0, 0.0)])
.unwrap();
let half = scene.placements_at("q", 0.5).unwrap();
assert_eq!(half[0].transform[12], 6.0);
assert_eq!(half[0].transform[0], 2.0);
assert_eq!(
half[0].transform,
scene.world_transform_interpolated_at("q", 0.5).unwrap(),
"one fold, so the two cannot disagree",
);
}
#[test]
fn a_moving_instancer_is_refused_not_reported_empty() {
let mut scene = Scene::default();
scene.create("inst", "instances").unwrap();
scene.create("proto", "mesh").unwrap();
scene.connect("inst", None, ".root", "objects").unwrap();
scene
.connect("proto", None, "inst", "sourcemodels")
.unwrap();
scene
.set_attribute_at_time(
"inst",
0.0,
vec![doubles("transformationmatrices", instance_matrix(0.0))],
)
.unwrap();
scene
.set_attribute_at_time(
"inst",
1.0,
vec![doubles("transformationmatrices", instance_matrix(8.0))],
)
.unwrap();
assert!(
matches!(
scene.instance_transforms("inst"),
Err(ResolveError::MotionSampledTransform { .. })
),
"an empty list would read as `no instances`",
);
let half = scene.instance_transforms_at("inst", 0.5).unwrap();
assert_eq!(half.len(), 1);
assert_eq!(half[0].transform[12], 4.0);
let after = scene.instance_transforms_at("inst", 5.0).unwrap();
assert_eq!(after[0].transform[12], 8.0);
}
#[test]
fn instance_transforms_at_agrees_on_a_static_instancer() {
let mut scene = Scene::default();
scene.create("inst", "instances").unwrap();
scene.create("proto", "mesh").unwrap();
scene.connect("inst", None, ".root", "objects").unwrap();
scene
.connect("proto", None, "inst", "sourcemodels")
.unwrap();
scene
.set_attribute(
"inst",
vec![doubles("transformationmatrices", instance_matrix(2.0))],
)
.unwrap();
assert_eq!(
scene.instance_transforms_at("inst", 0.75).unwrap(),
scene.instance_transforms("inst").unwrap(),
);
}
#[test]
fn attr_priority_applies_along_a_placement_path() {
let mut scene = Scene::default();
scene.create("q", "mesh").unwrap();
scene.create("xf", "transform").unwrap();
scene.create("near", "attributes").unwrap();
scene.create("far", "attributes").unwrap();
scene.connect("xf", None, ".root", "objects").unwrap();
scene.connect("q", None, "xf", "objects").unwrap();
scene
.connect("near", None, "q", "geometryattributes")
.unwrap();
scene
.connect("far", None, "xf", "geometryattributes")
.unwrap();
scene
.set_attribute("near", vec![integers("visibility", vec![0])])
.unwrap();
scene
.set_attribute(
"far",
vec![
integers("visibility", vec![1]),
integers("visibility.priority", vec![10]),
],
)
.unwrap();
let placements = scene.placements("q").unwrap();
let value = scene
.attribute_value_along(&placements[0].path, "visibility")
.expect("defined");
assert_eq!(value.node, "far", "priority outranks proximity here too");
assert_eq!(value.priority, 10);
}
#[test]
fn the_nearest_shader_attribute_wins_along_a_path() {
let mut scene = Scene::default();
scene.create("q", "mesh").unwrap();
scene.create("xf", "transform").unwrap();
scene.create("near", "attributes").unwrap();
scene.create("far", "attributes").unwrap();
scene.connect("xf", None, ".root", "objects").unwrap();
scene.connect("q", None, "xf", "objects").unwrap();
scene
.connect("near", None, "q", "shaderattributes")
.unwrap();
scene
.connect("far", None, "xf", "shaderattributes")
.unwrap();
scene
.set_attribute("near", vec![integers("tint", vec![1])])
.unwrap();
scene
.set_attribute("far", vec![integers("tint", vec![2])])
.unwrap();
let placements = scene.placements("q").unwrap();
let value = scene
.shader_attribute_value_along(&placements[0].path, "tint")
.expect("defined");
assert_eq!(value.node, "near");
}
#[test]
fn an_interior_sample_time_is_answered_for_instances_and_transforms() {
let mut scene = Scene::default();
scene.create("inst", "instances").unwrap();
scene.create("proto", "mesh").unwrap();
scene.create("xf", "transform").unwrap();
scene.connect("inst", None, ".root", "objects").unwrap();
scene
.connect("proto", None, "inst", "sourcemodels")
.unwrap();
scene.connect("xf", None, ".root", "objects").unwrap();
for (time, x) in [(0.0, 0.0), (0.5, 4.0), (1.0, 10.0)] {
scene
.set_attribute_at_time(
"inst",
time,
vec![doubles("transformationmatrices", instance_matrix(x))],
)
.unwrap();
scene
.set_attribute_at_time("xf", time, vec![translate(x, 0.0, 0.0)])
.unwrap();
}
assert_eq!(
scene.instance_transforms_at("inst", 0.5).unwrap()[0].transform[12],
4.0,
);
assert_eq!(
scene.world_transform_interpolated_at("xf", 0.5).unwrap()[12],
4.0,
);
assert_eq!(
scene.instance_transforms_at("inst", 0.25).unwrap()[0].transform[12],
2.0,
);
}
#[test]
fn sampled_instance_indices_take_their_last_value() {
let two = [instance_matrix(-1.0), instance_matrix(1.0)].concat();
let build = |disabled_at: [(f64, i32); 2]| {
let mut scene = Scene::default();
scene.create("inst", "instances").unwrap();
scene.create("proto", "mesh").unwrap();
scene.connect("inst", None, ".root", "objects").unwrap();
scene
.connect("proto", None, "inst", "sourcemodels")
.unwrap();
scene
.set_attribute(
"inst",
vec![doubles("transformationmatrices", two.clone())],
)
.unwrap();
for (time, value) in disabled_at {
scene
.set_attribute_at_time(
"inst",
time,
vec![integers("disabledinstances", vec![value])],
)
.unwrap();
}
scene
};
let scene = build([(0.0, 1), (1.0, 0)]);
for time in [0.0, 0.5, 1.0, 9.0] {
let at = scene.instance_transforms_at("inst", time).unwrap();
assert_eq!(at.len(), 1, "at {time}");
assert_eq!(
at[0].transform[12], 1.0,
"the last value applies at {time}"
);
}
let scene = build([(0.0, 0), (1.0, 1)]);
let at = scene.instance_transforms_at("inst", 0.5).unwrap();
assert_eq!(at[0].transform[12], -1.0);
let statically = scene.instance_transforms("inst").unwrap();
assert_eq!(statically.len(), 1);
assert_eq!(statically[0].transform[12], -1.0);
}
#[test]
fn a_sample_changing_the_instance_count_is_ignored() {
let mut scene = Scene::default();
scene.create("inst", "instances").unwrap();
scene.create("proto", "mesh").unwrap();
scene.connect("inst", None, ".root", "objects").unwrap();
scene
.connect("proto", None, "inst", "sourcemodels")
.unwrap();
let two = [instance_matrix(-1.0), instance_matrix(1.0)].concat();
let three = [
instance_matrix(-5.0),
instance_matrix(5.0),
instance_matrix(0.0),
]
.concat();
scene
.set_attribute_at_time(
"inst",
0.0,
vec![doubles("transformationmatrices", two)],
)
.unwrap();
scene
.set_attribute_at_time(
"inst",
1.0,
vec![doubles("transformationmatrices", three)],
)
.unwrap();
for time in [0.0, 0.5, 1.0, 9.0] {
let at = scene.instance_transforms_at("inst", time).unwrap();
assert_eq!(at.len(), 2, "the t=1 sample is ignored, at {time}");
assert_eq!(at[0].transform[12], -1.0, "and the set stays static");
assert_eq!(at[1].transform[12], 1.0);
}
}
#[test]
fn shader_attribute_value_refuses_an_unreachable_geometry() {
let mut scene = Scene::default();
scene.create("det", "mesh").unwrap();
scene
.set_attribute("det", vec![integers("tint", vec![1])])
.unwrap();
assert!(matches!(
scene.shader_attribute_value("det", "tint"),
Err(ResolveError::Detached { .. })
));
assert!(matches!(
scene.attribute_value("det", "tint"),
Err(ResolveError::Detached { .. })
));
let mut scene = Scene::default();
scene.create("q", "mesh").unwrap();
scene.create("a", "transform").unwrap();
scene.create("b", "transform").unwrap();
scene.connect("a", None, ".root", "objects").unwrap();
scene.connect("b", None, ".root", "objects").unwrap();
scene.connect("q", None, "a", "objects").unwrap();
scene.connect("q", None, "b", "objects").unwrap();
scene
.set_attribute("q", vec![integers("tint", vec![1])])
.unwrap();
assert!(matches!(
scene.shader_attribute_value("q", "tint"),
Err(ResolveError::MultipleParents { .. })
));
let placements = scene.placements("q").unwrap();
assert_eq!(
scene
.shader_attribute_value_along(&placements[0].path, "tint")
.expect("on the primitive")
.node,
"q",
);
}
#[test]
fn negative_zero_finds_an_interior_sample() {
let mut scene = Scene::default();
scene.create("xf", "transform").unwrap();
scene.create("q", "mesh").unwrap();
scene.create("inst", "instances").unwrap();
scene.create("proto", "mesh").unwrap();
scene.connect("xf", None, ".root", "objects").unwrap();
scene.connect("q", None, "xf", "objects").unwrap();
scene.connect("inst", None, ".root", "objects").unwrap();
scene
.connect("proto", None, "inst", "sourcemodels")
.unwrap();
for (time, x) in [(-1.0, -8.0), (0.0, 5.0), (1.0, 20.0)] {
scene
.set_attribute_at_time("xf", time, vec![translate(x, 0.0, 0.0)])
.unwrap();
scene
.set_attribute_at_time(
"inst",
time,
vec![doubles("transformationmatrices", instance_matrix(x))],
)
.unwrap();
}
assert_eq!(
scene.world_transform_interpolated_at("xf", -0.0).unwrap()[12],
5.0,
);
assert_eq!(
scene.instance_transforms_at("inst", -0.0).unwrap()[0].transform[12],
5.0,
);
assert_eq!(
scene.placements_at("q", -0.0).unwrap()[0].transform[12],
5.0,
);
assert_eq!(scene.world_transform_at("xf", -0.0).unwrap()[12], 5.0);
}
#[test]
fn sampled_model_indices_take_their_last_value() {
let mut scene = Scene::default();
scene.create("inst", "instances").unwrap();
for (handle, index) in [("a", 0), ("b", 1), ("c", 2)] {
scene.create(handle, "mesh").unwrap();
scene
.connect_with_arguments(
handle,
None,
"inst",
"sourcemodels",
vec![integers("index", vec![index])],
)
.unwrap();
}
scene.connect("inst", None, ".root", "objects").unwrap();
let two = [instance_matrix(-1.0), instance_matrix(1.0)].concat();
scene
.set_attribute("inst", vec![doubles("transformationmatrices", two)])
.unwrap();
for (time, indices) in
[(0.0, vec![0, 1]), (0.5, vec![1, 2]), (1.0, vec![2, 0])]
{
scene
.set_attribute_at_time(
"inst",
time,
vec![integers("modelindices", indices)],
)
.unwrap();
}
for time in [0.0, 0.25, 1.0] {
let at = scene.instance_transforms_at("inst", time).unwrap();
assert_eq!(at.len(), 2);
assert_eq!(at[0].source, 2, "the last value applies at {time}");
assert_eq!(at[1].source, 0);
}
}
#[test]
fn a_wrong_typed_later_sample_clears_the_attribute() {
let mut scene = Scene::default();
scene.create("inst", "instances").unwrap();
scene.create("proto", "mesh").unwrap();
scene.connect("inst", None, ".root", "objects").unwrap();
scene
.connect("proto", None, "inst", "sourcemodels")
.unwrap();
let two = [instance_matrix(-1.0), instance_matrix(1.0)].concat();
scene
.set_attribute("inst", vec![doubles("transformationmatrices", two)])
.unwrap();
scene
.set_attribute_at_time(
"inst",
0.0,
vec![integers("disabledinstances", vec![1])],
)
.unwrap();
scene
.set_attribute_at_time(
"inst",
1.0,
vec![OwnedArgument {
name: "disabledinstances".to_string(),
type_tag: Type::I64,
array_length: 1,
flags: 0,
data: OwnedData::I64(vec![0]),
}],
)
.unwrap();
let at = scene.instance_transforms_at("inst", 0.5).unwrap();
assert_eq!(at.len(), 2, "the int64 clears it; nothing is disabled");
}
#[test]
fn the_sampled_and_the_single_time_accessors_agree() {
let mut scene = Scene::default();
scene.create("outer", "transform").unwrap();
scene.create("inner", "transform").unwrap();
scene.create("q", "mesh").unwrap();
scene.connect("outer", None, ".root", "objects").unwrap();
scene.connect("inner", None, "outer", "objects").unwrap();
scene.connect("q", None, "inner", "objects").unwrap();
for (time, x) in [(0.0, -1.0), (1.0, 1.0)] {
scene
.set_attribute_at_time("outer", time, vec![translate(x, 0.0, 0.0)])
.unwrap();
}
for (time, y) in [(0.25, 0.0), (0.75, 2.0)] {
scene
.set_attribute_at_time("inner", time, vec![translate(0.0, y, 0.0)])
.unwrap();
}
let samples = scene.world_transform_samples("q").unwrap();
assert_eq!(
samples.iter().map(|(t, _)| *t).collect::<Vec<_>>(),
scene.motion_times("q").unwrap(),
"one entry per motion time",
);
for (time, matrix) in &samples {
assert_eq!(
*matrix,
scene.world_transform_interpolated_at("q", *time).unwrap(),
"the two accessors disagree at t={time}",
);
}
for time in [0.1, 0.5, 0.9] {
let composed =
scene.world_transform_interpolated_at("q", time).unwrap();
assert!(
composed[12] > -1.0 && composed[12] < 1.0,
"swept, not held, at t={time}",
);
}
}
#[test]
fn the_batch_walk_agrees_with_the_single_accessor() {
let mut scene = Scene::default();
scene.create("outer", "transform").unwrap();
scene.create("inner", "transform").unwrap();
scene.create("q", "mesh").unwrap();
scene.create("shared", "mesh").unwrap();
scene.connect("outer", None, ".root", "objects").unwrap();
scene.connect("inner", None, "outer", "objects").unwrap();
scene.connect("q", None, "inner", "objects").unwrap();
scene.connect("shared", None, "outer", "objects").unwrap();
scene.connect("shared", None, "inner", "objects").unwrap();
scene
.set_attribute("outer", vec![translate(1.0, 0.0, 0.0)])
.unwrap();
scene
.set_attribute("inner", vec![translate(0.0, 2.0, 0.0)])
.unwrap();
let flat: Vec<_> = scene.world_transforms().collect();
for (handle, matrix) in &flat {
if *handle == "shared" {
continue;
}
assert_eq!(
scene.world_transform(handle).unwrap(),
*matrix,
"`{handle}` differs between the two walks",
);
}
let shared: Vec<_> = flat
.iter()
.filter(|(handle, _)| *handle == "shared")
.collect();
assert_eq!(shared.len(), 2, "one entry per path");
assert!(matches!(
scene.world_transform("shared"),
Err(ResolveError::MultipleParents { .. })
));
let mut ys: Vec<f64> = shared.iter().map(|(_, m)| m[13]).collect();
ys.sort_by(f64::total_cmp);
assert_eq!(ys, vec![0.0, 2.0], "under `outer`, and under `inner`");
}
#[test]
fn the_borrowed_instances_agree_with_the_copied_ones() {
let mut scene = Scene::default();
scene.create("inst", "instances").unwrap();
scene.connect("inst", None, ".root", "objects").unwrap();
for (handle, index) in [("a", 7), ("b", 3), ("c", 11)] {
scene.create(handle, "mesh").unwrap();
scene
.connect_with_arguments(
handle,
None,
"inst",
"sourcemodels",
vec![integers("index", vec![index])],
)
.unwrap();
}
let four = [
instance_matrix(-1.0),
instance_matrix(1.0),
instance_matrix(2.0),
instance_matrix(3.0),
]
.concat();
scene
.set_attribute(
"inst",
vec![
doubles("transformationmatrices", four),
integers("modelindices", vec![11, 3, -1, 7]),
integers("disabledinstances", vec![1]),
],
)
.unwrap();
let copied = scene.instance_transforms("inst").unwrap();
let borrowed: Vec<_> = scene.instances("inst").unwrap().collect();
assert_eq!(copied.len(), 2, "one disabled, one negative index");
assert_eq!(borrowed.len(), copied.len());
for (copy, borrow) in copied.iter().zip(&borrowed) {
assert_eq!(copy.source, borrow.source);
assert_eq!(©.transform, borrow.transform);
}
let mut sampled = Scene::default();
sampled.create("inst", "instances").unwrap();
sampled.create("proto", "mesh").unwrap();
sampled.connect("inst", None, ".root", "objects").unwrap();
sampled
.connect("proto", None, "inst", "sourcemodels")
.unwrap();
sampled
.set_attribute_at_time(
"inst",
0.0,
vec![doubles("transformationmatrices", instance_matrix(0.0))],
)
.unwrap();
assert!(matches!(
sampled.instances("inst"),
Err(ResolveError::MotionSampledTransform { .. })
));
assert!(matches!(
sampled.instance_transforms("inst"),
Err(ResolveError::MotionSampledTransform { .. })
));
}
#[test]
fn instancer_matrices_are_a_doublematrix_by_declaration() {
let plain_doubles = |values: Vec<f64>| OwnedArgument {
name: "transformationmatrices".to_string(),
type_tag: Type::F64,
array_length: 1,
flags: 0,
data: OwnedData::F64(values),
};
let two = || [instance_matrix(-1.0), instance_matrix(1.0)].concat();
let build = |arg: OwnedArgument| {
let mut scene = Scene::default();
scene.create("inst", "instances").unwrap();
scene.create("proto", "mesh").unwrap();
scene.connect("inst", None, ".root", "objects").unwrap();
scene
.connect("proto", None, "inst", "sourcemodels")
.unwrap();
scene.set_attribute("inst", vec![arg]).unwrap();
scene
};
assert_eq!(
build(doubles("transformationmatrices", two()))
.instance_transforms("inst")
.unwrap()
.len(),
2,
"the control: a declared doublematrix draws two",
);
assert!(
build(plain_doubles(two()))
.instance_transforms("inst")
.unwrap()
.is_empty(),
"thirty-two doubles are not a doublematrix, and the renderer \
draws nothing for them",
);
let mut scene = Scene::default();
scene.create("inst", "instances").unwrap();
scene.create("proto", "mesh").unwrap();
scene.connect("inst", None, ".root", "objects").unwrap();
scene
.connect("proto", None, "inst", "sourcemodels")
.unwrap();
scene
.set_attribute_at_time(
"inst",
0.0,
vec![doubles("transformationmatrices", two())],
)
.unwrap();
scene
.set_attribute_at_time("inst", 1.0, vec![plain_doubles(two())])
.unwrap();
assert!(
scene
.instance_transforms_at("inst", 0.5)
.unwrap()
.is_empty(),
"the last call is not a doublematrix, so nothing is drawn",
);
let as_array = |mut arg: OwnedArgument| {
arg.flags |= nsi_ffi_wrap::nsi_sys::NSIParamFlags::IsArray.bits();
arg
};
assert!(
build(as_array(doubles("transformationmatrices", two())))
.instance_transforms("inst")
.unwrap()
.is_empty(),
"a doublematrix[n] is not a doublematrix",
);
let mut scene = Scene::default();
scene.create("xf", "transform").unwrap();
scene.create("q", "mesh").unwrap();
scene.connect("xf", None, ".root", "objects").unwrap();
scene.connect("q", None, "xf", "objects").unwrap();
scene
.set_attribute("xf", vec![as_array(translate(50.0, 0.0, 0.0))])
.unwrap();
assert_eq!(
scene.world_transform("q").unwrap(),
super::IDENTITY,
"3Delight logs E6007 and leaves the node at identity",
);
}
#[test]
fn the_two_interpolating_accessors_refuse_alike() {
let mut scene = Scene::default();
scene.create("inst", "instances").unwrap();
scene.create("proto", "mesh").unwrap();
scene
.connect("proto", None, "inst", "sourcemodels")
.unwrap();
let sampled = scene.world_transform_samples("proto").unwrap_err();
let single = scene
.world_transform_interpolated_at("proto", 0.0)
.unwrap_err();
assert_eq!(
mem::discriminant(&sampled),
mem::discriminant(&single),
"one said {sampled:?}, the other {single:?}",
);
}
#[test]
fn the_typing_rule_is_available_for_any_attribute() {
let point = |x: f32| OwnedArgument {
name: "P".to_string(),
type_tag: Type::Point,
array_length: 1,
flags: 0,
data: OwnedData::F32(vec![x, 0.0, 0.0]),
};
let readable = |arg: &OwnedArgument| arg.type_tag == Type::Point;
let mut scene = Scene::default();
scene.create("q", "mesh").unwrap();
scene
.set_attribute_at_time("q", 0.0, vec![point(-1.0)])
.unwrap();
assert!(
matches!(
scene.sampled_attribute("q", "P", readable).unwrap(),
Sampled::Yes { .. }
),
"one good sample stands",
);
assert!(
matches!(
scene.sampled_attribute("q", "nosuch", readable).unwrap(),
Sampled::No
),
"an attribute that was never sampled",
);
scene
.set_attribute_at_time(
"q",
1.0,
vec![OwnedArgument {
name: "P".to_string(),
type_tag: Type::F32,
array_length: 1,
flags: 0,
data: OwnedData::F32(vec![0.5]),
}],
)
.unwrap();
assert!(
matches!(
scene.sampled_attribute("q", "P", readable).unwrap(),
Sampled::Unset
),
"the last call is unreadable, so the attribute is unset -- not \
a fall back to the t=0 sample, which would draw a mesh the \
renderer does not",
);
assert_eq!(
scene.attribute_samples("q", "P").unwrap().len(),
2,
"while the untyped accessor still reports what was recorded",
);
scene
.set_attribute_at_time("q", 1.0, vec![point(1.0)])
.unwrap();
let Sampled::Yes { samples, .. } =
scene.sampled_attribute("q", "P", readable).unwrap()
else {
panic!("rebuilt by the later call");
};
assert_eq!(samples.len(), 1, "the t=0 sample did not survive");
assert_eq!(samples[0].0, 1.0);
assert!(matches!(
scene.sampled_attribute("nosuch", "P", readable),
Err(ResolveError::UnknownHandle { .. })
));
assert_eq!(
scene.sampled_attribute(crate::ROOT, "P", readable).unwrap(),
Sampled::No,
"a reserved handle needs no create and holds nothing",
);
}
#[test]
fn the_value_that_stands_is_the_last_call_at_that_time() {
let mut scene = Scene::default();
scene.create("a", "attributes").unwrap();
for step in 0..40 {
let time = f64::from(step % 2);
scene
.set_attribute_at_time(
"a",
time,
vec![integers("visibility", vec![step])],
)
.unwrap();
}
let samples = scene.attribute_samples("a", "visibility").unwrap();
assert_eq!(samples.len(), 2, "forty calls, two times");
assert_eq!(samples[0].1.data, OwnedData::I32(vec![38]));
assert_eq!(samples[1].1.data, OwnedData::I32(vec![39]));
}
#[test]
fn survivors_are_ordered_by_time_however_they_were_set() {
let mut scene = Scene::default();
scene.create("xf", "transform").unwrap();
scene.create("q", "mesh").unwrap();
scene.connect("xf", None, ".root", "objects").unwrap();
scene.connect("q", None, "xf", "objects").unwrap();
scene
.set_attribute_at_time("xf", 1.0, vec![translate(1.0, 0.0, 0.0)])
.unwrap();
scene
.set_attribute_at_time("xf", 0.0, vec![translate(-1.0, 0.0, 0.0)])
.unwrap();
assert_eq!(
scene.world_transform_interpolated_at("q", 0.5).unwrap()[12],
0.0,
"halfway between -1 and +1",
);
assert_eq!(
scene.world_transform_interpolated_at("q", 0.25).unwrap()[12],
-0.5,
"a quarter of the way, which an unsorted pair gets wrong",
);
let mut scene = Scene::default();
scene.create("inst", "instances").unwrap();
scene.create("proto", "mesh").unwrap();
scene.connect("inst", None, ".root", "objects").unwrap();
scene
.connect("proto", None, "inst", "sourcemodels")
.unwrap();
scene
.set_attribute_at_time(
"inst",
1.0,
vec![doubles("transformationmatrices", instance_matrix(1.0))],
)
.unwrap();
scene
.set_attribute_at_time(
"inst",
0.0,
vec![doubles("transformationmatrices", instance_matrix(-1.0))],
)
.unwrap();
let at = scene.instance_transforms_at("inst", 0.25).unwrap();
assert_eq!(at.len(), 1);
assert_eq!(at[0].transform[12], -0.5, "the instancer sorts too");
}
#[test]
fn the_last_defined_sample_wins_not_the_last_by_time() {
let mut scene = Scene::default();
scene.create("inst", "instances").unwrap();
scene.create("proto", "mesh").unwrap();
scene.connect("inst", None, ".root", "objects").unwrap();
scene
.connect("proto", None, "inst", "sourcemodels")
.unwrap();
let two = [instance_matrix(-1.0), instance_matrix(1.0)].concat();
scene
.set_attribute("inst", vec![doubles("transformationmatrices", two)])
.unwrap();
scene
.set_attribute_at_time(
"inst",
1.0,
vec![integers("disabledinstances", vec![0])],
)
.unwrap();
scene
.set_attribute_at_time(
"inst",
0.0,
vec![integers("disabledinstances", vec![1])],
)
.unwrap();
let at = scene.instance_transforms_at("inst", 0.5).unwrap();
assert_eq!(at.len(), 1);
assert_eq!(
at[0].transform[12], -1.0,
"the `t=0` sample `[1]` was defined last, so instance 1 is \
disabled and instance 0 draws at x=-1 -- what 3Delight renders",
);
}
#[test]
fn a_wrong_typed_last_transform_sample_unsets_it() {
let mut scene = Scene::default();
scene.create("xf", "transform").unwrap();
scene.create("q", "mesh").unwrap();
scene.connect("xf", None, ".root", "objects").unwrap();
scene.connect("q", None, "xf", "objects").unwrap();
scene
.set_attribute_at_time("xf", 0.0, vec![translate(-1.5, 0.0, 0.0)])
.unwrap();
scene
.set_attribute_at_time(
"xf",
1.0,
vec![OwnedArgument {
name: "transformationmatrix".to_string(),
type_tag: Type::F32,
array_length: 1,
flags: 0,
data: OwnedData::F32(vec![0.5]),
}],
)
.unwrap();
assert_eq!(scene.world_transform("q").unwrap(), super::IDENTITY);
for time in [0.0, 0.5, 1.0] {
assert_eq!(
scene.world_transform_at("q", time).unwrap(),
super::IDENTITY,
"exact accessor at {time}",
);
assert_eq!(
scene.world_transform_interpolated_at("q", time).unwrap(),
super::IDENTITY,
"interpolating accessor at {time}",
);
}
}
#[test]
fn a_wrong_typed_last_matrices_sample_draws_nothing() {
let mut scene = Scene::default();
scene.create("inst", "instances").unwrap();
scene.create("proto", "mesh").unwrap();
scene.connect("inst", None, ".root", "objects").unwrap();
scene
.connect("proto", None, "inst", "sourcemodels")
.unwrap();
let two = [instance_matrix(-1.0), instance_matrix(1.0)].concat();
scene
.set_attribute_at_time(
"inst",
0.0,
vec![doubles("transformationmatrices", two)],
)
.unwrap();
scene
.set_attribute_at_time(
"inst",
1.0,
vec![integers("transformationmatrices", vec![0])],
)
.unwrap();
for time in [0.0, 0.5, 1.0] {
assert!(
scene
.instance_transforms_at("inst", time)
.unwrap()
.is_empty(),
"unset at {time}; the renderer draws nothing",
);
}
}
#[test]
fn a_wrong_typed_earlier_sample_is_dropped() {
let mut scene = Scene::default();
scene.create("xf", "transform").unwrap();
scene.create("q", "mesh").unwrap();
scene.connect("xf", None, ".root", "objects").unwrap();
scene.connect("q", None, "xf", "objects").unwrap();
scene
.set_attribute_at_time(
"xf",
0.0,
vec![OwnedArgument {
name: "transformationmatrix".to_string(),
type_tag: Type::F32,
array_length: 1,
flags: 0,
data: OwnedData::F32(vec![0.5]),
}],
)
.unwrap();
scene
.set_attribute_at_time("xf", 1.0, vec![translate(4.0, 0.0, 0.0)])
.unwrap();
assert_eq!(scene.world_transform_at("q", 1.0).unwrap()[12], 4.0);
assert_eq!(
scene.world_transform_interpolated_at("q", 0.0).unwrap()[12],
4.0,
"one sample is constant, held at every time",
);
assert!(
matches!(
scene.world_transform_at("q", 0.0),
Err(ResolveError::MissingSampleAtTime { .. })
),
"the unreadable sample at t=0 was dropped, so no sample is there",
);
assert_eq!(
scene.motion_times("q").unwrap(),
vec![1.0],
"and it is not a motion time either",
);
}
#[test]
fn motion_times_and_attribute_times_differ_on_an_unreadable_sample() {
let mut scene = Scene::default();
scene.create("xf", "transform").unwrap();
scene.connect("xf", None, ".root", "objects").unwrap();
scene
.set_attribute_at_time(
"xf",
0.0,
vec![OwnedArgument {
name: "transformationmatrix".to_string(),
type_tag: Type::F32,
array_length: 1,
flags: 0,
data: OwnedData::F32(vec![0.5]),
}],
)
.unwrap();
scene
.set_attribute_at_time("xf", 1.0, vec![translate(2.0, 0.0, 0.0)])
.unwrap();
assert_eq!(
scene.motion_times("xf").unwrap(),
vec![1.0],
"the unreadable sample is not a motion time",
);
assert_eq!(
scene.attribute_times("xf", "transformationmatrix").unwrap(),
vec![0.0, 1.0],
"but it was recorded, and this reports what was recorded",
);
assert_eq!(
scene
.attribute_samples("xf", "transformationmatrix")
.unwrap()
.len(),
2,
"with the arguments, so a caller that knows the type can judge",
);
}
#[test]
fn an_unreadable_sample_discards_the_ones_before_it() {
let mut scene = Scene::default();
scene.create("xf", "transform").unwrap();
scene.create("q", "mesh").unwrap();
scene.connect("xf", None, ".root", "objects").unwrap();
scene.connect("q", None, "xf", "objects").unwrap();
scene
.set_attribute_at_time("xf", 0.0, vec![translate(-1.5, 0.0, 0.0)])
.unwrap();
scene
.set_attribute_at_time(
"xf",
1.0,
vec![OwnedArgument {
name: "transformationmatrix".to_string(),
type_tag: Type::F32,
array_length: 1,
flags: 0,
data: OwnedData::F32(vec![0.5]),
}],
)
.unwrap();
scene
.set_attribute_at_time("xf", 2.0, vec![translate(-3.0, 0.0, 0.0)])
.unwrap();
assert_eq!(
scene.motion_times("q").unwrap(),
vec![2.0],
"only the samples after the unreadable one survive",
);
for time in [0.0, 1.0, 2.0, 9.0] {
assert_eq!(
scene.world_transform_interpolated_at("q", time).unwrap()[12],
-3.0,
"static at the t=2 matrix, at {time}",
);
}
scene
.set_attribute_at_time("xf", 3.0, vec![translate(-9.0, 0.0, 0.0)])
.unwrap();
assert_eq!(
scene.motion_times("q").unwrap(),
vec![2.0, 3.0],
"the whole surviving tail, not just the last sample",
);
assert_eq!(
scene.world_transform_interpolated_at("q", 2.5).unwrap()[12],
-6.0,
"halfway between the two survivors",
);
}
#[test]
fn a_double_typed_matrix_is_not_a_matrix() {
let mut scene = Scene::default();
scene.create("xf", "transform").unwrap();
scene.create("q", "mesh").unwrap();
scene.connect("xf", None, ".root", "objects").unwrap();
scene.connect("q", None, "xf", "objects").unwrap();
#[rustfmt::skip]
let sixteen = vec![
1.0, 0.0, 0.0, 0.0,
0.0, 1.0, 0.0, 0.0,
0.0, 0.0, 1.0, 0.0,
-1.5, 0.0, 0.0, 1.0,
];
scene
.set_attribute(
"xf",
vec![OwnedArgument {
name: "transformationmatrix".to_string(),
type_tag: Type::F64,
array_length: 1,
flags: 0,
data: OwnedData::F64(sixteen),
}],
)
.unwrap();
assert_eq!(
scene.world_transform("q").unwrap(),
super::IDENTITY,
"the declared type is not `doublematrix`, so there is no matrix",
);
}
#[test]
fn a_count_change_drops_only_itself_unlike_a_type_error() {
let three_at = |x: f64| {
[
instance_matrix(-x),
instance_matrix(x),
instance_matrix(0.0),
]
.concat()
};
let build = |with_middle: bool| {
let mut scene = Scene::default();
scene.create("inst", "instances").unwrap();
scene.create("proto", "mesh").unwrap();
scene.connect("inst", None, ".root", "objects").unwrap();
scene
.connect("proto", None, "inst", "sourcemodels")
.unwrap();
scene
.set_attribute_at_time(
"inst",
0.0,
vec![doubles("transformationmatrices", three_at(1.0))],
)
.unwrap();
if with_middle {
let two = [instance_matrix(-0.2), instance_matrix(0.2)].concat();
scene
.set_attribute_at_time(
"inst",
0.5,
vec![doubles("transformationmatrices", two)],
)
.unwrap();
}
scene
.set_attribute_at_time(
"inst",
1.0,
vec![doubles("transformationmatrices", three_at(1.5))],
)
.unwrap();
scene
};
for time in [0.0, 0.25, 0.75, 1.0] {
assert_eq!(
build(true).instance_transforms_at("inst", time).unwrap(),
build(false).instance_transforms_at("inst", time).unwrap(),
"the count-changing sample is dropped, not a barrier, at {time}",
);
}
let mid = build(true).instance_transforms_at("inst", 0.5).unwrap();
assert_eq!(mid.len(), 3);
assert_eq!(mid[0].transform[12], -1.25, "halfway between -1 and -1.5");
}
#[test]
fn a_same_time_reset_after_an_unreadable_sample_stands_alone() {
let mut scene = Scene::default();
scene.create("xf", "transform").unwrap();
scene.create("q", "mesh").unwrap();
scene.connect("xf", None, ".root", "objects").unwrap();
scene.connect("q", None, "xf", "objects").unwrap();
scene
.set_attribute_at_time("xf", 0.0, vec![translate(-1.5, 0.0, 0.0)])
.unwrap();
scene
.set_attribute_at_time(
"xf",
1.0,
vec![OwnedArgument {
name: "transformationmatrix".to_string(),
type_tag: Type::F32,
array_length: 1,
flags: 0,
data: OwnedData::F32(vec![0.5]),
}],
)
.unwrap();
scene
.set_attribute_at_time("xf", 1.0, vec![translate(-3.0, 0.0, 0.0)])
.unwrap();
assert_eq!(
scene.motion_times("q").unwrap(),
vec![1.0],
"the t=0 sample did not survive the float",
);
assert_eq!(
scene.world_transform_interpolated_at("q", 0.5).unwrap()[12],
-3.0,
"static at the t=1 matrix, which is what 3Delight draws",
);
let mut scene = Scene::default();
scene.create("xf", "transform").unwrap();
scene.create("q", "mesh").unwrap();
scene.connect("xf", None, ".root", "objects").unwrap();
scene.connect("q", None, "xf", "objects").unwrap();
scene
.set_attribute_at_time("xf", 0.0, vec![translate(-1.5, 0.0, 0.0)])
.unwrap();
scene
.set_attribute_at_time("xf", 1.0, vec![translate(-9.0, 0.0, 0.0)])
.unwrap();
scene
.set_attribute_at_time("xf", 1.0, vec![translate(-3.0, 0.0, 0.0)])
.unwrap();
assert_eq!(scene.motion_times("q").unwrap(), vec![0.0, 1.0]);
assert_eq!(
scene.world_transform_interpolated_at("q", 0.5).unwrap()[12],
-2.25,
"halfway between -1.5 and the re-set -3.0",
);
}
#[test]
fn a_later_definition_supersedes_an_unreadable_sample() {
let mut scene = Scene::default();
scene.create("xf", "transform").unwrap();
scene.create("q", "mesh").unwrap();
scene.connect("xf", None, ".root", "objects").unwrap();
scene.connect("q", None, "xf", "objects").unwrap();
scene
.set_attribute_at_time(
"xf",
1.0,
vec![OwnedArgument {
name: "transformationmatrix".to_string(),
type_tag: Type::F32,
array_length: 1,
flags: 0,
data: OwnedData::F32(vec![0.5]),
}],
)
.unwrap();
scene
.set_attribute_at_time("xf", 0.0, vec![translate(-1.5, 0.0, 0.0)])
.unwrap();
assert_eq!(
scene.world_transform_interpolated_at("q", 0.0).unwrap()[12],
-1.5,
"the float was superseded by a later call, so the t=0 matrix \
stands alone and is held -- what 3Delight draws",
);
}
#[test]
fn sampled_reads_the_attribute_it_was_asked_for() {
let mut scene = Scene::default();
scene.create("xf", "transform").unwrap();
scene.create("q", "mesh").unwrap();
scene.connect("xf", None, ".root", "objects").unwrap();
scene.connect("q", None, "xf", "objects").unwrap();
for (time, x) in [(0.0, -1.5), (1.0, -3.0)] {
scene
.set_attribute_at_time(
"xf",
time,
vec![
integers("disabledinstances", vec![0]),
translate(x, 0.0, 0.0),
],
)
.unwrap();
}
assert_eq!(scene.motion_times("q").unwrap(), vec![0.0, 1.0]);
assert_eq!(
scene.world_transform_interpolated_at("q", 0.5).unwrap()[12],
-2.25,
"the transform, not whichever attribute happens to be first",
);
}
#[test]
fn an_unreadable_sample_discards_only_what_was_defined_before_it() {
let float = || OwnedArgument {
name: "transformationmatrix".to_string(),
type_tag: Type::F32,
array_length: 1,
flags: 0,
data: OwnedData::F32(vec![0.5]),
};
let mut scene = Scene::default();
scene.create("xf", "transform").unwrap();
scene.create("q", "mesh").unwrap();
scene.connect("xf", None, ".root", "objects").unwrap();
scene.connect("q", None, "xf", "objects").unwrap();
scene
.set_attribute_at_time("xf", 0.5, vec![float()])
.unwrap();
scene
.set_attribute_at_time("xf", 0.0, vec![translate(-1.5, 0.0, 0.0)])
.unwrap();
scene
.set_attribute_at_time("xf", 1.0, vec![translate(-3.0, 0.0, 0.0)])
.unwrap();
assert_eq!(
scene.motion_times("q").unwrap(),
vec![0.0, 1.0],
"both goods were defined after the float, so both survive",
);
assert_eq!(
scene.world_transform_interpolated_at("q", 0.0).unwrap()[12],
-1.5,
"and the sweep starts at the t=0 matrix",
);
type Calls = [(f64, Option<f64>); 3];
let orders: [(Calls, f64); 3] = [
([(0.0, Some(-1.5)), (0.5, None), (1.0, Some(-3.0))], -3.0),
([(1.0, Some(-3.0)), (0.5, None), (0.0, Some(-1.5))], -1.5),
([(0.0, Some(-1.5)), (1.0, Some(-3.0)), (0.5, None)], 0.0),
];
for (calls, expected) in orders {
let mut scene = Scene::default();
scene.create("xf", "transform").unwrap();
scene.create("q", "mesh").unwrap();
scene.connect("xf", None, ".root", "objects").unwrap();
scene.connect("q", None, "xf", "objects").unwrap();
for (time, x) in calls {
let arg = match x {
Some(x) => translate(x, 0.0, 0.0),
None => float(),
};
scene.set_attribute_at_time("xf", time, vec![arg]).unwrap();
}
assert_eq!(
scene.world_transform_interpolated_at("q", 0.0).unwrap()[12],
expected,
"call order decides what the float discarded",
);
}
}
#[test]
fn an_attribute_set_only_at_a_time_is_gathered() {
let mut scene = Scene::default();
scene.create("m", "mesh").unwrap();
scene.create("a", "attributes").unwrap();
scene.connect("m", None, ".root", "objects").unwrap();
scene.connect("a", None, "m", "geometryattributes").unwrap();
scene
.set_attribute_at_time("a", 0.0, vec![integers("visibility", vec![0])])
.unwrap();
let value = scene.attribute_value("m", "visibility").unwrap();
let value = value.expect("3Delight honours it; so must this");
assert_eq!(value.node, "a");
assert_eq!(
value.arg.expect("a recorded value").data,
OwnedData::I32(vec![0])
);
}
#[test]
fn a_sampled_attr_priority_is_read() {
let mut scene = scene_with_two_attribute_levels();
scene
.set_attribute("near", vec![integers("visibility", vec![0])])
.unwrap();
scene
.set_attribute_at_time(
"far",
0.0,
vec![
integers("visibility", vec![1]),
integers("visibility.priority", vec![10]),
],
)
.unwrap();
let value = scene.attribute_value("mesh", "visibility").unwrap();
let value = value.expect("defined");
assert_eq!(value.node, "far", "the sampled priority still wins");
assert_eq!(value.priority, 10);
}
#[test]
fn a_sampled_shader_attribute_is_gathered() {
let mut scene = Scene::default();
scene.create("m", "mesh").unwrap();
scene.create("sa", "attributes").unwrap();
scene.connect("m", None, ".root", "objects").unwrap();
scene.connect("sa", None, "m", "shaderattributes").unwrap();
scene
.set_attribute_at_time("sa", 0.0, vec![integers("tint", vec![5])])
.unwrap();
assert_eq!(
scene
.shader_attribute_value("m", "tint")
.unwrap()
.unwrap()
.node,
"sa",
);
scene
.set_attribute_at_time("m", 0.0, vec![integers("tint", vec![9])])
.unwrap();
assert_eq!(
scene
.shader_attribute_value("m", "tint")
.unwrap()
.unwrap()
.node,
"m",
);
}
#[test]
fn motion_times_are_available_along_a_placement_path() {
let mut scene = Scene::default();
scene.create("q", "mesh").unwrap();
scene.create("xfA", "transform").unwrap();
scene.create("xfB", "transform").unwrap();
scene.connect("xfA", None, ".root", "objects").unwrap();
scene.connect("xfB", None, ".root", "objects").unwrap();
scene.connect("q", None, "xfA", "objects").unwrap();
scene.connect("q", None, "xfB", "objects").unwrap();
scene
.set_attribute_at_time("xfA", 0.0, vec![translate(0.0, 0.0, 0.0)])
.unwrap();
scene
.set_attribute_at_time("xfA", 1.0, vec![translate(10.0, 0.0, 0.0)])
.unwrap();
scene
.set_attribute("xfB", vec![translate(-4.0, 0.0, 0.0)])
.unwrap();
assert!(matches!(
scene.motion_times("q"),
Err(ResolveError::MultipleParents { .. })
));
let placements = scene.placements_at("q", 0.0).unwrap();
assert_eq!(
scene.motion_times_along(&placements[0].path),
vec![0.0, 1.0],
"the moving path",
);
assert!(
scene.motion_times_along(&placements[1].path).is_empty(),
"the static path",
);
}
#[test]
fn an_output_layer_carries_the_specifications_defaults() {
let scene = scene_with_output();
let outputs = scene.render_outputs();
let layer = &outputs[0].layers[0];
assert_eq!(layer.variable_source, "shader");
assert_eq!(layer.layer_type, "color");
assert_eq!(layer.scalar_format, "uint8");
assert_eq!(layer.filter, "blackman-harris");
assert_eq!(layer.filter_width, 3.0);
assert!(!layer.with_alpha);
assert!(!layer.dithering);
assert_eq!(layer.variable_name, None, "no default; the scene owes it");
assert_eq!(layer.layer_name, None);
assert_eq!(layer.color_profile, None);
assert_eq!(layer.sort_key, None);
}
#[test]
fn an_output_layer_reads_what_it_sets() {
let mut scene = scene_with_output();
scene
.set_attribute(
"beauty",
vec![
string_attribute("variablename", "Ci"),
string_attribute("variablesource", "builtin"),
string_attribute("layername", "rgba"),
string_attribute("layertype", "quad"),
string_attribute("scalarformat", "half"),
string_attribute("filter", "box"),
string_attribute("colorprofile", "acescg"),
OwnedArgument::new(
"filterwidth",
Type::F64,
1,
0,
OwnedData::F64(vec![1.0]),
),
OwnedArgument::new(
"withalpha",
Type::I32,
1,
0,
OwnedData::I32(vec![1]),
),
],
)
.unwrap();
let outputs = scene.render_outputs();
let layer = &outputs[0].layers[0];
assert_eq!(layer.variable_name.as_deref(), Some("Ci"));
assert_eq!(layer.variable_source, "builtin");
assert_eq!(layer.layer_name.as_deref(), Some("rgba"));
assert_eq!(layer.layer_type, "quad");
assert_eq!(layer.scalar_format, "half");
assert_eq!(layer.filter, "box");
assert_eq!(layer.filter_width, 1.0);
assert_eq!(layer.color_profile.as_deref(), Some("acescg"));
assert!(layer.with_alpha);
}
#[test]
fn layers_order_by_sort_key_then_by_connection() {
let mut scene = Scene::default();
scene.create("cam", "perspectivecamera").unwrap();
scene.create("scr", "screen").unwrap();
scene.connect("scr", None, "cam", "screens").unwrap();
for (handle, key) in
[("last", Some(9)), ("unkeyed", None), ("first", Some(-1))]
{
scene.create(handle, "outputlayer").unwrap();
scene.connect(handle, None, "scr", "outputlayers").unwrap();
if let Some(key) = key {
scene
.set_attribute(
handle,
vec![OwnedArgument::new(
"sortkey",
Type::I32,
1,
0,
OwnedData::I32(vec![key]),
)],
)
.unwrap();
}
}
let outputs = scene.render_outputs();
let order: Vec<&str> = outputs[0]
.layers
.iter()
.map(|l| l.handle.as_str())
.collect();
assert_eq!(order, vec!["unkeyed", "first", "last"]);
}
fn string_attribute(name: &str, value: &str) -> OwnedArgument {
OwnedArgument::new(
name,
Type::String,
1,
0,
OwnedData::String(vec![value.as_bytes().to_vec()]),
)
}
#[test]
fn nholes_regroups_nvertices_into_faces() {
let mut scene = Scene::default();
scene.create("holey", "mesh").unwrap();
scene
.set_attribute(
"holey",
vec![
int_attribute("nholes", &[1, 2, 0]),
int_attribute("nvertices", &[4, 3, 4, 4, 4, 4]),
],
)
.unwrap();
let faces: Vec<_> = scene.faces("holey").expect("faces").collect();
assert_eq!(faces.len(), 3, "three faces, not six counts");
assert_eq!(faces[0].outer, 4);
assert_eq!(faces[0].holes, [3]);
assert_eq!(faces[0].vertices(), 7);
assert_eq!(faces[1].outer, 4);
assert_eq!(faces[1].holes, [4, 4]);
assert_eq!(faces[1].vertices(), 12);
assert_eq!(faces[2].outer, 4);
assert_eq!(faces[2].holes, [] as [i32; 0]);
assert_eq!(faces[2].vertices(), 4);
}
#[test]
fn without_nholes_every_count_is_a_face() {
let mut scene = Scene::default();
scene.create("quad", "mesh").unwrap();
scene
.set_attribute("quad", vec![int_attribute("nvertices", &[4, 3])])
.unwrap();
let faces: Vec<_> = scene.faces("quad").expect("faces").collect();
assert_eq!(faces.len(), 2);
assert_eq!((faces[0].outer, faces[0].vertices()), (4, 4));
assert_eq!((faces[1].outer, faces[1].vertices()), (3, 3));
}
#[test]
fn face_counts_that_disagree_are_an_error() {
let mut scene = Scene::default();
scene.create("bad", "mesh").unwrap();
scene
.set_attribute(
"bad",
vec![
int_attribute("nholes", &[2]),
int_attribute("nvertices", &[4, 3]),
],
)
.unwrap();
assert!(matches!(
scene.faces("bad"),
Err(ResolveError::MalformedFaceCounts {
expected: 3,
found: 2,
..
})
));
}
#[test]
fn a_mesh_without_nvertices_is_an_error() {
let mut scene = Scene::default();
scene.create("bare", "mesh").unwrap();
assert!(matches!(
scene.faces("bare"),
Err(ResolveError::MissingFaceCounts { .. })
));
}
fn int_attribute(name: &str, values: &[i32]) -> OwnedArgument {
OwnedArgument::new(name, Type::I32, 1, 0, OwnedData::I32(values.to_vec()))
}
fn indexed_quads() -> Scene {
let mut scene = Scene::default();
scene.create("m", "mesh").unwrap();
scene
.set_attribute(
"m",
vec![
int_attribute("nvertices", &[4, 4]),
OwnedArgument::new(
"P",
Type::Point,
1,
0,
OwnedData::F32(vec![0.0; 6 * 3]),
),
int_attribute("P.indices", &[0, 1, 4, 3, 1, 2, 5, 4]),
],
)
.unwrap();
scene
}
#[test]
fn a_face_varying_variable_reads_in_order() {
let mut scene = indexed_quads();
scene
.set_attribute("m", vec![float_attribute("width", &[0.0; 8])])
.unwrap();
let variable = scene.primitive_variable("m", "width").unwrap().unwrap();
assert_eq!(variable.interpolation(), Interpolation::FaceVarying);
let indices: Vec<usize> = variable.face_varying_indices().collect();
assert_eq!(indices, vec![0, 1, 2, 3, 4, 5, 6, 7]);
}
#[test]
fn a_per_vertex_variable_reads_through_the_position_indices() {
let mut scene = indexed_quads();
scene
.set_attribute("m", vec![float_attribute("temperature", &[0.0; 6])])
.unwrap();
let variable = scene
.primitive_variable("m", "temperature")
.unwrap()
.unwrap();
assert_eq!(variable.interpolation(), Interpolation::Vertex);
let indices: Vec<usize> = variable.face_varying_indices().collect();
assert_eq!(indices, vec![0, 1, 4, 3, 1, 2, 5, 4], "P.indices order");
}
#[test]
fn a_uniform_variable_repeats_across_its_face() {
let mut scene = indexed_quads();
scene
.set_attribute("m", vec![float_attribute("shell", &[0.0; 2])])
.unwrap();
let variable = scene.primitive_variable("m", "shell").unwrap().unwrap();
assert_eq!(variable.interpolation(), Interpolation::Uniform);
let indices: Vec<usize> = variable.face_varying_indices().collect();
assert_eq!(indices, vec![0, 0, 0, 0, 1, 1, 1, 1]);
}
#[test]
fn a_constant_variable_is_one_value_everywhere() {
let mut scene = indexed_quads();
scene
.set_attribute("m", vec![float_attribute("scale", &[1.0])])
.unwrap();
let variable = scene.primitive_variable("m", "scale").unwrap().unwrap();
assert_eq!(variable.interpolation(), Interpolation::Constant);
assert!(variable.face_varying_indices().all(|index| index == 0));
assert_eq!(variable.face_varying_indices().count(), 8);
}
#[test]
fn an_indexed_variable_reads_through_its_own_indices() {
let mut scene = indexed_quads();
scene
.set_attribute(
"m",
vec![
float_attribute("st", &[0.0; 3]),
int_attribute("st.indices", &[2, 1, 0, 1, 2, 2, 1, 0]),
],
)
.unwrap();
let variable = scene.primitive_variable("m", "st").unwrap().unwrap();
assert_eq!(variable.interpolation(), Interpolation::FaceVarying);
let indices: Vec<usize> = variable.face_varying_indices().collect();
assert_eq!(indices, vec![2, 1, 0, 1, 2, 2, 1, 0]);
}
#[test]
fn the_per_face_flag_breaks_the_tetrahedron_tie() {
let mut scene = Scene::default();
scene.create("tet", "mesh").unwrap();
scene
.set_attribute(
"tet",
vec![
int_attribute("nvertices", &[3, 3, 3, 3]),
OwnedArgument::new(
"P",
Type::Point,
1,
0,
OwnedData::F32(vec![0.0; 4 * 3]),
),
int_attribute(
"P.indices",
&[0, 1, 2, 0, 2, 3, 0, 3, 1, 1, 3, 2],
),
OwnedArgument::new(
"id",
Type::F32,
1,
NSIParamFlags::PerFace.bits(),
OwnedData::F32(vec![0.0; 4]),
),
],
)
.unwrap();
let variable = scene.primitive_variable("tet", "id").unwrap().unwrap();
assert_eq!(
variable.interpolation(),
Interpolation::Uniform,
"four values, four faces and four vertices: only the flag decides",
);
let indices: Vec<usize> = variable.face_varying_indices().collect();
assert_eq!(indices, vec![0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3]);
}
#[test]
fn the_per_vertex_flag_breaks_it_the_other_way() {
let mut scene = tetrahedron(NSIParamFlags::PerVertex.bits());
let variable = scene.primitive_variable("tet", "id").unwrap().unwrap();
assert_eq!(variable.interpolation(), Interpolation::Vertex);
let indices: Vec<usize> = variable.face_varying_indices().collect();
assert_eq!(
indices,
vec![0, 1, 2, 0, 2, 3, 0, 3, 1, 1, 3, 2],
"the position indices",
);
let _ = &mut scene;
}
#[test]
fn an_unflagged_tetrahedron_variable_is_ambiguous() {
let scene = tetrahedron(0);
assert!(matches!(
scene.primitive_variable("tet", "id"),
Err(ResolveError::AmbiguousInterpolation {
values: 4,
faces: 4,
vertices: 4,
..
})
));
}
fn tetrahedron(flags: i32) -> Scene {
let mut scene = Scene::default();
scene.create("tet", "mesh").unwrap();
scene
.set_attribute(
"tet",
vec![
int_attribute("nvertices", &[3, 3, 3, 3]),
OwnedArgument::new(
"P",
Type::Point,
1,
0,
OwnedData::F32(vec![0.0; 4 * 3]),
),
int_attribute(
"P.indices",
&[0, 1, 2, 0, 2, 3, 0, 3, 1, 1, 3, 2],
),
OwnedArgument::new(
"id",
Type::F32,
1,
flags,
OwnedData::F32(vec![0.0; 4]),
),
],
)
.unwrap();
scene
}
#[test]
fn a_count_matching_no_interpolation_is_an_error() {
let mut scene = indexed_quads();
scene
.set_attribute("m", vec![float_attribute("odd", &[0.0; 5])])
.unwrap();
assert!(matches!(
scene.primitive_variable("m", "odd"),
Err(ResolveError::AmbiguousInterpolation { values: 5, .. })
));
}
#[test]
fn indices_that_do_not_match_the_face_vertices_are_an_error() {
let mut scene = indexed_quads();
scene
.set_attribute(
"m",
vec![
float_attribute("st", &[0.0; 3]),
int_attribute("st.indices", &[0, 1]),
],
)
.unwrap();
assert!(matches!(
scene.primitive_variable("m", "st"),
Err(ResolveError::MalformedIndices {
indices: 2,
face_vertices: 8,
..
})
));
}
#[test]
fn an_absent_variable_is_none() {
let scene = indexed_quads();
assert!(scene.primitive_variable("m", "st").unwrap().is_none());
}
fn float_attribute(name: &str, values: &[f32]) -> OwnedArgument {
OwnedArgument::new(name, Type::F32, 1, 0, OwnedData::F32(values.to_vec()))
}