[update] the pipeline to support vertex buffers & attributes.

Author: vmarcella

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

@@ -1,25 +1,77 @@
 //! Primitive assembly for the graphics pipeline.
 
-use gfx_hal::pso;
+use gfx_hal::pso::{
+  self,
+  AttributeDesc,
+  Element,
+  VertexBufferDesc,
+};
+
+use super::{
+  buffer::Buffer,
+  surface::ColorFormat,
+};
+
+/// Attributes for a vertex.
+pub struct VertexAttribute {
+  pub location: u32,
+  pub offset: u32,
+  pub element: Element<ColorFormat>,
+}
 
 /// PrimitiveAssemblerBuilder for preparing PrimitiveAssemblers to use in the
 /// lambda-platform Rendering pipeline.
-pub struct PrimitiveAssemblerBuilder {}
+pub struct PrimitiveAssemblerBuilder {
+  buffer_descriptions: Vec<VertexBufferDesc>,
+  attribute_descriptions: Vec<AttributeDesc>,
+}
 
 impl PrimitiveAssemblerBuilder {
   pub fn new() -> Self {
-    return Self {};
+    return Self {
+      buffer_descriptions: Vec::new(),
+      attribute_descriptions: Vec::new(),
+    };
   }
 
   /// Build a primitive assembler given the lambda-platform vertex shader
-  /// module.
+  /// module. Buffers & attributes do not have to be tied to
   pub fn build<'shader, RenderBackend: gfx_hal::Backend>(
-    self,
+    &'shader mut self,
     vertex_shader: &'shader super::shader::ShaderModule<RenderBackend>,
+    buffers: Option<&Vec<Buffer<RenderBackend>>>,
+    attributes: Option<&Vec<VertexAttribute>>,
   ) -> PrimitiveAssembler<'shader, RenderBackend> {
+    let binding = self.buffer_descriptions.len() as u32;
+
+    match (buffers, attributes) {
+      (Some(buffers), Some(attributes)) => {
+        self.buffer_descriptions = buffers
+          .iter()
+          .map(|buffer| VertexBufferDesc {
+            binding,
+            stride: buffer.stride() as u32,
+            rate: pso::VertexInputRate::Vertex,
+          })
+          .collect();
+
+        self.attribute_descriptions = attributes
+          .iter()
+          .map(|attribute| {
+            return AttributeDesc {
+              location: attribute.location,
+              binding,
+              element: attribute.element,
+            };
+          })
+          .collect();
+      }
+      _ => {}
+    }
+
     let primitive_assembler = pso::PrimitiveAssemblerDesc::Vertex {
-      buffers: &[],
-      attributes: &[],
+      buffers: self.buffer_descriptions.as_slice(),
+      attributes: self.attribute_descriptions.as_slice(),
       input_assembler: pso::InputAssemblerDesc::new(
         pso::Primitive::TriangleList,
       ),

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

@@ -9,11 +9,13 @@ 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
+/// The type of buffers that can be allocated on the GPU.
 #[derive(Debug, Clone, Copy)]
 pub enum BufferType {
   Vertex,
   Index,
+  Uniform,
+  Storage,
 }
 
 /// A buffer is a block of memory that can be used to store data that can be
@@ -26,7 +28,11 @@ pub struct Buffer<RenderBackend: super::internal::Backend> {
   buffer_type: BufferType,
 }
 
-impl<RenderBackend: super::internal::Backend> Buffer<RenderBackend> {}
+impl<RenderBackend: super::internal::Backend> Buffer<RenderBackend> {
+  pub fn stride(&self) -> usize {
+    return self.stride;
+  }
+}
 
 pub struct BufferBuilder {
   buffer_length: usize,

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

@@ -106,12 +106,14 @@ impl<RenderBackend: internal::Backend> RenderPipelineBuilder<RenderBackend> {
         )
     };
 
-    let primitive_assembler =
-      super::assembler::PrimitiveAssemblerBuilder::new().build(vertex_shader);
+    // TODO(vmarcella): The primitive assembler should be configurable through
+    // the RenderPipelineBuilder so that buffers & attributes can be bound.
+    let mut builder = super::assembler::PrimitiveAssemblerBuilder::new();
+    let primitive_assembler = builder.build(vertex_shader, None, None);
 
     let fragment_entry = match fragment_shader {
       Some(shader) => Some(internal::EntryPoint::<RenderBackend> {
-        entry: "main",
+        entry: shader.entry(),
         module: super::internal::module_for(shader),
         specialization: gfx_hal::pso::Specialization::default(),
       }),

lambda/src/core/render/buffer.rs

@@ -1,4 +1,6 @@
 mod internal {
+  // Placed these in an internal module to avoid a name collision with the
+  // high level Buffer & BufferBuilder types in the parent module.
   pub use lambda_platform::gfx::buffer::{
     Buffer,
     BufferBuilder,
@@ -23,6 +25,9 @@ pub struct Buffer {
   buffer_type: BufferType,
 }
 
+/// A buffer is a block of memory that can be used to store data that can be
+/// accessed by the GPU. The buffer is created with a length, usage, and
+/// properties that determine how the buffer can be used.
 pub struct BufferBuilder {
   buffer_builder: internal::BufferBuilder,
   buffer_type: BufferType,
@@ -36,28 +41,32 @@ impl BufferBuilder {
     };
   }
 
+  /// Sets the length of the buffer (In bytes).
   pub fn with_length(&mut self, size: usize) -> &mut Self {
     self.buffer_builder.with_length(size);
     return self;
   }
 
+  /// Sets the type of buffer to create.
   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;
   }
 
+  /// Sets the usage of the buffer.
   pub fn with_usage(&mut self, usage: Usage) -> &mut Self {
     self.buffer_builder.with_usage(usage);
     return self;
   }
 
+  /// Sets the properties of the buffer.
   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.
+  /// Build a buffer utilizing the current render context
   pub fn build<Data: Sized>(
     &self,
     render_context: &mut RenderContext,

lambda/src/core/render/mesh.rs

@@ -15,7 +15,6 @@ use super::{
 #[derive(Debug)]
 pub struct Mesh {
   vertices: Vec<Vertex>,
-  indices: Vec<u32>,
   buffer: Buffer,
 }
 
@@ -26,15 +25,13 @@ pub struct Mesh {
 pub struct MeshBuilder {
   capacity: usize,
   vertices: Vec<Vertex>,
-  indices: Vec<u32>,
 }
 
 impl MeshBuilder {
   pub fn new() -> Self {
     return Self {
       capacity: 0,
       vertices: vec![],
-      indices: vec![],
     };
   }
 
@@ -72,7 +69,6 @@ impl MeshBuilder {
       Ok(buffer) => {
         return Ok(Mesh {
           vertices: self.vertices.clone(),
-          indices: self.indices.clone(),
           buffer,
         });
       }
@@ -90,7 +86,6 @@ mod tests {
     let mut mesh = super::MeshBuilder::new();
 
     assert_eq!(mesh.vertices.len(), 0);
-    assert_eq!(mesh.indices.len(), 0);
   }
 
   // TODO(vmarcella): Add more tests for mesh building once the render context

lambda/src/core/render/mod.rs

@@ -212,7 +212,9 @@ impl RenderContext {
     return self.frame_buffer.as_ref().unwrap().clone();
   }
 
-  /// Allocates a command buffer and records commands to the GPU.
+  /// Allocates a command buffer and records commands to the GPU. This is the
+  /// primary entry point for submitting commands to the GPU and where rendering
+  /// will occur.
   pub fn render(&mut self, commands: Vec<RenderCommand>) {
     let (width, height) = self
       .surface