Merge pull request #37 from lambda-sh/vmarcella/rendering-improvements

Rendering improvements

Author: vmarcella

README.md

@@ -24,27 +24,28 @@ Lambda :
 * Desktop applications
 * Productivity tools
 * Data visualizations
-* Physical simulations
+* Physical system simulations
 * Games
 
-While lambda is still in beta, we're making sure to create a solid
-foundation other projects to build upon. Over the last couple of years, the
-prominence of the web has replaced traditional desktop applications. While
-this has lead to a golden age for developing UI/UX for applications across all
-platforms, it has come at the cost of degraded performance & resource consumption.
+Over the last couple of years, the prominence of the web has replaced
+traditional desktop applications. While this has lead to a golden age for
+developing UI/UX for applications across all platforms, it has come at the
+cost of degraded performance & resource consumption.
 
-Lambda's goal isn't to replace electron, webview, or other similar web based desktop
-frameworks, however; it is to instead create a cross platform ecosystem for
-desktop applications with performance and resource consumption at the forefront
-of it's priorities without sacrificing. Lambda will not be HTML/CSS based and will instead provide
+Lambda's goal isn't to replace electron, webview, or other similar web based
+desktop frameworks, however; it is to instead create a cross platform ecosystem
+for desktop applications with performance and resource consumption at the
+forefront of it's priorities without sacrificing good UI/UX. Lambda may offer
+lightweight HTML/CSS based rendering in the future but we're primarily focused
+on implementing a Rust native UI framework built on top of our rendering engine.
 
 ## Documentation <a name="documentation"></a>
 Documentation to be added soon.
 
 ## Building <a name="building"></a>
 
 ### From source <a name="source"></a>
-Currently, building from source is the only method to obtain a copy of Lambda. 
+Currently, building from source is the only method to obtain a copy of Lambda.
 
 #### Required external dependencies <a name="ext_deps"></a>
 * All platforms
@@ -56,12 +57,14 @@ Currently, building from source is the only method to obtain a copy of Lambda.
 	* `pre-commit` is used for development git commit hooks and any changes that do not pass the pre-commit checks will not be accepted.
 
 #### Rendering API support
-These are the Rendering APIs that are supported on each platform and must be installed manually. More information on how to choose which backend lambda uses on each platform is provided further below.
+These are the Rendering APIs that are supported on each platform and must be
+installed manually. More information on how to choose which backend lambda
+uses on each platform is provided further below.
 * Windows
 	* `OpenGL`
 	* `Vulkan`
 	* `DirectX11`
-	* `DirectX12` 
+	* `DirectX12`
 * Linux
 	* `OpenGL`
 	* `Vulkan`
@@ -74,7 +77,7 @@ If planning to develop for lambda, you must run the setup script provided by rep
 ```bash
 ./scripts/setup.sh
 ```
