voxj-codec 0.1.0

Encodes voxj types into .voxj / .voxjz documents.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

use crate::{decode_voxj_object, voxj_palette_cell_counts};
use std::io;
use voxj::{VoxjCodecFile, VoxjCodecMain, VoxjSerdeFile};

/// Decodes a [`VoxjSerdeFile`] (encoded `.voxj` blocks) into a [`VoxjCodecFile`]
/// (decoded geometry), the inverse of [`encode_voxj_file`](crate::encode_voxj_file). Each
/// object's palette cell counts come from the palettes it references; the
/// palettes, hierarchy, roots, and `ext` carry over unchanged.
pub fn decode_voxj_file(file: &VoxjSerdeFile) -> io::Result<VoxjCodecFile> {
    let palettes = &file.main.palettes;
    let objects = file
        .main
        .objects
        .iter()
        .map(|object| {
            let cell_counts = voxj_palette_cell_counts(&object.palette_refs, palettes);
            decode_voxj_object(object, &cell_counts)
        })
        .collect::<io::Result<Vec<_>>>()?;
    Ok(VoxjCodecFile {
        version: file.version,
        main: VoxjCodecMain {
            objects,
            palettes: palettes.clone(),
            hierarchy_nodes: file.main.hierarchy_nodes.clone(),
            root_hierarchy_nodes: file.main.root_hierarchy_nodes.clone(),
            ext: file.main.ext.clone(),
        },
    })
}

#[cfg(test)]
mod tests {
    use crate::{
        PositionEncoding, SampleEncoding, decode_voxj_file, encode_voxj_file,
        encode_voxj_file_smallest,
    };
    use std::collections::BTreeSet;
    use voxj::{VoxjCodecFile, VoxjCodecMain, VoxjCodecObject, VoxjPalette, VoxjValue};

    /// `n` single-attribute palette cells; only the count matters to the codec
    /// (it fixes each channel's packed width).
    fn cells(n: usize) -> Vec<Vec<VoxjValue>> {
        (0..n).map(|i| vec![VoxjValue::Number(i as f64)]).collect()
    }

    /// Two objects sampling two palettes of differing cell counts, with an `ext`
    /// blob, so a round trip exercises per-object geometry plus the shared
    /// palettes/ext carry-over.
    fn codec_file() -> VoxjCodecFile {
        VoxjCodecFile {
            version: 1,
            main: VoxjCodecMain {
                objects: vec![
                    VoxjCodecObject {
                        name: "a".to_owned(),
                        palette_refs: vec![0],
                        bounds: [4, 4, 4],
                        positions: vec![[0, 0, 0], [3, 1, 2], [1, 3, 0], [2, 2, 3]],
                        samples: vec![vec![1], vec![0], vec![5], vec![2]],
                    },
                    VoxjCodecObject {
                        name: "b".to_owned(),
                        palette_refs: vec![0, 1],
                        bounds: [2, 1, 1],
                        positions: vec![[0, 0, 0], [1, 0, 0]],
                        samples: vec![vec![3, 0], vec![1, 1]],
                    },
                ],
                palettes: vec![
                    VoxjPalette {
                        attributes: vec!["rgba".to_owned()],
                        data: cells(6),
                    },
                    VoxjPalette {
                        attributes: vec!["metallic".to_owned()],
                        data: cells(2),
                    },
                ],
                hierarchy_nodes: Vec::new(),
                root_hierarchy_nodes: Vec::new(),
                ext: Some(VoxjValue::Text("vendor".to_owned())),
            },
        }
    }

    /// `(position, samples)` pairs of one object, order-independent, since the
    /// block encodings reorder voxels.
    fn voxels(object: &VoxjCodecObject) -> BTreeSet<([u32; 3], Vec<u32>)> {
        object
            .positions
            .iter()
            .copied()
            .zip(object.samples.iter().cloned())
            .collect()
    }

    fn assert_round_trip(decoded: &VoxjCodecFile) {
        let original = codec_file();
        assert_eq!(decoded.version, original.version);
        assert_eq!(decoded.main.palettes, original.main.palettes);
        assert_eq!(decoded.main.ext, original.main.ext);
        assert_eq!(decoded.main.objects.len(), original.main.objects.len());
        for (got, want) in decoded.main.objects.iter().zip(&original.main.objects) {
            assert_eq!(got.name, want.name);
            assert_eq!(got.palette_refs, want.palette_refs);
            assert_eq!(got.bounds, want.bounds);
            assert_eq!(voxels(got), voxels(want));
        }
    }

    #[test]
    fn round_trips_file_through_fixed_encoding() {
        let encoded = encode_voxj_file(
            &codec_file(),
            PositionEncoding::BitmapBase64,
            SampleEncoding::PackedBase64,
        );
        assert_round_trip(&decode_voxj_file(&encoded).unwrap());
    }

    #[test]
    fn round_trips_file_through_smallest() {
        let encoded = encode_voxj_file_smallest(&codec_file());
        assert_round_trip(&decode_voxj_file(&encoded).unwrap());
    }
}