[add] high level buffer implementation & introduce buffer types for use in the render pipeline.

Author: vmarcella

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

@@ -1,9 +1,6 @@
-use gfx_hal::{
-  memory::{
-    Segment,
-    SparseFlags,
-  },
-  Backend,
+use gfx_hal::memory::{
+  Segment,
+  SparseFlags,
 };
 
 use super::gpu::Gpu;
@@ -12,12 +9,21 @@ use super::gpu::Gpu;
 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 is accessed
+#[derive(Debug, Clone, Copy)]
+pub enum BufferType {
+  Vertex,
+  Index,
+}
+
 /// 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,
+  stride: usize,
+  buffer_type: BufferType,
 }
 
 impl<RenderBackend: super::internal::Backend> Buffer<RenderBackend> {}
@@ -26,14 +32,16 @@ pub struct BufferBuilder {
   buffer_length: usize,
   usage: Usage,
   properties: Properties,
+  buffer_type: BufferType,
 }
 
 impl BufferBuilder {
   pub fn new() -> Self {
     return Self {
       buffer_length: 0,
-      usage: gfx_hal::buffer::Usage::empty(),
-      properties: gfx_hal::memory::Properties::empty(),
+      usage: Usage::empty(),
+      properties: Properties::empty(),
+      buffer_type: BufferType::Vertex,
     };
   }
 
@@ -48,6 +56,12 @@ impl BufferBuilder {
   }
 
   pub fn with_properties(&mut self, properties: Properties) -> &mut Self {
+    self.properties = properties;
+    return self;
+  }
+
+  pub fn with_buffer_type(&mut self, buffer_type: BufferType) -> &mut Self {
+    self.buffer_type = buffer_type;
     return self;
   }
 
@@ -160,6 +174,8 @@ impl BufferBuilder {
     return Ok(Buffer {
       buffer,
       memory: buffer_memory,
+      stride: std::mem::size_of::<Data>(),
+      buffer_type: self.buffer_type,
     });
   }
 }

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

@@ -36,6 +36,7 @@ use std::ops::Range;
 use gfx_hal::device::Device;
 
 use super::{
+  buffer::Buffer,
   gpu::Gpu,
   shader::ShaderModule,
 };
@@ -58,6 +59,10 @@ impl<RenderBackend: internal::Backend> RenderPipelineBuilder<RenderBackend> {
     };
   }
 
+  pub fn with_buffer(&mut self, buffer: &Buffer<RenderBackend>) -> &mut Self {
+    todo!()
+  }
+
   /// Adds a push constant to the render pipeline at the set PipelineStage(s)
   pub fn with_push_constant(
     mut self,

lambda/src/core/render/buffer.rs

@@ -0,0 +1,82 @@
+mod internal {
+  pub use lambda_platform::gfx::buffer::{
+    Buffer,
+    BufferBuilder,
+  };
+}
+
+// publicly use Properties and Usage from buffer.rs
+pub use lambda_platform::gfx::buffer::{
+  BufferType,
+  Properties,
+  Usage,
+};
+
+use super::{
+  internal::mut_gpu_from_context,
+  RenderContext,
+};
+
+#[derive(Debug)]
+pub struct Buffer {
+  buffer: internal::Buffer<super::internal::RenderBackend>,
+  buffer_type: BufferType,
+}
+
+pub struct BufferBuilder {
+  buffer_builder: internal::BufferBuilder,
+  buffer_type: BufferType,
+}
+
+impl BufferBuilder {
+  pub fn new() -> Self {
+    return Self {
+      buffer_builder: internal::BufferBuilder::new(),
+      buffer_type: BufferType::Vertex,
+    };
+  }
+
+  pub fn with_length(&mut self, size: usize) -> &mut Self {
+    self.buffer_builder.with_length(size);
+    return self;
+  }
+
+  pub fn with_buffer_type(&mut self, buffer_type: BufferType) -> &mut Self {
+    self.buffer_type = buffer_type;
+    self.buffer_builder.with_buffer_type(buffer_type);
+    return self;
+  }
+
+  pub fn with_usage(&mut self, usage: Usage) -> &mut Self {
+    self.buffer_builder.with_usage(usage);
+    return self;
+  }
+
+  pub fn with_properties(&mut self, properties: Properties) -> &mut Self {
+    self.buffer_builder.with_properties(properties);
+    return self;
+  }
+
+  /// Build a buffer from the render context.
+  pub fn build<Data: Sized>(
+    &self,
+    render_context: &mut RenderContext,
+    data: Vec<Data>,
+  ) -> Result<Buffer, &'static str> {
+    let buffer_allocation = self
+      .buffer_builder
+      .build(&mut mut_gpu_from_context(render_context), data);
+
+    match buffer_allocation {
+      Ok(buffer) => {
+        return Ok(Buffer {
+          buffer,
+          buffer_type: self.buffer_type,
+        });
+      }
+      Err(error) => {
+        return Err(error);
+      }
+    }
+  }
+}

