[add] buffer allocations.

Author: vmarcella

crates/lambda-platform/src/gfx/buffer.rs

@@ -1,15 +1,33 @@
-pub struct Buffer;
+use gfx_hal::{
+  memory::SparseFlags,
+  Backend,
+};
+
+use super::gpu::Gpu;
+
+// Reuse gfx-hal buffer usage & properties for now.
+pub type Usage = gfx_hal::buffer::Usage;
+pub type Properties = gfx_hal::memory::Properties;
+
+/// A buffer is a block of memory that can be used to store data that can be
+/// accessed by the GPU.
+pub struct Buffer<RenderBackend: super::internal::Backend> {
+  buffer: RenderBackend::Buffer,
+  memory: RenderBackend::Memory,
+}
 
 pub struct BufferBuilder {
   buffer_length: usize,
-  usage: gfx_hal::buffer::Usage,
+  usage: Usage,
+  properties: Properties,
 }
 
 impl BufferBuilder {
   pub fn new() -> Self {
     return Self {
       buffer_length: 0,
       usage: gfx_hal::buffer::Usage::empty(),
+      properties: gfx_hal::memory::Properties::empty(),
     };
   }
 
@@ -18,15 +36,79 @@ impl BufferBuilder {
     return self;
   }
 
-  pub fn with_usage(&mut self, usage: gfx_hal::buffer::Usage) -> &mut Self {
+  pub fn with_usage(&mut self, usage: Usage) -> &mut Self {
     self.usage = usage;
     return self;
   }
 
+  pub fn with_properties(&mut self, properties: Properties) -> &mut Self {
+    return self;
+  }
+
   pub fn build<RenderBackend: super::internal::Backend>(
     self,
-    device: &mut RenderBackend::Device,
-  ) -> Buffer {
-    todo!();
+    gpu: &mut Gpu<RenderBackend>,
+  ) -> Result<Buffer<RenderBackend>, &'static str> {
+    use gfx_hal::{
+      adapter::PhysicalDevice,
+      device::Device,
+      MemoryTypeId,
+    };
+    let logical_device = super::internal::logical_device_for(gpu);
+    let physical_device = super::internal::physical_device_for(gpu);
+
+    // Allocate buffer
+    let mut buffer_result = unsafe {
+      logical_device.create_buffer(
+        self.buffer_length as u64,
+        self.usage,
+        SparseFlags::empty(),
+      )
+    };
+
+    if buffer_result.is_err() {
+      return Err("Failed to create buffer for allocating memory.");
+    }
+
+    let mut buffer = buffer_result.unwrap();
+
+    let requirements =
+      unsafe { logical_device.get_buffer_requirements(&buffer) };
+    let memory_types = physical_device.memory_properties().memory_types;
+
+    // Find a memory type that supports the requirements of the buffer.
+    let memory_type = memory_types
+      .iter()
+      .enumerate()
+      .find(|(id, memory_type)| {
+        let type_supported = requirements.type_mask & (1 << id) != 0;
+        type_supported && memory_type.properties.contains(self.properties)
+      })
+      .map(|(id, _)| MemoryTypeId(id))
+      .unwrap();
+
+    let buffer_memory_allocation =
+      unsafe { logical_device.allocate_memory(memory_type, requirements.size) };
+
+    if buffer_memory_allocation.is_err() {
+      return Err("Failed to allocate memory for buffer.");
+    }
+
+    let buffer_memory = buffer_memory_allocation.unwrap();
+
+    let buffer_binding = unsafe {
+      logical_device.bind_buffer_memory(&buffer_memory, 0, &mut buffer)
+    };
+
+    // Destroy the buffer if we failed to bind it to memory.
+    if buffer_binding.is_err() {
+      unsafe { logical_device.destroy_buffer(buffer) };
+      return Err("Failed to bind buffer memory.");
+    }
+
+    return Ok(Buffer {
+      buffer,
+      memory: buffer_memory,
+    });
   }
 }

crates/lambda-platform/src/vertex.rs

@@ -128,14 +128,13 @@ impl Component for PushConstantsExample {
   }
 
   /// Update the frame number every frame.
-  fn on_update(&mut self, last_frame: &std::time::Duration) {
-    self.frame_number += 1;
-  }
+  fn on_update(&mut self, last_frame: &std::time::Duration) {}
 
   fn on_render(
     &mut self,
     render_context: &mut lambda::core::render::RenderContext,
   ) -> Vec<lambda::core::render::command::RenderCommand> {
+    self.frame_number += 1;
     let mut camera = [0.0, 0.0, -2.0];
     let view: [[f32; 4]; 4] = matrix::translation_matrix(camera);