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

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

//! Export particle system settings.

#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ParticleSystemExport {
    pub name: String,
    pub count: u32,
    pub lifetime: f32,
    pub emit_from: u8,
    pub gravity: f32,
    pub velocity: [f32; 3],
    pub size: f32,
    pub enabled: bool,
}

#[allow(dead_code)]
pub fn default_particle_system_export(name: &str) -> ParticleSystemExport {
    ParticleSystemExport {
        name: name.to_string(),
        count: 1000,
        lifetime: 60.0,
        emit_from: 0,
        gravity: -9.81,
        velocity: [0.0, 1.0, 0.0],
        size: 0.05,
        enabled: true,
    }
}

#[allow(dead_code)]
pub fn export_particle_system_to_json(p: &ParticleSystemExport) -> String {
    format!(
        r#"{{"name":"{}","count":{},"lifetime":{},"emit_from":{},"gravity":{},"velocity":[{},{},{}],"size":{},"enabled":{}}}"#,
        p.name, p.count, p.lifetime, p.emit_from, p.gravity,
        p.velocity[0], p.velocity[1], p.velocity[2],
        p.size, p.enabled
    )
}

#[allow(dead_code)]
pub fn particle_system_from_str(s: &str) -> ParticleSystemExport {
    // Minimal stub: extract name if present, else default
    let name = if let Some(start) = s.find("\"name\":\"") {
        let rest = &s[start + 8..];
        if let Some(end) = rest.find('"') {
            &rest[..end]
        } else {
            "unknown"
        }
    } else {
        "unknown"
    };
    default_particle_system_export(name)
}

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

    #[test]
    fn default_has_name() {
        let p = default_particle_system_export("sparks");
        assert_eq!(p.name, "sparks");
    }

    #[test]
    fn default_count_1000() {
        let p = default_particle_system_export("x");
        assert_eq!(p.count, 1000);
    }

    #[test]
    fn default_enabled_true() {
        let p = default_particle_system_export("x");
        assert!(p.enabled);
    }

    #[test]
    fn export_json_has_name() {
        let p = default_particle_system_export("fire");
        let j = export_particle_system_to_json(&p);
        assert!(j.contains("fire"));
    }

    #[test]
    fn export_json_has_count() {
        let p = default_particle_system_export("x");
        let j = export_particle_system_to_json(&p);
        assert!(j.contains("count"));
    }

    #[test]
    fn export_json_has_velocity() {
        let p = default_particle_system_export("x");
        let j = export_particle_system_to_json(&p);
        assert!(j.contains("velocity"));
    }

    #[test]
    fn export_json_has_gravity() {
        let p = default_particle_system_export("x");
        let j = export_particle_system_to_json(&p);
        assert!(j.contains("gravity"));
    }

    #[test]
    fn from_str_roundtrip_name() {
        let p = default_particle_system_export("dust");
        let j = export_particle_system_to_json(&p);
        let p2 = particle_system_from_str(&j);
        assert_eq!(p2.name, "dust");
    }

    #[test]
    fn export_json_has_size() {
        let p = default_particle_system_export("x");
        let j = export_particle_system_to_json(&p);
        assert!(j.contains("size"));
    }
}