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

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

/// Mesh primitive export data.
#[allow(dead_code)]
#[derive(Debug, Clone, PartialEq)]
pub struct MeshPrimitiveExport {
    pub mode: u32,
    pub vertex_count: u32,
    pub index_count: u32,
    pub material_index: Option<u32>,
}

/// Export a mesh primitive.
#[allow(dead_code)]
pub fn export_mesh_primitive(mode: u32, vertex_count: u32, index_count: u32, material_index: Option<u32>) -> MeshPrimitiveExport {
    MeshPrimitiveExport { mode, vertex_count, index_count, material_index }
}

/// Get primitive mode (4 = triangles, 0 = points, etc).
#[allow(dead_code)]
pub fn primitive_mode(e: &MeshPrimitiveExport) -> u32 {
    e.mode
}

/// Get vertex count.
#[allow(dead_code)]
pub fn primitive_vertex_count_mpe(e: &MeshPrimitiveExport) -> u32 {
    e.vertex_count
}

/// Get index count.
#[allow(dead_code)]
pub fn primitive_index_count_mpe(e: &MeshPrimitiveExport) -> u32 {
    e.index_count
}

/// Serialize to JSON.
#[allow(dead_code)]
pub fn primitive_to_json(e: &MeshPrimitiveExport) -> String {
    format!(
        "{{\"mode\":{},\"vertices\":{},\"indices\":{}}}",
        e.mode, e.vertex_count, e.index_count
    )
}

/// Get material index.
#[allow(dead_code)]
pub fn primitive_material_index(e: &MeshPrimitiveExport) -> Option<u32> {
    e.material_index
}

/// Get export size estimate.
#[allow(dead_code)]
pub fn primitive_export_size(e: &MeshPrimitiveExport) -> usize {
    (e.vertex_count as usize * 12) + (e.index_count as usize * 4)
}

/// Validate primitive.
#[allow(dead_code)]
pub fn validate_primitive(e: &MeshPrimitiveExport) -> bool {
    e.vertex_count > 0 && (0..=6).contains(&e.mode)
}

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

    #[test]
    fn test_export_mesh_primitive() {
        let e = export_mesh_primitive(4, 100, 300, Some(0));
        assert_eq!(e.mode, 4);
    }

    #[test]
    fn test_primitive_mode() {
        let e = export_mesh_primitive(4, 10, 30, None);
        assert_eq!(primitive_mode(&e), 4);
    }

    #[test]
    fn test_primitive_vertex_count() {
        let e = export_mesh_primitive(4, 50, 150, None);
        assert_eq!(primitive_vertex_count_mpe(&e), 50);
    }

    #[test]
    fn test_primitive_index_count() {
        let e = export_mesh_primitive(4, 50, 150, None);
        assert_eq!(primitive_index_count_mpe(&e), 150);
    }

    #[test]
    fn test_primitive_to_json() {
        let e = export_mesh_primitive(4, 10, 30, None);
        let j = primitive_to_json(&e);
        assert!(j.contains("\"mode\":4"));
    }

    #[test]
    fn test_primitive_material_index() {
        let e = export_mesh_primitive(4, 10, 30, Some(2));
        assert_eq!(primitive_material_index(&e), Some(2));
    }

    #[test]
    fn test_primitive_material_index_none() {
        let e = export_mesh_primitive(4, 10, 30, None);
        assert_eq!(primitive_material_index(&e), None);
    }

    #[test]
    fn test_primitive_export_size() {
        let e = export_mesh_primitive(4, 10, 30, None);
        assert_eq!(primitive_export_size(&e), 10 * 12 + 30 * 4);
    }

    #[test]
    fn test_validate_ok() {
        let e = export_mesh_primitive(4, 10, 30, None);
        assert!(validate_primitive(&e));
    }

    #[test]
    fn test_validate_bad_mode() {
        let e = export_mesh_primitive(10, 10, 30, None);
        assert!(!validate_primitive(&e));
    }
}