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

// Copyright (C) 2026 COOLJAPAN OU (Team KitaSan)
// SPDX-License-Identifier: Apache-2.0
#![allow(dead_code)]
//! USD export v2 with composition arc support.

#[allow(dead_code)]
pub struct UsdPrimV2 {
    pub path: String,
    pub kind: String,
    pub attributes: Vec<(String, String)>,
}

#[allow(dead_code)]
pub struct UsdExportV2 {
    pub prims: Vec<UsdPrimV2>,
    pub up_axis: char,
}

#[allow(dead_code)]
pub fn new_usd_export_v2(up_axis: char) -> UsdExportV2 {
    UsdExportV2 { prims: Vec::new(), up_axis }
}

#[allow(dead_code)]
pub fn usd2_add_prim(e: &mut UsdExportV2, path: &str, kind: &str) -> usize {
    let idx = e.prims.len();
    e.prims.push(UsdPrimV2 { path: path.to_string(), kind: kind.to_string(), attributes: Vec::new() });
    idx
}

#[allow(dead_code)]
pub fn usd2_set_attr(e: &mut UsdExportV2, prim_idx: usize, key: &str, value: &str) {
    if prim_idx < e.prims.len() {
        e.prims[prim_idx].attributes.push((key.to_string(), value.to_string()));
    }
}

#[allow(dead_code)]
pub fn usd2_prim_count(e: &UsdExportV2) -> usize {
    e.prims.len()
}

#[allow(dead_code)]
pub fn usd2_to_usda(e: &UsdExportV2) -> String {
    let mut out = format!("#usda 1.0\n(\n    upAxis = \"{}\"\n)\n\n", e.up_axis);
    for prim in &e.prims {
        out.push_str(&format!("def {} \"{}\"\n{{\n", prim.kind, prim.path));
        for (k, v) in &prim.attributes {
            out.push_str(&format!("    {} = {}\n", k, v));
        }
        out.push_str("}\n\n");
    }
    out
}

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

    #[test]
    fn test_new() {
        let e = new_usd_export_v2('Y');
        assert_eq!(e.up_axis, 'Y');
        assert_eq!(usd2_prim_count(&e), 0);
    }

    #[test]
    fn test_add_prim() {
        let mut e = new_usd_export_v2('Y');
        let idx = usd2_add_prim(&mut e, "/World/Mesh", "Mesh");
        assert_eq!(idx, 0);
        assert_eq!(usd2_prim_count(&e), 1);
    }

    #[test]
    fn test_set_attr() {
        let mut e = new_usd_export_v2('Y');
        usd2_add_prim(&mut e, "/World/Mesh", "Mesh");
        usd2_set_attr(&mut e, 0, "faceVertexCounts", "[]");
        assert_eq!(e.prims[0].attributes.len(), 1);
    }

    #[test]
    fn test_prim_count() {
        let mut e = new_usd_export_v2('Y');
        for i in 0..3 {
            usd2_add_prim(&mut e, &format!("/p{}", i), "Xform");
        }
        assert_eq!(usd2_prim_count(&e), 3);
    }

    #[test]
    fn test_to_usda_contains_magic() {
        let e = new_usd_export_v2('Y');
        let s = usd2_to_usda(&e);
        assert!(s.contains("#usda"));
    }

    #[test]
    fn test_to_usda_contains_prim() {
        let mut e = new_usd_export_v2('Y');
        usd2_add_prim(&mut e, "/World", "Xform");
        let s = usd2_to_usda(&e);
        assert!(s.contains("/World"));
    }

    #[test]
    fn test_to_usda_up_axis() {
        let e = new_usd_export_v2('Z');
        let s = usd2_to_usda(&e);
        assert!(s.contains("upAxis"));
    }

    #[test]
    fn test_attr_in_usda() {
        let mut e = new_usd_export_v2('Y');
        usd2_add_prim(&mut e, "/Mesh", "Mesh");
        usd2_set_attr(&mut e, 0, "extent", "[(0,0,0),(1,1,1)]");
        let s = usd2_to_usda(&e);
        assert!(s.contains("extent"));
    }
}