vulk-ext 0.1.18

Vulkan bindings for Rust, except only the bleeding edge features
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

use super::*;

#[derive(Clone, Copy, Debug)]
pub struct SamplerCreator(vk::SamplerCreateInfo);

impl SamplerCreator {
    #[must_use]
    pub fn new() -> Self {
        Self(vk::SamplerCreateInfo {
            s_type: vk::StructureType::SamplerCreateInfo,
            p_next: null(),
            flags: vk::SamplerCreateFlags::empty(),
            mag_filter: vk::Filter::Nearest,
            min_filter: vk::Filter::Nearest,
            mipmap_mode: vk::SamplerMipmapMode::Nearest,
            address_mode_u: vk::SamplerAddressMode::ClampToEdge,
            address_mode_v: vk::SamplerAddressMode::ClampToEdge,
            address_mode_w: vk::SamplerAddressMode::ClampToEdge,
            mip_lod_bias: 0.0,
            anisotropy_enable: vk::FALSE,
            max_anisotropy: 0.0,
            compare_enable: vk::FALSE,
            compare_op: vk::CompareOp::Always,
            min_lod: 0.0,
            max_lod: 0.0,
            border_color: vk::BorderColor::FloatTransparentBlack,
            unnormalized_coordinates: vk::FALSE,
        })
    }

    #[must_use]
    pub fn mag_filter(self, mag_filter: vk::Filter) -> Self {
        Self(vk::SamplerCreateInfo {
            mag_filter,
            ..self.0
        })
    }

    #[must_use]
    pub fn min_filter(self, min_filter: vk::Filter) -> Self {
        Self(vk::SamplerCreateInfo {
            min_filter,
            ..self.0
        })
    }

    #[must_use]
    pub fn mipmap_mode(self, mipmap_mode: vk::SamplerMipmapMode) -> Self {
        Self(vk::SamplerCreateInfo {
            mipmap_mode,
            ..self.0
        })
    }

    #[must_use]
    pub fn address_mode_uvw(self, address_mode: vk::SamplerAddressMode) -> Self {
        Self(vk::SamplerCreateInfo {
            address_mode_u: address_mode,
            address_mode_v: address_mode,
            address_mode_w: address_mode,
            ..self.0
        })
    }

    pub unsafe fn create(self, device: &Device) -> Result<(vk::Sampler, vk::SamplerCreateInfo)> {
        let sampler_create_info = self.0;
        let sampler = device.create_sampler(&raw const sampler_create_info)?;
        Ok((sampler, sampler_create_info))
    }
}

impl Default for SamplerCreator {
    fn default() -> Self {
        Self::new()
    }
}

/// [`SamplerResource`] is meant to be used by a shader.
#[derive(Debug)]
pub struct SamplerResource {
    sampler: vk::Sampler,
    sampler_create_info: vk::SamplerCreateInfo,
    descriptor: Descriptor,
}

impl SamplerResource {
    pub unsafe fn create(
        physical_device: &PhysicalDevice,
        device: &Device,
        samplers: &[vk::Sampler],
        sampler_create_infos: &[vk::SamplerCreateInfo],
    ) -> Result<Vec<Self>> {
        // Validation.
        ensure!(!samplers.is_empty());
        ensure!(!sampler_create_infos.is_empty());
        ensure!(samplers.len() == sampler_create_infos.len());

        // Sampler resources.
        let mut sampler_resources = vec![];
        for i in 0..samplers.len() {
            let sampler = samplers[i];
            let sampler_create_info = sampler_create_infos[i];
            let descriptor = Descriptor::create(
                physical_device,
                device,
                DescriptorCreateInfo::Sampler(sampler),
            );
            sampler_resources.push(Self {
                sampler,
                sampler_create_info,
                descriptor,
            });
        }
        Ok(sampler_resources)
    }

    pub unsafe fn destroy(self, device: &Device) {
        device.destroy_sampler(self.sampler);
    }

    #[must_use]
    pub fn handle(&self) -> vk::Sampler {
        self.sampler
    }

    #[must_use]
    pub fn create_info(&self) -> &vk::SamplerCreateInfo {
        &self.sampler_create_info
    }

    #[must_use]
    pub fn descriptor(&self) -> Descriptor {
        self.descriptor
    }
}