gravitron 0.1.2

A GameEngine based on an ECS and Vulkan
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

use ash::vk;
use gpu_allocator::vulkan;

pub struct Buffer {
  pub buffer: vk::Buffer,
  pub allocation: vulkan::Allocation,
  pub size: u64,
}

impl Buffer {
  pub fn new(
    allocator: &mut vulkan::Allocator,
    device: &ash::Device,
    size: u64,
    usage: vk::BufferUsageFlags,
    memory_location: gpu_allocator::MemoryLocation,
  ) -> Result<Self, vk::Result> {
    let buffer_create_info = vk::BufferCreateInfo::default().size(size).usage(usage);
    let buffer = unsafe { device.create_buffer(&buffer_create_info, None) }?;
    let requirements = unsafe { device.get_buffer_memory_requirements(buffer) };

    let allocation_create_desc = vulkan::AllocationCreateDesc {
      requirements,
      location: memory_location,
      linear: true,
      allocation_scheme: vulkan::AllocationScheme::GpuAllocatorManaged,
      name: "Buffer",
    };
    let allocation = allocator.allocate(&allocation_create_desc).unwrap();

    unsafe { device.bind_buffer_memory(buffer, allocation.memory(), allocation.offset()) }?;

    Ok(Self {
      buffer,
      allocation,
      size,
    })
  }

  pub fn fill<T: Sized>(&mut self, data: &[T]) -> Result<(), vk::Result> {
    let bytes_to_write = std::mem::size_of_val(data) as u64;
    if bytes_to_write > self.size {
      return Err(vk::Result::ERROR_OUT_OF_HOST_MEMORY);
    }
    let data_ptr = self.allocation.mapped_ptr().unwrap().as_ptr() as *mut T;
    unsafe {
      data_ptr.copy_from_nonoverlapping(data.as_ptr(), data.len());
    }
    Ok(())
  }
}