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

use super::*;
use std::mem::ManuallyDrop;

pub const VK_COLOR_ATTACHMENT_FORMAT: vk::Format = vk::Format::R8G8B8A8_SRGB;
pub const VK_DEPTH_ATTACHMENT_FORMAT: vk::Format = vk::Format::D32_SFLOAT_S8_UINT;

pub struct VkImage {
    pub image: vk::Image,
    pub format: vk::Format,
    pub view_aspect: vk::ImageAspectFlags,
    pub allocation: ManuallyDrop<Allocation>,

    drop_queue_ref: VkDropQueueRef,
}

impl VkImage {
    pub fn new(
        dev: &Device,
        drop_queue_ref: &VkDropQueueRef,
        alloc: &mut Allocator,
        format: vk::Format,
        usage: vk::ImageUsageFlags,
        view_aspect: vk::ImageAspectFlags,
        samples: vk::SampleCountFlags,
        mip_levels: u32,
        is_cubemap: bool,
        extent: vk::Extent3D,
    ) -> GResult<Self> {
        let image_create = vk::ImageCreateInfo::builder()
            .format(format)
            .usage(usage)
            .extent(extent)
            .image_type(vk::ImageType::TYPE_2D)
            .mip_levels(mip_levels)
            .array_layers(if is_cubemap { 6 } else { 1 })
            .flags(if is_cubemap {
                vk::ImageCreateFlags::CUBE_COMPATIBLE
            } else {
                vk::ImageCreateFlags::empty()
            })
            .samples(samples)
            .tiling(vk::ImageTiling::OPTIMAL)
            .build();

        let image = unsafe { dev.create_image(&image_create, None) }.unwrap();
        let requirements = unsafe { dev.get_image_memory_requirements(image) };

        let allocation = alloc
            .allocate(&AllocationCreateDesc {
                //  TODO EXT: Allow the naming of buffers.
                name: "Vulkan Generic Buffer",
                requirements,
                location: MemoryLocation::GpuOnly,
                linear: true,
                allocation_scheme: AllocationScheme::GpuAllocatorManaged
            })
            .unwrap();

        unsafe {
            dev.bind_image_memory(image, allocation.memory(), allocation.offset())
                .map_err(|e| gpu_api_err!("vulkan image bind {}", e))?;
        };

        Ok(VkImage {
            image,
            format,
            allocation: ManuallyDrop::new(allocation),
            view_aspect,

            drop_queue_ref: Arc::clone(drop_queue_ref),
        })
    }
}

impl Drop for VkImage {
    fn drop(&mut self) {
        let image = self.image;
        let allocation = unsafe { ManuallyDrop::take(&mut self.allocation) };
        self.drop_queue_ref
            .lock()
            .unwrap()
            .push(Box::new(move |dev, alloc| unsafe {
                alloc.free(allocation).unwrap();
                dev.destroy_image(image, None);
            }));
    }
}

pub fn new_image_view(
    dev: &Device,
    image: vk::Image,
    format: vk::Format,
    aspect: vk::ImageAspectFlags,
    mip_level: u32,
    is_cubemap: bool,
) -> GResult<vk::ImageView> {
    let image_view_create = vk::ImageViewCreateInfo::builder()
        .image(image)
        .format(format)
        .components(
            vk::ComponentMapping::builder()
                .r(vk::ComponentSwizzle::IDENTITY)
                .g(vk::ComponentSwizzle::IDENTITY)
                .b(vk::ComponentSwizzle::IDENTITY)
                .a(vk::ComponentSwizzle::IDENTITY)
                .build(),
        )
        .subresource_range(
            vk::ImageSubresourceRange::builder()
                .aspect_mask(aspect)
                .base_mip_level(0)
                .level_count(mip_level)
                .base_array_layer(0)
                .layer_count(if is_cubemap { 6 } else { 1 })
                .build(),
        )
        .view_type(if is_cubemap {
            vk::ImageViewType::CUBE
        } else {
            vk::ImageViewType::TYPE_2D
        })
        .build();
    unsafe { dev.create_image_view(&image_view_create, None) }
        .map_err(|e| gpu_api_err!("vulkan image view init {}", e))
}