[merge] new demos and API changes

New demos & API additions

Author: vmarcella

Cargo.lock

@@ -4,7 +4,9 @@
 members = [
     "lambda",
     "crates/lambda-platform",
-    "tools/lambda_rs_demo"
+    "tools/lambda_rs_demo",
+    "tools/minimal",
+    "tools/triangles_demo",
 ]
 
 default-members = [

Cargo.toml

@@ -9,7 +9,7 @@ path = "src/lib.rs"
 
 [dependencies]
 gfx-hal = "=0.9.0"
-winit = "=0.26.1"
+winit = "=0.27.4"
 shaderc = "=0.7"
 cfg-if = "=1.0.0"
 

crates/lambda-platform/Cargo.toml

@@ -2,15 +2,15 @@
 //! implementations to use.
 
 cfg_if::cfg_if! {
-  if #[cfg(feature = "with-gl")] {
+  if #[cfg(feature = "gfx-with-gl")] {
     pub use gfx_backend_gl as RenderingAPI;
-  } else if #[cfg(feature = "with-vulkan")] {
+  } else if #[cfg(feature = "gfx-with-vulkan")] {
     pub use gfx_backend_vulkan as RenderingAPI;
-  } else if #[cfg(feature = "with-metal")] {
+  } else if #[cfg(feature = "gfx-with-metal")] {
     pub use gfx_backend_metal as RenderingAPI;
-  } else if #[cfg(feature = "with-dx11")] {
+  } else if #[cfg(feature = "gfx-with-dx11")] {
     pub use gfx_backend_dx11 as RenderingAPI;
-  } else if #[cfg(feature = "with-dx12")] {
+  } else if #[cfg(feature = "gfx-with-dx12")] {
     pub use gfx_backend_dx12 as RenderingAPI;
   } else if #[cfg(feature = "detect-platform")] {
       pub use gfx_platform_backend as RenderingAPI;

crates/lambda-platform/src/gfx/api.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: Vec<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.as_slice(),
+        ),
         Command::Draw { vertices } => self.command_buffer.draw(vertices, 0..1),
         Command::EndRecording => self.command_buffer.finish(),
       }
@@ -364,8 +381,9 @@ impl<RenderBackend: gfx_hal::Backend> CommandPool<RenderBackend> {
   /// Moves the command pool into itself and destroys any command pool and
   /// buffer resources allocated on the GPU.
   #[inline]
-  pub fn destroy(self, gpu: &super::gpu::Gpu<RenderBackend>) {
+  pub fn destroy(mut self, gpu: &super::gpu::Gpu<RenderBackend>) {
     unsafe {
+      self.command_pool.reset(true);
       super::gpu::internal::logical_device_for(gpu)
         .destroy_command_pool(self.command_pool);
     }

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

@@ -1,6 +1,6 @@
-//! GPU fence & semaphore implementations for rendering synchronizations. These
-//! implementations built on top of gfx-hal and are used by the lambda-platform
-//! rendering implementations to synchronize GPU operations.
+//! GPU synchronization Implementations that are built on top of gfx-hal and
+//! are used by the lambda-platform rendering implementations to synchronize
+//! GPU operations.
 
 use gfx_hal::device::Device;
 
@@ -25,6 +25,9 @@ impl RenderSemaphoreBuilder {
   }
 }
 
+/// Render semaphores are used to synchronize operations happening within the
+/// GPU. This allows for us to tell the GPU to wait for a frame to finish
+/// rendering before presenting it to the screen.
 pub struct RenderSemaphore<RenderBackend: gfx_hal::Backend> {
   semaphore: RenderBackend::Semaphore,
 }
@@ -75,6 +78,9 @@ impl RenderSubmissionFenceBuilder {
   }
 }
 
+/// A GPU fence is used to synchronize GPU operations. It is used to ensure that
+/// a GPU operation has completed before the CPU attempts to submit commands to
+/// it.
 pub struct RenderSubmissionFence<RenderBackend: gfx_hal::Backend> {
   fence: RenderBackend::Fence,
   default_render_timeout: u64,
@@ -95,12 +101,13 @@ impl<RenderBackend: gfx_hal::Backend> RenderSubmissionFence<RenderBackend> {
     unsafe {
       super::gpu::internal::logical_device_for(gpu)
         .wait_for_fence(&self.fence, timeout)
-        .expect("The GPU ran out of memory or has become detached from the current context.");
+    }
+    .expect("The GPU ran out of memory or has become detached from the current context.");
 
-      super::gpu::internal::logical_device_for(gpu)
-        .reset_fence(&mut self.fence)
-        .expect("The fence failed to reset.");
+    unsafe {
+      super::gpu::internal::logical_device_for(gpu).reset_fence(&mut self.fence)
     }
+    .expect("The fence failed to reset.");
   }
 
   /// Destroy this fence given the GPU that created it.
@@ -126,4 +133,10 @@ pub mod internal {
   ) -> &mut RenderBackend::Semaphore {
     return &mut semaphore.semaphore;
   }
+
+  pub fn semaphore_for<RenderBackend: gfx_hal::Backend>(
+    semaphore: &super::RenderSemaphore<RenderBackend>,
+  ) -> &RenderBackend::Semaphore {
+    return &semaphore.semaphore;
+  }
 }

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

@@ -10,6 +10,7 @@ use super::{
 };
 
 /// Framebuffer for the given render backend.
+#[derive(Debug)]
 pub struct Framebuffer<RenderBackend: gfx_hal::Backend> {
   frame_buffer: RenderBackend::Framebuffer,
 }

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

@@ -129,7 +129,7 @@ impl<RenderBackend: gfx_hal::Backend> Gpu<RenderBackend> {
   pub fn submit_command_buffer<'render_context>(
     &mut self,
     command_buffer: &mut CommandBuffer<RenderBackend>,
-    signal_semaphores: Vec<RenderSemaphore<RenderBackend>>,
+    signal_semaphores: Vec<&RenderSemaphore<RenderBackend>>,
     fence: &mut RenderSubmissionFence<RenderBackend>,
   ) {
     let commands =
@@ -139,7 +139,11 @@ impl<RenderBackend: gfx_hal::Backend> Gpu<RenderBackend> {
       self.queue_group.queues[0].submit(
         commands,
         vec![].into_iter(),
-        vec![].into_iter(),
+        // TODO(vmarcella): This was needed to allow the push constants to
+        // properly render to the screen. Look into a better way to do this.
+        signal_semaphores.into_iter().map(|semaphore| {
+          return super::fence::internal::semaphore_for(semaphore);
+        }),
         Some(super::fence::internal::mutable_fence_for(fence)),
       );
     }

crates/lambda-platform/src/gfx/gpu.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(
@@ -54,10 +89,13 @@ impl<RenderBackend: internal::Backend> RenderPipelineBuilder<RenderBackend> {
   ) -> RenderPipeline<RenderBackend> {
     // TODO(vmarcella): The pipeline layout should be configurable through the
     // RenderPipelineBuilder.
+    let push_constants = self.push_constants.into_iter();
+
     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(), push_constants)
         .expect(
           "The GPU does not have enough memory to allocate a pipeline layout",
         )

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

@@ -125,7 +125,7 @@ impl SubpassBuilder {
     };
   }
 
-  pub fn use_color_attachment(
+  pub fn with_color_attachment(
     mut self,
     attachment_index: usize,
     layout: ImageLayoutHint,
@@ -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 };
   }