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
147
148

#![allow(dead_code)]
//! Export format version data.

/// Format version.
#[allow(dead_code)]
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct FormatVersion {
    pub major: u16,
    pub minor: u16,
    pub patch: u16,
}

/// Create a new format version.
#[allow(dead_code)]
pub fn new_format_version(major: u16, minor: u16, patch: u16) -> FormatVersion {
    FormatVersion { major, minor, patch }
}

/// Get major version.
#[allow(dead_code)]
pub fn version_major(v: &FormatVersion) -> u16 {
    v.major
}

/// Get minor version.
#[allow(dead_code)]
pub fn version_minor(v: &FormatVersion) -> u16 {
    v.minor
}

/// Get patch version.
#[allow(dead_code)]
pub fn version_patch(v: &FormatVersion) -> u16 {
    v.patch
}

/// Convert version to string.
#[allow(dead_code)]
pub fn version_to_string(v: &FormatVersion) -> String {
    format!("{}.{}.{}", v.major, v.minor, v.patch)
}

/// Check if two versions are compatible (same major version).
#[allow(dead_code)]
pub fn version_compatible(a: &FormatVersion, b: &FormatVersion) -> bool {
    a.major == b.major
}

/// Convert version to bytes (6 bytes: 2 per component).
#[allow(dead_code)]
pub fn version_to_bytes(v: &FormatVersion) -> Vec<u8> {
    let mut bytes = Vec::with_capacity(6);
    bytes.extend_from_slice(&v.major.to_le_bytes());
    bytes.extend_from_slice(&v.minor.to_le_bytes());
    bytes.extend_from_slice(&v.patch.to_le_bytes());
    bytes
}

/// Parse version from bytes.
#[allow(dead_code)]
pub fn version_from_bytes(bytes: &[u8]) -> Option<FormatVersion> {
    if bytes.len() < 6 {
        return None;
    }
    let major = u16::from_le_bytes([bytes[0], bytes[1]]);
    let minor = u16::from_le_bytes([bytes[2], bytes[3]]);
    let patch = u16::from_le_bytes([bytes[4], bytes[5]]);
    Some(FormatVersion { major, minor, patch })
}

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

    #[test]
    fn test_new_format_version() {
        let v = new_format_version(1, 2, 3);
        assert_eq!(v.major, 1);
        assert_eq!(v.minor, 2);
        assert_eq!(v.patch, 3);
    }

    #[test]
    fn test_version_major() {
        let v = new_format_version(5, 0, 0);
        assert_eq!(version_major(&v), 5);
    }

    #[test]
    fn test_version_minor() {
        let v = new_format_version(1, 7, 0);
        assert_eq!(version_minor(&v), 7);
    }

    #[test]
    fn test_version_patch() {
        let v = new_format_version(1, 0, 9);
        assert_eq!(version_patch(&v), 9);
    }

    #[test]
    fn test_version_to_string() {
        let v = new_format_version(1, 2, 3);
        assert_eq!(version_to_string(&v), "1.2.3");
    }

    #[test]
    fn test_version_compatible() {
        let a = new_format_version(1, 0, 0);
        let b = new_format_version(1, 5, 3);
        assert!(version_compatible(&a, &b));
    }

    #[test]
    fn test_version_not_compatible() {
        let a = new_format_version(1, 0, 0);
        let b = new_format_version(2, 0, 0);
        assert!(!version_compatible(&a, &b));
    }

    #[test]
    fn test_version_to_bytes() {
        let v = new_format_version(1, 2, 3);
        let bytes = version_to_bytes(&v);
        assert_eq!(bytes.len(), 6);
    }

    #[test]
    fn test_version_from_bytes() {
        let v = new_format_version(10, 20, 30);
        let bytes = version_to_bytes(&v);
        let parsed = version_from_bytes(&bytes);
        assert_eq!(parsed, Some(v));
    }

    #[test]
    fn test_version_from_bytes_too_short() {
        assert!(version_from_bytes(&[0, 1]).is_none());
    }

    #[test]
    fn test_version_roundtrip() {
        let v = new_format_version(255, 128, 64);
        let bytes = version_to_bytes(&v);
        let restored = version_from_bytes(&bytes).expect("should succeed");
        assert_eq!(v, restored);
    }
}