[update] buffer to fill data upon being built, implement buffer allocation inside of mesh.

Author: vmarcella

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

@@ -1,5 +1,8 @@
 use gfx_hal::{
-  memory::SparseFlags,
+  memory::{
+    Segment,
+    SparseFlags,
+  },
   Backend,
 };
 
@@ -11,11 +14,14 @@ 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.
+#[derive(Debug, Clone, Copy)]
 pub struct Buffer<RenderBackend: super::internal::Backend> {
   buffer: RenderBackend::Buffer,
   memory: RenderBackend::Memory,
 }
 
+impl<RenderBackend: super::internal::Backend> Buffer<RenderBackend> {}
+
 pub struct BufferBuilder {
   buffer_length: usize,
   usage: Usage,
@@ -47,9 +53,12 @@ impl BufferBuilder {
 
   /// Builds & binds a buffer of memory to the GPU. If the buffer cannot be
   /// bound to the GPU, the buffer memory is freed before the error is returned.
-  pub fn build<RenderBackend: super::internal::Backend>(
-    self,
+  /// Data must represent the data that will be stored in the buffer, meaning
+  /// it must repr C and be the same size as the buffer length.
+  pub fn build<RenderBackend: super::internal::Backend, Data: Sized>(
+    &self,
     gpu: &mut Gpu<RenderBackend>,
+    data: Vec<Data>,
   ) -> Result<Buffer<RenderBackend>, &'static str> {
     use gfx_hal::{
       adapter::PhysicalDevice,
@@ -98,7 +107,7 @@ impl BufferBuilder {
       return Err("Failed to allocate memory for buffer.");
     }
 
-    let buffer_memory = buffer_memory_allocation.unwrap();
+    let mut buffer_memory = buffer_memory_allocation.unwrap();
 
     // Bind the buffer to the GPU memory
     let buffer_binding = unsafe {
@@ -111,6 +120,43 @@ impl BufferBuilder {
       return Err("Failed to bind buffer memory.");
     }
 
+    // Get address of the buffer memory on the GPU so that we can write to it.
+    let get_mapping_to_memory =
+      unsafe { logical_device.map_memory(&mut buffer_memory, Segment::ALL) };
+
+    if get_mapping_to_memory.is_err() {
+      unsafe { logical_device.destroy_buffer(buffer) };
+      return Err("Failed to map memory.");
+    }
+    let mapped_memory = get_mapping_to_memory.unwrap();
+
+    // Copy the data to the GPU memory.
+    unsafe {
+      std::ptr::copy_nonoverlapping(
+        data.as_ptr() as *const u8,
+        mapped_memory,
+        self.buffer_length,
+      );
+    };
+
+    // Flush the data to ensure it is written to the GPU memory.
+    let memory_flush = unsafe {
+      logical_device
+        .flush_mapped_memory_ranges(std::iter::once((
+          &buffer_memory,
+          Segment::ALL,
+        )))
+        .map_err(|_| "Failed to flush memory.")
+    };
+
+    if memory_flush.is_err() {
+      unsafe { logical_device.destroy_buffer(buffer) };
+      return Err("No memory available on the GPU.");
+    }
+
+    // Unmap the memory now that it's no longer needed by the CPU.
+    unsafe { logical_device.unmap_memory(&mut buffer_memory) };
+
     return Ok(Buffer {
       buffer,
       memory: buffer_memory,

lambda/src/core/render/mesh.rs

@@ -1,12 +1,24 @@
-use super::vertex::Vertex;
+use lambda_platform::gfx::buffer::{
+  Buffer,
+  BufferBuilder,
+  Properties,
+  Usage,
+};
+
+use super::{
+  vertex::Vertex,
+  RenderContext,
+};
+use crate::core::render::internal::mut_gpu_from_context;
 
 // ---------------------------------- Mesh ------------------------------------
 
 /// Collection of vertices and indices that define a 3D object.
-#[derive(Clone, Debug)]
+#[derive(Debug)]
 pub struct Mesh {
   vertices: Vec<Vertex>,
   indices: Vec<u32>,
+  buffer: Buffer<super::internal::RenderBackend>,
 }
 
 // ------------------------------ MeshBuilder ---------------------------------
@@ -38,11 +50,38 @@ impl MeshBuilder {
     return self;
   }
 
-  pub fn build(&self) -> Mesh {
-    return Mesh {
-      vertices: self.vertices.clone(),
-      indices: self.indices.clone(),
-    };
+  /// Builds a mesh from the vertices and indices that have been added to the
+  /// builder and allocates the memory for the mesh on the GPU.
+  pub fn build(
+    &self,
+    render_context: &mut RenderContext,
+  ) -> Result<Mesh, &'static str> {
+    let gpu_memory_required =
+      self.vertices.len() * std::mem::size_of::<Vertex>();
+    println!(
+      "Allocating {} bytes of GPU memory for mesh.",
+      gpu_memory_required
+    );
+
+    // Allocate memory for the mesh on the GPU.
+    let buffer_allocation = BufferBuilder::new()
+      .with_length(gpu_memory_required)
+      .with_usage(Usage::VERTEX)
+      .with_properties(Properties::CPU_VISIBLE | Properties::COHERENT)
+      .build(mut_gpu_from_context(render_context), self.vertices.clone());
+
+    match buffer_allocation {
+      Ok(buffer) => {
+        return Ok(Mesh {
+          vertices: self.vertices.clone(),
+          indices: self.indices.clone(),
+          buffer,
+        });
+      }
+      Err(error) => {
+        return Err(error);
+      }
+    }
   }
 }
 
@@ -54,16 +93,9 @@ mod tests {
 
     assert_eq!(mesh.vertices.len(), 0);
     assert_eq!(mesh.indices.len(), 0);
-
-    let mesh = mesh
-      .with_capacity(10)
-      .with_vertex(crate::core::render::vertex::VertexBuilder::new().build())
-      .build();
-
-    assert_eq!(mesh.vertices.len(), 1);
-    assert_eq!(mesh.indices.len(), 0);
-    assert_eq!(mesh.vertices[0].position, [0.0, 0.0, 0.0]);
-    assert_eq!(mesh.vertices[0].normal, [0.0, 0.0, 0.0]);
-    assert_eq!(mesh.vertices[0].color, [0.0, 0.0, 0.0]);
   }
+
+  // TODO(vmarcella): Add more tests for mesh building once the render context
+  // is mockable. As of right now, testing would require the creation of a real
+  // render context to perform the GPU memory allocation & binding for the mesh.
 }

lambda/src/core/render/vertex.rs

@@ -1,3 +1,4 @@
+#[repr(C)]
 #[derive(Clone, Copy, Debug)]
 pub struct Vertex {
   pub position: [f32; 3],