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
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

use ash::vk;
#[cfg(all(feature = "vma", not(feature = "gpu-allocator")))]
use vk_mem::Alloc;

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

pub struct Image {
    pub(crate) raw: vk::Image,
    #[cfg(all(feature = "vma", not(feature = "gpu-allocator")))]
    allocation: vk_mem::Allocation,
}

impl Image {
    pub fn destroy(&mut self, device: &Device) {
        unsafe {
            device
                .allocator
                .destroy_image(self.raw, &mut self.allocation);
        }
    }
}

pub struct ImageBuilder<'a> {
    pub device: &'a Device,
    pub create_info: vk::ImageCreateInfo<'static>,
    #[cfg(all(feature = "vma", not(feature = "gpu-allocator")))]
    pub alloc_info: vk_mem::AllocationCreateInfo,
}

impl<'a> ImageBuilder<'a> {
    pub fn depth(device: &'a Device, format: vk::Format, extent: vk::Extent2D) -> Self {
        Self {
            device,
            create_info: vk::ImageCreateInfo::default()
                .mip_levels(1)
                .initial_layout(vk::ImageLayout::UNDEFINED)
                .extent(extent.into())
                .format(format)
                .tiling(vk::ImageTiling::OPTIMAL)
                .samples(vk::SampleCountFlags::TYPE_1)
                .array_layers(1)
                .sharing_mode(vk::SharingMode::EXCLUSIVE)
                .usage(vk::ImageUsageFlags::DEPTH_STENCIL_ATTACHMENT)
                .image_type(vk::ImageType::TYPE_2D),
            alloc_info: vk_mem::AllocationCreateInfo {
                usage: vk_mem::MemoryUsage::AutoPreferDevice,
                ..Default::default()
            },
        }
    }

    #[allow(dead_code)]
    pub fn cube(device: &'a Device, format: vk::Format, extent: vk::Extent2D) -> Self {
        Self {
            device,
            create_info: vk::ImageCreateInfo::default()
                .mip_levels(1)
                .initial_layout(vk::ImageLayout::UNDEFINED)
                .extent(extent.into())
                .format(format)
                .tiling(vk::ImageTiling::OPTIMAL)
                .samples(vk::SampleCountFlags::TYPE_1)
                .array_layers(6)
                .sharing_mode(vk::SharingMode::EXCLUSIVE)
                .usage(vk::ImageUsageFlags::DEPTH_STENCIL_ATTACHMENT)
                .image_type(vk::ImageType::TYPE_2D)
                .flags(vk::ImageCreateFlags::CUBE_COMPATIBLE),
            alloc_info: vk_mem::AllocationCreateInfo {
                usage: vk_mem::MemoryUsage::AutoPreferDevice,
                ..Default::default()
            },
        }
    }

    #[allow(dead_code)]
    pub fn new_2d(device: &'a Device, format: vk::Format, extent: vk::Extent2D) -> Self {
        Self {
            device,
            create_info: vk::ImageCreateInfo::default()
                .mip_levels(1)
                .initial_layout(vk::ImageLayout::UNDEFINED)
                .extent(extent.into())
                .format(format)
                .tiling(vk::ImageTiling::OPTIMAL)
                .samples(vk::SampleCountFlags::TYPE_1)
                .array_layers(1)
                .sharing_mode(vk::SharingMode::EXCLUSIVE)
                .usage(vk::ImageUsageFlags::COLOR_ATTACHMENT)
                .image_type(vk::ImageType::TYPE_2D),
            alloc_info: vk_mem::AllocationCreateInfo {
                usage: vk_mem::MemoryUsage::AutoPreferDevice,
                ..Default::default()
            },
        }
    }

    #[allow(dead_code)]
    pub fn usage(mut self, usage: vk::ImageUsageFlags) -> Self {
        self.create_info = self.create_info.usage(usage);
        self
    }

    pub fn build(self) -> VulkanResult<Image> {
        let (image, allocation) = unsafe {
            profiling::scope!("vmaCreateImage");
            self.device
                .allocator
                .create_image(&self.create_info, &self.alloc_info)
                .map_err(VulkanError::Unknown)?
        };

        Ok(Image { raw: image, allocation })
    }
}