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

// Copyright (C) 2026 COOLJAPAN OU (Team KitaSan)
// SPDX-License-Identifier: Apache-2.0

#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct WorldBackground {
    pub color: [f32; 3],
    pub strength: f32,
    pub use_sky: bool,
}

#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct WorldSettings {
    pub background: WorldBackground,
    pub ambient_color: [f32; 3],
    pub mist_start: f32,
    pub mist_depth: f32,
}

#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct WorldSettingsExport {
    pub settings: WorldSettings,
}

#[allow(dead_code)]
pub fn default_world_settings() -> WorldSettings {
    WorldSettings {
        background: WorldBackground {
            color: [0.05, 0.05, 0.05],
            strength: 1.0,
            use_sky: false,
        },
        ambient_color: [0.0; 3],
        mist_start: 0.0,
        mist_depth: 25.0,
    }
}

#[allow(dead_code)]
pub fn new_world_settings_export() -> WorldSettingsExport {
    WorldSettingsExport { settings: default_world_settings() }
}

#[allow(dead_code)]
pub fn ws_set_background_color(exp: &mut WorldSettingsExport, color: [f32; 3]) {
    exp.settings.background.color = color;
}

#[allow(dead_code)]
pub fn ws_set_ambient(exp: &mut WorldSettingsExport, color: [f32; 3]) {
    exp.settings.ambient_color = color;
}

#[allow(dead_code)]
pub fn ws_set_mist(exp: &mut WorldSettingsExport, start: f32, depth: f32) {
    exp.settings.mist_start = start;
    exp.settings.mist_depth = depth;
}

#[allow(dead_code)]
pub fn ws_to_json(exp: &WorldSettingsExport) -> String {
    let bg = &exp.settings.background;
    format!(
        r#"{{"bg_strength":{},"mist_depth":{},"use_sky":{}}}"#,
        bg.strength,
        exp.settings.mist_depth,
        bg.use_sky
    )
}

#[allow(dead_code)]
pub fn ws_validate(exp: &WorldSettingsExport) -> bool {
    exp.settings.background.strength >= 0.0 && exp.settings.mist_depth >= 0.0
}

#[allow(dead_code)]
pub fn ws_background_luminance(exp: &WorldSettingsExport) -> f32 {
    let c = &exp.settings.background.color;
    let lum = 0.2126 * c[0] + 0.7152 * c[1] + 0.0722 * c[2];
    lum * exp.settings.background.strength
}

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

    #[test]
    fn test_default_settings() {
        let s = default_world_settings();
        assert!((s.background.strength - 1.0).abs() < 1e-6);
        assert!(!s.background.use_sky);
    }

    #[test]
    fn test_new_export() {
        let e = new_world_settings_export();
        assert!((e.settings.mist_depth - 25.0).abs() < 1e-5);
    }

    #[test]
    fn test_set_background_color() {
        let mut e = new_world_settings_export();
        ws_set_background_color(&mut e, [1.0, 0.0, 0.0]);
        assert!((e.settings.background.color[0] - 1.0).abs() < 1e-6);
    }

    #[test]
    fn test_set_ambient() {
        let mut e = new_world_settings_export();
        ws_set_ambient(&mut e, [0.1, 0.1, 0.1]);
        assert!((e.settings.ambient_color[0] - 0.1).abs() < 1e-6);
    }

    #[test]
    fn test_set_mist() {
        let mut e = new_world_settings_export();
        ws_set_mist(&mut e, 5.0, 50.0);
        assert!((e.settings.mist_start - 5.0).abs() < 1e-5);
        assert!((e.settings.mist_depth - 50.0).abs() < 1e-5);
    }

    #[test]
    fn test_validate() {
        let e = new_world_settings_export();
        assert!(ws_validate(&e));
    }

    #[test]
    fn test_luminance() {
        let mut e = new_world_settings_export();
        ws_set_background_color(&mut e, [1.0, 1.0, 1.0]);
        let lum = ws_background_luminance(&e);
        assert!(lum > 0.0);
    }

    #[test]
    fn test_to_json() {
        let e = new_world_settings_export();
        let j = ws_to_json(&e);
        assert!(j.contains("bg_strength"));
        assert!(j.contains("mist_depth"));
    }
}