[update] the render context to take in the pipeline & renderers in exchange for a resource ID to simplify render commands.

Author: vmarcella

lambda/src/core/render/command.rs

@@ -24,23 +24,25 @@ pub enum RenderCommand {
     viewports: Vec<super::viewport::Viewport>,
   },
   SetPipeline {
-    pipeline: Rc<super::pipeline::RenderPipeline>,
+    pipeline: super::ResourceId,
   },
   /// Begins the render pass.
   BeginRenderPass {
-    render_pass: Rc<super::render_pass::RenderPass>,
+    render_pass: super::ResourceId,
     viewport: super::viewport::Viewport,
   },
   /// Ends the render pass.
   EndRenderPass,
   PushConstants {
-    pipeline: Rc<super::pipeline::RenderPipeline>,
+    pipeline: super::ResourceId,
     stage: super::pipeline::PipelineStage,
     offset: u32,
     bytes: Vec<u32>,
   },
   /// Draws a graphical primitive.
-  Draw { vertices: Range<u32> },
+  Draw {
+    vertices: Range<u32>,
+  },
 }
 
 impl RenderCommand {
@@ -76,12 +78,17 @@ impl RenderCommand {
         viewport,
       } => {
         let surface = surface_from_context(render_context);
-        let render_pass = render_pass.into_gfx_render_pass();
-        let frame_buffer =
-          render_context.allocate_and_get_frame_buffer(render_pass.as_ref());
+        let frame_buffer = render_context.allocate_and_get_frame_buffer(
+          render_context
+            .get_render_pass(render_pass)
+            .into_gfx_render_pass()
+            .as_ref(),
+        );
 
         PlatformRenderCommand::BeginRenderPass {
-          render_pass: render_pass.clone(),
+          render_pass: render_context
+            .get_render_pass(render_pass)
+            .into_gfx_render_pass(),
           surface: surface.clone(),
           frame_buffer: frame_buffer.clone(),
           viewport: viewport.into_gfx_viewport(),
@@ -90,7 +97,11 @@ impl RenderCommand {
       RenderCommand::EndRenderPass => PlatformRenderCommand::EndRenderPass,
       RenderCommand::SetPipeline { pipeline } => {
         PlatformRenderCommand::AttachGraphicsPipeline {
-          pipeline: pipeline.into_platform_render_pipeline(),
+          pipeline: render_context
+            .render_pipelines
+            .get(pipeline)
+            .unwrap()
+            .into_platform_render_pipeline(),
         }
       }
       RenderCommand::PushConstants {
@@ -99,7 +110,11 @@ impl RenderCommand {
         offset,
         bytes,
       } => PlatformRenderCommand::PushConstants {
-        pipeline: pipeline.into_platform_render_pipeline(),
+        pipeline: render_context
+          .render_pipelines
+          .get(pipeline)
+          .unwrap()
+          .into_platform_render_pipeline(),
         stage,
         offset,
         bytes,

lambda/src/core/render/mod.rs

@@ -22,7 +22,6 @@ use lambda_platform::gfx::{
   },
   framebuffer::FramebufferBuilder,
   surface::SwapchainBuilder,
-  viewport::ViewPort,
 };
 
 use self::{
@@ -104,7 +103,6 @@ impl RenderContextBuilder {
       submission_fence: Some(submission_fence),
       render_semaphore: Some(render_semaphore),
       command_pool: Some(command_pool),
-      viewports: vec![],
       render_passes: vec![],
       render_pipelines: vec![],
     };
@@ -123,12 +121,29 @@ pub struct RenderContext {
     Option<internal::RenderSubmissionFence<internal::RenderBackend>>,
   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>,
+  render_passes: Vec<RenderPass>,
+  render_pipelines: Vec<RenderPipeline>,
 }
 
+pub type ResourceId = usize;
+
 impl RenderContext {
+  /// Permanently transfer a render pipeline to the render context in exchange
+  /// for a resource ID that you can use in render commands.
+  pub fn attach_pipeline(&mut self, pipeline: RenderPipeline) -> ResourceId {
+    let index = self.render_pipelines.len();
+    self.render_pipelines.push(pipeline);
+    return index;
+  }
+
+  /// Permanently transfer a render pipeline to the render context in exchange
+  /// for a resource ID that you can use in render commands.
+  pub fn attach_render_pass(&mut self, render_pass: RenderPass) -> ResourceId {
+    let index = self.render_passes.len();
+    self.render_passes.push(render_pass);
+    return index;
+  }
+
   /// destroys the RenderContext and all associated resources.
   pub fn destroy(mut self) {
     println!("{} will now start destroying resources.", self.name);
@@ -147,30 +162,32 @@ impl RenderContext {
       .expect("Couldn't take the rendering semaphore from the context and destroy it.")
       .destroy(&self.gpu);
 
+    self
+      .command_pool
+      .as_mut()
+      .unwrap()
+      .deallocate_command_buffer("primary");
+
+    self
+      .command_pool
+      .take()
+      .expect("Couldn't take the command pool from the context and destroy it.")
+      .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()
-        .expect(
-          "Couldn't take the render pass from the context and destroy it.",
-        )
-        .destroy(&self);
+    for render_pass in render_passes {
+      render_pass.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()
-        .expect(
-          "Couldn't take the render pipeline from the context and destroy it.",
-        )
-        .destroy(&self);
+    for render_pipeline in render_pipelines {
+      render_pipeline.destroy(&self);
     }
 
     // Takes the inner surface and destroys it.
@@ -232,7 +249,6 @@ impl RenderContext {
     command_buffer.issue_commands(platform_command_list);
     command_buffer.issue_command(PlatformRenderCommand::EndRecording);
 
-    println!("[INFO] {} will now submit commands to the GPU.", self.name);
     self.gpu.submit_command_buffer(
       &mut command_buffer,
       vec![self.render_semaphore.as_ref().unwrap()],
@@ -242,7 +258,6 @@ impl RenderContext {
         .expect("Failed to get mutable reference to submission fence."),
     );
 
-    println!("[INFO] {} will now render to the surface.", self.name);
     self
       .gpu
       .render_to_surface(
@@ -252,15 +267,10 @@ impl RenderContext {
       )
       .expect("Failed to render to the surface");
 
-    println!(
-      "[INFO] {} will now wait for the GPU to finish rendering.",
-      self.name
-    );
     match self.frame_buffer {
       Some(_) => {
         Rc::try_unwrap(self.frame_buffer.take().unwrap())
-          .ok()
-          .unwrap()
+          .expect("Failed to unwrap the frame buffer.")
           .destroy(&self.gpu);
       }
       None => {}
@@ -276,6 +286,14 @@ impl RenderContext {
       .apply_swapchain(&self.gpu, swapchain, 1_000_000_000)
       .expect("Failed to apply the swapchain to the surface while attempting to resize.");
   }
+
+  pub fn get_render_pass(&self, id: ResourceId) -> &RenderPass {
+    return &self.render_passes[id];
+  }
+
+  pub fn get_render_pipeline(&mut self, id: ResourceId) -> &RenderPipeline {
+    return &self.render_pipelines[id];
+  }
 }
 
 type PlatformRenderCommand = Command<internal::RenderBackend>;

lambda/src/runtimes/mod.rs

@@ -156,6 +156,8 @@ impl Runtime for GenericRuntime {
               event: RuntimeEvent::Shutdown,
               issued_at: Instant::now(),
             });
+
+            *control_flow = ControlFlow::Exit;
           }
           WinitWindowEvent::Resized(dims) => {
             active_render_context
@@ -292,7 +294,6 @@ impl Runtime for GenericRuntime {
                 component
                   .on_renderer_detached(active_render_context.as_mut().unwrap());
               }
-              *control_flow = ControlFlow::Exit;
             }
           },
           _ => {

tools/lambda_rs_demo/src/main.rs

@@ -15,14 +15,8 @@ use lambda::{
     },
     render::{
       command::RenderCommand,
-      pipeline::{
-        self,
-        RenderPipeline,
-      },
-      render_pass::{
-        self,
-        RenderPass,
-      },
+      pipeline,
+      render_pass,
       shader::{
         Shader,
         ShaderBuilder,
@@ -39,8 +33,8 @@ use lambda::{
 pub struct DemoComponent {
   triangle_vertex: Shader,
   vertex_shader: Shader,
-  render_pass: Option<Rc<RenderPass>>,
-  render_pipeline: Option<Rc<RenderPipeline>>,
+  render_pass_id: Option<lambda::core::render::ResourceId>,
+  render_pipeline_id: Option<lambda::core::render::ResourceId>,
   width: u32,
   height: u32,
 }
@@ -119,18 +113,18 @@ impl RenderableComponent<Events> for DemoComponent {
   ) {
     println!("Attached the demo component to the renderer");
     let render_pass =
-      Rc::new(render_pass::RenderPassBuilder::new().build(&render_context));
-
-    self.render_pass = Some(render_pass.clone());
+      render_pass::RenderPassBuilder::new().build(&render_context);
 
-    let pipeline = Rc::new(pipeline::RenderPipelineBuilder::new().build(
+    let pipeline = pipeline::RenderPipelineBuilder::new().build(
       render_context,
-      &self.render_pass.as_ref().unwrap(),
+      &render_pass,
       &self.vertex_shader,
       &self.triangle_vertex,
-    ));
+    );
 
-    self.render_pipeline = Some(pipeline.clone());
+    // Attach the render pass and pipeline to the render context
+    self.render_pass_id = Some(render_context.attach_render_pass(render_pass));
+    self.render_pipeline_id = Some(render_context.attach_pipeline(pipeline));
   }
 
   fn on_render(
@@ -152,19 +146,13 @@ impl RenderableComponent<Events> for DemoComponent {
       },
       RenderCommand::SetPipeline {
         pipeline: self
-          .render_pipeline
-          .as_ref()
-          .expect(
-            "No render pipeline set while trying to issue a render command.",
-          )
-          .clone(),
+          .render_pipeline_id
+          .expect("No pipeline attached to the component"),
       },
       RenderCommand::BeginRenderPass {
         render_pass: self
-          .render_pass
-          .as_ref()
-          .expect("Cannot begin the render pass when it doesn't exist.")
-          .clone(),
+          .render_pass_id
+          .expect("No render pass attached to the component"),
         viewport: viewport.clone(),
       },
       RenderCommand::Draw { vertices: 0..3 },
@@ -208,8 +196,8 @@ impl Default for DemoComponent {
     return DemoComponent {
       vertex_shader: vs,
       triangle_vertex: fs,
-      render_pass: None,
-      render_pipeline: None,
+      render_pass_id: None,
+      render_pipeline_id: None,
       width: 800,
       height: 600,
     };