[update] the runtime component API to have rendering builtin and update the primary demo.

Author: vmarcella

lambda/src/core/component.rs

@@ -1,27 +1,27 @@
 use std::time::Duration;
 
+use super::{
+  events::Events,
+  render::{
+    command::RenderCommand,
+    RenderContext,
+  },
+};
+
 /// The Component Interface for allowing Component based data structures
 /// like the ComponentStack to store components with various purposes
 /// and implementations to work together.
-pub trait Component<E> {
-  fn on_attach(&mut self);
-  fn on_detach(&mut self);
-  fn on_event(&mut self, event: &E);
+pub trait Component {
+  fn on_attach(&mut self, render_context: &mut RenderContext);
+  fn on_detach(&mut self, render_context: &mut RenderContext);
+  fn on_event(&mut self, event: Events);
+
+  /// When the application state should perform logic updates.
   fn on_update(&mut self, last_frame: &Duration);
-}
 
-/// The interface for a Component that can be rendered.
-pub trait RenderableComponent<E>: Component<E> {
-  fn on_renderer_attached(
-    &mut self,
-    render_context: &mut super::render::RenderContext,
-  );
+  /// When the application state should perform rendering.
   fn on_render(
     &mut self,
-    render_context: &mut super::render::RenderContext,
-  ) -> Vec<super::render::command::RenderCommand>;
-  fn on_renderer_detached(
-    &mut self,
-    render_context: &mut super::render::RenderContext,
-  );
+    render_context: &mut RenderContext,
+  ) -> Vec<RenderCommand>;
 }

lambda/src/runtimes/mod.rs

@@ -12,7 +12,7 @@ use lambda_platform::winit::{
 };
 
 use crate::core::{
-  component::RenderableComponent,
+  component::Component,
   events::{
     ComponentEvent,
     Events,
@@ -35,7 +35,7 @@ pub struct GenericRuntimeBuilder {
   app_name: String,
   render_context_builder: RenderContextBuilder,
   window_builder: WindowBuilder,
-  components: Vec<Box<dyn RenderableComponent<Events>>>,
+  components: Vec<Box<dyn Component>>,
 }
 
 impl GenericRuntimeBuilder {
@@ -78,7 +78,7 @@ impl GenericRuntimeBuilder {
   }
 
   /// Attach a component to the current runnable.
-  pub fn with_component<T: Default + RenderableComponent<Events> + 'static>(
+  pub fn with_component<T: Default + Component + 'static>(
     self,
     configure_component: impl FnOnce(Self, T) -> (Self, T),
   ) -> Self {
@@ -97,13 +97,13 @@ impl GenericRuntimeBuilder {
     let window = self.window_builder.build(&mut event_loop);
 
     let component_stack = self.components;
-    let render_api = self.render_context_builder.build(&window);
+    let render_context = self.render_context_builder.build(&window);
 
     return GenericRuntime {
       name,
       event_loop,
       window,
-      render_context: render_api,
+      render_context,
       component_stack,
     };
   }
@@ -116,7 +116,7 @@ pub struct GenericRuntime {
   name: String,
   event_loop: Loop<Events>,
   window: Window,
-  component_stack: Vec<Box<dyn RenderableComponent<Events>>>,
+  component_stack: Vec<Box<dyn Component>>,
   render_context: RenderContext,
 }
 
@@ -283,22 +283,18 @@ impl Runtime for GenericRuntime {
             RuntimeEvent::Initialized => {
               println!("[INFO] Initializing all of the components for the runtime: {}", name);
               for component in &mut component_stack {
-                component.on_attach();
-                component
-                  .on_renderer_attached(active_render_context.as_mut().unwrap());
+                component.on_attach(active_render_context.as_mut().unwrap());
               }
             }
             RuntimeEvent::Shutdown => {
               for component in &mut component_stack {
-                component.on_detach();
-                component
-                  .on_renderer_detached(active_render_context.as_mut().unwrap());
+                component.on_detach(active_render_context.as_mut().unwrap());
               }
             }
           },
           _ => {
             for component in &mut component_stack {
-              component.on_event(&lambda_event);
+              component.on_event(lambda_event.clone());
             }
           }
         },

tools/lambda_rs_demo/src/main.rs

@@ -1,16 +1,10 @@
-use std::rc::Rc;
-
 use lambda::{
   core::{
-    component::{
-      Component,
-      RenderableComponent,
-    },
+    component::Component,
     events::{
       ComponentEvent,
       Events,
       KeyEvent,
-      RuntimeEvent,
       WindowEvent,
     },
     render::{
@@ -24,6 +18,7 @@ use lambda::{
         VirtualShader,
       },
       viewport,
+      RenderContext,
     },
     runtime::start_runtime,
   },
@@ -39,14 +34,29 @@ pub struct DemoComponent {
   height: u32,
 }
 
-impl Component<Events> for DemoComponent {
-  fn on_attach(&mut self) {
+impl Component for DemoComponent {
+  fn on_attach(&mut self, render_context: &mut RenderContext) {
+    println!("Attached the demo component to the renderer");
+    let render_pass =
+      render_pass::RenderPassBuilder::new().build(&render_context);
+
+    let pipeline = pipeline::RenderPipelineBuilder::new().build(
+      render_context,
+      &render_pass,
+      &self.vertex_shader,
+      &self.triangle_vertex,
+    );
+
+    // 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));
+
     println!("Attached the DemoComponent.");
   }
 
-  fn on_detach(self: &mut DemoComponent) {}
+  fn on_detach(self: &mut DemoComponent, render_context: &mut RenderContext) {}
 
-  fn on_event(self: &mut DemoComponent, event: &lambda::core::events::Events) {
+  fn on_event(self: &mut DemoComponent, event: Events) {
     match event {
       Events::Runtime { event, issued_at } => match event {
         lambda::core::events::RuntimeEvent::Shutdown => {
@@ -57,8 +67,8 @@ impl Component<Events> for DemoComponent {
       Events::Window { event, issued_at } => match event {
         WindowEvent::Resize { width, height } => {
           println!("Window resized to {}x{}", width, height);
-          self.width = *width;
-          self.height = *height;
+          self.width = width;
+          self.height = height;
         }
         WindowEvent::Close => {
           println!("Window closed");
@@ -103,30 +113,6 @@ impl Component<Events> for DemoComponent {
       false => {}
     }
   }
-}
-
-/// Implement rendering for the component.
-impl RenderableComponent<Events> for DemoComponent {
-  fn on_renderer_attached(
-    &mut self,
-    render_context: &mut lambda::core::render::RenderContext,
-  ) {
-    println!("Attached the demo component to the renderer");
-    let render_pass =
-      render_pass::RenderPassBuilder::new().build(&render_context);
-
-    let pipeline = pipeline::RenderPipelineBuilder::new().build(
-      render_context,
-      &render_pass,
-      &self.vertex_shader,
-      &self.triangle_vertex,
-    );
-
-    // 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(
     self: &mut DemoComponent,
     _render_context: &mut lambda::core::render::RenderContext,
@@ -159,13 +145,6 @@ impl RenderableComponent<Events> for DemoComponent {
       RenderCommand::EndRenderPass,
     ];
   }
-
-  fn on_renderer_detached(
-    self: &mut DemoComponent,
-    _render_context: &mut lambda::core::render::RenderContext,
-  ) {
-    println!("Detached the demo component from the renderer");
-  }
 }
 
 impl DemoComponent {}