despero 0.1.0

Rusty game engine, using API Vulkan and implementing paradigm of ECS
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

use std::mem::size_of;
use gpu_allocator::vulkan::*;
use gpu_allocator::MemoryLocation;
use ash::vk;

#[derive(Debug)]
pub struct Buffer {
    pub buffer: vk::Buffer,
    pub allocation: Option<Allocation>,
    allocation_name: String,
    size_in_bytes: u64,
    buffer_usage: vk::BufferUsageFlags,
    memory_location: MemoryLocation,
}

impl Buffer {
    pub fn new(
        logical_device: &ash::Device,
        allocator: &mut gpu_allocator::vulkan::Allocator,
        size_in_bytes: u64,
        buffer_usage: vk::BufferUsageFlags,
        memory_location: MemoryLocation,
        alloc_name: &str,
    ) -> Result<Buffer, vk::Result> {
        //Buffer creating
        let buffer = unsafe { logical_device.create_buffer(
            &vk::BufferCreateInfo::builder()
                .size(size_in_bytes)
                .usage(buffer_usage),
            None
        ) }?;
        // Buffer memory requirements
        let requirements = unsafe { logical_device.get_buffer_memory_requirements(buffer) };
        // Allocation info
        let allocation_info = &AllocationCreateDesc {
            name: alloc_name,
            requirements,
            location: memory_location,
            linear: true,
        };
        // Create memory allocation
        let allocation = allocator.allocate(allocation_info).unwrap();
        // Bind memory allocation to the buffer
        unsafe { logical_device.bind_buffer_memory(
            buffer, 
            allocation.memory(), 
            allocation.offset()).unwrap() 
        };
        
        Ok(Buffer {
            buffer,
            allocation: Some(allocation),
            allocation_name: String::from(alloc_name),
            size_in_bytes,
            buffer_usage,
            memory_location,
        })
    }
    
    pub fn fill<T: Sized>(
        &mut self,
        logical_device: &ash::Device,
        allocator: &mut gpu_allocator::vulkan::Allocator,
        data: &[T],
    ) -> Result<(), vk::Result> {
        let bytes_to_write = (data.len() * size_of::<T>()) as u64;
        if bytes_to_write > self.size_in_bytes {            
            let mut alloc: Option<Allocation> = None;
            std::mem::swap(&mut alloc, &mut self.allocation);
            let alloc = alloc.unwrap();
            allocator.free(alloc).unwrap();
            unsafe { logical_device.destroy_buffer(self.buffer, None); }
            
            let newbuffer = Buffer::new(
                logical_device,
                allocator,
                bytes_to_write,
                self.buffer_usage,
                self.memory_location,
                self.allocation_name.as_str(),
            )?;
            *self = newbuffer;
        }
        
        // Get memory pointer
        let data_ptr = self.allocation.as_ref().unwrap().mapped_ptr().unwrap().as_ptr() as *mut T;
        // Write to the buffer
        unsafe { data_ptr.copy_from_nonoverlapping(data.as_ptr(), data.len()) };
        Ok(())
    }
}