[update] event imports & update lambda-platform documentation.

Author: vmarcella

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

@@ -1,3 +1,6 @@
+//! GPU API exports to set the platforms primary rendering API for rendering
+//! implementations to use.
+
 cfg_if::cfg_if! {
   if #[cfg(feature = "with-gl")] {
     pub use gfx_backend_gl as RenderingAPI;

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

@@ -15,6 +15,40 @@ pub mod viewport;
 
 use gfx_hal::Instance as _;
 
+// ----------------------- INSTANCE BUILDER AND INSTANCE -------------------------------
+
+pub struct InstanceBuilder {}
+
+impl InstanceBuilder {
+  pub fn new() -> Self {
+    return Self {};
+  }
+
+  /// Builds a graphical instance for the current platform.
+  pub fn build<RenderBackend: internal::Backend>(
+    self,
+    name: &str,
+  ) -> Instance<RenderBackend> {
+    return Instance::new(name);
+  }
+}
+
+pub struct Instance<RenderBackend: internal::Backend> {
+  gfx_hal_instance: RenderBackend::Instance,
+}
+
+impl<RenderBackend: internal::Backend> Instance<RenderBackend> {
+  /// Create a new GfxInstance connected to the current platforms primary backend.
+  fn new(name: &str) -> Self {
+    let instance = RenderBackend::Instance::create(name, 1)
+      .expect("gfx backend not supported by the current platform");
+
+    return Self {
+      gfx_hal_instance: instance,
+    };
+  }
+}
+
 // ----------------------- INTERNAL INSTANCE OPERATIONS ------------------------
 
 pub mod internal {
@@ -43,7 +77,7 @@ pub mod internal {
       let surface = instance
         .gfx_hal_instance
         .create_surface(&window_handle.window_handle)
-        .unwrap();
+        .expect("Failed to create a surface using the current instance and window handle.");
 
       return surface;
     };
@@ -70,34 +104,3 @@ pub mod internal {
       .remove(adapter_num);
   }
 }
-
-pub struct InstanceBuilder {}
-
-impl InstanceBuilder {
-  pub fn new() -> Self {
-    return Self {};
-  }
-
-  pub fn build<RenderBackend: internal::Backend>(
-    self,
-    name: &str,
-  ) -> Instance<RenderBackend> {
-    return Instance::new(name);
-  }
-}
-
-pub struct Instance<RenderBackend: internal::Backend> {
-  gfx_hal_instance: RenderBackend::Instance,
-}
-
-impl<RenderBackend: internal::Backend> Instance<RenderBackend> {
-  /// Create a new GfxInstance connected to the platforms primary backend.
-  fn new(name: &str) -> Self {
-    let instance = RenderBackend::Instance::create(name, 1)
-      .expect("gfx backend not supported by the current platform");
-
-    return Self {
-      gfx_hal_instance: instance,
-    };
-  }
-}

tools/lambda_rs_demo/src/main.rs

@@ -6,7 +6,13 @@ use lambda::{
       Component,
       RenderableComponent,
     },
-    events::Events,
+    events::{
+      ComponentEvent,
+      Events,
+      KeyEvent,
+      RuntimeEvent,
+      WindowEvent,
+    },
     render::{
       command::RenderCommand,
       pipeline::{
@@ -39,7 +45,7 @@ pub struct DemoComponent {
 
 impl Component<Events> for DemoComponent {
   fn on_attach(&mut self) {
-    println!("Attached the first layer to lambda");
+    println!("Attached the DemoComponent.");
   }
 
   fn on_detach(self: &mut DemoComponent) {}
@@ -53,38 +59,38 @@ impl Component<Events> for DemoComponent {
         _ => {}
       },
       Events::Window { event, issued_at } => match event {
-        lambda::core::events::WindowEvent::Resize { width, height } => {
+        WindowEvent::Resize { width, height } => {
           println!("Window resized to {}x{}", width, height);
         }
-        lambda::core::events::WindowEvent::Close => {
+        WindowEvent::Close => {
           println!("Window closed");
         }
       },
       Events::Keyboard { event, issued_at } => match event {
-        lambda::core::events::KeyEvent::KeyPressed {
+        KeyEvent::KeyPressed {
           scan_code,
           virtual_key,
         } => {
           println!("Key pressed: {:?}", virtual_key);
         }
-        lambda::core::events::KeyEvent::KeyReleased {
+        KeyEvent::KeyReleased {
           scan_code,
           virtual_key,
         } => {
           println!("Key released: {:?}", virtual_key);
         }
-        lambda::core::events::KeyEvent::ModifierPressed {
+        KeyEvent::ModifierPressed {
           modifier,
           virtual_key,
         } => {
           println!("Modifier pressed: {:?}", virtual_key);
         }
       },
       Events::Component { event, issued_at } => match event {
-        lambda::core::events::ComponentEvent::Attached { name } => {
+        ComponentEvent::Attached { name } => {
           println!("Component attached: {:?}", name);
         }
-        lambda::core::events::ComponentEvent::Detached { name } => {
+        ComponentEvent::Detached { name } => {
           println!("Component detached: {:?}", name);
         }
       },
@@ -207,10 +213,10 @@ impl Default for DemoComponent {
 fn main() {
   let runtime = GenericRuntimeBuilder::new("2D Triangle Demo")
     .with_renderer(move |render_context_builder| {
-      return render_context_builder;
+      return render_context_builder.with_render_timeout(1_000_000_000);
     })
-    .with_component(move |kernel, demo: DemoComponent| {
-      return (kernel, demo);
+    .with_component(move |runtime, demo: DemoComponent| {
+      return (runtime, demo);
     })
     .build();