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

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

#[derive(Debug, Clone)]
pub struct MipLevelView {
    pub current_mip: u32,
    pub max_mip: u32,
    pub enabled: bool,
}

pub fn new_mip_level_view() -> MipLevelView {
    MipLevelView {
        current_mip: 0,
        max_mip: 8,
        enabled: false,
    }
}

pub fn mlv_set_mip(v: &mut MipLevelView, mip: u32) {
    v.current_mip = mip.min(v.max_mip);
}

pub fn mlv_enable(v: &mut MipLevelView) {
    v.enabled = true;
}

pub fn mlv_mip_color(v: &MipLevelView) -> [f32; 3] {
    /* each mip level gets a unique hue */
    let t = if v.max_mip == 0 {
        0.0
    } else {
        v.current_mip as f32 / v.max_mip as f32
    };
    let r = (t * 2.0 - 1.0).clamp(0.0, 1.0);
    let g = (1.0 - (t * 2.0 - 1.0).abs()).clamp(0.0, 1.0);
    let b = (1.0 - t * 2.0).clamp(0.0, 1.0);
    [r, g, b]
}

pub fn mlv_level_count(v: &MipLevelView) -> u32 {
    v.max_mip + 1
}

pub fn mlv_is_enabled(v: &MipLevelView) -> bool {
    v.enabled
}

pub fn mlv_to_json(v: &MipLevelView) -> String {
    format!(
        r#"{{"current_mip":{},"max_mip":{},"enabled":{}}}"#,
        v.current_mip, v.max_mip, v.enabled
    )
}

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

    #[test]
    fn test_new_defaults() {
        /* new at mip 0, disabled */
        let v = new_mip_level_view();
        assert_eq!(v.current_mip, 0);
        assert!(!v.enabled);
    }

    #[test]
    fn test_set_mip() {
        /* mip stored */
        let mut v = new_mip_level_view();
        mlv_set_mip(&mut v, 3);
        assert_eq!(v.current_mip, 3);
    }

    #[test]
    fn test_set_mip_clamped() {
        /* mip clamped to max */
        let mut v = new_mip_level_view();
        mlv_set_mip(&mut v, 100);
        assert_eq!(v.current_mip, v.max_mip);
    }

    #[test]
    fn test_enable() {
        /* enable sets flag */
        let mut v = new_mip_level_view();
        mlv_enable(&mut v);
        assert!(mlv_is_enabled(&v));
    }

    #[test]
    fn test_mip_color_range() {
        /* color components in [0,1] */
        let v = new_mip_level_view();
        let c = mlv_mip_color(&v);
        for ch in c {
            assert!((0.0..=1.0).contains(&ch));
        }
    }

    #[test]
    fn test_level_count() {
        /* max_mip=8 => 9 levels */
        let v = new_mip_level_view();
        assert_eq!(mlv_level_count(&v), 9);
    }

    #[test]
    fn test_to_json() {
        /* JSON has current_mip */
        let v = new_mip_level_view();
        assert!(mlv_to_json(&v).contains("current_mip"));
    }

    #[test]
    fn test_to_json_enabled_false() {
        /* new view JSON shows disabled */
        let v = new_mip_level_view();
        assert!(mlv_to_json(&v).contains("false"));
    }

    #[test]
    fn test_clone() {
        /* clone independent */
        let v = new_mip_level_view();
        let v2 = v.clone();
        assert_eq!(v.max_mip, v2.max_mip);
    }
}