oxihuman-export 0.1.2

Export pipeline for OxiHuman — glTF, COLLADA, STL, and streaming formats
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
128
129
130
131
132
133
134
135
136
137

#![allow(dead_code)]
//! Export asset manifests.

/// Asset manifest export data.
#[allow(dead_code)]
#[derive(Debug, Clone, PartialEq)]
pub struct AssetManifestExport {
    pub version: String,
    pub assets: Vec<String>,
    pub checksum: u32,
}

/// Export an asset manifest.
#[allow(dead_code)]
pub fn export_asset_manifest(version: &str, assets: &[&str]) -> AssetManifestExport {
    let asset_list: Vec<String> = assets.iter().map(|s| s.to_string()).collect();
    let checksum = asset_list.iter().fold(0u32, |acc, s| acc.wrapping_add(s.len() as u32));
    AssetManifestExport {
        version: version.to_string(),
        assets: asset_list,
        checksum,
    }
}

/// Return asset count.
#[allow(dead_code)]
pub fn manifest_asset_count(exp: &AssetManifestExport) -> usize {
    exp.assets.len()
}

/// Serialize to JSON.
#[allow(dead_code)]
pub fn manifest_to_json(exp: &AssetManifestExport) -> String {
    let files: Vec<String> = exp.assets.iter().map(|a| format!("\"{}\"", a)).collect();
    format!(
        "{{\"version\":\"{}\",\"assets\":[{}],\"checksum\":{}}}",
        exp.version,
        files.join(","),
        exp.checksum
    )
}

/// Return version string.
#[allow(dead_code)]
pub fn manifest_version(exp: &AssetManifestExport) -> &str {
    &exp.version
}

/// Return checksum.
#[allow(dead_code)]
pub fn manifest_checksum(exp: &AssetManifestExport) -> u32 {
    exp.checksum
}

/// Return file list.
#[allow(dead_code)]
pub fn manifest_file_list(exp: &AssetManifestExport) -> &[String] {
    &exp.assets
}

/// Compute export size.
#[allow(dead_code)]
pub fn manifest_export_size(exp: &AssetManifestExport) -> usize {
    manifest_to_json(exp).len()
}

/// Validate manifest.
#[allow(dead_code)]
pub fn validate_manifest(exp: &AssetManifestExport) -> bool {
    !exp.version.is_empty() && !exp.assets.is_empty()
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_export_asset_manifest() {
        let e = export_asset_manifest("1.0", &["mesh.bin", "tex.png"]);
        assert_eq!(manifest_asset_count(&e), 2);
    }

    #[test]
    fn test_manifest_version() {
        let e = export_asset_manifest("2.1", &["a"]);
        assert_eq!(manifest_version(&e), "2.1");
    }

    #[test]
    fn test_manifest_to_json() {
        let e = export_asset_manifest("1.0", &["mesh.bin"]);
        let j = manifest_to_json(&e);
        assert!(j.contains("\"version\":\"1.0\""));
    }

    #[test]
    fn test_manifest_checksum() {
        let e = export_asset_manifest("1.0", &["abc"]);
        assert!(manifest_checksum(&e) > 0);
    }

    #[test]
    fn test_manifest_file_list() {
        let e = export_asset_manifest("1.0", &["a", "b"]);
        assert_eq!(manifest_file_list(&e).len(), 2);
    }

    #[test]
    fn test_manifest_export_size() {
        let e = export_asset_manifest("1.0", &["a"]);
        assert!(manifest_export_size(&e) > 0);
    }

    #[test]
    fn test_validate_manifest() {
        let e = export_asset_manifest("1.0", &["a"]);
        assert!(validate_manifest(&e));
    }

    #[test]
    fn test_validate_empty_assets() {
        let e = export_asset_manifest("1.0", &[]);
        assert!(!validate_manifest(&e));
    }

    #[test]
    fn test_validate_empty_version() {
        let e = export_asset_manifest("", &["a"]);
        assert!(!validate_manifest(&e));
    }

    #[test]
    fn test_empty_manifest() {
        let e = export_asset_manifest("1.0", &[]);
        assert_eq!(manifest_asset_count(&e), 0);
    }
}