lambda/src/core/render/mesh.rs

@@ -1,15 +1,13 @@
-use lambda_platform::gfx::buffer::{
-  Buffer,
-  BufferBuilder,
-  Properties,
-  Usage,
-};
-
 use super::{
+  buffer::{
+    Buffer,
+    BufferBuilder,
+    Properties,
+    Usage,
+  },
   vertex::Vertex,
   RenderContext,
 };
-use crate::core::render::internal::mut_gpu_from_context;
 
 // ---------------------------------- Mesh ------------------------------------
 
@@ -18,7 +16,7 @@ use crate::core::render::internal::mut_gpu_from_context;
 pub struct Mesh {
   vertices: Vec<Vertex>,
   indices: Vec<u32>,
-  buffer: Buffer<super::internal::RenderBackend>,
+  buffer: Buffer,
 }
 
 // ------------------------------ MeshBuilder ---------------------------------
@@ -68,7 +66,7 @@ impl MeshBuilder {
       .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());
+      .build(render_context, self.vertices.clone());
 
     match buffer_allocation {
       Ok(buffer) => {

lambda/src/core/render/mod.rs

@@ -2,6 +2,7 @@
 //! windowing.
 
 // Module Exports
+pub mod buffer;
 pub mod command;
 pub mod mesh;
 pub mod pipeline;

lambda/src/core/render/pipeline.rs

@@ -6,6 +6,7 @@ use lambda_platform::gfx::shader::{
 };
 
 use super::{
+  buffer::Buffer,
   internal::{
     gpu_from_context,
     mut_gpu_from_context,
@@ -45,27 +46,35 @@ use lambda_platform::gfx::pipeline::PushConstantUpload;
 
 pub struct RenderPipelineBuilder {
   push_constants: Vec<PushConstantUpload>,
+  buffers: Vec<Buffer>,
 }
 
 impl RenderPipelineBuilder {
   pub fn new() -> Self {
     return Self {
       push_constants: Vec::new(),
+      buffers: Vec::new(),
     };
   }
 
+  /// Adds a buffer to the render pipeline.
+  pub fn with_buffer(&mut self, buffer: Buffer) -> &mut Self {
+    self.buffers.push(buffer);
+    return self;
+  }
+
   pub fn with_push_constant(
-    mut self,
+    &mut self,
     stage: PipelineStage,
     bytes: u32,
-  ) -> Self {
+  ) -> &mut Self {
     self.push_constants.push((stage, 0..bytes));
     return self;
   }
 
   /// Builds a render pipeline based on your builder configuration.
   pub fn build(
-    self,
+    &self,
     render_context: &mut RenderContext,
     render_pass: &super::render_pass::RenderPass,
     vertex_shader: &Shader,
@@ -88,7 +97,7 @@ impl RenderPipelineBuilder {
 
     let render_pipeline =
       lambda_platform::gfx::pipeline::RenderPipelineBuilder::new()
-        .with_push_constants(self.push_constants)
+        .with_push_constants(self.push_constants.clone())
         .build(
           gpu_from_context(render_context),
           &platform_render_pass_from_render_pass(render_pass),