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

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

//! Compositor node tree export settings.

/* ── legacy API (kept) ── */

pub struct CompositorExport {
    pub use_compositor: bool,
    pub use_sequencer: bool,
    pub use_nodes: bool,
    pub node_count: u32,
}

pub fn default_compositor_export() -> CompositorExport {
    CompositorExport {
        use_compositor: true,
        use_sequencer: false,
        use_nodes: true,
        node_count: 0,
    }
}

pub fn export_compositor_to_json(c: &CompositorExport) -> String {
    format!(
        r#"{{"use_compositor":{},"use_sequencer":{},"use_nodes":{},"node_count":{}}}"#,
        c.use_compositor, c.use_sequencer, c.use_nodes, c.node_count
    )
}

/* ── spec functions (wave 150B) ── */

/// Spec-style compositor node.
#[derive(Debug, Clone)]
pub struct CompositorNode {
    pub name: String,
    pub node_type: String,
    pub inputs: Vec<String>,
    pub outputs: Vec<String>,
    pub is_output: bool,
}

/// Create a new `CompositorNode`.
pub fn new_compositor_node(name: &str, node_type: &str) -> CompositorNode {
    CompositorNode {
        name: name.to_string(),
        node_type: node_type.to_string(),
        inputs: Vec::new(),
        outputs: Vec::new(),
        is_output: false,
    }
}

/// Add an input socket name.
pub fn comp_push_input(node: &mut CompositorNode, input: &str) {
    node.inputs.push(input.to_string());
}

/// Add an output socket name.
pub fn comp_push_output(node: &mut CompositorNode, output: &str) {
    node.outputs.push(output.to_string());
}

/// Serialize a single node to JSON.
pub fn comp_node_to_json(n: &CompositorNode) -> String {
    format!(
        "{{\"name\":\"{}\",\"type\":\"{}\",\"inputs\":{},\"outputs\":{},\"is_output\":{}}}",
        n.name,
        n.node_type,
        n.inputs.len(),
        n.outputs.len(),
        n.is_output
    )
}

/// Serialize multiple nodes to a JSON array.
pub fn comp_nodes_to_json(nodes: &[CompositorNode]) -> String {
    let inner: Vec<String> = nodes.iter().map(comp_node_to_json).collect();
    format!("[{}]", inner.join(","))
}

/// Returns true if the node is an output node.
pub fn comp_node_is_output(n: &CompositorNode) -> bool {
    n.is_output
}

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

    #[test]
    fn test_new_compositor_node() {
        let n = new_compositor_node("output", "CompositorNodeComposite");
        assert_eq!(n.name, "output");
    }

    #[test]
    fn test_comp_push_input() {
        let mut n = new_compositor_node("n", "T");
        comp_push_input(&mut n, "Image");
        assert_eq!(n.inputs.len(), 1);
    }

    #[test]
    fn test_comp_push_output() {
        let mut n = new_compositor_node("n", "T");
        comp_push_output(&mut n, "Value");
        assert_eq!(n.outputs.len(), 1);
    }

    #[test]
    fn test_comp_node_to_json() {
        let n = new_compositor_node("blur", "Blur");
        let j = comp_node_to_json(&n);
        assert!(j.contains("blur"));
    }

    #[test]
    fn test_comp_node_is_output() {
        let mut n = new_compositor_node("out", "Composite");
        n.is_output = true;
        assert!(comp_node_is_output(&n));
    }
}