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
138
139
140
141
142
143
144

#![allow(dead_code)]
//! Mesh accessor export.

/// Accessor export data.
#[allow(dead_code)]
#[derive(Debug, Clone, PartialEq)]
pub struct MeshAccessorExport {
    pub component_type: u32,
    pub type_name: String,
    pub count: u32,
    pub min_values: Vec<f32>,
    pub max_values: Vec<f32>,
}

/// Export an accessor.
#[allow(dead_code)]
pub fn export_accessor(
    component_type: u32,
    type_name: &str,
    count: u32,
    min_values: Vec<f32>,
    max_values: Vec<f32>,
) -> MeshAccessorExport {
    MeshAccessorExport {
        component_type,
        type_name: type_name.to_string(),
        count,
        min_values,
        max_values,
    }
}

/// Get component type (5126 = FLOAT, 5123 = UNSIGNED_SHORT, etc).
#[allow(dead_code)]
pub fn accessor_component_type(e: &MeshAccessorExport) -> u32 {
    e.component_type
}

/// Get type name (VEC3, VEC4, SCALAR, etc).
#[allow(dead_code)]
pub fn accessor_type_name(e: &MeshAccessorExport) -> &str {
    &e.type_name
}

/// Get element count.
#[allow(dead_code)]
pub fn accessor_count_mae(e: &MeshAccessorExport) -> u32 {
    e.count
}

/// Get min values.
#[allow(dead_code)]
pub fn accessor_min(e: &MeshAccessorExport) -> &[f32] {
    &e.min_values
}

/// Get max values.
#[allow(dead_code)]
pub fn accessor_max(e: &MeshAccessorExport) -> &[f32] {
    &e.max_values
}

/// Serialize to JSON.
#[allow(dead_code)]
pub fn accessor_to_json(e: &MeshAccessorExport) -> String {
    format!(
        "{{\"componentType\":{},\"type\":\"{}\",\"count\":{}}}",
        e.component_type, e.type_name, e.count
    )
}

/// Validate accessor.
#[allow(dead_code)]
pub fn validate_accessor(e: &MeshAccessorExport) -> bool {
    e.count > 0
        && !e.type_name.is_empty()
        && e.min_values.len() == e.max_values.len()
}

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

    #[test]
    fn test_export_accessor() {
        let e = export_accessor(5126, "VEC3", 100, vec![0.0; 3], vec![1.0; 3]);
        assert_eq!(e.count, 100);
    }

    #[test]
    fn test_accessor_component_type() {
        let e = export_accessor(5126, "VEC3", 10, vec![], vec![]);
        assert_eq!(accessor_component_type(&e), 5126);
    }

    #[test]
    fn test_accessor_type_name() {
        let e = export_accessor(5126, "VEC4", 10, vec![], vec![]);
        assert_eq!(accessor_type_name(&e), "VEC4");
    }

    #[test]
    fn test_accessor_count() {
        let e = export_accessor(5126, "SCALAR", 50, vec![], vec![]);
        assert_eq!(accessor_count_mae(&e), 50);
    }

    #[test]
    fn test_accessor_min() {
        let e = export_accessor(5126, "VEC3", 10, vec![-1.0, -2.0, -3.0], vec![1.0; 3]);
        assert_eq!(accessor_min(&e), &[-1.0, -2.0, -3.0]);
    }

    #[test]
    fn test_accessor_max() {
        let e = export_accessor(5126, "VEC3", 10, vec![0.0; 3], vec![1.0, 2.0, 3.0]);
        assert_eq!(accessor_max(&e), &[1.0, 2.0, 3.0]);
    }

    #[test]
    fn test_accessor_to_json() {
        let e = export_accessor(5126, "VEC3", 10, vec![], vec![]);
        let j = accessor_to_json(&e);
        assert!(j.contains("VEC3"));
    }

    #[test]
    fn test_validate_ok() {
        let e = export_accessor(5126, "VEC3", 10, vec![0.0; 3], vec![1.0; 3]);
        assert!(validate_accessor(&e));
    }

    #[test]
    fn test_validate_zero_count() {
        let e = export_accessor(5126, "VEC3", 0, vec![], vec![]);
        assert!(!validate_accessor(&e));
    }

    #[test]
    fn test_validate_mismatch_minmax() {
        let e = export_accessor(5126, "VEC3", 10, vec![0.0; 3], vec![1.0; 2]);
        assert!(!validate_accessor(&e));
    }
}