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

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

//! Cascaded shadow maps parameters.

#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ShadowCascadeV2 {
    pub near: f32,
    pub far: f32,
    pub bias: f32,
    pub resolution: u32,
}

#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ShadowCascadeSetV2 {
    pub cascades: Vec<ShadowCascadeV2>,
    pub num_cascades: usize,
}

#[allow(dead_code)]
pub fn new_shadow_cascade_set_v2(num_cascades: usize, near: f32, far: f32) -> ShadowCascadeSetV2 {
    let n = num_cascades.max(1);
    let range = far - near;
    let step = range / n as f32;
    let cascades = (0..n)
        .map(|i| ShadowCascadeV2 {
            near: near + i as f32 * step,
            far: near + (i + 1) as f32 * step,
            bias: 0.005,
            resolution: 1024,
        })
        .collect();
    ShadowCascadeSetV2 { cascades, num_cascades: n }
}

#[allow(dead_code)]
pub fn scsv2_cascade_count(set: &ShadowCascadeSetV2) -> usize {
    set.cascades.len()
}

#[allow(dead_code)]
pub fn scsv2_cascade_at(set: &ShadowCascadeSetV2, i: usize) -> &ShadowCascadeV2 {
    &set.cascades[i]
}

#[allow(dead_code)]
pub fn scsv2_set_bias(set: &mut ShadowCascadeSetV2, bias: f32) {
    for c in &mut set.cascades {
        c.bias = bias;
    }
}

#[allow(dead_code)]
pub fn scsv2_split_depth(set: &ShadowCascadeSetV2, i: usize) -> f32 {
    set.cascades[i].far
}

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

    #[test]
    fn test_cascade_count() {
        let s = new_shadow_cascade_set_v2(4, 0.1, 100.0);
        assert_eq!(scsv2_cascade_count(&s), 4);
    }

    #[test]
    fn test_cascade_at() {
        let s = new_shadow_cascade_set_v2(4, 0.0, 100.0);
        let c = scsv2_cascade_at(&s, 0);
        assert!((c.near - 0.0).abs() < 1e-5);
    }

    #[test]
    fn test_set_bias() {
        let mut s = new_shadow_cascade_set_v2(3, 0.1, 100.0);
        scsv2_set_bias(&mut s, 0.01);
        for c in &s.cascades {
            assert!((c.bias - 0.01).abs() < 1e-6);
        }
    }

    #[test]
    fn test_split_depth() {
        let s = new_shadow_cascade_set_v2(4, 0.0, 100.0);
        let depth = scsv2_split_depth(&s, 3);
        assert!((depth - 100.0).abs() < 1e-4);
    }

    #[test]
    fn test_near_less_than_far() {
        let s = new_shadow_cascade_set_v2(4, 0.1, 100.0);
        for c in &s.cascades {
            assert!(c.near < c.far);
        }
    }

    #[test]
    fn test_cascades_cover_range() {
        let s = new_shadow_cascade_set_v2(2, 0.0, 100.0);
        let first_near = scsv2_cascade_at(&s, 0).near;
        let last_far = scsv2_split_depth(&s, 1);
        assert!(first_near < 1.0);
        assert!((last_far - 100.0).abs() < 1e-4);
    }

    #[test]
    fn test_resolution_default() {
        let s = new_shadow_cascade_set_v2(1, 0.0, 10.0);
        assert_eq!(scsv2_cascade_at(&s, 0).resolution, 1024);
    }

    #[test]
    fn test_single_cascade() {
        let s = new_shadow_cascade_set_v2(1, 1.0, 50.0);
        assert_eq!(scsv2_cascade_count(&s), 1);
        assert!((scsv2_split_depth(&s, 0) - 50.0).abs() < 1e-4);
    }
}