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

#![allow(dead_code)]
// Copyright (C) 2026 COOLJAPAN OU (Team KitaSan)
// SPDX-License-Identifier: Apache-2.0

/// Texture information export.
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct TextureInfoExport {
    pub width: u32,
    pub height: u32,
    pub format: String,
    pub mip_count: u32,
    pub name: String,
}

/// Create a texture info export.
#[allow(dead_code)]
pub fn export_texture_info(
    name: &str,
    width: u32,
    height: u32,
    format: &str,
    mip_count: u32,
) -> TextureInfoExport {
    TextureInfoExport {
        width,
        height,
        format: format.to_string(),
        mip_count,
        name: name.to_string(),
    }
}

/// Return texture width.
#[allow(dead_code)]
pub fn texture_width(t: &TextureInfoExport) -> u32 {
    t.width
}

/// Return texture height.
#[allow(dead_code)]
pub fn texture_height(t: &TextureInfoExport) -> u32 {
    t.height
}

/// Return format name.
#[allow(dead_code)]
pub fn texture_format_name(t: &TextureInfoExport) -> &str {
    &t.format
}

/// Return mip-map count.
#[allow(dead_code)]
pub fn texture_mip_count(t: &TextureInfoExport) -> u32 {
    t.mip_count
}

/// Serialize to JSON.
#[allow(dead_code)]
pub fn texture_to_json(t: &TextureInfoExport) -> String {
    format!(
        "{{\"name\":\"{}\",\"width\":{},\"height\":{},\"format\":\"{}\",\"mips\":{}}}",
        t.name, t.width, t.height, t.format, t.mip_count,
    )
}

/// Return estimated byte size of the texture info record.
#[allow(dead_code)]
pub fn texture_info_size(t: &TextureInfoExport) -> usize {
    // name + format string lengths + 3 u32 fields
    t.name.len() + t.format.len() + 12
}

/// Validate: width/height > 0, non-empty name and format.
#[allow(dead_code)]
pub fn validate_texture_info(t: &TextureInfoExport) -> bool {
    t.width > 0 && t.height > 0 && !t.name.is_empty() && !t.format.is_empty()
}

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

    fn sample() -> TextureInfoExport {
        export_texture_info("diffuse", 1024, 1024, "RGBA8", 10)
    }

    #[test]
    fn test_width() {
        assert_eq!(texture_width(&sample()), 1024);
    }

    #[test]
    fn test_height() {
        assert_eq!(texture_height(&sample()), 1024);
    }

    #[test]
    fn test_format_name() {
        assert_eq!(texture_format_name(&sample()), "RGBA8");
    }

    #[test]
    fn test_mip_count() {
        assert_eq!(texture_mip_count(&sample()), 10);
    }

    #[test]
    fn test_to_json() {
        let j = texture_to_json(&sample());
        assert!(j.contains("\"diffuse\""));
        assert!(j.contains("\"width\":1024"));
    }

    #[test]
    fn test_info_size() {
        assert!(texture_info_size(&sample()) > 0);
    }

    #[test]
    fn test_validate_ok() {
        assert!(validate_texture_info(&sample()));
    }

    #[test]
    fn test_validate_zero_width() {
        let t = export_texture_info("x", 0, 512, "RGB8", 1);
        assert!(!validate_texture_info(&t));
    }

    #[test]
    fn test_validate_empty_name() {
        let t = export_texture_info("", 512, 512, "RGB8", 1);
        assert!(!validate_texture_info(&t));
    }

    #[test]
    fn test_validate_empty_format() {
        let t = export_texture_info("n", 512, 512, "", 1);
        assert!(!validate_texture_info(&t));
    }
}