[update] render commands to support binding vertex buffers.

Author: vmarcella

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

@@ -40,11 +40,20 @@ impl<RenderBackend: super::internal::Backend> Buffer<RenderBackend> {
       gpu.internal_logical_device().destroy_buffer(self.buffer);
     }
   }
+
+  /// Size of each buffer element in bytes.
   pub fn stride(&self) -> usize {
     return self.stride;
   }
 }
 
+impl<RenderBackend: super::internal::Backend> Buffer<RenderBackend> {
+  /// Retrieve a reference to the internal buffer.
+  pub(super) fn internal_buffer(&self) -> &RenderBackend::Buffer {
+    return &self.buffer;
+  }
+}
+
 pub struct BufferBuilder {
   buffer_length: usize,
   usage: Usage,

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

@@ -96,6 +96,9 @@ pub enum Command<RenderBackend: gfx_hal::Backend> {
     offset: u32,
     bytes: Vec<u32>,
   },
+  BindVertexBuffer {
+    buffer: Rc<super::buffer::Buffer<RenderBackend>>,
+  },
   EndRecording,
 }
 
@@ -187,6 +190,13 @@ impl<'command_pool, RenderBackend: gfx_hal::Backend>
         Command::Draw { vertices } => {
           self.command_buffer.draw(vertices.clone(), 0..1)
         }
+        Command::BindVertexBuffer { buffer } => {
+          self.command_buffer.bind_vertex_buffers(
+            0,
+            vec![(buffer.internal_buffer(), gfx_hal::buffer::SubRange::WHOLE)]
+              .into_iter(),
+          )
+        }
         Command::EndRecording => self.command_buffer.finish(),
       }
     }
@@ -386,7 +396,8 @@ impl<RenderBackend: gfx_hal::Backend> CommandPool<RenderBackend> {
   pub fn destroy(mut self, gpu: &super::gpu::Gpu<RenderBackend>) {
     unsafe {
       self.command_pool.reset(true);
-      super::gpu::internal::logical_device_for(gpu)
+      gpu
+        .internal_logical_device()
         .destroy_command_pool(self.command_pool);
     }
   }

lambda/examples/push_constants.rs

@@ -238,6 +238,10 @@ impl Component for PushConstantsExample {
           .clone(),
         viewport: viewport.clone(),
       },
+      RenderCommand::BindVertexBuffer {
+        pipeline: render_pipeline.clone(),
+        buffer: 0,
+      },
       RenderCommand::PushConstants {
         pipeline: render_pipeline.clone(),
         stage: PipelineStage::VERTEX,
@@ -247,8 +251,11 @@ impl Component for PushConstantsExample {
           render_matrix: mesh_matrix,
         })),
       },
-      RenderCommand::Draw { vertices: 0..3 },
+      RenderCommand::Draw {
+        vertices: 0..self.mesh.as_ref().unwrap().vertices().len() as u32,
+      },
     ];
+
     commands.push(RenderCommand::EndRenderPass);
 
     return commands;

lambda/src/core/render/buffer.rs

@@ -7,6 +7,8 @@ mod internal {
   };
 }
 