-This will initialize pre commit checks for development use and setup git-lfs for asset management. 
+This will initialize pre commit checks for development use and setup git-lfs for asset management.
 
 In order to validate that lambda successfully compiles, you can build the library by performing a build with cargo.
 ```bash
@@ -87,9 +90,9 @@ Coming soon.
 
 
 ## Plans <a name="plans"></a>
-- [ ] Architecture support
+- [x] Architecture support
 	- [x] x86
-	- [ ] arm64
+	- [x] arm64
 - [ ] Operating system support
 	- [x] MacOS
 	- [x] Linux
@@ -105,12 +108,12 @@ Coming soon.
 	- [x] DirectX12
 - [ ] Crates
 	- [ ] lambda-arch -- Architecture support
-	- [ ] (WIP) lambda-platform -- Platform support
+	- [x] (WIP) lambda-platform -- Platform support
 	- [ ] (WIP) lambda-core -- Core library implementations
 	- [ ] lambda-cloud -- Cloud integrations
-	- [ ] (WIP) lambda --  Stable Lambda API
+	- [ ] (WIP) lambda -- The public Lambda API
 - [ ] Tools
-	- [ ] lambda-rs-demo -- 2D rendering demo
+	- [x] lambda-rs-demo -- 2D rendering demo
 	- [ ] lambda-rs-cube -- 3D rendering demo
 	- [ ] lambda-checker -- Checks system specifications against lambda requirements
 - [ ] CI/CD
@@ -128,7 +131,7 @@ This process may take anywhere from 3-7 days depending on the scope of the
 changes made, my schedule, and any other variable factors. They must also pass
 all of the build pipelines are configured to run at merge.
 
-## Resources I used for creating this project. <a name="resources"></a>
+## Resources <a name="resources"></a>
 [The Cherno's playlist for making a game engine](https://www.youtube.com/playlist?list=PLlrATfBNZ98dC-V-N3m0Go4deliWHPFwT)
 
-[Creator of the repository logo.](https://github.com/RinniSwift)
+[Creator of Logo](https://github.com/RinniSwift)

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

@@ -35,19 +35,19 @@ pub mod winit_exports {
 }
 
 /// Loop wrapping for the winit event loop.
-pub struct Loop<E: 'static> {
+pub struct Loop<E: 'static + std::fmt::Debug> {
   event_loop: EventLoop<E>,
 }
 
-pub fn create_event_loop<Events: 'static>() -> Loop<Events> {
+pub fn create_event_loop<Events: 'static + std::fmt::Debug>() -> Loop<Events> {
   let event_loop = EventLoop::<Events>::with_user_event();
   return Loop { event_loop };
 }
 
 /// Structure that contains properties needed for building a window.
 pub struct WindowProperties {
   pub name: String,
-  pub dimensions: [u32; 2],
+  pub dimensions: (u32, u32),
   pub monitor_handle: MonitorHandle,
 }
 
@@ -70,25 +70,27 @@ pub struct WindowHandle {
 /// the monitor being rendered to.
 #[inline]
 fn construct_window_size(
-  window_size: [u32; 2],
+  window_size: (u32, u32),
   scale_factor: f64,
 ) -> WindowSize {
   let logical: LogicalSize<u32> = window_size.into();
   let physical: PhysicalSize<u32> = logical.to_physical(scale_factor);
 
+  let (width, height) = window_size;
   return WindowSize {
-    width: window_size[0],
-    height: window_size[1],
+    width,
+    height,
     logical,
     physical,
   };
 }
 
-pub struct EventLoopPublisher<E: 'static> {
+#[derive(Clone, Debug)]
+pub struct EventLoopPublisher<E: 'static + std::fmt::Debug> {
   winit_proxy: EventLoopProxy<E>,
 }
 
-impl<E: 'static> EventLoopPublisher<E> {
+impl<E: 'static + std::fmt::Debug> EventLoopPublisher<E> {
   /// Instantiate a new EventLoopPublisher from an event loop proxy.
   #[inline]
   pub fn new(winit_proxy: EventLoopProxy<E>) -> Self {
@@ -97,12 +99,15 @@ impl<E: 'static> EventLoopPublisher<E> {
 
   /// Send an event
   #[inline]
-  pub fn send_event(&self, event: E) {
-    self.winit_proxy.send_event(event);
+  pub fn publish_event(&self, event: E) {
+    self
+      .winit_proxy
+      .send_event(event)
+      .expect("Failed to send event");
   }
 }
 
-impl<E: 'static> Loop<E> {
+impl<E: 'static + std::fmt::Debug> Loop<E> {
   pub fn create_publisher(&mut self) -> EventLoopPublisher<E> {
     let proxy = self.event_loop.create_proxy();
     return EventLoopPublisher::new(proxy);
@@ -119,6 +124,7 @@ impl<E: 'static> Loop<E> {
   }
 
   pub fn get_any_available_monitors(&self) -> MonitorHandle {
+    // TODO(vmarcella): Remove the panic from this in favor of returning a result or an error.
     match self.event_loop.available_monitors().next() {
       Some(monitor) => monitor,
       None => panic!("No available monitors found."),

lambda/src/core/events.rs

@@ -1,22 +1,31 @@
 use std::time::Instant;
 
+/// events generated by kernel interactions with the component.
+#[derive(Debug)]
 pub enum ComponentEvent {
   Attached { name: String },
   Detached { name: String },
+  Update { delta: Instant },
 }
 
+/// Window events are generated in response to window events coming from
+/// the windowing system.
+#[derive(Debug)]
 pub enum WindowEvent {
   Close,
   Resize { width: u32, height: u32 },
 }
 
-pub enum KernelEvent {
+/// Kernel events are generated by the kernel itself
+#[derive(Debug)]
+pub enum RuntimeEvent {
   Initialized,
   Shutdown,
 }
 
-/// Generic Event Enum which encapsulates all possible events that will be emitted
-/// by the LambdaKernel
+/// Generic Event Enum which encapsulates all possible events that will be
+/// emitted by the LambdaKernel
+#[derive(Debug)]
 pub enum Events {
   Component {
     event: ComponentEvent,
@@ -26,8 +35,8 @@ pub enum Events {
     event: WindowEvent,
     issued_at: Instant,
   },
-  Kernel {
-    event: KernelEvent,
+  Runtime {
+    event: RuntimeEvent,
     issued_at: Instant,
   },
 }

lambda/src/core/kernel.rs

@@ -1,5 +1,5 @@
 pub mod component;
 pub mod events;
-pub mod kernel;
 pub mod render;
+pub mod runtime;
 pub mod window;

lambda/src/core/mod.rs

@@ -10,6 +10,7 @@ use super::{
   PlatformRenderCommand,
   RenderContext,
 };
+
 /// Commands that are used to render a frame within the RenderContext.
 pub enum RenderCommand {
   /// sets the viewports for the render context.

lambda/src/core/render/command.rs

@@ -126,11 +126,11 @@ impl RenderContextBuilder {
       internal::SurfaceBuilder::new().build(&instance, window.window_handle()),
     );
 
-    // Build a GPU with a 3D Render queue that can render to our surface.
+    // Build a GPU with a Graphical Render queue that can render to our surface.
     let mut gpu = internal::GpuBuilder::new()
       .with_render_queue_type(internal::RenderQueueType::Graphical)
       .build(&mut instance, Some(&surface))
-      .expect("Failed to build a GPU.");
+      .expect("Failed to build a GPU with a graphical render queue.");
 
     // Build command pool and allocate a single buffer named Primary
     let command_pool = internal::CommandPoolBuilder::new().build(&gpu);
@@ -145,9 +145,9 @@ impl RenderContextBuilder {
 
     // Create the image extent and initial frame buffer attachment description
     // for rendering.
-    let dimensions = window.dimensions();
+    let (width, height) = window.dimensions();
     let swapchain = SwapchainBuilder::new()
-      .with_size(dimensions[0], dimensions[1])
+      .with_size(width, height)
       .build(&gpu, &surface);
 
     Rc::get_mut(&mut surface)
@@ -194,27 +194,49 @@ impl RenderContext {
     println!("{} will now start destroying resources.", self.name);
 
     // Destroy the submission fence and rendering semaphore.
-    self.submission_fence.take().unwrap().destroy(&self.gpu);
-    self.render_semaphore.take().unwrap().destroy(&self.gpu);
+    self
+      .submission_fence
+      .take()
+      .expect(
+        "Couldn't take the submission fence from the context and destroy it.",
+      )
+      .destroy(&self.gpu);
+    self
+      .render_semaphore
+      .take()
+      .expect("Couldn't take the rendering semaphore 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().unwrap().destroy(&self);
+      render_pass
+        .take()
+        .expect(
+          "Couldn't take the render pass from the context and destroy it.",
+        )
+        .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);
+      render_pipeline
+        .take()
+        .expect(
+          "Couldn't take the render pipeline from the context and destroy it.",
+        )
+        .destroy(&self);
     }
 
     // Takes the inner surface and destroys it.
-    let mut surface = Rc::try_unwrap(self.surface).ok().unwrap();
+    let mut surface = Rc::try_unwrap(self.surface)
+      .expect("Couldn't obtain the surface from the context.");
+
     surface.remove_swapchain(&self.gpu);
     surface.destroy(&self.instance);
   }
@@ -273,13 +295,17 @@ impl RenderContext {
     self.gpu.submit_command_buffer(
       &mut command_buffer,
       vec![],
-      self.submission_fence.as_mut().unwrap(),
+      self
+        .submission_fence
+        .as_mut()
+        .expect("Failed to get mutable reference to submission fence."),
     );
 
     self
       .gpu
       .render_to_surface(
-        Rc::get_mut(&mut self.surface).expect(""),
+        Rc::get_mut(&mut self.surface)
+          .expect("Failed to obtain a surface to render on."),
         self.render_semaphore.as_mut().unwrap(),
       )
       .expect("Failed to render to the surface");