[update] how the render pipelines & primitive assembler process buffers.

Author: vmarcella

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

@@ -13,6 +13,7 @@ use super::{
 };
 
 /// Attributes for a vertex.
+#[derive(Debug, Clone)]
 pub struct VertexAttribute {
   pub location: u32,
   pub offset: u32,
@@ -39,8 +40,8 @@ impl PrimitiveAssemblerBuilder {
   pub fn build<'shader, RenderBackend: gfx_hal::Backend>(
     &'shader mut self,
     vertex_shader: &'shader super::shader::ShaderModule<RenderBackend>,
-    buffers: Option<&Vec<Buffer<RenderBackend>>>,
-    attributes: Option<&Vec<VertexAttribute>>,
+    buffers: Option<&Vec<&Buffer<RenderBackend>>>,
+    attributes: Option<&[VertexAttribute]>,
   ) -> PrimitiveAssembler<'shader, RenderBackend> {
     let binding = self.buffer_descriptions.len() as u32;
 

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

@@ -182,6 +182,10 @@ impl<RenderBackend: gfx_hal::Backend> Gpu<RenderBackend> {
 
     return Ok(());
   }
+
+  pub(super) fn logical_device(&self) -> &RenderBackend::Device {
+    return &self.gpu.device;
+  }
 }
 
 #[cfg(test)]

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