+use std::rc::Rc;
+
 // publicly use Properties and Usage from buffer.rs
 pub use lambda_platform::gfx::buffer::{
   BufferType,
@@ -21,7 +23,7 @@ use super::{
 
 #[derive(Debug)]
 pub struct Buffer {
-  buffer: internal::Buffer<super::internal::RenderBackend>,
+  buffer: Rc<internal::Buffer<super::internal::RenderBackend>>,
   buffer_type: BufferType,
 }
 
@@ -30,13 +32,21 @@ impl Buffer {
   /// Destroy the buffer and all it's resources with the render context that
   /// created it.
   pub fn destroy(self, render_context: &RenderContext) {
-    self.buffer.destroy(render_context.internal_gpu());
+    Rc::try_unwrap(self.buffer)
+      .expect("Failed to get inside buffer")
+      .destroy(render_context.internal_gpu());
   }
 }
 
 /// Internal interface for working with buffers.
 impl Buffer {
   /// Retrieve a reference to the internal buffer.
+  pub(super) fn internal_buffer_rc(
+    &self,
+  ) -> Rc<internal::Buffer<super::internal::RenderBackend>> {
+    return self.buffer.clone();
+  }
+
   pub(super) fn internal_buffer(
     &self,
   ) -> &internal::Buffer<super::internal::RenderBackend> {
@@ -78,7 +88,7 @@ impl BufferBuilder {
     match internal_buffer {
       Ok(internal_buffer) => {
         return Ok(Buffer {
-          buffer: internal_buffer,
+          buffer: Rc::new(internal_buffer),
           buffer_type: BufferType::Vertex,
         });
       }
@@ -126,7 +136,7 @@ impl BufferBuilder {
     match buffer_allocation {
       Ok(buffer) => {
         return Ok(Buffer {
-          buffer,
+          buffer: Rc::new(buffer),
           buffer_type: self.buffer_type,
         });
       }

lambda/src/core/render/command.rs

@@ -37,6 +37,10 @@ pub enum RenderCommand {
     offset: u32,
     bytes: Vec<u32>,
   },
+  BindVertexBuffer {
+    pipeline: super::ResourceId,
+    buffer: u32,
+  },
   /// Draws a graphical primitive.
   Draw {
     vertices: Range<u32>,
@@ -47,15 +51,15 @@ impl RenderCommand {
   /// Converts the RenderCommand into a platform compatible render command.
   // TODO(vmarcella): implement this using Into<PlatformRenderCommand>
   pub fn into_platform_command(
-    self,
+    &self,
     render_context: &mut RenderContext,
   ) -> PlatformRenderCommand {
     return match self {
       RenderCommand::SetViewports {
         start_at,
         viewports,
       } => PlatformRenderCommand::SetViewports {
-        start_at,
+        start_at: *start_at,
         viewports: viewports
           .into_iter()
           .map(|viewport| viewport.clone_gfx_viewport())
@@ -65,7 +69,7 @@ impl RenderCommand {
         start_at,
         viewports,
       } => PlatformRenderCommand::SetScissors {
-        start_at,
+        start_at: *start_at,
         viewports: viewports
           .into_iter()
           .map(|viewport| viewport.clone_gfx_viewport())
@@ -78,14 +82,14 @@ impl RenderCommand {
         let surface = surface_from_context(render_context);
         let frame_buffer = render_context.allocate_and_get_frame_buffer(
           render_context
-            .get_render_pass(render_pass)
+            .get_render_pass(*render_pass)
             .into_gfx_render_pass()
             .as_ref(),
         );
 
         PlatformRenderCommand::BeginRenderPass {
           render_pass: render_context
-            .get_render_pass(render_pass)
+            .get_render_pass(*render_pass)
             .into_gfx_render_pass(),
           surface: surface.clone(),
           frame_buffer: frame_buffer.clone(),
@@ -97,7 +101,7 @@ impl RenderCommand {
         PlatformRenderCommand::AttachGraphicsPipeline {
           pipeline: render_context
             .render_pipelines
-            .get(pipeline)
+            .get(*pipeline)
             .unwrap()
             .into_platform_render_pipeline(),
         }
@@ -110,13 +114,25 @@ impl RenderCommand {
       } => PlatformRenderCommand::PushConstants {
         pipeline: render_context
           .render_pipelines
-          .get(pipeline)
+          .get(*pipeline)
           .unwrap()
           .into_platform_render_pipeline(),
-        stage,
-        offset,
+        stage: *stage,
+        offset: *offset,
         bytes: bytes.clone(),
       },
+      RenderCommand::BindVertexBuffer { pipeline, buffer } => {
+        PlatformRenderCommand::BindVertexBuffer {
+          buffer: render_context
+            .render_pipelines
+            .get(*pipeline)
+            .unwrap()
+            .buffers()
+            .get(*buffer as usize)
+            .unwrap()
+            .internal_buffer_rc(),
+        }
+      }
       RenderCommand::Draw { vertices } => PlatformRenderCommand::Draw {
         vertices: vertices.clone(),
       },

lambda/src/core/render/pipeline.rs

@@ -1,4 +1,8 @@
-use std::rc::Rc;
+use std::{
+  borrow::Borrow,
+  ops::Deref,
+  rc::Rc,
+};
 
 use lambda_platform::gfx::{
   buffer::Buffer as InternalBuffer,
@@ -25,22 +29,30 @@ pub struct RenderPipeline {
       super::internal::RenderBackend,
     >,
   >,
-  buffers: Vec<Buffer>,
+  buffers: Vec<Rc<Buffer>>,
 }
 
 impl RenderPipeline {
   /// Destroy the render pipeline with the render context that created it.
   pub fn destroy(self, render_context: &RenderContext) {
     Rc::try_unwrap(self.pipeline)
       .expect("Failed to destroy render pipeline")
-      .destroy(gpu_from_context(render_context));
+      .destroy(render_context.internal_gpu());
 
     for buffer in self.buffers {
-      buffer.destroy(render_context);
+      Rc::try_unwrap(buffer)
+        .expect("Failed to get high level buffer.")
+        .destroy(render_context);
     }
   }
+}
+
+impl RenderPipeline {
+  pub(super) fn buffers(&self) -> &Vec<Rc<Buffer>> {
+    return &self.buffers;
+  }
 
-  pub fn into_platform_render_pipeline(
+  pub(super) fn into_platform_render_pipeline(
     &self,
   ) -> Rc<lambda_platform::gfx::pipeline::RenderPipeline<RenderBackend>> {
     return self.pipeline.clone();
@@ -55,7 +67,7 @@ pub use lambda_platform::gfx::{
 
 pub struct RenderPipelineBuilder {
   push_constants: Vec<PushConstantUpload>,
-  buffers: Vec<Buffer>,
+  buffers: Vec<Rc<Buffer>>,
   attributes: Vec<VertexAttribute>,
 }
 
@@ -74,7 +86,7 @@ impl RenderPipelineBuilder {
     buffer: Buffer,
     attributes: Vec<VertexAttribute>,
   ) -> Self {
-    self.buffers.push(buffer);
+    self.buffers.push(Rc::new(buffer));
     self.attributes.extend(attributes);
     return self;
   }
@@ -117,7 +129,7 @@ impl RenderPipelineBuilder {
     let internal_buffers = buffers
       .iter()
       .map(|b| b.internal_buffer())
-      .collect::<Vec<&InternalBuffer<RenderBackend>>>();
+      .collect::<Vec<_>>();
 
     let render_pipeline = builder
       .with_push_constants(self.push_constants.clone())