mepeyew 0.3.5

mepeyew - Small But Powerful Graphics Library
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

use super::*;
use std::collections::HashMap;

impl WebGpuContext {
    pub fn get_sampler(&mut self, ext: Option<GetSamplerExt>) -> GResult<SamplerId> {
        let GetSamplerExt {
            min_filter,
            mag_filter,
            mip_filter,
            u_mode,
            v_mode,
            min_lod,
            max_lod,
        } = ext.unwrap_or_default();
        let data = SamplerData {
            min_filter,
            mag_filter,
            mip_filter,
            u_mode,
            v_mode,
            min_lod: min_lod.map(HashableF32::from_val),
            max_lod: max_lod.map(HashableF32::from_val),
        };
        self.sampler_cache
            .get_or_insert(&self.device, data)
            .map(SamplerId::from_id)
    }
}

//  We don't care about the f32 hashing edge cases.
#[derive(Clone, Copy, Hash, PartialEq, Eq)]
struct HashableF32(u32);

impl HashableF32 {
    fn from_val(val: f32) -> Self {
        HashableF32(val.to_bits())
    }

    fn get_val(&self) -> f32 {
        f32::from_bits(self.0)
    }
}

#[derive(Clone, Copy, Hash, Default, PartialEq, Eq)]
struct SamplerData {
    min_filter: SamplerFilter,
    mag_filter: SamplerFilter,
    u_mode: SamplerMode,
    v_mode: SamplerMode,
    min_lod: Option<HashableF32>,
    max_lod: Option<HashableF32>,
    mip_filter: MipSamplerFilter,
}

pub struct WebGpuSamplerCache {
    samplers: HashMap<SamplerData, GpuSampler>,
    sampler_datas: Vec<SamplerData>,
}

fn filter_into_webgpu(filter: SamplerFilter) -> GpuFilterMode {
    match filter {
        SamplerFilter::Nearest => GpuFilterMode::Nearest,
        SamplerFilter::Linear => GpuFilterMode::Linear,
    }
}

fn mode_into_webgpu(mode: SamplerMode) -> GpuAddressMode {
    match mode {
        SamplerMode::Repeat => GpuAddressMode::Repeat,
        //  TODO FIX: This variant does not exist yet!
        SamplerMode::ClampToBorder => GpuAddressMode::ClampToEdge,
        SamplerMode::ClampToEdge => GpuAddressMode::ClampToEdge,
        SamplerMode::Mirror => GpuAddressMode::MirrorRepeat,
    }
}

impl WebGpuSamplerCache {
    pub fn new() -> Self {
        Self {
            samplers: HashMap::new(),
            sampler_datas: Vec::new(),
        }
    }

    pub fn get(&self, sampler_id: SamplerId) -> Option<GpuSampler> {
        let data = self.sampler_datas.get(sampler_id.id())?;
        self.samplers.get(data).cloned()
    }

    fn get_or_insert(&mut self, device: &GpuDevice, data: SamplerData) -> GResult<usize> {
        if let Some(id) = self
            .sampler_datas
            .iter()
            .position(|&cached_data| cached_data == data)
        {
            Ok(id)
        } else {
            let mut sampler_info = GpuSamplerDescriptor::new();

            sampler_info
                .mipmap_filter(match data.mip_filter {
                    MipSamplerFilter::Nearest => GpuMipmapFilterMode::Nearest,
                    MipSamplerFilter::Linear => GpuMipmapFilterMode::Linear,
                })
                .min_filter(filter_into_webgpu(data.min_filter))
                .mag_filter(filter_into_webgpu(data.mag_filter))
                .address_mode_u(mode_into_webgpu(data.u_mode))
                .address_mode_v(mode_into_webgpu(data.v_mode));

            if let Some(lod) = data.min_lod {
                sampler_info.lod_min_clamp(lod.get_val());
            }
            if let Some(lod) = data.max_lod {
                sampler_info.lod_max_clamp(lod.get_val());
            }

            let sampler = device.create_sampler_with_descriptor(&sampler_info);

            let id = self.sampler_datas.len();
            self.sampler_datas.push(data);
            self.samplers.insert(data, sampler);

            Ok(id)
        }
    }
}