aluminium 0.1.0

vulkan-based graphics engine
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

use ash::vk;

use super::device::Device;
use super::{VulkanError, VulkanResult};

pub struct DescriptorPool {
    pub raw: vk::DescriptorPool,
}

impl DescriptorPool {
    pub fn create_descriptor_set(&self, device: &Device, layouts: &[vk::DescriptorSetLayout]) -> VulkanResult<Vec<vk::DescriptorSet>> {
        let desc = vk::DescriptorSetAllocateInfo::default()
            .descriptor_pool(self.raw)
            .set_layouts(layouts);

        unsafe {
            profiling::scope!("vkCreateDescriptorSet");
            device
                .allocate_descriptor_sets(&desc)
                .map_err(VulkanError::Unknown)
        }
    }
}

pub struct DescriptorPoolBuilder<'a> {
    device: &'a Device,
    flags: vk::DescriptorPoolCreateFlags,
    sizes: Option<&'a [vk::DescriptorPoolSize]>,
    max_sets: Option<u32>,
}

impl<'a> DescriptorPoolBuilder<'a> {
    pub fn new(device: &'a Device) -> Self {
        Self {
            device,
            flags: vk::DescriptorPoolCreateFlags::empty(),
            sizes: None,
            max_sets: None,
        }
    }

    pub fn flags(mut self, flags: vk::DescriptorPoolCreateFlags) -> Self {
        self.flags = flags;
        self
    }

    pub fn pool_sizes(mut self, sizes: &'a [vk::DescriptorPoolSize]) -> Self {
        self.sizes = Some(sizes);
        self
    }

    pub fn max_sets(mut self, sets: u32) -> Self {
        self.max_sets = Some(sets);
        self
    }

    pub fn build(self) -> VulkanResult<DescriptorPool> {
        let sizes = self.sizes.expect("Missing DescriptorPoolSizes");
        let max_sets = self.max_sets.expect("Missing Max sets");
        let flags = self.flags;

        #[cfg(debug_assertions)]
        {
            if max_sets == 0 {
                panic!("DescriptorPool max sets cannot be 0");
            }

            if sizes.is_empty() {
                panic!("DescriptorPool must have at least one pool size");
            }
        }

        let create_info = vk::DescriptorPoolCreateInfo::default()
            .flags(flags)
            .pool_sizes(sizes)
            .max_sets(max_sets);

        let pool = unsafe {
            profiling::scope!("vkCreateDescriptorPool");
            self.device
                .create_descriptor_pool(&create_info, None)
                .map_err(VulkanError::Unknown)
        }?;

        Ok(DescriptorPool { raw: pool })
    }
}