[update] gfx pipelines to take in push constants.

Author: vmarcella

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

@@ -90,6 +90,12 @@ pub enum Command<RenderBackend: gfx_hal::Backend> {
   Draw {
     vertices: Range<u32>,
   },
+  PushConstants {
+    pipeline: Rc<RenderPipeline<RenderBackend>>,
+    stage: super::pipeline::PipelineStage,
+    offset: u32,
+    bytes: &'static [u32],
+  },
   EndRecording,
 }
 
@@ -167,6 +173,17 @@ impl<'command_pool, RenderBackend: gfx_hal::Backend>
           )
         }
         Command::EndRenderPass => self.command_buffer.end_render_pass(),
+        Command::PushConstants {
+          pipeline,
+          stage,
+          offset,
+          bytes,
+        } => self.command_buffer.push_graphics_constants(
+          super::pipeline::internal::pipeline_layout_for(pipeline.as_ref()),
+          stage,
+          offset,
+          bytes,
+        ),
         Command::Draw { vertices } => self.command_buffer.draw(vertices, 0..1),
         Command::EndRecording => self.command_buffer.finish(),
       }

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

@@ -23,8 +23,16 @@ pub mod internal {
   ) -> &RenderBackend::GraphicsPipeline {
     return &pipeline.pipeline;
   }
+
+  pub fn pipeline_layout_for<RenderBackend: gfx_hal::Backend>(
+    pipeline: &super::RenderPipeline<RenderBackend>,
+  ) -> &RenderBackend::PipelineLayout {
+    return &pipeline.pipeline_layout;
+  }
 }
 
+use std::ops::Range;
+
 use gfx_hal::device::Device;
 
 use super::{
@@ -35,14 +43,41 @@ use super::{
 /// Builder for a gfx-hal backed render pipeline.
 pub struct RenderPipelineBuilder<RenderBackend: internal::Backend> {
   pipeline_layout: Option<RenderBackend::PipelineLayout>,
+  push_constants: Vec<PushConstantUpload>,
 }
 
+pub type PipelineStage = gfx_hal::pso::ShaderStageFlags;
+
+pub type PushConstantUpload = (PipelineStage, Range<u32>);
+
 impl<RenderBackend: internal::Backend> RenderPipelineBuilder<RenderBackend> {
   pub fn new() -> Self {
     return Self {
       pipeline_layout: None,
+      push_constants: Vec::new(),
     };
   }
+
+  /// Adds a push constant to the render pipeline at the set PipelineStage(s)
+  pub fn with_push_constant(
+    mut self,
+    stage: PipelineStage,
+    bytes: u32,
+  ) -> Self {
+    self.push_constants.push((stage, 0..bytes));
+    return self;
+  }
+
+  /// Adds multiple push constants to the render pipeline at their
+  /// set PipelineStage(s)
+  pub fn with_push_constants(
+    mut self,
+    push_constants: Vec<PushConstantUpload>,
+  ) -> Self {
+    self.push_constants.extend(push_constants);
+    return self;
+  }
+
   /// Builds a render pipeline based on your builder configuration. You can
   /// configure a render pipeline to be however you'd like it to be.
   pub fn build(
@@ -57,7 +92,10 @@ impl<RenderBackend: internal::Backend> RenderPipelineBuilder<RenderBackend> {
     let pipeline_layout = unsafe {
       use internal::Device;
       super::internal::logical_device_for(gpu)
-        .create_pipeline_layout(vec![].into_iter(), vec![].into_iter())
+        .create_pipeline_layout(
+          vec![].into_iter(),
+          self.push_constants.into_iter(),
+        )
         .expect(
           "The GPU does not have enough memory to allocate a pipeline layout",
         )

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

@@ -224,16 +224,13 @@ impl<'builder> RenderPassBuilder<'builder> {
     };
 
     let render_pass = unsafe {
-      super::internal::logical_device_for(gpu)
-        .create_render_pass(
-          attachments.into_iter(),
-          subpasses.into_iter(),
-          vec![].into_iter(),
-        )
-        .expect(
-          "The GPU does not have enough memory to allocate a render pass.",
-        )
-    };
+      super::internal::logical_device_for(gpu).create_render_pass(
+        attachments.into_iter(),
+        subpasses.into_iter(),
+        vec![].into_iter(),
+      )
+    }
+    .expect("The GPU does not have enough memory to allocate a render pass.");
 
     return RenderPass { render_pass };
   }