oxihuman-viewer 0.2.1

wgpu/WebGPU rendering adapter for OxiHuman
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

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

//! Shader node graph view.

/// A shader graph node.
#[derive(Debug, Clone)]
pub struct ShaderNode {
    pub id: u32,
    pub node_type: String,
    pub x: f32,
    pub y: f32,
}

/// An edge connecting two shader nodes.
#[derive(Debug, Clone)]
pub struct ShaderEdge {
    pub from_id: u32,
    pub to_id: u32,
}

/// State for the shader graph view.
#[derive(Debug, Clone)]
pub struct ShaderGraphView {
    pub nodes: Vec<ShaderNode>,
    pub edges: Vec<ShaderEdge>,
    pub zoom: f32,
    pub enabled: bool,
}

/// Create a new shader graph view.
pub fn new_shader_graph_view() -> ShaderGraphView {
    ShaderGraphView {
        nodes: Vec::new(),
        edges: Vec::new(),
        zoom: 1.0,
        enabled: true,
    }
}

/// Add a shader node.
pub fn sgv_add_node(v: &mut ShaderGraphView, id: u32, node_type: &str, x: f32, y: f32) {
    v.nodes.push(ShaderNode {
        id,
        node_type: node_type.to_string(),
        x,
        y,
    });
}

/// Connect two nodes with an edge.
pub fn sgv_connect(v: &mut ShaderGraphView, from: u32, to: u32) {
    v.edges.push(ShaderEdge {
        from_id: from,
        to_id: to,
    });
}

/// Clear all nodes and edges.
pub fn sgv_clear(v: &mut ShaderGraphView) {
    v.nodes.clear();
    v.edges.clear();
}

/// Set zoom level (clamped 0.1–10).
pub fn sgv_set_zoom(v: &mut ShaderGraphView, zoom: f32) {
    v.zoom = zoom.clamp(0.1, 10.0);
}

/// Serialise to JSON.
pub fn sgv_to_json(v: &ShaderGraphView) -> String {
    format!(
        r#"{{"nodes":{},"edges":{},"zoom":{:.2},"enabled":{}}}"#,
        v.nodes.len(),
        v.edges.len(),
        v.zoom,
        v.enabled
    )
}

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

    #[test]
    fn default_empty() {
        let v = new_shader_graph_view();
        assert!(v.nodes.is_empty() /* no nodes */);
    }

    #[test]
    fn add_node() {
        let mut v = new_shader_graph_view();
        sgv_add_node(&mut v, 1, "Texture2D", 0.0, 0.0);
        assert_eq!(v.nodes.len(), 1 /* one node */);
    }

    #[test]
    fn connect_creates_edge() {
        let mut v = new_shader_graph_view();
        sgv_connect(&mut v, 1, 2);
        assert_eq!(v.edges.len(), 1 /* one edge */);
    }

    #[test]
    fn clear_removes_all() {
        let mut v = new_shader_graph_view();
        sgv_add_node(&mut v, 1, "UV", 0.0, 0.0);
        sgv_connect(&mut v, 1, 2);
        sgv_clear(&mut v);
        assert!(v.nodes.is_empty() && v.edges.is_empty() /* cleared */);
    }

    #[test]
    fn zoom_clamps() {
        let mut v = new_shader_graph_view();
        sgv_set_zoom(&mut v, 0.0);
        assert!((v.zoom - 0.1).abs() < 1e-6 /* clamped to 0.1 */);
    }

    #[test]
    fn json_has_edges() {
        let v = new_shader_graph_view();
        assert!(sgv_to_json(&v).contains("edges") /* json has edges */);
    }

    #[test]
    fn enabled_default() {
        let v = new_shader_graph_view();
        assert!(v.enabled /* enabled */);
    }

    #[test]
    fn node_type_stored() {
        let mut v = new_shader_graph_view();
        sgv_add_node(&mut v, 1, "BRDF", 0.0, 0.0);
        assert_eq!(v.nodes[0].node_type, "BRDF" /* node type stored */);
    }
}