simple-wgpu 0.3.0

Ergonomic wrapper around wgpu-rs
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


use crate::context::Context;

/// A texture sampler
///
/// Samplers configure texture addressing and filtering modes.
///
/// Equivalent to [wgpu::Sampler]
#[derive(Clone, PartialEq, Eq, Hash, Debug)]
pub struct Sampler {
    clamp: bool,
    linear: bool,
    mipmap_linear: bool,
}

impl Sampler {
    pub(crate) fn sampler_type(&self) -> wgpu::SamplerBindingType {
        if self.linear || self.mipmap_linear {
            wgpu::SamplerBindingType::Filtering
        } else {
            wgpu::SamplerBindingType::NonFiltering
        }
    }

    pub(crate) fn get_or_build(&self, context: &Context) -> wgpu::Sampler {
        let mut sampler_cache = context.caches.sampler_cache.borrow_mut();

        let address_mode = if self.clamp {
            wgpu::AddressMode::ClampToEdge
        } else {
            wgpu::AddressMode::Repeat
        };

        let filter = if self.linear {
            wgpu::FilterMode::Linear
        } else {
            wgpu::FilterMode::Nearest
        };

        let mipmap_filter = if self.mipmap_linear {
            wgpu::FilterMode::Linear
        } else {
            wgpu::FilterMode::Nearest
        };

        sampler_cache
            .get_or_insert_with(self.clone(), || {
                context.device().create_sampler(&wgpu::SamplerDescriptor {
                    label: Some("mip"),
                    address_mode_u: address_mode,
                    address_mode_v: address_mode,
                    address_mode_w: address_mode,
                    mag_filter: filter,
                    min_filter: filter,
                    mipmap_filter,
                    ..Default::default()
                })
            })
            .clone()
    }
}

/// Builds a [Sampler]
pub struct SamplerBuilder {
    clamp: bool,
    linear: bool,
    mipmap_linear: bool,
}

impl SamplerBuilder {
    pub fn new() -> Self {
        Self {
            clamp: true,
            linear: true,
            mipmap_linear: true,
        }
    }

    pub fn clamp(mut self) -> Self {
        self.clamp = true;
        self
    }

    pub fn wrap(mut self) -> Self {
        self.clamp = false;
        self
    }

    pub fn linear(mut self) -> Self {
        self.linear = true;
        self
    }
    pub fn nearest(mut self) -> Self {
        self.linear = false;
        self
    }

    pub fn mipmap_linear(mut self) -> Self {
        self.mipmap_linear = true;
        self
    }
    pub fn mipmap_nearest(mut self) -> Self {
        self.mipmap_linear = false;
        self
    }

    pub fn build(self) -> Sampler {
        Sampler {
            clamp: self.clamp,
            linear: self.linear,
            mipmap_linear: self.mipmap_linear,
        }
    }
}