vulkanalia-vma 0.9.0

An integration of Vulkan Memory Allocator with vulkanalia.
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
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156

// SPDX-License-Identifier: Apache-2.0

use alloc::sync::Arc;
use core::ffi::CStr;
use core::marker::PhantomData;
use core::mem;
use core::ptr::NonNull;

use vulkanalia::prelude::v1_0::*;
use vulkanalia::{ResultExt, VkResult};

use crate::allocator::Allocator;
use crate::flags::PoolCreateFlags;
use crate::vma::*;

#[derive(Copy, Clone, Debug)]
pub struct PoolHandle(pub(crate) VmaPool);

impl PoolHandle {
    pub const DEFAULT: Self = Self(core::ptr::null_mut());
}

unsafe impl Send for PoolHandle {}
unsafe impl Sync for PoolHandle {}

#[derive(Copy, Clone, Debug)]
pub struct PoolOptions<'a> {
    pub memory_type_index: u32,
    pub flags: PoolCreateFlags,
    pub block_size: vk::DeviceSize,
    pub min_block_count: usize,
    pub max_block_count: usize,
    pub priority: f32,
    pub min_allocation_alignment: vk::DeviceSize,
    pub next: *mut core::ffi::c_void,
    _marker: PhantomData<&'a ()>,
}

impl<'a> PoolOptions<'a> {
    pub fn push_next<T>(mut self, next: &'a mut impl vk::Cast<Target = T>) -> Self
    where
        T: vk::ExtendsMemoryAllocateInfo,
    {
        self.next = vk::merge(self.next, NonNull::from(next).cast());
        self
    }
}

impl Default for PoolOptions<'_> {
    fn default() -> Self {
        Self {
            memory_type_index: 0,
            flags: PoolCreateFlags::empty(),
            block_size: 0,
            min_block_count: 0,
            max_block_count: 0,
            priority: 0.0,
            min_allocation_alignment: 0,
            next: core::ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

#[derive(Clone, Debug)]
pub struct Pool {
    pub(crate) allocator: Arc<Allocator>,
    pub(crate) handle: PoolHandle,
}

impl Allocator {
    pub fn create_pool(self: &Arc<Self>, options: &PoolOptions) -> VkResult<Pool> {
        let info = VmaPoolCreateInfo {
            memoryTypeIndex: options.memory_type_index,
            flags: options.flags.bits(),
            blockSize: options.block_size,
            minBlockCount: options.min_block_count,
            maxBlockCount: options.max_block_count,
            priority: options.priority,
            minAllocationAlignment: options.min_allocation_alignment,
            pMemoryAllocateNext: options.next,
        };

        let handle = unsafe {
            let mut pool: VmaPool = mem::zeroed();
            vmaCreatePool(self.0, &info, &mut pool).result()?;
            PoolHandle(pool)
        };

        Ok(Pool {
            allocator: self.clone(),
            handle,
        })
    }

    pub fn get_default_pool(self: &Arc<Self>) -> Pool {
        Pool {
            allocator: self.clone(),
            handle: PoolHandle::DEFAULT,
        }
    }
}

impl Pool {
    pub fn name(&self) -> Option<&CStr> {
        if self.handle.0.is_null() {
            return None;
        }

        unsafe {
            let mut name = core::ptr::null();
            vmaGetPoolName(self.allocator.0, self.handle.0, &mut name);
            if !name.is_null() {
                Some(CStr::from_ptr(name))
            } else {
                None
            }
        }
    }

    pub fn set_name(&self, name: Option<&CStr>) {
        if self.handle.0.is_null() {
            return;
        }

        let name = name.map_or(core::ptr::null(), CStr::as_ptr);
        unsafe { vmaSetPoolName(self.allocator.0, self.handle.0, name) };
    }

    pub fn get_statistics(&self) -> VkResult<VmaStatistics> {
        unsafe {
            let mut statistics: VmaStatistics = mem::zeroed();
            vmaGetPoolStatistics(self.allocator.0, self.handle.0, &mut statistics);
            Ok(statistics)
        }
    }

    pub fn calculate_statistics(&self) -> VkResult<VmaDetailedStatistics> {
        unsafe {
            let mut statistics: VmaDetailedStatistics = mem::zeroed();
            vmaCalculatePoolStatistics(self.allocator.0, self.handle.0, &mut statistics);
            Ok(statistics)
        }
    }

    pub fn check_corruption(&self) -> VkResult<()> {
        unsafe { vmaCheckPoolCorruption(self.allocator.0, self.handle.0).result() }
    }
}

impl Drop for Pool {
    fn drop(&mut self) {
        unsafe { vmaDestroyPool(self.allocator.0, self.handle.0) };
        self.handle = PoolHandle::DEFAULT;
    }
}