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
145
146

#![allow(dead_code)]
//! Export physics collision shapes.

/// Physics shape export data.
#[allow(dead_code)]
#[derive(Debug, Clone, PartialEq)]
pub struct PhysicsShapeExport {
    pub shape_type: String,
    pub vertices: Vec<[f32; 3]>,
    pub is_convex: bool,
}

/// Export a physics shape.
#[allow(dead_code)]
pub fn export_physics_shape(
    shape_type: &str,
    vertices: &[[f32; 3]],
    convex: bool,
) -> PhysicsShapeExport {
    PhysicsShapeExport {
        shape_type: shape_type.to_string(),
        vertices: vertices.to_vec(),
        is_convex: convex,
    }
}

/// Return shape type.
#[allow(dead_code)]
pub fn shape_type_export(exp: &PhysicsShapeExport) -> &str {
    &exp.shape_type
}

/// Serialize to JSON.
#[allow(dead_code)]
pub fn shape_to_json(exp: &PhysicsShapeExport) -> String {
    format!(
        "{{\"type\":\"{}\",\"vertices\":{},\"convex\":{}}}",
        exp.shape_type,
        exp.vertices.len(),
        exp.is_convex
    )
}

/// Serialize to bytes.
#[allow(dead_code)]
pub fn shape_to_bytes(exp: &PhysicsShapeExport) -> Vec<u8> {
    let mut buf = Vec::new();
    for v in &exp.vertices {
        for &f in v {
            buf.extend_from_slice(&f.to_le_bytes());
        }
    }
    buf
}

/// Return vertex count.
#[allow(dead_code)]
pub fn shape_vertex_count(exp: &PhysicsShapeExport) -> usize {
    exp.vertices.len()
}

/// Check if convex.
#[allow(dead_code)]
pub fn shape_is_convex_export(exp: &PhysicsShapeExport) -> bool {
    exp.is_convex
}

/// Compute export size.
#[allow(dead_code)]
pub fn shape_export_size(exp: &PhysicsShapeExport) -> usize {
    exp.vertices.len() * 12
}

/// Validate physics shape.
#[allow(dead_code)]
pub fn validate_physics_shape(exp: &PhysicsShapeExport) -> bool {
    !exp.shape_type.is_empty()
        && !exp.vertices.is_empty()
        && exp.vertices.iter().all(|v| v.iter().all(|f| f.is_finite()))
}

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

    #[test]
    fn test_export_physics_shape() {
        let e = export_physics_shape("box", &[[0.0; 3], [1.0; 3]], true);
        assert_eq!(shape_vertex_count(&e), 2);
    }

    #[test]
    fn test_shape_type() {
        let e = export_physics_shape("sphere", &[[0.0; 3]], true);
        assert_eq!(shape_type_export(&e), "sphere");
    }

    #[test]
    fn test_shape_to_json() {
        let e = export_physics_shape("mesh", &[[0.0; 3]], false);
        let j = shape_to_json(&e);
        assert!(j.contains("\"type\":\"mesh\""));
    }

    #[test]
    fn test_shape_to_bytes() {
        let e = export_physics_shape("box", &[[1.0, 2.0, 3.0]], true);
        assert_eq!(shape_to_bytes(&e).len(), 12);
    }

    #[test]
    fn test_shape_is_convex() {
        let e = export_physics_shape("hull", &[[0.0; 3]], true);
        assert!(shape_is_convex_export(&e));
    }

    #[test]
    fn test_shape_not_convex() {
        let e = export_physics_shape("mesh", &[[0.0; 3]], false);
        assert!(!shape_is_convex_export(&e));
    }

    #[test]
    fn test_shape_export_size() {
        let e = export_physics_shape("box", &[[0.0; 3]; 8], true);
        assert_eq!(shape_export_size(&e), 96);
    }

    #[test]
    fn test_validate_physics_shape() {
        let e = export_physics_shape("box", &[[0.0; 3]], true);
        assert!(validate_physics_shape(&e));
    }

    #[test]
    fn test_validate_empty_verts() {
        let e = export_physics_shape("box", &[], true);
        assert!(!validate_physics_shape(&e));
    }

    #[test]
    fn test_validate_empty_type() {
        let e = export_physics_shape("", &[[0.0; 3]], true);
        assert!(!validate_physics_shape(&e));
    }
}