@@ -36,6 +36,7 @@ use std::ops::Range;
 use gfx_hal::device::Device;
 
 use super::{
+  assembler::VertexAttribute,
   buffer::Buffer,
   gpu::Gpu,
   shader::ShaderModule,
@@ -45,6 +46,8 @@ use super::{
 pub struct RenderPipelineBuilder<RenderBackend: internal::Backend> {
   pipeline_layout: Option<RenderBackend::PipelineLayout>,
   push_constants: Vec<PushConstantUpload>,
+  buffers: Vec<Buffer<RenderBackend>>,
+  attributes: Vec<VertexAttribute>,
 }
 
 pub type PipelineStage = gfx_hal::pso::ShaderStageFlags;
@@ -56,19 +59,27 @@ impl<RenderBackend: internal::Backend> RenderPipelineBuilder<RenderBackend> {
     return Self {
       pipeline_layout: None,
       push_constants: Vec::new(),
+      buffers: Vec::new(),
+      attributes: Vec::new(),
     };
   }
 
-  pub fn with_buffer(&mut self, buffer: &Buffer<RenderBackend>) -> &mut Self {
-    todo!()
+  pub fn with_buffer(
+    &mut self,
+    buffer: Buffer<RenderBackend>,
+    attributes: Vec<VertexAttribute>,
+  ) -> &mut Self {
+    self.buffers.push(buffer);
+    self.attributes.extend(attributes);
+    return self;
   }
 
   /// Adds a push constant to the render pipeline at the set PipelineStage(s)
   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;
   }
@@ -91,6 +102,8 @@ impl<RenderBackend: internal::Backend> RenderPipelineBuilder<RenderBackend> {
     render_pass: &super::render_pass::RenderPass<RenderBackend>,
     vertex_shader: &ShaderModule<RenderBackend>,
     fragment_shader: Option<&ShaderModule<RenderBackend>>,
+    buffers: &Vec<&Buffer<RenderBackend>>,
+    attributes: &[VertexAttribute],
   ) -> RenderPipeline<RenderBackend> {
     // TODO(vmarcella): The pipeline layout should be configurable through the
     // RenderPipelineBuilder.
@@ -109,7 +122,8 @@ impl<RenderBackend: internal::Backend> RenderPipelineBuilder<RenderBackend> {
     // 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 primitive_assembler =
+      builder.build(vertex_shader, Some(buffers), Some(attributes));
 
     let fragment_entry = match fragment_shader {
       Some(shader) => Some(internal::EntryPoint::<RenderBackend> {
@@ -143,14 +157,16 @@ impl<RenderBackend: internal::Backend> RenderPipelineBuilder<RenderBackend> {
       });
 
     let pipeline = unsafe {
-      super::internal::logical_device_for(gpu)
+      gpu
+        .logical_device()
         .create_graphics_pipeline(&pipeline_desc, None)
         .expect("Failed to create graphics pipeline")
     };
 
     return RenderPipeline {
       pipeline_layout,
       pipeline,
+      buffers: self.buffers,
     };
   }
 }
@@ -160,16 +176,19 @@ impl<RenderBackend: internal::Backend> RenderPipelineBuilder<RenderBackend> {
 pub struct RenderPipeline<RenderBackend: internal::Backend> {
   pipeline_layout: RenderBackend::PipelineLayout,
   pipeline: RenderBackend::GraphicsPipeline,
+  buffers: Vec<Buffer<RenderBackend>>,
 }
 
 impl<RenderBackend: internal::Backend> RenderPipeline<RenderBackend> {
   /// Destroys the pipeline layout and graphical pipeline
   pub fn destroy(self, gpu: &super::gpu::Gpu<RenderBackend>) {
     unsafe {
-      super::gpu::internal::logical_device_for(gpu)
+      gpu
+        .logical_device()
         .destroy_pipeline_layout(self.pipeline_layout);
 
-      super::gpu::internal::logical_device_for(gpu)
+      gpu
+        .logical_device()
         .destroy_graphics_pipeline(self.pipeline);
     }
   }

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

@@ -39,7 +39,7 @@ impl SurfaceBuilder {
     let gfx_hal_surface = super::internal::create_surface(instance, window);
     let name = match self.name {
       Some(name) => name,
-      None => "LambdaSurface".to_string(),
+      None => "RenderSurface".to_string(),
     };
 
     return Surface {

lambda/src/core/render/buffer.rs

@@ -25,6 +25,15 @@ pub struct Buffer {
   buffer_type: BufferType,
 }
 
+impl Buffer {
+  /// Retrieve a reference to the internal buffer.
+  pub(super) fn internal_buffer(
+    &self,
+  ) -> &internal::Buffer<super::internal::RenderBackend> {
+    return &self.buffer;
+  }
+}
+
 /// 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.

lambda/src/core/render/mesh.rs

@@ -18,6 +18,12 @@ pub struct Mesh {
   buffer: Buffer,
 }
 
+impl Mesh {
+  pub(super) fn buffer(&self) -> &Buffer {
+    return &self.buffer;
+  }
+}
+
 // ------------------------------ MeshBuilder ---------------------------------
 
 /// Construction for a mesh.

lambda/src/core/render/pipeline.rs

@@ -1,8 +1,12 @@
 use std::rc::Rc;
 
-use lambda_platform::gfx::shader::{
-  ShaderModuleBuilder,
-  ShaderModuleType,
+use lambda_platform::gfx::{
+  assembler::VertexAttribute,
+  buffer::Buffer as InternalBuffer,
+  shader::{
+    ShaderModuleBuilder,
+    ShaderModuleType,
+  },
 };
 
 use super::{
@@ -12,7 +16,6 @@ use super::{
     mut_gpu_from_context,
     RenderBackend,
   },
-  render_pass::internal::platform_render_pass_from_render_pass,
   shader::Shader,
   RenderContext,
 };
@@ -47,19 +50,26 @@ use lambda_platform::gfx::pipeline::PushConstantUpload;
 pub struct RenderPipelineBuilder {
   push_constants: Vec<PushConstantUpload>,
   buffers: Vec<Buffer>,
+  attributes: Vec<VertexAttribute>,
 }
 
 impl RenderPipelineBuilder {
   pub fn new() -> Self {
     return Self {
       push_constants: Vec::new(),
       buffers: Vec::new(),
+      attributes: Vec::new(),
     };
   }
 
   /// Adds a buffer to the render pipeline.
-  pub fn with_buffer(&mut self, buffer: Buffer) -> &mut Self {
+  pub fn with_buffer(
+    &mut self,
+    buffer: Buffer,
+    attributes: Vec<VertexAttribute>,
+  ) -> &mut Self {
     self.buffers.push(buffer);
+    self.attributes.extend(attributes);
     return self;
   }
 
@@ -95,15 +105,24 @@ impl RenderPipelineBuilder {
       None => None,
     };
 
-    let render_pipeline =
-      lambda_platform::gfx::pipeline::RenderPipelineBuilder::new()
-        .with_push_constants(self.push_constants.clone())
-        .build(
-          gpu_from_context(render_context),
-          &platform_render_pass_from_render_pass(render_pass),
-          &vertex_shader_module,
-          fragment_shader_module.as_ref(),
-        );
+    let builder = lambda_platform::gfx::pipeline::RenderPipelineBuilder::new();
+
+    let internal_buffers = self
+      .buffers
+      .iter()
+      .map(|b| b.internal_buffer())
+      .collect::<Vec<&InternalBuffer<RenderBackend>>>();
+
+    let render_pipeline = builder
+      .with_push_constants(self.push_constants.clone())
+      .build(
+        gpu_from_context(render_context),
+        render_pass.internal_render_pass(),
+        &vertex_shader_module,
+        fragment_shader_module.as_ref(),
+        &internal_buffers,
+        self.attributes.as_slice(),
+      );
 
     // Clean up shader modules.
     vertex_shader_module.destroy(mut_gpu_from_context(render_context));

lambda/src/core/render/render_pass.rs

@@ -20,8 +20,15 @@ impl RenderPass {
       .destroy(gpu_from_context(render_context));
   }
 
+  /// Retrieve a reference to the lower level render pass.
+  pub(super) fn internal_render_pass(
+    &self,
+  ) -> &Rc<render_pass::RenderPass<super::internal::RenderBackend>> {
+    return &self.render_pass;
+  }
+
   /// Converts
-  pub fn into_gfx_render_pass(
+  pub(super) fn into_gfx_render_pass(
     &self,
   ) -> Rc<render_pass::RenderPass<super::internal::RenderBackend>> {
     return self.render_pass.clone();
@@ -45,14 +52,3 @@ impl RenderPassBuilder {
     };
   }
 }
-
-pub(crate) mod internal {
-  use crate::core::render::internal::RenderBackend;
-
-  /// Converts a render pass into a platform render pass.
-  pub fn platform_render_pass_from_render_pass(
-    render_pass: &super::RenderPass,
-  ) -> &lambda_platform::gfx::render_pass::RenderPass<RenderBackend> {
-    return &render_pass.render_pass;
-  }
-}