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

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

//! Shadow atlas texture packing.

#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ShadowAtlasRegion {
    pub x: u32,
    pub y: u32,
    pub size: u32,
}

#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ShadowAtlas {
    pub width: u32,
    pub height: u32,
    pub regions: Vec<ShadowAtlasRegion>,
}

#[allow(dead_code)]
pub fn new_shadow_atlas(width: u32, height: u32) -> ShadowAtlas {
    ShadowAtlas { width, height, regions: Vec::new() }
}

#[allow(dead_code)]
pub fn sa_allocate(atlas: &mut ShadowAtlas, size: u32) -> Option<ShadowAtlasRegion> {
    /* simple row packing: fill current row, then start new row */
    let mut x_cursor = 0u32;
    let mut y_cursor = 0u32;
    let mut row_h = 0u32;
    for r in &atlas.regions {
        if x_cursor + r.size > atlas.width {
            y_cursor += row_h;
            x_cursor = 0;
            row_h = 0;
        }
        x_cursor += r.size;
        if r.size > row_h {
            row_h = r.size;
        }
    }
    if x_cursor + size > atlas.width {
        y_cursor += row_h;
        x_cursor = 0;
    }
    if y_cursor + size > atlas.height {
        return None;
    }
    let region = ShadowAtlasRegion { x: x_cursor, y: y_cursor, size };
    atlas.regions.push(region.clone());
    Some(region)
}

#[allow(dead_code)]
pub fn sa_region_count(atlas: &ShadowAtlas) -> usize {
    atlas.regions.len()
}

#[allow(dead_code)]
pub fn sa_used_area(atlas: &ShadowAtlas) -> u32 {
    atlas.regions.iter().map(|r| r.size * r.size).sum()
}

#[allow(dead_code)]
pub fn sa_utilization(atlas: &ShadowAtlas) -> f32 {
    let total = atlas.width * atlas.height;
    if total == 0 { return 0.0; }
    sa_used_area(atlas) as f32 / total as f32
}

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

    #[test]
    fn test_allocate_returns_some() {
        let mut a = new_shadow_atlas(512, 512);
        let r = sa_allocate(&mut a, 128);
        assert!(r.is_some());
    }

    #[test]
    fn test_region_count_after_allocate() {
        let mut a = new_shadow_atlas(512, 512);
        sa_allocate(&mut a, 128);
        assert_eq!(sa_region_count(&a), 1);
    }

    #[test]
    fn test_used_area_single_region() {
        let mut a = new_shadow_atlas(512, 512);
        sa_allocate(&mut a, 128);
        assert_eq!(sa_used_area(&a), 128 * 128);
    }

    #[test]
    fn test_utilization_in_range() {
        let mut a = new_shadow_atlas(512, 512);
        sa_allocate(&mut a, 128);
        let u = sa_utilization(&a);
        assert!((0.0..=1.0).contains(&u));
    }

    #[test]
    fn test_utilization_zero_empty() {
        let a = new_shadow_atlas(512, 512);
        assert_eq!(sa_utilization(&a), 0.0);
    }

    #[test]
    fn test_multiple_allocations() {
        let mut a = new_shadow_atlas(512, 512);
        sa_allocate(&mut a, 128);
        sa_allocate(&mut a, 64);
        assert_eq!(sa_region_count(&a), 2);
    }

    #[test]
    fn test_allocate_too_large_returns_none() {
        let mut a = new_shadow_atlas(64, 64);
        let r = sa_allocate(&mut a, 128);
        assert!(r.is_none());
    }

    #[test]
    fn test_region_starts_at_origin() {
        let mut a = new_shadow_atlas(512, 512);
        let r = sa_allocate(&mut a, 128).expect("should succeed");
        assert_eq!(r.x, 0);
        assert_eq!(r.y, 0);
    }
}