[update] logging for lambda modules.

Author: vmarcella

crates/lambda-rs-logging/README.md

@@ -0,0 +1,46 @@
+# lambda-rs-logging
+A simple logger implementation for lamba-rs crates. Inspired by
+python's [logging](https://docs.python.org/3/library/logging.html) module.
+
+
+# Installation
+First, add the following to your `Cargo.toml`:
+```toml
+[dependencies]
+lambda-rs-logging = "2023.1.30"
+```
+
+or run this command from your project directory:
+```bash
+cargo add lambda-rs-logging
+```
+
+# Getting started
+## Using the global logger
+```rust
+use logging;
+
+fn main() {
+  logging::trace!("Hello world");
+  logging::debug!("Hello world");
+  logging::info!("Hello world");
+  logging::warn!("Hello world");
+  logging::error!("Hello world");
+  logging::fatal!("Hello world");
+}
+```
+
+## Using an instance of the logger
+```rust
+use logging::Logger;
+
+fn main() {
+  let logger = Logger::new("my-logger");
+  logger.trace("Hello world");
+  logger.debug("Hello world");
+  logger.info("Hello world");
+  logger.warn("Hello world");
+  logger.error("Hello world");
+  logger.fatal("Hello world");
+}
+```

crates/lambda-rs-logging/src/handler.rs

@@ -125,12 +125,12 @@ impl ConsoleHandler {
     );
 
     let colored_message = match log_level {
-      LogLevel::TRACE => format!("\x1B[34m{}\x1B[0m\n", log_message),
-      LogLevel::DEBUG => format!("\x1B[33m{}\x1B[0m\n", log_message),
-      LogLevel::INFO => format!("\x1B[32m{}\x1B[0m\n", log_message),
-      LogLevel::WARN => format!("\x1B[31m{}\x1B[0m\n", log_message),
-      LogLevel::ERROR => format!("\x1B[31;1m{}\x1B[0m\n", log_message),
-      LogLevel::FATAL => format!("\x1B[31;1m{}\x1B[0m\n", log_message),
+      LogLevel::TRACE => format!("\x1B[37m{}\x1B[0m", log_message),
+      LogLevel::DEBUG => format!("\x1B[35m{}\x1B[0m", log_message),
+      LogLevel::INFO => format!("\x1B[32m{}\x1B[0m", log_message),
+      LogLevel::WARN => format!("\x1B[33m{}\x1B[0m", log_message),
+      LogLevel::ERROR => format!("\x1B[31;1m{}\x1B[0m", log_message),
+      LogLevel::FATAL => format!("\x1B[31;1m{}\x1B[0m", log_message),
     };
 
     println!("{}", colored_message);

crates/lambda-rs-logging/src/lib.rs

@@ -126,50 +126,50 @@ impl Logger {
   }
 }
 
-static mut LOGGER: Option<Logger> = None;
+pub(crate) static mut LOGGER: Option<Logger> = None;
 
 /// Trace logging macro using the global logger instance.
 #[macro_export]
 macro_rules! trace {
   ($($arg:tt)*) => {
-      Logger::global().trace(format!("{}", format_args!($($arg)*)));
+      logging::Logger::global().trace(format!("{}", format_args!($($arg)*)));
   };
 }
 
 /// Trace logging macro using the global logger instance.
 #[macro_export]
 macro_rules! debug {
   ($($arg:tt)*) => {
-      Logger::global().debug(format!("{}", format_args!($($arg)*)));
+      logging::Logger::global().debug(format!("{}", format_args!($($arg)*)));
   };
 }
 
 /// Trace logging macro using the global logger instance.
 #[macro_export]
 macro_rules! info {
   ($($arg:tt)*) => {
-      Logger::global().info(format!("{}", format_args!($($arg)*)));
+      logging::Logger::global().info(format!("{}", format_args!($($arg)*)));
   };
 }
 
 // Define logging macros that use the global logger instance
 #[macro_export]
 macro_rules! warn {
   ($($arg:tt)*) => {
-      Logger.global().warn(format!("{}", format_args!($($arg)*)));
+      logging::Logger::global().warn(format!("{}", format_args!($($arg)*)));
   };
 }
 
 #[macro_export]
 macro_rules! error {
   ($($arg:tt)*) => {
-      Logger::global().error(format!("{}", format_args!($($arg)*)));
+      logging::Logger::global().error(format!("{}", format_args!($($arg)*)));
   };
 }
 
 #[macro_export]
 macro_rules! fatal {
   ($($arg:tt)*) => {
-      Logger::global().fatal(format!("{}", format_args!($($arg)*)));
+      logging::Logger::global().fatal(format!("{}", format_args!($($arg)*)));
   };
 }

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

@@ -33,6 +33,7 @@ pub struct ShaderCompiler {
 }
 
 /// Meta Representations of real shaders to use for easy compilation
