[update] high level renderer to re apply the swapchain every frame, update the demo application.

Author: vmarcella

lambda/src/core/kernel.rs

@@ -1,6 +1,6 @@
 pub trait Kernel {
-  fn on_start(&self);
-  fn on_stop(&self);
+  fn on_start(&mut self);
+  fn on_stop(&mut self);
   fn run(self);
 }
 
@@ -13,7 +13,7 @@ pub fn build_and_start_kernel<T: Default + Kernel>() {
 }
 
 /// Simple function for starting any prebuilt Runnable.
-pub fn start_kernel<T: Kernel>(kernel: T) {
+pub fn start_kernel<T: Kernel>(mut kernel: T) {
   kernel.on_start();
   kernel.run();
 }

lambda/src/core/render/command.rs

@@ -30,11 +30,11 @@ pub enum RenderCommand {
     viewports: Vec<super::viewport::Viewport>,
   },
   SetPipeline {
-    pipeline: super::pipeline::RenderPipeline,
+    pipeline: Rc<super::pipeline::RenderPipeline>,
   },
   /// Begins the render pass.
   BeginRenderPass {
-    render_pass: super::render_pass::RenderPass,
+    render_pass: Rc<super::render_pass::RenderPass>,
     viewport: super::viewport::Viewport,
   },
   /// Ends the render pass.
@@ -78,17 +78,21 @@ impl RenderCommand {
         let surface = surface_for_context(render_context);
         let render_pass = render_pass.into_gfx_render_pass();
         let frame_buffer =
-          render_context.allocate_and_get_frame_buffer(&render_pass);
+          render_context.allocate_and_get_frame_buffer(render_pass.as_ref());
 
         PlatformRenderCommand::BeginRenderPass {
-          render_pass,
-          surface,
-          frame_buffer,
+          render_pass: render_pass.clone(),
+          surface: surface.clone(),
+          frame_buffer: frame_buffer.clone(),
           viewport: viewport.into_gfx_viewport(),
         }
       }
       RenderCommand::EndRenderPass => PlatformRenderCommand::EndRenderPass,
-      RenderCommand::SetPipeline { pipeline } => todo!(),
+      RenderCommand::SetPipeline { pipeline } => {
+        PlatformRenderCommand::AttachGraphicsPipeline {
+          pipeline: pipeline.into_platform_render_pipeline(),
+        }
+      }
       RenderCommand::Draw { vertices } => {
         PlatformRenderCommand::Draw { vertices }
       }

lambda/src/core/render/mod.rs

@@ -90,6 +90,7 @@ use lambda_platform::gfx::{
 
 use self::{
   command::RenderCommand,
+  pipeline::RenderPipeline,
   render_pass::RenderPass,
 };
 
@@ -124,8 +125,9 @@ impl RenderContextBuilder {
 
     let mut instance = internal::InstanceBuilder::new()
       .build::<internal::RenderBackend>(name.as_str());
-    let mut surface =
-      internal::SurfaceBuilder::new().build(&instance, window.window_handle());
+    let mut surface = Rc::new(
+      internal::SurfaceBuilder::new().build(&instance, window.window_handle()),
+    );
 
     // Build a GPU with a 3D Render queue that can render to our surface.
     let mut gpu = internal::GpuBuilder::new()
@@ -151,21 +153,23 @@ impl RenderContextBuilder {
       .with_size(dimensions[0], dimensions[1])
       .build(&gpu, &surface);
 
-    surface
-      .apply_swapchain(&gpu, swapchain, 1_000_000_000)
+    Rc::get_mut(&mut surface)
+      .expect("Failed to get mutable reference to surface.")
+      .apply_swapchain(&gpu, swapchain, self.render_timeout)
       .expect("Failed to apply the swapchain to the surface.");
 
     return RenderContext {
       name,
       instance,
       gpu,
-      surface: Rc::new(surface),
+      surface: surface.clone(),
       frame_buffer: None,
       submission_fence: Some(submission_fence),
       render_semaphore: Some(render_semaphore),
       command_pool: Some(command_pool),
       viewports: vec![],
       render_passes: vec![],
+      render_pipelines: vec![],
     };
   }
 }
@@ -183,6 +187,7 @@ pub struct RenderContext {
   render_semaphore: Option<internal::RenderSemaphore<internal::RenderBackend>>,
   command_pool: Option<internal::CommandPool<internal::RenderBackend>>,
   render_passes: Vec<Option<RenderPass>>,
+  render_pipelines: Vec<Option<RenderPipeline>>,
   viewports: Vec<ViewPort>,
 }
 
@@ -195,13 +200,22 @@ impl RenderContext {
     self.submission_fence.take().unwrap().destroy(&self.gpu);
     self.render_semaphore.take().unwrap().destroy(&self.gpu);
 
+    // Destroy render passes.
     let mut render_passes = vec![];
     swap(&mut self.render_passes, &mut render_passes);
 
     for render_pass in &mut render_passes {
       render_pass.take().unwrap().destroy(&self);
     }
 
+    // Destroy render pipelines.
+    let mut render_pipelines = vec![];
+    swap(&mut self.render_pipelines, &mut render_pipelines);
+
+    for render_pipeline in &mut render_pipelines {
+      render_pipeline.take().unwrap().destroy(&self);
+    }
+
     // Takes the inner surface and destroys it.
     let mut surface = Rc::try_unwrap(self.surface).ok().unwrap();
     surface.remove_swapchain(&self.gpu);
@@ -211,15 +225,12 @@ impl RenderContext {
   pub fn allocate_and_get_frame_buffer(
     &mut self,
     render_pass: &internal::RenderPass<internal::RenderBackend>,
-  ) -> Rc<
-    lambda_platform::gfx::framebuffer::Framebuffer<
-      lambda_platform::gfx::api::RenderingAPI::Backend,
-    >,
-  > {
+  ) -> Rc<lambda_platform::gfx::framebuffer::Framebuffer<internal::RenderBackend>>
+  {
     let frame_buffer = FramebufferBuilder::new().build(
       &mut self.gpu,
       &render_pass,
-      &self.surface,
+      self.surface.as_ref(),
     );
 
     // TODO(vmarcella): Update the framebuffer allocation to not be so hacky.
@@ -231,6 +242,20 @@ impl RenderContext {
 
   /// Allocates a command buffer and records commands to the GPU.
   pub fn render(&mut self, commands: Vec<RenderCommand>) {
+    let dimensions = self
+      .surface
+      .size()
+      .expect("Surface has no size configured.");
+
+    let swapchain = SwapchainBuilder::new()
+      .with_size(dimensions[0], dimensions[1])
+      .build(&self.gpu, &self.surface);
+
+    Rc::get_mut(&mut self.surface)
+      .expect("Failed to get mutable reference to surface.")
+      .apply_swapchain(&self.gpu, swapchain, 1_000_000_000)
+      .expect("Failed to apply the swapchain to the surface.");
+
     let platform_command_list = commands
       .into_iter()
       .map(|command| command.into_platform_command(self))

lambda/src/core/render/pipeline.rs

@@ -1,3 +1,5 @@
+use std::rc::Rc;
+
 use lambda_platform::gfx::shader::{
   ShaderModuleBuilder,
   ShaderModuleType,
@@ -7,21 +9,34 @@ use super::{
   internal::{
     gpu_from_context,
     mut_gpu_from_context,
+    RenderBackend,
   },
   render_pass::internal::platform_render_pass_from_render_pass,
   shader::Shader,
   RenderContext,
 };
+
+#[derive(Debug)]
 pub struct RenderPipeline {
-  pipeline: lambda_platform::gfx::pipeline::RenderPipeline<
-    super::internal::RenderBackend,
+  pipeline: Rc<
+    lambda_platform::gfx::pipeline::RenderPipeline<
+      super::internal::RenderBackend,
+    >,
   >,
 }
 
 impl RenderPipeline {
   /// Destroy the render pipeline with the render context that created it.
   pub fn destroy(self, render_context: &RenderContext) {
-    self.pipeline.destroy(gpu_from_context(render_context));
+    Rc::try_unwrap(self.pipeline)
+      .expect("Failed to destroy render pipeline")
+      .destroy(gpu_from_context(render_context));
+  }
+
+  pub fn into_platform_render_pipeline(
+    &self,
+  ) -> Rc<lambda_platform::gfx::pipeline::RenderPipeline<RenderBackend>> {
+    return self.pipeline.clone();
   }
 }
 
@@ -64,7 +79,7 @@ impl RenderPipelineBuilder {
     fragment_shader_module.destroy(mut_gpu_from_context(render_context));
 
     return RenderPipeline {
-      pipeline: render_pipeline,
+      pipeline: Rc::new(render_pipeline),
     };
   }
 }

lambda/src/core/render/render_pass.rs

@@ -1,24 +1,30 @@
+use std::rc::Rc;
+
 use lambda_platform::gfx::render_pass;
 
 use super::{
   internal::gpu_from_context,
   RenderContext,
 };
+
+#[derive(Debug)]
 pub struct RenderPass {
-  render_pass: render_pass::RenderPass<super::internal::RenderBackend>,
+  render_pass: Rc<render_pass::RenderPass<super::internal::RenderBackend>>,
 }
 
 impl RenderPass {
   /// Destroy the render pass with the render context that created it.
   pub fn destroy(self, render_context: &RenderContext) {
-    self.render_pass.destroy(gpu_from_context(render_context));
+    Rc::try_unwrap(self.render_pass)
+      .expect("Failed to destroy render pass. Is something holding a reference to it?")
+      .destroy(gpu_from_context(render_context));
   }
 
   /// Converts
   pub fn into_gfx_render_pass(
-    self,
-  ) -> render_pass::RenderPass<super::internal::RenderBackend> {
-    return self.render_pass;
+    &self,
+  ) -> Rc<render_pass::RenderPass<super::internal::RenderBackend>> {
+    return self.render_pass.clone();
   }
 }
 
@@ -34,7 +40,9 @@ impl RenderPassBuilder {
     let render_pass =
       lambda_platform::gfx::render_pass::RenderPassBuilder::new()
         .build(gpu_from_context(render_context));
-    return RenderPass { render_pass };
+    return RenderPass {
+      render_pass: Rc::new(render_pass),
+    };
   }
 }
 

lambda/src/kernels/mod.rs

@@ -202,13 +202,7 @@ impl Kernel for LambdaKernel {
         WinitEvent::DeviceEvent { device_id, event } => {}
         WinitEvent::UserEvent(lambda_event) => {
           match lambda_event {
-            Event::Initialized => {
-              for component in &mut component_stack {
-                component.on_attach();
-                component
-                  .on_renderer_attached(active_render_api.as_mut().unwrap());
-              }
-            }
+            Event::Initialized => {}
             Event::Shutdown => {
               // Once this has been set, the ControlFlow can no longer be
               // modified.
@@ -239,11 +233,15 @@ impl Kernel for LambdaKernel {
     });
   }
 
-  fn on_start(&self) {
-    println!("Starting {}", self.name)
+  fn on_start(&mut self) {
+    println!("Starting {}", self.name);
+    for component in &mut self.component_stack {
+      component.on_attach();
+      component.on_renderer_attached(&mut self.render_api);
+    }
   }
 
-  fn on_stop(&self) {
+  fn on_stop(&mut self) {
     println!("Stopping {}", self.name)
   }
 }