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

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

//! Status bar info view.

/// An info segment in the status bar.
#[derive(Debug, Clone)]
pub struct StatusSegment {
    pub key: String,
    pub value: String,
}

/// State for the status bar view.
#[derive(Debug, Clone)]
pub struct StatusBarView {
    pub segments: Vec<StatusSegment>,
    pub message: String,
    pub show_memory: bool,
    pub enabled: bool,
}

/// Create a new status bar view.
pub fn new_status_bar_view() -> StatusBarView {
    StatusBarView {
        segments: Vec::new(),
        message: String::new(),
        show_memory: true,
        enabled: true,
    }
}

/// Set the status message.
pub fn sbv_set_message(v: &mut StatusBarView, msg: &str) {
    v.message = msg.to_string();
}

/// Add an info segment.
pub fn sbv_add_segment(v: &mut StatusBarView, key: &str, value: &str) {
    v.segments.push(StatusSegment {
        key: key.to_string(),
        value: value.to_string(),
    });
}

/// Update a segment value by key.
pub fn sbv_update_segment(v: &mut StatusBarView, key: &str, value: &str) {
    if let Some(s) = v.segments.iter_mut().find(|s| s.key == key) {
        s.value = value.to_string();
    }
}

/// Build a display string from all segments.
pub fn sbv_display_string(v: &StatusBarView) -> String {
    v.segments
        .iter()
        .map(|s| format!("{}: {}", s.key, s.value))
        .collect::<Vec<_>>()
        .join(" | ")
}

/// Serialise to JSON.
pub fn sbv_to_json(v: &StatusBarView) -> String {
    format!(
        r#"{{"message":"{}","segment_count":{},"enabled":{}}}"#,
        v.message,
        v.segments.len(),
        v.enabled
    )
}

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

    #[test]
    fn default_empty_message() {
        let v = new_status_bar_view();
        assert!(v.message.is_empty() /* empty message */);
    }

    #[test]
    fn set_message() {
        let mut v = new_status_bar_view();
        sbv_set_message(&mut v, "Ready");
        assert_eq!(v.message, "Ready" /* message set */);
    }

    #[test]
    fn add_segment() {
        let mut v = new_status_bar_view();
        sbv_add_segment(&mut v, "FPS", "60");
        assert_eq!(v.segments.len(), 1 /* one segment */);
    }

    #[test]
    fn update_segment() {
        let mut v = new_status_bar_view();
        sbv_add_segment(&mut v, "FPS", "60");
        sbv_update_segment(&mut v, "FPS", "30");
        assert_eq!(v.segments[0].value, "30" /* updated */);
    }

    #[test]
    fn display_string_joined() {
        let mut v = new_status_bar_view();
        sbv_add_segment(&mut v, "FPS", "60");
        sbv_add_segment(&mut v, "Tris", "1000");
        let s = sbv_display_string(&v);
        assert!(s.contains("FPS: 60") && s.contains("Tris: 1000") /* both in string */);
    }

    #[test]
    fn json_has_message() {
        let mut v = new_status_bar_view();
        sbv_set_message(&mut v, "Loading");
        assert!(sbv_to_json(&v).contains("Loading") /* message in json */);
    }

    #[test]
    fn show_memory_default() {
        let v = new_status_bar_view();
        assert!(v.show_memory /* memory shown by default */);
    }

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