+#[derive(Debug, Clone)]
 pub enum VirtualShader {
   File {
     path: String,

crates/lambda-rs/src/render/buffer.rs

@@ -17,6 +17,7 @@ pub use lambda_platform::gfx::buffer::{
   Properties,
   Usage,
 };
+use logging;
 
 use super::{
   mesh::Mesh,
@@ -143,12 +144,21 @@ impl BufferBuilder {
 
     match buffer_allocation {
       Ok(buffer) => {
+        logging::debug!(
+          "Buffer allocation for {:?} succeeded.",
+          self.buffer_type
+        );
         return Ok(Buffer {
           buffer: Rc::new(buffer),
           buffer_type: self.buffer_type,
         });
       }
       Err(error) => {
+        logging::error!(
+          "Buffer allocation for {:?} failed with error: {:?}",
+          self.buffer_type,
+          error
+        );
         return Err(error);
       }
     }

crates/lambda-rs/src/render/pipeline.rs

@@ -27,15 +27,19 @@ pub struct RenderPipeline {
 impl RenderPipeline {
   /// Destroy the render pipeline with the render context that created it.
   pub fn destroy(self, render_context: &RenderContext) {
+    logging::trace!("Destroying render pipeline");
     Rc::try_unwrap(self.pipeline)
       .expect("Failed to destroy render pipeline")
       .destroy(render_context.internal_gpu());
 
+    logging::trace!("Destroying buffers");
     for buffer in self.buffers {
       Rc::try_unwrap(buffer)
         .expect("Failed to get high level buffer.")
         .destroy(render_context);
     }
+
+    logging::info!("Render pipeline & all attached buffers destroyed");
   }
 }
 
@@ -103,21 +107,21 @@ impl RenderPipelineBuilder {
     vertex_shader: &Shader,
     fragment_shader: Option<&Shader>,
   ) -> RenderPipeline {
-    println!("[DEBUG] Building render pipeline...");
+    logging::debug!("Building render pipeline");
 
-    print!("[DEBUG] Building vertex shader... ");
+    logging::debug!("Building vertex shader... ");
     let vertex_shader_module = ShaderModuleBuilder::new().build(
       render_context.internal_mutable_gpu(),
       &vertex_shader.as_binary(),
       ShaderModuleType::Vertex,
     );
 
-    println!(
-      " Done. (Vertex shader: {} bytes)",
+    logging::debug!(
+      "\tDone. (Vertex shader: {} bytes)",
       vertex_shader.as_binary().len()
     );
 
-    print!("[DEBUG] Building fragment shader... ");
+    logging::debug!("Building fragment shader... ");
     let fragment_shader_module = match fragment_shader {
       Some(shader) => Some(ShaderModuleBuilder::new().build(
         render_context.internal_mutable_gpu(),
@@ -127,8 +131,8 @@ impl RenderPipelineBuilder {
       None => None,
     };
 
-    println!(
-      " Done. (Fragment shader: {} bytes)",
+    logging::debug!(
+      "\tDone. (Fragment shader: {} bytes)",
       fragment_shader.map(|s| s.as_binary().len()).unwrap_or(0)
     );
 

crates/lambda-rs/src/render/render_pass.rs

@@ -16,6 +16,7 @@ impl RenderPass {
     Rc::try_unwrap(self.render_pass)
       .expect("Failed to destroy render pass. Is something holding a reference to it?")
       .destroy(render_context.internal_gpu());
+    logging::debug!("Render pass destroyed");
   }
 }
 

crates/lambda-rs/src/render/shader.rs

@@ -22,6 +22,7 @@ impl ShaderBuilder {
   /// Compiles the virtual shader into a real shader with SPIR-V binary
   /// representation.
   pub fn build(&mut self, virtual_shader: VirtualShader) -> Shader {
+    logging::trace!("Compiling shader: {:?}", virtual_shader);
     let binary = self.compiler.compile_into_binary(&virtual_shader);
 
     return Shader {

crates/lambda-rs/src/render/window.rs

@@ -81,6 +81,7 @@ impl Window {
       .with_window_properties(window_properties, event_loop)
       .build();
 
+    logging::debug!("Created window: {}", name);
     return Self { window_handle };
   }
 

crates/lambda-rs/src/runtime.rs

@@ -2,6 +2,8 @@
 
 use std::fmt::Debug;
 
+use logging;
+
 /// A runtime is an important but simple type in lambda that is responsible for
 /// executing the application. The event loop for the application is started
 /// within the runtime and should live for the duration of the application.
@@ -23,10 +25,10 @@ pub fn start_runtime<R: Sized + Debug, E: Sized + Debug, T: Runtime<R, E>>(
   let runtime_result = runtime.run();
   match runtime_result {
     Ok(_) => {
-      print!("[INFO] Runtime finished successfully.");
+      logging::info!("Runtime finished successfully.");
     }
     Err(e) => {
-      println!("[FATAL] Runtime panicked because: {:?}", e);
+      logging::fatal!("Runtime panicked because: {:?}", e);
     }
   }
 }