rotex-vulkan 0.1.1

A Vulkan backend for rotex_core
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

use ash::vk;

use super::device::Device;
use crate::core::Instance;
use crate::error::{Error, ErrorKind};

pub struct RotexBuffer {
    handle: vk::Buffer,
    device_memory: vk::DeviceMemory,
    size: vk::DeviceSize,
}

impl RotexBuffer {
    pub fn new(
        instance: &Instance,
        device: &Device,
        size: vk::DeviceSize,
        usage: vk::BufferUsageFlags,
        properties: vk::MemoryPropertyFlags,
    ) -> Result<Self, Error> {
        let buffer_info = vk::BufferCreateInfo::default()
            .size(size)
            .usage(usage)
            .sharing_mode(vk::SharingMode::EXCLUSIVE);

        let handle = unsafe { device.logical_device().create_buffer(&buffer_info, None) }
            .map_err(ErrorKind::Vulkan)
            .map_err(Error::fatal)?;

        let requirements = unsafe { device.logical_device().get_buffer_memory_requirements(handle) };
        let memory_type =
            device.find_memory_type(instance, requirements.memory_type_bits, properties)?;

        let alloc_info = vk::MemoryAllocateInfo::default()
            .allocation_size(requirements.size)
            .memory_type_index(memory_type);

        let device_memory = unsafe { device.logical_device().allocate_memory(&alloc_info, None) }
            .map_err(ErrorKind::Vulkan)
            .map_err(Error::fatal)?;

        unsafe {
            device
                .logical_device()
                .bind_buffer_memory(handle, device_memory, 0)
        }
        .map_err(ErrorKind::Vulkan)
        .map_err(Error::fatal)?;

        Ok(Self {
            handle,
            device_memory,
            size,
        })
    }

    pub fn map(&self, device: &Device) -> Result<*mut std::ffi::c_void, Error> {
        unsafe {
            device.logical_device().map_memory(
                self.device_memory,
                0,
                self.size,
                vk::MemoryMapFlags::empty(),
            )
        }
        .map_err(ErrorKind::Vulkan)
        .map_err(Error::fatal)
    }

    pub fn unmap(&self, device: &Device) {
        unsafe { device.logical_device().unmap_memory(self.device_memory) };
    }

    pub fn handle(&self) -> vk::Buffer {
        self.handle
    }

    pub fn size(&self) -> vk::DeviceSize {
        self.size
    }

    pub fn destroy(&self, device: &Device) {
        unsafe {
            device.logical_device().destroy_buffer(self.handle, None);
            device
                .logical_device()
                .free_memory(self.device_memory, None);
        }
    }
}