mirror of
https://github.com/storytold/craft-libs.git
synced 2026-11-17 18:04:48 +00:00
340 lines
14 KiB
Rust
340 lines
14 KiB
Rust
//! write_prc → reader round trips.
|
|
|
|
#![allow(clippy::unwrap_used, clippy::indexing_slicing)]
|
|
|
|
use super::readback::assemble;
|
|
use super::*;
|
|
use crate::PrcFile;
|
|
|
|
fn tri(material: Option<usize>, dx: f64) -> ScenePrimitive {
|
|
ScenePrimitive {
|
|
positions: vec![[dx, 0.0, 0.0], [dx + 1.0, 0.0, 0.0], [dx, 1.0, 0.0]],
|
|
triangles: vec![[0, 1, 2]],
|
|
material,
|
|
..ScenePrimitive::default()
|
|
}
|
|
}
|
|
|
|
fn node(name: &str, mesh: Option<usize>, children: Vec<usize>) -> SceneNode {
|
|
SceneNode { name: Some(name.into()), mesh, children, ..SceneNode::default() }
|
|
}
|
|
|
|
/// A frame over a glass pane and a shared bolt placed twice.
|
|
fn scene() -> MeshScene {
|
|
let mut bolt2 = node("bolt-2", Some(1), vec![]);
|
|
let mut m = [0.0; 16];
|
|
for (i, v) in [1.0, 1.0, 1.0, 1.0].into_iter().enumerate() {
|
|
m[i * 5] = v;
|
|
}
|
|
m[12] = 10.0;
|
|
bolt2.matrix = Some(m);
|
|
MeshScene {
|
|
nodes: vec![node("frame", None, vec![1, 2, 3]), node("glass", Some(0), vec![]), node("bolt-1", Some(1), vec![]), bolt2],
|
|
roots: vec![0],
|
|
meshes: vec![
|
|
SceneMesh { name: Some("pane".into()), primitives: vec![tri(Some(0), 0.0)] },
|
|
SceneMesh { name: Some("bolt".into()), primitives: vec![tri(Some(1), 5.0), tri(None, 7.0)] },
|
|
],
|
|
materials: vec![
|
|
SceneMaterial { name: Some("glass".into()), rgba: [0.2, 0.4, 0.6, 0.4], texture: None, emissive: [0.0; 3] },
|
|
SceneMaterial { name: Some("steel".into()), rgba: [1.0, 0.0, 0.0, 1.0], texture: None, emissive: [0.0; 3] },
|
|
],
|
|
textures: vec![],
|
|
units_in_mm: 1000.0,
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn triangles_colours_and_alpha_read_back() {
|
|
let r = write_prc(&scene()).unwrap();
|
|
assert_eq!((r.triangles, r.flat_normals, r.empty_primitives), (3, 3, 0));
|
|
let m = assemble(&r.prc);
|
|
// The glass once, the bolt's two primitives at both placements.
|
|
assert_eq!(m.triangles, 5);
|
|
let mut colours: Vec<_> = m.colours.iter().flatten().copied().collect();
|
|
colours.sort_unstable();
|
|
assert!(colours.contains(&[51, 102, 153, 102]), "{colours:?}");
|
|
assert_eq!(colours.iter().filter(|c| **c == [255, 0, 0, 255]).count(), 2);
|
|
}
|
|
|
|
#[test]
|
|
fn node_names_reach_the_model_tree() {
|
|
let r = write_prc(&scene()).unwrap();
|
|
let tree = PrcFile::parse(&r.prc).unwrap().model_tree().unwrap();
|
|
let names: Vec<_> = tree.iter().map(|n| n.name.as_deref()).collect();
|
|
assert_eq!(names, [Some("frame"), Some("glass"), Some("bolt-1"), Some("bolt-2")]);
|
|
assert_eq!(tree[3].parent, Some(0));
|
|
}
|
|
|
|
#[test]
|
|
fn a_translation_moves_the_second_placement() {
|
|
let m = assemble(&write_prc(&scene()).unwrap().prc);
|
|
let xs: Vec<f64> = m.meshes.iter().flat_map(|t| t.positions.iter().map(|p| p[0])).collect();
|
|
// bolt-1's first primitive starts at x = 5; bolt-2's at 15.
|
|
assert!(xs.contains(&5.0) && xs.contains(&15.0), "{xs:?}");
|
|
}
|
|
|
|
#[test]
|
|
fn a_non_uniform_scale_is_a_general_transformation() {
|
|
let mut s = scene();
|
|
let mut m = [0.0; 16];
|
|
(m[0], m[5], m[10], m[15]) = (2.0, 1.0, 1.0, 1.0);
|
|
s.nodes[3].matrix = Some(m);
|
|
let a = assemble(&write_prc(&s).unwrap().prc);
|
|
let xs: Vec<f64> = a.meshes.iter().flat_map(|t| t.positions.iter().map(|p| p[0])).collect();
|
|
assert!(xs.contains(&10.0) && xs.contains(&12.0), "{xs:?}");
|
|
}
|
|
|
|
#[test]
|
|
fn several_roots_get_one_synthetic_root() {
|
|
let mut s = scene();
|
|
s.nodes[0].children = vec![1];
|
|
s.roots = vec![0, 2, 3];
|
|
let tree = PrcFile::parse(&write_prc(&s).unwrap().prc).unwrap().model_tree().unwrap();
|
|
assert_eq!(tree.len(), 5);
|
|
assert_eq!(tree[0].name, None);
|
|
assert!(tree[1..].iter().all(|n| n.parent.is_some()));
|
|
}
|
|
|
|
#[test]
|
|
fn writing_is_deterministic() {
|
|
assert_eq!(write_prc(&scene()).unwrap().prc, write_prc(&scene()).unwrap().prc);
|
|
}
|
|
|
|
#[test]
|
|
fn invalid_scenes_are_refused() {
|
|
let mut s = scene();
|
|
s.nodes[0].children.push(1);
|
|
s.nodes[2].children.push(1);
|
|
assert!(matches!(write_prc(&s), Err(PrcWriteError::NotATree(_))));
|
|
let mut s = scene();
|
|
s.roots = vec![1];
|
|
s.nodes[0].children.clear();
|
|
s.meshes[0].primitives[0].triangles[0] = [0, 1, 9];
|
|
assert_eq!(write_prc(&s), Err(PrcWriteError::BadIndex { what: "vertex", index: 9 }));
|
|
let mut s = scene();
|
|
s.meshes[0].primitives[0].positions[0][1] = f64::NAN;
|
|
assert!(matches!(write_prc(&s), Err(PrcWriteError::BadNumber(_))));
|
|
let mut s = scene();
|
|
s.units_in_mm = 0.0;
|
|
assert!(matches!(write_prc(&s), Err(PrcWriteError::BadNumber(_))));
|
|
let mut s = scene();
|
|
s.meshes.iter_mut().flat_map(|m| &mut m.primitives).for_each(|p| p.triangles.clear());
|
|
assert_eq!(write_prc(&s), Err(PrcWriteError::Empty));
|
|
assert_eq!(write_prc(&MeshScene::default()), Err(PrcWriteError::BadNumber("units_in_mm")));
|
|
}
|
|
|
|
#[test]
|
|
fn a_root_listed_twice_is_refused_not_written_twice() {
|
|
let mut s = scene();
|
|
s.roots = vec![0; 100];
|
|
assert_eq!(write_prc(&s), Err(PrcWriteError::NotATree("a root is listed twice")));
|
|
}
|
|
|
|
#[test]
|
|
fn a_cycle_is_refused_not_looped() {
|
|
let mut s = scene();
|
|
s.nodes[1].children.push(0);
|
|
assert!(write_prc(&s).is_err());
|
|
}
|
|
|
|
#[test]
|
|
fn a_mirrored_rotation_reads_back() {
|
|
// 90° about z, then mirror z, scale 2, translate y by 3: x' = -2y,
|
|
// y' = 2x + 3.
|
|
let mut s = scene();
|
|
let mut m = [0.0; 16];
|
|
(m[1], m[4], m[10], m[13], m[15]) = (2.0, -2.0, -2.0, 3.0, 1.0);
|
|
s.nodes[3].matrix = Some(m);
|
|
let a = assemble(&write_prc(&s).unwrap().prc);
|
|
let pts: Vec<[f64; 3]> = a.meshes.iter().flat_map(|t| t.positions.clone()).collect();
|
|
// bolt's first vertex (5,0,0) → (0,13,0); (5,1,0) → (-2,13,0).
|
|
let near = |q: [f64; 3]| pts.iter().any(|p| (0..3).all(|i| (p[i] - q[i]).abs() < 1e-9));
|
|
assert!(near([0.0, 13.0, 0.0]) && near([-2.0, 13.0, 0.0]), "{pts:?}");
|
|
}
|
|
|
|
/// Every son precedes the occurrence that uses it [WD 7.3.6], so a reader
|
|
/// can resolve the tree in one forward pass.
|
|
#[test]
|
|
fn every_son_precedes_its_father_and_the_root_is_last() {
|
|
for roots in [vec![0], vec![0, 2, 3]] {
|
|
let mut s = scene();
|
|
if roots.len() > 1 {
|
|
s.nodes[0].children = vec![1];
|
|
}
|
|
s.roots = roots;
|
|
let occ = validate::plan(&s).unwrap().occurrences;
|
|
for (i, o) in occ.iter().enumerate() {
|
|
assert!(o.sons.iter().all(|&son| (son as usize) < i), "{i}");
|
|
}
|
|
let root = occ.len() - 1;
|
|
let fathered = |k: usize| occ.iter().any(|o| o.sons.contains(&(k as u32)));
|
|
assert!(!fathered(root));
|
|
assert!((0..root).all(fathered), "every other occurrence has a father");
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn textures_are_checked_before_writing() {
|
|
let mut s = scene();
|
|
s.materials[1].texture = Some(0);
|
|
assert_eq!(write_prc(&s), Err(PrcWriteError::BadIndex { what: "texture", index: 0 }));
|
|
s.textures = vec![SceneTexture { image: b"GIF89a".to_vec(), ..SceneTexture::default() }];
|
|
assert_eq!(write_prc(&s), Err(PrcWriteError::BadTexture { index: 0 }));
|
|
let mut s = scene();
|
|
s.meshes[0].primitives[0].uvs = vec![[0.0, 0.0]];
|
|
assert!(matches!(write_prc(&s), Err(PrcWriteError::BadIndex { .. })));
|
|
// Coordinates under an untextured material are not written.
|
|
let mut s = scene();
|
|
s.meshes[0].primitives[0].uvs = vec![[0.0, 0.0]; 3];
|
|
assert_eq!(write_prc(&s).unwrap().textured, 0);
|
|
}
|
|
|
|
#[test]
|
|
fn texture_coordinates_read_back() {
|
|
let mut s = scene();
|
|
// A PNG signature and header claiming 1 x 2: enough for the writer.
|
|
let image = b"\x89PNG\r\n\x1a\n\0\0\0\x0dIHDR\0\0\0\x01\0\0\0\x02".to_vec();
|
|
s.textures = vec![SceneTexture { image: image.clone(), wrap: [TextureWrap::Clamp, TextureWrap::MirroredRepeat], alpha: false }];
|
|
s.materials[1].texture = Some(0);
|
|
s.meshes[1].primitives[0].uvs = vec![[0.5, 0.1], [0.5, 0.1], [0.5, 0.9]];
|
|
let r = write_prc(&s).unwrap();
|
|
assert_eq!(r.textured, 1);
|
|
let file = PrcFile::parse(&r.prc).unwrap();
|
|
let pictures: Vec<&Vec<u8>> = file.file_structures.iter().flat_map(|fs| &fs.pictures).collect();
|
|
assert_eq!(pictures, [&image], "the picture is stored as it is");
|
|
let m = assemble(&r.prc);
|
|
let with_uvs: Vec<_> = m.meshes.iter().filter(|t| !t.uvs.is_empty()).collect();
|
|
assert_eq!(with_uvs.len(), 2, "the bolt's primitive at both placements");
|
|
assert!(with_uvs.iter().all(|t| t.uvs == [[0.5, 0.1], [0.5, 0.1], [0.5, 0.9]]));
|
|
}
|
|
|
|
/// The box holds every placed triangle, a child placed through its parent's matrix too.
|
|
#[test]
|
|
fn bounds_follow_each_node_through_its_parents() {
|
|
let mut s = scene();
|
|
let mut lift = [0.0; 16];
|
|
(lift[0], lift[5], lift[10], lift[15], lift[14]) = (1.0, 1.0, 1.0, 1.0, 2.0);
|
|
s.nodes[0].matrix = Some(lift);
|
|
// bolt-2 starts at x 5 + 10 and ends at 8 + 10; everything is raised to z 2 by the frame.
|
|
assert_eq!(s.bounds(), Some([[0.0, 0.0, 2.0], [18.0, 1.0, 2.0]]));
|
|
s.roots = vec![1];
|
|
assert_eq!(s.bounds(), Some([[0.0, 0.0, 0.0], [1.0, 1.0, 0.0]]), "only what the roots reach");
|
|
s.nodes[1].children = vec![1];
|
|
assert_eq!(s.bounds(), Some([[0.0, 0.0, 0.0], [1.0, 1.0, 0.0]]), "a cycle ends");
|
|
s.roots = vec![99];
|
|
assert_eq!(s.bounds(), None, "nothing drawn");
|
|
}
|
|
|
|
/// `prc`'s materials' emissive colours as `[r, g, b]`, the unlit ones dropped.
|
|
fn emissives(prc: &[u8]) -> Vec<[f64; 3]> {
|
|
let all = PrcFile::parse(prc).unwrap().material_emissives().unwrap();
|
|
all.into_iter().flatten().flatten().map(|c| [c.r, c.g, c.b]).collect()
|
|
}
|
|
|
|
#[test]
|
|
fn an_emissive_colour_reads_back_on_its_material_only() {
|
|
let mut s = scene();
|
|
s.materials[0].emissive = [0.0, 0.5, 1.0];
|
|
let prc = write_prc(&s).unwrap().prc;
|
|
assert_eq!(emissives(&prc), [[0.0, 0.5, 1.0]]);
|
|
// The glass keeps its colour and alpha through the material style.
|
|
let colours: Vec<_> = assemble(&prc).colours.into_iter().flatten().collect();
|
|
assert!(colours.contains(&[51, 102, 153, 102]), "{colours:?}");
|
|
assert!(emissives(&write_prc(&scene()).unwrap().prc).is_empty());
|
|
// A wholly transparent material does not glow.
|
|
s.materials[0].rgba[3] = 0.0;
|
|
assert!(emissives(&write_prc(&s).unwrap().prc).is_empty());
|
|
}
|
|
|
|
#[test]
|
|
fn a_textured_material_carries_its_glow() {
|
|
let mut s = scene();
|
|
let image = b"\x89PNG\r\n\x1a\n\0\0\0\x0dIHDR\0\0\0\x01\0\0\0\x02".to_vec();
|
|
s.textures = vec![SceneTexture { image, wrap: [TextureWrap::Clamp, TextureWrap::Clamp], alpha: false }];
|
|
s.materials[1].texture = Some(0);
|
|
s.materials[1].emissive = [1.0, 0.0, 0.0];
|
|
s.meshes[1].primitives[0].uvs = vec![[0.5, 0.1], [0.5, 0.1], [0.5, 0.9]];
|
|
let r = write_prc(&s).unwrap();
|
|
assert_eq!(r.textured, 1);
|
|
assert_eq!(emissives(&r.prc), [[1.0, 0.0, 0.0]]);
|
|
}
|
|
|
|
/// A chain of `n` nodes, the last holding the pane.
|
|
fn chain(n: usize) -> MeshScene {
|
|
let mut s = scene();
|
|
s.nodes = (0..n).map(|i| node("link", (i + 1 == n).then_some(0), if i + 1 < n { vec![i + 1] } else { vec![] })).collect();
|
|
s
|
|
}
|
|
|
|
/// The writer accepts no deeper nesting than this crate's reader walks, with
|
|
/// one root or with the root the writer adds over several.
|
|
#[test]
|
|
fn the_deepest_accepted_chain_reads_back() {
|
|
for roots in [1, 2] {
|
|
let mut s = chain(MAX_NODE_DEPTH);
|
|
if roots == 2 {
|
|
s.nodes.push(node("bolt", Some(1), vec![]));
|
|
s.roots = vec![0, MAX_NODE_DEPTH];
|
|
}
|
|
let file = PrcFile::parse(&write_prc(&s).unwrap().prc).unwrap();
|
|
assert!(file.model_tree().is_ok(), "{roots} root(s)");
|
|
assert!(!file.placements().unwrap().is_empty());
|
|
}
|
|
assert_eq!(write_prc(&chain(MAX_NODE_DEPTH + 1)), Err(PrcWriteError::NotATree("nested too deeply")));
|
|
}
|
|
|
|
#[test]
|
|
fn supplied_normals_are_stored_not_replaced() {
|
|
let mut s = scene();
|
|
let up = [[0.0, 0.0, 1.0], [0.0, 0.6, 0.8], [0.6, 0.0, 0.8]];
|
|
s.meshes[0].primitives[0].normals = up.to_vec();
|
|
let r = write_prc(&s).unwrap();
|
|
assert_eq!(r.flat_normals, 2, "only the bolt's primitives get flat normals");
|
|
let file = PrcFile::parse(&r.prc).unwrap();
|
|
let meshes: Vec<_> = file.file_structures.iter().flat_map(|fs| fs.tessellations().unwrap()).collect();
|
|
let supplied = |t: &&crate::Tessellation| matches!(t, crate::Tessellation::Mesh(m) if m.normals.len() == 3);
|
|
let Some(crate::Tessellation::Mesh(pane)) = meshes.iter().find(supplied) else { panic!("{meshes:?}") };
|
|
assert_eq!(pane.normals, up);
|
|
assert_eq!(pane.triangle_normals, [[0, 1, 2]]);
|
|
assert!(!pane.normals_recalculated);
|
|
let mut s = scene();
|
|
s.meshes[0].primitives[0].normals = vec![[0.0, 0.0, 1.0]];
|
|
assert!(matches!(write_prc(&s), Err(PrcWriteError::BadIndex { .. })), "one normal for three vertices");
|
|
}
|
|
|
|
/// A wholly transparent textured material stays transparent: its style says so, not only its
|
|
/// material, whose alpha of 0 a reader may take as unset.
|
|
#[test]
|
|
fn a_transparent_textured_material_reads_back_transparent() {
|
|
let mut s = scene();
|
|
let image = b"\x89PNG\r\n\x1a\n\0\0\0\x0dIHDR\0\0\0\x01\0\0\0\x02".to_vec();
|
|
s.textures = vec![SceneTexture { image, wrap: [TextureWrap::Clamp, TextureWrap::Clamp], alpha: false }];
|
|
s.materials[1].texture = Some(0);
|
|
s.materials[1].rgba[3] = 0.0;
|
|
s.meshes[1].primitives[0].uvs = vec![[0.5, 0.1], [0.5, 0.1], [0.5, 0.9]];
|
|
let prc = write_prc(&s).unwrap().prc;
|
|
let colours: Vec<_> = assemble(&prc).colours.into_iter().flatten().collect();
|
|
assert!(colours.iter().filter(|c| c[..3] == [255, 0, 0]).all(|c| c[3] == 0), "{colours:?}");
|
|
assert!(colours.iter().any(|c| c[..3] == [255, 0, 0]), "{colours:?}");
|
|
}
|
|
|
|
/// What the roots do not reach is checked too.
|
|
#[test]
|
|
fn unreached_nodes_and_meshes_are_checked() {
|
|
let mut s = scene();
|
|
s.nodes.push(node("stray", Some(999), vec![]));
|
|
assert_eq!(write_prc(&s), Err(PrcWriteError::BadIndex { what: "mesh", index: 999 }));
|
|
let mut s = scene();
|
|
s.meshes.push(SceneMesh { name: None, primitives: vec![tri(Some(999), 0.0)] });
|
|
assert_eq!(write_prc(&s), Err(PrcWriteError::BadIndex { what: "material", index: 999 }));
|
|
let mut s = scene();
|
|
s.nodes.push(node("a", None, vec![5]));
|
|
s.nodes.push(node("b", None, vec![4]));
|
|
assert_eq!(write_prc(&s), Err(PrcWriteError::NotATree("a cycle")));
|
|
// An unreached tree is fine.
|
|
let mut s = scene();
|
|
s.nodes.push(node("spare", Some(0), vec![]));
|
|
assert!(write_prc(&s).is_ok());
|
|
}
|