chore(math): remove warnings

crates/comet_app/src/app.rs

@@ -33,7 +33,6 @@ pub struct App {
     game_state: Option<Box<dyn Any>>,
     audio: Box<dyn Audio>,
     scene: Scene,
-    fullscreen: bool,
     should_quit: bool,
 }
 
@@ -51,7 +50,6 @@ impl App {
             game_state: None,
             audio: Box::new(KiraAudio::new()),
             scene: Scene::new(),
-            fullscreen: false,
             should_quit: false,
         }
     }
@@ -372,6 +370,7 @@ impl App {
                         }
                     }
 
+                    #[allow(unused_variables)]
                     match event {
                         Event::WindowEvent {
                             ref event,

crates/comet_ecs/component_derive/src/lib.rs

@@ -2,16 +2,12 @@ extern crate proc_macro;
 
 use proc_macro::TokenStream;
 use quote::quote;
-use syn::{parse_macro_input, DeriveInput, Data, Fields};
+use syn::{parse_macro_input, Data, DeriveInput, Fields};
 
-// This is the procedural macro for `derive(MyTrait)`
 #[proc_macro_derive(Component)]
-pub fn my_trait_derive(input: TokenStream) -> TokenStream {
-    // Parse the input tokens into a syntax tree (AST)
+pub fn component_derive(input: TokenStream) -> TokenStream {
     let input = parse_macro_input!(input as DeriveInput);
 
-    // Get the name of the struct
-    let name = &input.ident;
     let name = &input.ident;
 
     let fields = if let Data::Struct(data) = &input.data {
@@ -33,19 +29,21 @@ pub fn my_trait_derive(input: TokenStream) -> TokenStream {
 
     let default_fields = if let Data::Struct(data) = &input.data {
         match &data.fields {
-            Fields::Named(fields) => {
-                // Generate code to assign each field a default value
-                fields.named.iter().map(|field| {
+            Fields::Named(fields) => fields
+                .named
+                .iter()
+                .map(|field| {
                     let field_name = &field.ident;
                     quote! { #field_name: Default::default() }
-                }).collect::<Vec<_>>()
-            },
-            Fields::Unnamed(fields) => {
-                // Generate default values for tuple structs
-                fields.unnamed.iter().map(|_field| {
+                })
+                .collect::<Vec<_>>(),
+            Fields::Unnamed(fields) => fields
+                .unnamed
+                .iter()
+                .map(|_field| {
                     quote! { Default::default() }
-                }).collect::<Vec<_>>()
-            },
+                })
+                .collect::<Vec<_>>(),
             Fields::Unit => Vec::new(),
         }
     } else {
@@ -59,13 +57,6 @@ pub fn my_trait_derive(input: TokenStream) -> TokenStream {
         }
     });
 
-    for field in &fields {
-        if !is_copy_field(&field) {
-            panic!("All fields in the struct must implement Copy");
-        }
-    }
-
-    // Generate the implementation of MyTrait for the given struct
     let expanded = quote! {
         impl Component for #name {
             fn new() -> Self {
@@ -83,7 +74,6 @@ pub fn my_trait_derive(input: TokenStream) -> TokenStream {
 
         impl Default for #name {
             fn default() -> Self {
-                // Construct the struct with default values
                 Self {
                     #(#default_fields),*
                 }
@@ -115,16 +105,5 @@ pub fn my_trait_derive(input: TokenStream) -> TokenStream {
         }
     };
 
-    // Convert the generated code into a TokenStream and return it
     TokenStream::from(expanded)
 }
-
-
-fn is_copy_field(field: &syn::Field) -> bool {
-    // Logic to check if the field type implements Copy (this is simplified)
-    // You might need more sophisticated logic to check the actual type of the field.
-    let field_type = &field.ty;
-    // Implement a check for Copy trait for the field type if needed
-    // Return true if it implements Copy; false otherwise
-    true // Assuming it does, just for simplicity
-}

crates/comet_ecs/src/archetypes.rs

@@ -1,59 +1,47 @@
-use std::collections::{HashMap, HashSet};
 use comet_structs::ComponentSet;
+use std::collections::{HashMap, HashSet};
 
 #[derive(Debug, Clone)]
 pub struct Archetypes {
-	archetypes: HashMap<ComponentSet, HashSet<u32>>
+    archetypes: HashMap<ComponentSet, HashSet<u32>>,
 }
 
 impl Archetypes {
-	pub fn new() -> Self {
-		Self {
-			archetypes: HashMap::new()
-		}
-	}
+    pub fn new() -> Self {
+        Self {
+            archetypes: HashMap::new(),
+        }
+    }
 
-	pub fn component_sets(&self) -> Vec<ComponentSet> {
-		self.archetypes.keys().cloned().collect()
-	}
+    pub fn component_sets(&self) -> Vec<ComponentSet> {
+        self.archetypes.keys().cloned().collect()
+    }
 
-	pub fn create_archetype(&mut self, components: ComponentSet) {
-		self.archetypes.insert(components, HashSet::new());
-	}
+    pub fn create_archetype(&mut self, components: ComponentSet) {
+        self.archetypes.insert(components, HashSet::new());
+    }
 
-	pub fn get_archetype(&self, components: &ComponentSet) -> Option<&HashSet<u32>> {
-		self.archetypes.get(components)
-	}
+    pub fn get_archetype(&self, components: &ComponentSet) -> Option<&HashSet<u32>> {
+        self.archetypes.get(components)
+    }
 
-	pub fn get_archetype_mut(&mut self, components: &ComponentSet) -> Option<&mut HashSet<u32>> {
-		self.archetypes.get_mut(components)
-	}
+    pub fn add_entity_to_archetype(&mut self, components: &ComponentSet, entity: u32) {
+        if let Some(archetype) = self.archetypes.get_mut(components) {
+            archetype.insert(entity);
+        }
+    }
 
-	pub fn add_entity_to_archetype(&mut self, components: &ComponentSet, entity: u32) {
-		if let Some(archetype) = self.archetypes.get_mut(components) {
-			archetype.insert(entity);
-		}
-	}
+    pub fn remove_entity_from_archetype(&mut self, components: &ComponentSet, entity: u32) {
+        if let Some(archetype) = self.archetypes.get_mut(components) {
+            archetype.retain(|&id| id != entity);
+        }
+    }
 
-	pub fn remove_entity_from_archetype(&mut self, components: &ComponentSet, entity: u32) {
-		if let Some(archetype) = self.archetypes.get_mut(components) {
-			archetype.retain(|&id| id != entity);
-		}
-	}
+    pub fn remove_archetype(&mut self, components: &ComponentSet) {
+        self.archetypes.remove(components);
+    }
 
-	pub fn remove_archetype(&mut self, components: &ComponentSet) {
-		self.archetypes.remove(components);
-	}
-
-	pub fn contains_archetype(&self, components: &ComponentSet) -> bool {
-		self.archetypes.contains_key(components)
-	}
-
-	pub fn archetype_contains_entity(&self, entity_id: u32, components: &ComponentSet) -> bool {
-		if self.contains_archetype(components) {
-			let archetype = self.get_archetype(components).unwrap();
-			return archetype.contains(&entity_id);
-		}
-		false
-	}
+    pub fn contains_archetype(&self, components: &ComponentSet) -> bool {
+        self.archetypes.contains_key(components)
+    }
 }

crates/comet_input/src/input_handler.rs

@@ -1,73 +1,81 @@
-use winit::event::{ElementState, WindowEvent, KeyEvent, Event};
-use std::collections::HashSet;
-use winit::event::WindowEvent::KeyboardInput;
-use winit::keyboard::PhysicalKey;
 use crate::keyboard::Key;
+use winit::event::{ElementState, Event, KeyEvent, WindowEvent};
+use winit::keyboard::PhysicalKey;
 
 #[derive(Debug)]
 pub struct InputHandler {
-	keys_pressed: Vec<PhysicalKey>,
-	keys_held: Vec<PhysicalKey>,
-	keys_released: Vec<PhysicalKey>
+    keys_pressed: Vec<PhysicalKey>,
+    keys_held: Vec<PhysicalKey>,
+    keys_released: Vec<PhysicalKey>,
 }
 
 impl InputHandler {
-	pub fn new() -> Self {
-		Self {
-			keys_pressed: Vec::new(),
-			keys_held: Vec::new(),
-			keys_released: Vec::new()
-		}
-	}
+    pub fn new() -> Self {
+        Self {
+            keys_pressed: Vec::new(),
+            keys_held: Vec::new(),
+            keys_released: Vec::new(),
+        }
+    }
 
-	pub fn update<T>(&mut self, event: &Event<T>) {
-		match event {
-			Event::WindowEvent {
-				event: WindowEvent::KeyboardInput {
-					event: KeyEvent {
-						state,
-						physical_key: PhysicalKey::Code(keycode),
-						..
-					},
-					..
-				},
-				..
-			} =>
-				{
-					match state {
-						ElementState::Pressed => {
-							if self.keys_pressed.contains(&PhysicalKey::Code(keycode.clone())) {
-								self.keys_held.push(PhysicalKey::Code(keycode.clone()));
-							} else {
-								self.keys_pressed.push(PhysicalKey::Code(keycode.clone()));
-							}
-							self.keys_pressed.push(PhysicalKey::Code(keycode.clone()));
-						}
-						ElementState::Released => {
-							self.keys_released = vec![];
-							if let Some(index) = self.keys_pressed.iter().position(|&x| x == PhysicalKey::Code(keycode.clone())) {
-								self.keys_pressed.remove(index);
-							}
-							if let Some(index) = self.keys_held.iter().position(|&x| x == PhysicalKey::Code(keycode.clone())) {
-								self.keys_held.remove(index);
-							}
-							self.keys_released.push(PhysicalKey::Code(keycode.clone()));
-						}
-					}
-				}
-			_ => {}
-		}
-	}
+    pub fn update<T>(&mut self, event: &Event<T>) {
+        match event {
+            Event::WindowEvent {
+                event:
+                    WindowEvent::KeyboardInput {
+                        event:
+                            KeyEvent {
+                                state,
+                                physical_key: PhysicalKey::Code(keycode),
+                                ..
+                            },
+                        ..
+                    },
+                ..
+            } => match state {
+                ElementState::Pressed => {
+                    if self
+                        .keys_pressed
+                        .contains(&PhysicalKey::Code(keycode.clone()))
+                    {
+                        self.keys_held.push(PhysicalKey::Code(keycode.clone()));
+                    } else {
+                        self.keys_pressed.push(PhysicalKey::Code(keycode.clone()));
+                    }
+                    self.keys_pressed.push(PhysicalKey::Code(keycode.clone()));
+                }
+                ElementState::Released => {
+                    self.keys_released = vec![];
+                    if let Some(index) = self
+                        .keys_pressed
+                        .iter()
+                        .position(|&x| x == PhysicalKey::Code(keycode.clone()))
+                    {
+                        self.keys_pressed.remove(index);
+                    }
+                    if let Some(index) = self
+                        .keys_held
+                        .iter()
+                        .position(|&x| x == PhysicalKey::Code(keycode.clone()))
+                    {
+                        self.keys_held.remove(index);
+                    }
+                    self.keys_released.push(PhysicalKey::Code(keycode.clone()));
+                }
+            },
+            _ => {}
+        }
+    }
 
-	pub fn key_pressed(&self, key: Key) -> bool {
-		self.keys_pressed.contains(&PhysicalKey::Code(key))
-	}
+    pub fn key_pressed(&self, key: Key) -> bool {
+        self.keys_pressed.contains(&PhysicalKey::Code(key))
+    }
 
-	pub fn key_held(&self, key: Key) -> bool {
-		self.keys_held.contains(&PhysicalKey::Code(key))
-	}
+    pub fn key_held(&self, key: Key) -> bool {
+        self.keys_held.contains(&PhysicalKey::Code(key))
+    }
 
-	pub fn key_released(&self, key: Key) -> bool {
-		self.keys_released.contains(&PhysicalKey::Code(key))
-	}
+    pub fn key_released(&self, key: Key) -> bool {
+        self.keys_released.contains(&PhysicalKey::Code(key))
+    }
 }

crates/comet_math/Cargo.toml

@@ -8,3 +8,4 @@ comet_log = { path = "../comet_log" }
 rand = "0.9.0-beta.1"
 image = { version = "0.24", default_features = false, features = ["png", "jpeg", "hdr"] }
 chrono = "0.4.40"
+serde = { version = "1.0", features = ["derive"] }

crates/comet_math/src/bezier.rs

@@ -1,4 +1,4 @@
-use crate::{InnerSpace, Point};
+use crate::InnerSpace;
 
 /// Representation of a Bezier curve of degree n in any (2-4) dimensions.
 pub struct Bezier<V: InnerSpace> {

crates/comet_math/src/matrix.rs

@@ -1,6 +1,7 @@
 use crate::vector::{v2, v3, v4};
 use std::ops::*;
 
+#[allow(dead_code)]
 trait LinearTransformation {
     fn det(&self) -> f32;
 }
@@ -12,6 +13,7 @@ trait LinearTransformation {
 /// Representation of a 2x2 matrix.
 #[repr(C)]
 #[derive(Debug, PartialEq)]
+#[allow(non_camel_case_types)]
 pub struct m2 {
     x00: f32,
     x01: f32,
@@ -208,6 +210,7 @@ impl Into<[[f32; 2]; 2]> for m2 {
 /// Representation of a 3x3 matrix.
 #[repr(C)]
 #[derive(Debug, PartialEq)]
+#[allow(non_camel_case_types)]
 pub struct m3 {
     x00: f32,
     x01: f32,
@@ -497,6 +500,7 @@ impl Into<[[f32; 3]; 3]> for m3 {
 /// Representation of a 4x4 matrix.
 #[repr(C)]
 #[derive(Debug, PartialEq)]
+#[allow(non_camel_case_types)]
 pub struct m4 {
     x00: f32,
     x01: f32,

crates/comet_math/src/noise.rs

@@ -323,9 +323,12 @@ impl ValueNoise {
                 let mut f = 0.0;
                 let mut amplitude = 0.5;
 
-                f += amplitude * self.noise(uv);
-                uv = (uv.0 * 2.0, uv.1 * 2.0);
-                amplitude *= 0.5;
+                for _ in 0..4 {
+                    f += amplitude * self.noise(uv);
+                    uv = (uv.0 * 2.0, uv.1 * 2.0);
+                    amplitude *= 0.5;
+                }
+
                 f = ((f / max_amplitude) + 1.0) * 0.5;
 
                 noise.push(f);

crates/comet_math/src/point.rs

@@ -7,6 +7,7 @@ pub trait Point {
 }
 
 /// Representation of a 2D point.
+#[allow(non_camel_case_types)]
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub struct p2 {
     x: f32,
@@ -36,6 +37,7 @@ impl p2 {
 }
 
 /// Representation of a 3D point.
+#[allow(non_camel_case_types)]
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub struct p3 {
     x: f32,
@@ -81,7 +83,7 @@ impl Point for p2 {
         Self { x, y }
     }
 
-    fn to_vec(&self) -> v2 {
+    fn to_vec(&self) -> impl InnerSpace {
         v2::new(self.x, self.y)
     }
 }
@@ -93,23 +95,11 @@ impl Point for p3 {
         Self { x, y, z }
     }
 
-    fn to_vec(&self) -> v3 {
+    fn to_vec(&self) -> impl InnerSpace {
         v3::new(self.x, self.y, self.z)
     }
 }
 
-impl Into<v2> for p2 {
-    fn into(self) -> v2 {
-        self.to_vec()
-    }
-}
-
-impl Into<v3> for p3 {
-    fn into(self) -> v3 {
-        self.to_vec()
-    }
-}
-
 impl From<v2> for p2 {
     fn from(v: v2) -> Self {
         Self::from_vec(v)

crates/comet_math/src/polynomial.rs

@@ -118,7 +118,7 @@ impl Div for Polynomial {
         let divisor = other.coefficients.clone();
         while dividend.len() >= divisor.len() {
             let mut quotient = vec![0.0; dividend.len() - divisor.len() + 1];
-            let mut i = dividend.len() - divisor.len();
+            let i = dividend.len() - divisor.len();
             quotient[i] = dividend.last().unwrap() / divisor.last().unwrap();
             for (j, &d) in divisor.iter().enumerate() {
                 dividend[i + j] -= quotient[i] * d;

crates/comet_math/src/quaternion.rs

@@ -11,6 +11,7 @@ pub struct Quat {
 
 impl Quat {
     /// The zero quaternion.
+    #[allow(unused)]
     const ZERO: Self = Self {
         s: 0.0,
         v: v3 {

crates/comet_math/src/vector.rs

@@ -1,6 +1,9 @@
-use crate::point::{p2, p3};
-use crate::quaternion::Quat;
-use crate::Point;
+use crate::{
+    point::{p2, p3},
+    quaternion::Quat,
+    Point,
+};
+use serde::{Deserialize, Serialize};
 use std::ops::*;
 
 pub trait InnerSpace:
@@ -31,8 +34,7 @@ pub trait InnerSpace:
 
 /// Representation of a 2D vector
 #[repr(C)]
-#[derive(Debug, Clone, Copy, PartialEq, Default)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[derive(Debug, Clone, Copy, PartialEq, Default, Serialize, Deserialize)]
 #[allow(non_camel_case_types)]
 pub struct v2 {
     x: f32,
@@ -175,8 +177,7 @@ impl Into<v2> for [f32; 2] {
 
 /// Representation of a 2D integer vector
 #[repr(C)]
-#[derive(Debug, Clone, Copy, PartialEq, Default)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[derive(Debug, Clone, Copy, PartialEq, Default, Serialize, Deserialize)]
 #[allow(non_camel_case_types)]
 pub struct v2i {
     x: i64,
@@ -423,8 +424,7 @@ impl Into<[f32; 2]> for v2i {
 
 /// Representation of a 3D vector
 #[repr(C)]
-#[derive(Debug, Clone, Copy, PartialEq, Default)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[derive(Debug, Clone, Copy, PartialEq, Default, Serialize, Deserialize)]
 #[allow(non_camel_case_types)]
 pub struct v3 {
     pub x: f32,
@@ -620,8 +620,7 @@ impl Into<v3> for [f32; 3] {
 
 /// Representation of a 3D integer vector
 #[repr(C)]
-#[derive(Debug, Clone, Copy, PartialEq, Default)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[derive(Debug, Clone, Copy, PartialEq, Default, Serialize, Deserialize)]
 #[allow(non_camel_case_types)]
 pub struct v3i {
     pub x: i64,
@@ -824,8 +823,7 @@ impl From<v3> for v3i {
 
 /// Representation of a 4D vector
 #[repr(C)]
-#[derive(Debug, Clone, Copy, PartialEq, Default)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[derive(Debug, Clone, Copy, PartialEq, Default, Serialize, Deserialize)]
 #[allow(non_camel_case_types)]
 pub struct v4 {
     x: f32,

crates/comet_renderer/src/camera.rs

@@ -1,5 +1,4 @@
 use comet_ecs::{Camera2D, Transform2D};
-use comet_log::fatal;
 use comet_math::{m4, v2, v3};
 
 pub struct CameraManager {
@@ -15,16 +14,6 @@ impl CameraManager {
         }
     }
 
-    pub fn set_cameras(&mut self, cameras: Vec<RenderCamera>) {
-        self.cameras = cameras
-    }
-
-    pub fn set_active(&mut self, active: usize) {
-        if active >= self.cameras.len() {
-            fatal!("Active camera index is out of range of the RenderCamera array!")
-        }
-    }
-
     pub fn get_camera(&self) -> &RenderCamera {
         self.cameras.get(self.active_camera).unwrap()
     }

crates/comet_resources/src/font.rs

@@ -1,120 +1,120 @@
-use image::{DynamicImage, Rgba, RgbaImage};
-use ab_glyph::{FontArc, PxScale, ScaleFont, Glyph, point, Font as AbFont};
-use comet_log::debug;
 use crate::texture_atlas::{TextureAtlas, TextureRegion};
+use ab_glyph::{point, Font as AbFont, FontArc, Glyph, PxScale, ScaleFont};
+use image::{DynamicImage, Rgba, RgbaImage};
 
 pub struct GlyphData {
-	pub name: String,
-	pub render: DynamicImage,
-	pub advance: f32,
-	pub offset_x: f32,
-	pub offset_y: f32,
+    pub name: String,
+    pub render: DynamicImage,
+    pub advance: f32,
+    pub offset_x: f32,
+    pub offset_y: f32,
 }
 
 pub struct Font {
-	name: String,
-	size: f32,
-	line_height: f32,
-	glyphs: TextureAtlas,
+    name: String,
+    size: f32,
+    line_height: f32,
+    glyphs: TextureAtlas,
 }
 
 impl Font {
-	pub fn new(path: &str, size: f32) -> Self {
-		let (glyphs, line_height) = Self::generate_atlas(path, size);
-		Font {
-			name: path.to_string(),
-			size,
-			line_height,
-			glyphs
-		}
-	}
+    pub fn new(path: &str, size: f32) -> Self {
+        let (glyphs, line_height) = Self::generate_atlas(path, size);
+        Font {
+            name: path.to_string(),
+            size,
+            line_height,
+            glyphs,
+        }
+    }
 
-	pub fn name(&self) -> &str {
-		&self.name
-	}
+    pub fn name(&self) -> &str {
+        &self.name
+    }
 
-	pub fn size(&self) -> f32 {
-		self.size
-	}
+    pub fn size(&self) -> f32 {
+        self.size
+    }
 
-	pub fn line_height(&self) -> f32 {
-		self.line_height
-	}
+    pub fn line_height(&self) -> f32 {
+        self.line_height
+    }
 
-	pub fn glyphs(&self) -> &TextureAtlas {
-		&self.glyphs
-	}
+    pub fn glyphs(&self) -> &TextureAtlas {
+        &self.glyphs
+    }
 
-	pub fn get_glyph(&self, ch: char) -> Option<&TextureRegion> {
-		self.glyphs.textures().get(&ch.to_string())
-	}
+    pub fn get_glyph(&self, ch: char) -> Option<&TextureRegion> {
+        self.glyphs.textures().get(&ch.to_string())
+    }
 
-	fn generate_atlas(path: &str, size: f32) -> (TextureAtlas, f32) {
-		let font_data = std::fs::read(path).expect("Failed to read font file");
-		let font = FontArc::try_from_vec(font_data).expect("Failed to load font");
+    fn generate_atlas(path: &str, size: f32) -> (TextureAtlas, f32) {
+        let font_data = std::fs::read(path).expect("Failed to read font file");
+        let font = FontArc::try_from_vec(font_data).expect("Failed to load font");
 
-		let scale = PxScale::from(size);
-		let scaled_font = font.as_scaled(scale);
+        let scale = PxScale::from(size);
+        let scaled_font = font.as_scaled(scale);
 
-		let mut glyphs: Vec<GlyphData> = Vec::new();
+        let mut glyphs: Vec<GlyphData> = Vec::new();
 
-		for code_point in 0x0020..=0x007E {
-			if let Some(ch) = std::char::from_u32(code_point) {
-				let glyph_id = font.glyph_id(ch);
-				if glyph_id.0 == 0 {
-					continue;
-				}
+        for code_point in 0x0020..=0x007E {
+            if let Some(ch) = std::char::from_u32(code_point) {
+                let glyph_id = font.glyph_id(ch);
+                if glyph_id.0 == 0 {
+                    continue;
+                }
 
-				if ch == ' ' {
-					let advance = scaled_font.h_advance(glyph_id);
-					glyphs.push(GlyphData {
-						name: ch.to_string(),
-						render: DynamicImage::new_rgba8(0, 0), // no bitmap
-						advance,
-						offset_x: 0.0,
-						offset_y: 0.0,
-					});
-					continue;
-				}
+                if ch == ' ' {
+                    let advance = scaled_font.h_advance(glyph_id);
+                    glyphs.push(GlyphData {
+                        name: ch.to_string(),
+                        render: DynamicImage::new_rgba8(0, 0), // no bitmap
+                        advance,
+                        offset_x: 0.0,
+                        offset_y: 0.0,
+                    });
+                    continue;
+                }
 
-				let glyph = Glyph {
-					id: glyph_id,
-					scale,
-					position: point(0.0, 0.0),
-				};
+                let glyph = Glyph {
+                    id: glyph_id,
+                    scale,
+                    position: point(0.0, 0.0),
+                };
 
-				if let Some(outline) = scaled_font.outline_glyph(glyph.clone()) {
-					let bounds = outline.px_bounds();
-					let width = bounds.width().ceil() as u32;
-					let height = bounds.height().ceil() as u32;
+                if let Some(outline) = scaled_font.outline_glyph(glyph.clone()) {
+                    let bounds = outline.px_bounds();
+                    let width = bounds.width().ceil() as u32;
+                    let height = bounds.height().ceil() as u32;
 
-					if width == 0 || height == 0 {
-						continue;
-					}
+                    if width == 0 || height == 0 {
+                        continue;
+                    }
 
-					let mut image = RgbaImage::new(width, height);
-					for pixel in image.pixels_mut() {
-						*pixel = Rgba([0, 0, 0, 0]);
-					}
+                    let mut image = RgbaImage::new(width, height);
+                    for pixel in image.pixels_mut() {
+                        *pixel = Rgba([0, 0, 0, 0]);
+                    }
 
-					outline.draw(|x, y, v| {
-						let alpha = (v * 255.0) as u8;
-						image.put_pixel(x, y, Rgba([255, 255, 255, alpha]));
-					});
+                    outline.draw(|x, y, v| {
+                        let alpha = (v * 255.0) as u8;
+                        image.put_pixel(x, y, Rgba([255, 255, 255, alpha]));
+                    });
 
-					glyphs.push(
-						GlyphData {
-							name: ch.to_string(),
-							render: DynamicImage::ImageRgba8(image),
-							advance: scaled_font.h_advance(glyph_id),
-							offset_x: bounds.min.x,
-							offset_y: bounds.min.y,
-						}
-					)
-				}
-			}
-		}
+                    glyphs.push(GlyphData {
+                        name: ch.to_string(),
+                        render: DynamicImage::ImageRgba8(image),
+                        advance: scaled_font.h_advance(glyph_id),
+                        offset_x: bounds.min.x,
+                        offset_y: bounds.min.y,
+                    })
+                }
+            }
+        }
 
-		(TextureAtlas::from_glyphs(glyphs), scaled_font.ascent() - scaled_font.descent())
-	}
+        (
+            TextureAtlas::from_glyphs(glyphs),
+            scaled_font.ascent() - scaled_font.descent(),
+        )
+    }
 }

crates/comet_resources/src/resources.rs

@@ -1,182 +1,181 @@
-use std::{
-	collections::HashMap, path::Path
+use std::{collections::HashMap, path::Path};
+
+use crate::{
+    texture,
+    texture_atlas::{TextureAtlas, TextureRegion},
 };
 
-use wgpu::{Device, FilterMode, Queue, TextureFormat, TextureUsages};
-use crate::{texture, Texture};
-use crate::texture_atlas::{TextureAtlas, TextureRegion};
-
 pub struct ResourceManager {
-	texture_atlas: TextureAtlas,
-	data_files: HashMap<String, String>
+    texture_atlas: TextureAtlas,
+    data_files: HashMap<String, String>,
 }
 
 impl ResourceManager {
-	pub fn new() -> Self {
-		Self {
-			texture_atlas: TextureAtlas::empty(),
-			data_files: HashMap::new()
-		}
-	}
+    pub fn new() -> Self {
+        Self {
+            texture_atlas: TextureAtlas::empty(),
+            data_files: HashMap::new(),
+        }
+    }
 
-	pub fn texture_atlas(&self) -> &TextureAtlas {
-		&self.texture_atlas
-	}
+    pub fn texture_atlas(&self) -> &TextureAtlas {
+        &self.texture_atlas
+    }
 
-	pub fn texture_locations(&self) -> &HashMap<String, TextureRegion> {
-		&self.texture_atlas.textures()
-	}
+    pub fn texture_locations(&self) -> &HashMap<String, TextureRegion> {
+        &self.texture_atlas.textures()
+    }
 
-	pub fn data_files(&self) -> &HashMap<String, String> {
-		&self.data_files
-	}
+    pub fn data_files(&self) -> &HashMap<String, String> {
+        &self.data_files
+    }
 
-	pub fn set_texture_atlas(&mut self, texture_atlas: TextureAtlas) {
-		self.texture_atlas = texture_atlas;
+    pub fn set_texture_atlas(&mut self, texture_atlas: TextureAtlas) {
+        self.texture_atlas = texture_atlas;
 
-		// This is just for testing purposes
-		//self.texture_locations.insert("normal_comet.png".to_string(), ([0,0], [15,15]));
-		//self.texture_locations.insert("green_comet.png".to_string(), ([0,15], [15,31]));
-	}
+        // This is just for testing purposes
+        //self.texture_locations.insert("normal_comet.png".to_string(), ([0,0], [15,15]));
+        //self.texture_locations.insert("green_comet.png".to_string(), ([0,15], [15,31]));
+    }
 
-	pub fn create_texture_atlas(&mut self, paths: Vec<String>) {
-		self.texture_atlas = TextureAtlas::from_texture_paths(paths)
-	}
+    pub fn create_texture_atlas(&mut self, paths: Vec<String>) {
+        self.texture_atlas = TextureAtlas::from_texture_paths(paths)
+    }
 
-	pub async fn load_string(&self, file_name: &str) -> anyhow::Result<String> {
-		let path = Path::new(std::env::var("OUT_DIR")?.as_str())
-			.join("res")
-			.join(file_name);
-		let txt = std::fs::read_to_string(path)?;
+    pub async fn load_string(&self, file_name: &str) -> anyhow::Result<String> {
+        let path = Path::new(std::env::var("OUT_DIR")?.as_str())
+            .join("res")
+            .join(file_name);
+        let txt = std::fs::read_to_string(path)?;
 
-		Ok(txt)
-	}
+        Ok(txt)
+    }
 
-	pub async fn load_binary(&self, file_name: &str) -> anyhow::Result<Vec<u8>> {
-		let path = Path::new(std::env::var("OUT_DIR").unwrap().as_str())
-			.join("res")
-			.join(file_name);
-		let data = std::fs::read(path)?;
+    pub async fn load_binary(&self, file_name: &str) -> anyhow::Result<Vec<u8>> {
+        let path = Path::new(std::env::var("OUT_DIR").unwrap().as_str())
+            .join("res")
+            .join(file_name);
+        let data = std::fs::read(path)?;
 
-		Ok(data)
-	}
+        Ok(data)
+    }
 
-	pub async fn load_texture(
-		&self,
-		file_name: &str,
-		is_normal_map: bool,
-		device: &wgpu::Device,
-		queue: &wgpu::Queue,
-	) -> anyhow::Result<texture::Texture> {
-		let data = self.load_binary(file_name).await?;
-		texture::Texture::from_bytes(device, queue, &data, file_name, is_normal_map)
-	}
+    pub async fn load_texture(
+        &self,
+        file_name: &str,
+        is_normal_map: bool,
+        device: &wgpu::Device,
+        queue: &wgpu::Queue,
+    ) -> anyhow::Result<texture::Texture> {
+        let data = self.load_binary(file_name).await?;
+        texture::Texture::from_bytes(device, queue, &data, file_name, is_normal_map)
+    }
 
-	/*pub async fn load_model(
-		&self,
-		file_name: &str,
-		device: &wgpu::Device,
-		queue: &wgpu::Queue,
-		layout: &wgpu::BindGroupLayout,
-	) -> anyhow::Result<model::Model> {
-		let obj_text = self.load_string(file_name).await?;
-		let obj_cursor = Cursor::new(obj_text);
-		let mut obj_reader = BufReader::new(obj_cursor);
+    /*pub async fn load_model(
+        &self,
+        file_name: &str,
+        device: &wgpu::Device,
+        queue: &wgpu::Queue,
+        layout: &wgpu::BindGroupLayout,
+    ) -> anyhow::Result<model::Model> {
+        let obj_text = self.load_string(file_name).await?;
+        let obj_cursor = Cursor::new(obj_text);
+        let mut obj_reader = BufReader::new(obj_cursor);
 
-		let (models, obj_materials) = tobj::load_obj_buf_async(
-			&mut obj_reader,
-			&tobj::LoadOptions {
-				triangulate: true,
-				single_index: true,
-				..Default::default()
-			},
-			|p| async move {
-				let mat_text = self.load_string(&p).await.unwrap();
-				tobj::load_mtl_buf(&mut BufReader::new(Cursor::new(mat_text)))
-			},
-		)
-			.await?;
+        let (models, obj_materials) = tobj::load_obj_buf_async(
+            &mut obj_reader,
+            &tobj::LoadOptions {
+                triangulate: true,
+                single_index: true,
+                ..Default::default()
+            },
+            |p| async move {
+                let mat_text = self.load_string(&p).await.unwrap();
+                tobj::load_mtl_buf(&mut BufReader::new(Cursor::new(mat_text)))
+            },
+        )
+            .await?;
 
-		let mut materials = Vec::new();
-		for m in obj_materials? {
-			let diffuse_texture = self.load_texture(&m.diffuse_texture, false, device, queue).await?;
-			let normal_texture = self.load_texture(&m.normal_texture, true, device, queue).await?;
-			let bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
-				layout,
-				entries: &[
-					wgpu::BindGroupEntry {
-						binding: 0,
-						resource: wgpu::BindingResource::TextureView(&diffuse_texture.view),
-					},
-					wgpu::BindGroupEntry {
-						binding: 1,
-						resource: wgpu::BindingResource::Sampler(&diffuse_texture.sampler),
-					},
-				],
-				label: None,
-			});
+        let mut materials = Vec::new();
+        for m in obj_materials? {
+            let diffuse_texture = self.load_texture(&m.diffuse_texture, false, device, queue).await?;
+            let normal_texture = self.load_texture(&m.normal_texture, true, device, queue).await?;
+            let bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
+                layout,
+                entries: &[
+                    wgpu::BindGroupEntry {
+                        binding: 0,
+                        resource: wgpu::BindingResource::TextureView(&diffuse_texture.view),
+                    },
+                    wgpu::BindGroupEntry {
+                        binding: 1,
+                        resource: wgpu::BindingResource::Sampler(&diffuse_texture.sampler),
+                    },
+                ],
+                label: None,
+            });
 
-			materials.push(model::Material {
-				name: m.name,
-				diffuse_texture,
-				bind_group,
-			});
-		}
+            materials.push(model::Material {
+                name: m.name,
+                diffuse_texture,
+                bind_group,
+            });
+        }
 
-		let meshes = models
-			.into_iter()
-			.map(|m| {
-				let vertices = (0..m.mesh.positions.len() / 3)
-					.map(|i| {
-						if m.mesh.normals.is_empty() {
-							model::ModelVertex {
-								position: [
-									m.mesh.positions[i * 3],
-									m.mesh.positions[i * 3 + 1],
-									m.mesh.positions[i * 3 + 2],
-								],
-								tex_coords: [m.mesh.texcoords[i * 2], 1.0 - m.mesh.texcoords[i * 2 + 1]],
-								normal: [0.0, 0.0, 0.0],
-							}
-						} else {
-							model::ModelVertex {
-								position: [
-									m.mesh.positions[i * 3],
-									m.mesh.positions[i * 3 + 1],
-									m.mesh.positions[i * 3 + 2],
-								],
-								tex_coords: [m.mesh.texcoords[i * 2], 1.0 - m.mesh.texcoords[i * 2 + 1]],
-								normal: [
-									m.mesh.normals[i * 3],
-									m.mesh.normals[i * 3 + 1],
-									m.mesh.normals[i * 3 + 2],
-								],
-							}
-						}
-					})
-					.collect::<Vec<_>>();
+        let meshes = models
+            .into_iter()
+            .map(|m| {
+                let vertices = (0..m.mesh.positions.len() / 3)
+                    .map(|i| {
+                        if m.mesh.normals.is_empty() {
+                            model::ModelVertex {
+                                position: [
+                                    m.mesh.positions[i * 3],
+                                    m.mesh.positions[i * 3 + 1],
+                                    m.mesh.positions[i * 3 + 2],
+                                ],
+                                tex_coords: [m.mesh.texcoords[i * 2], 1.0 - m.mesh.texcoords[i * 2 + 1]],
+                                normal: [0.0, 0.0, 0.0],
+                            }
+                        } else {
+                            model::ModelVertex {
+                                position: [
+                                    m.mesh.positions[i * 3],
+                                    m.mesh.positions[i * 3 + 1],
+                                    m.mesh.positions[i * 3 + 2],
+                                ],
+                                tex_coords: [m.mesh.texcoords[i * 2], 1.0 - m.mesh.texcoords[i * 2 + 1]],
+                                normal: [
+                                    m.mesh.normals[i * 3],
+                                    m.mesh.normals[i * 3 + 1],
+                                    m.mesh.normals[i * 3 + 2],
+                                ],
+                            }
+                        }
+                    })
+                    .collect::<Vec<_>>();
 
-				let vertex_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
-					label: Some(&format!("{:?} Vertex Buffer", file_name)),
-					contents: bytemuck::cast_slice(&vertices),
-					usage: wgpu::BufferUsages::VERTEX,
-				});
-				let index_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
-					label: Some(&format!("{:?} Index Buffer", file_name)),
-					contents: bytemuck::cast_slice(&m.mesh.indices),
-					usage: wgpu::BufferUsages::INDEX,
-				});
+                let vertex_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
+                    label: Some(&format!("{:?} Vertex Buffer", file_name)),
+                    contents: bytemuck::cast_slice(&vertices),
+                    usage: wgpu::BufferUsages::VERTEX,
+                });
+                let index_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
+                    label: Some(&format!("{:?} Index Buffer", file_name)),
+                    contents: bytemuck::cast_slice(&m.mesh.indices),
+                    usage: wgpu::BufferUsages::INDEX,
+                });
 
-				model::Mesh {
-					name: file_name.to_string(),
-					vertex_buffer,
-					index_buffer,
-					num_elements: m.mesh.indices.len() as u32,
-					material: m.mesh.material_id.unwrap_or(0),
-				}
-			})
-			.collect::<Vec<_>>();
+                model::Mesh {
+                    name: file_name.to_string(),
+                    vertex_buffer,
+                    index_buffer,
+                    num_elements: m.mesh.indices.len() as u32,
+                    material: m.mesh.material_id.unwrap_or(0),
+                }
+            })
+            .collect::<Vec<_>>();
 
-		Ok(model::Model { meshes, materials })
-	}*/
+        Ok(model::Model { meshes, materials })
+    }*/
 }

crates/comet_resources/src/texture_atlas.rs

@@ -334,7 +334,7 @@ impl TextureAtlas {
             for glyph_name in glyph_names {
                 let region = font.glyphs().textures().get(&glyph_name).unwrap();
 
-                let (u0, v0, u1, v1) = (region.u0(), region.v0(), region.u1(), region.v1());
+                let (u0, v0) = (region.u0(), region.v0());
                 let (width, height) = region.dimensions();
 
                 let src_x = (u0 * font.glyphs().atlas().width() as f32) as u32;

crates/comet_resources/src/vertex.rs

@@ -1,55 +1,53 @@
-use wgpu::Color;
-
 #[repr(C)]
 #[derive(Copy, Clone, Debug, bytemuck::Pod, bytemuck::Zeroable, PartialEq)]
 pub struct Vertex {
-	position: [f32; 3],
-	tex_coords: [f32; 2],
-	color: [f32; 4]
+    position: [f32; 3],
+    tex_coords: [f32; 2],
+    color: [f32; 4],
 }
 
 impl Vertex {
-	pub fn new(position: [f32; 3], tex_coords: [f32; 2], color: [f32; 4]) -> Self {
-		Self {
-			position,
-			tex_coords,
-			color
-		}
-	}
+    pub fn new(position: [f32; 3], tex_coords: [f32; 2], color: [f32; 4]) -> Self {
+        Self {
+            position,
+            tex_coords,
+            color,
+        }
+    }
 
-	pub fn set_position(&mut self, new_position: [f32;3]) {
-		self.position = new_position
-	}
+    pub fn set_position(&mut self, new_position: [f32; 3]) {
+        self.position = new_position
+    }
 
-	pub fn set_tex_coords(&mut self, new_tex_coords: [f32; 2]) {
-		self.tex_coords = new_tex_coords
-	}
+    pub fn set_tex_coords(&mut self, new_tex_coords: [f32; 2]) {
+        self.tex_coords = new_tex_coords
+    }
 
-	pub fn set_color(&mut self, new_color: [f32; 4]) {
-		self.color = new_color
-	}
+    pub fn set_color(&mut self, new_color: [f32; 4]) {
+        self.color = new_color
+    }
 
-	pub fn desc() -> wgpu::VertexBufferLayout<'static> {
-		wgpu::VertexBufferLayout {
-			array_stride: std::mem::size_of::<Vertex>() as wgpu::BufferAddress,
-			step_mode: wgpu::VertexStepMode::Vertex,
-			attributes: &[
-				wgpu::VertexAttribute {
-					offset: 0,
-					shader_location: 0,
-					format: wgpu::VertexFormat::Float32x3,
-				},
-				wgpu::VertexAttribute {
-					offset: std::mem::size_of::<[f32; 3]>() as wgpu::BufferAddress,
-					shader_location: 1,
-					format: wgpu::VertexFormat::Float32x2,
-				},
-				wgpu::VertexAttribute {
-					offset: std::mem::size_of::<[f32; 5]>() as wgpu::BufferAddress,
-					shader_location: 2,
-					format: wgpu::VertexFormat::Float32x4,
-				}
-			]
-		}
-	}
+    pub fn desc() -> wgpu::VertexBufferLayout<'static> {
+        wgpu::VertexBufferLayout {
+            array_stride: std::mem::size_of::<Vertex>() as wgpu::BufferAddress,
+            step_mode: wgpu::VertexStepMode::Vertex,
+            attributes: &[
+                wgpu::VertexAttribute {
+                    offset: 0,
+                    shader_location: 0,
+                    format: wgpu::VertexFormat::Float32x3,
+                },
+                wgpu::VertexAttribute {
+                    offset: std::mem::size_of::<[f32; 3]>() as wgpu::BufferAddress,
+                    shader_location: 1,
+                    format: wgpu::VertexFormat::Float32x2,
+                },
+                wgpu::VertexAttribute {
+                    offset: std::mem::size_of::<[f32; 5]>() as wgpu::BufferAddress,
+                    shader_location: 2,
+                    format: wgpu::VertexFormat::Float32x4,
+                },
+            ],
+        }
+    }
 }

crates/comet_structs/src/component_storage.rs

@@ -1,65 +1,58 @@
-use std::any::{Any, TypeId};
-use comet_log::*;
 use crate::{FlatMap, SparseSet};
+use comet_log::*;
+use std::any::TypeId;
 
 pub type ComponentStorage = FlatMap<TypeId, SparseSet>;
 
 impl ComponentStorage {
+    pub fn register_component<T: 'static>(&mut self, capacity: usize) {
+        if !self.contains(&TypeId::of::<T>()) {
+            self.insert(TypeId::of::<T>(), SparseSet::new::<T>(capacity, 1000));
+        } else {
+            error!("Component {:?} already exists", TypeId::of::<T>());
+        }
+    }
 
-	pub fn register_component<T: 'static>(&mut self, capacity: usize) {
-		if !self.contains(&TypeId::of::<T>()) {
-			self.insert(TypeId::of::<T>(), SparseSet::new::<T>(capacity, 1000));
-		}
-		else {
-			error!("Component {:?} already exists", TypeId::of::<T>());
-		}
-	}
+    pub fn deregister_component<T: 'static>(&mut self) {
+        if self.contains(&TypeId::of::<T>()) {
+            self.remove(&TypeId::of::<T>());
+        } else {
+            error!("Component {:?} does not exist", TypeId::of::<T>());
+        }
+    }
 
-	pub fn deregister_component<T: 'static>(&mut self) {
-		if self.contains(&TypeId::of::<T>()) {
-			self.remove(&TypeId::of::<T>());
-		}
-		else {
-			error!("Component {:?} does not exist", TypeId::of::<T>());
-		}
-	}
+    pub fn set_component<T: 'static>(&mut self, index: usize, element: T) {
+        if let Some(sparse_set) = self.get_mut(&TypeId::of::<T>()) {
+            sparse_set.insert(index, element);
+        } else {
+            error!("Component {:?} is not registered", TypeId::of::<T>());
+        }
+    }
 
-	pub fn set_component<T: 'static>(&mut self, index: usize, element: T) {
-		if let Some(sparse_set) = self.get_mut(&TypeId::of::<T>()) {
-			sparse_set.insert(index, element);
-		}
-		else {
-			error!("Component {:?} is not registered", TypeId::of::<T>());
-		}
-	}
+    pub fn remove_component<T: 'static>(&mut self, index: usize) -> Option<T> {
+        if let Some(sparse_set) = self.get_mut(&TypeId::of::<T>()) {
+            sparse_set.remove(index)
+        } else {
+            error!("Component {:?} is not registered", TypeId::of::<T>());
+            None
+        }
+    }
 
-	pub fn remove_component<T: 'static>(&mut self, index: usize) -> Option<T> {
-		if let Some(sparse_set) = self.get_mut(&TypeId::of::<T>()) {
-			sparse_set.remove(index)
-		}
-		else {
-			error!("Component {:?} is not registered", TypeId::of::<T>());
-			None
-		}
-	}
+    pub fn get_component<T: 'static>(&self, index: usize) -> Option<&T> {
+        if let Some(sparse_set) = self.get(&TypeId::of::<T>()) {
+            sparse_set.get(index)
+        } else {
+            error!("Component {:?} is not registered", TypeId::of::<T>());
+            None
+        }
+    }
 
-	pub fn get_component<T: 'static>(&self, index: usize) -> Option<&T> {
-		if let Some(sparse_set) = self.get(&TypeId::of::<T>()) {
-			sparse_set.get(index)
-		}
-		else {
-			error!("Component {:?} is not registered", TypeId::of::<T>());
-			None
-		}
-	}
-
-	pub fn get_component_mut<T: 'static>(&mut self, index: usize) -> Option<&mut T> {
-		if let Some(sparse_set) = self.get_mut(&TypeId::of::<T>()) {
-			sparse_set.get_mut(index)
-		}
-		else {
-			error!("Component {:?} is not registered", TypeId::of::<T>());
-			None
-		}
-	}
+    pub fn get_component_mut<T: 'static>(&mut self, index: usize) -> Option<&mut T> {
+        if let Some(sparse_set) = self.get_mut(&TypeId::of::<T>()) {
+            sparse_set.get_mut(index)
+        } else {
+            error!("Component {:?} is not registered", TypeId::of::<T>());
+            None
+        }
+    }
 }

examples/hello_world.rs

@@ -1,17 +1,19 @@
 use comet::prelude::*;
 
 // This function will only be called once before the event loop starts.
+#[allow(unused_variables)]
 fn setup(app: &mut App, renderer: &mut Renderer2D) {}
 
 // This function will be called on every tick after the event loop starts.
+#[allow(unused_variables)]
 fn update(app: &mut App, renderer: &mut Renderer2D, dt: f32) {}
 
 fn main() {
-	// This creates a window with the title "Hello world".
-	// Note: You can call your functions differently if you want to though it is advised to use
-	// `setup` and `update` as the names.
-	// You can also replace `Renderer2D` with any other struct that implements the `Renderer` trait.
-	App::new()
-		.with_title("Hello world")
-		.run::<Renderer2D>(setup, update);
+    // This creates a window with the title "Hello world".
+    // Note: You can call your functions differently if you want to though it is advised to use
+    // `setup` and `update` as the names.
+    // You can also replace `Renderer2D` with any other struct that implements the `Renderer` trait.
+    App::new()
+        .with_title("Hello world")
+        .run::<Renderer2D>(setup, update);
 }

examples/prefabs.rs

@@ -43,6 +43,7 @@ fn setup(app: &mut App, renderer: &mut Renderer2D) {
     }
 }
 
+#[allow(unused_variables)]
 fn update(app: &mut App, renderer: &mut Renderer2D, dt: f32) {}
 
 fn main() {

examples/simple_text.rs

@@ -26,6 +26,7 @@ fn setup(app: &mut App, renderer: &mut Renderer2D) {
     );
 }
 
+#[allow(unused_variables)]
 fn update(app: &mut App, renderer: &mut Renderer2D, dt: f32) {
     // Getting the windows size
     let size = renderer.size();

examples/textured_entity.rs

@@ -18,6 +18,7 @@ fn setup(app: &mut App, renderer: &mut Renderer2D) {
     app.add_component(e0, render);
 }
 
+#[allow(unused_variables)]
 fn update(app: &mut App, renderer: &mut Renderer2D, dt: f32) {
     renderer.render_scene_2d(app.scene_mut())
 }