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,15 +1,15 @@
-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()
+            archetypes: HashMap::new(),
         }
     }
 
@@ -25,10 +25,6 @@ impl Archetypes {
         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);
@@ -48,12 +44,4 @@ impl Archetypes {
     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
-	}
 }

crates/comet_input/src/input_handler.rs

@@ -1,14 +1,12 @@
-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_released: Vec<PhysicalKey>,
 }
 
 impl InputHandler {
@@ -16,15 +14,17 @@ impl InputHandler {
         Self {
             keys_pressed: Vec::new(),
             keys_held: Vec::new(),
-			keys_released: Vec::new()
+            keys_released: Vec::new(),
         }
     }
 
     pub fn update<T>(&mut self, event: &Event<T>) {
         match event {
             Event::WindowEvent {
-				event: WindowEvent::KeyboardInput {
-					event: KeyEvent {
+                event:
+                    WindowEvent::KeyboardInput {
+                        event:
+                            KeyEvent {
                                 state,
                                 physical_key: PhysicalKey::Code(keycode),
                                 ..
@@ -32,11 +32,12 @@ impl InputHandler {
                         ..
                     },
                 ..
-			} =>
-				{
-					match state {
+            } => match state {
                 ElementState::Pressed => {
-							if self.keys_pressed.contains(&PhysicalKey::Code(keycode.clone())) {
+                    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()));
@@ -45,16 +46,23 @@ impl InputHandler {
                 }
                 ElementState::Released => {
                     self.keys_released = vec![];
-							if let Some(index) = self.keys_pressed.iter().position(|&x| x == PhysicalKey::Code(keycode.clone())) {
+                    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())) {
+                    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()));
                 }
-					}
-				}
+            },
             _ => {}
         }
     }

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;
 
+                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,7 +1,6 @@
-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,
@@ -25,7 +24,7 @@ impl Font {
             name: path.to_string(),
             size,
             line_height,
-			glyphs
+            glyphs,
         }
     }
 
@@ -102,19 +101,20 @@ impl Font {
                         image.put_pixel(x, y, Rgba([255, 255, 255, alpha]));
                     });
 
-					glyphs.push(
-						GlyphData {
+                    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,21 +1,20 @@
-use std::{
-	collections::HashMap, path::Path
-};
+use std::{collections::HashMap, path::Path};
 
-use wgpu::{Device, FilterMode, Queue, TextureFormat, TextureUsages};
-use crate::{texture, Texture};
-use crate::texture_atlas::{TextureAtlas, TextureRegion};
+use crate::{
+    texture,
+    texture_atlas::{TextureAtlas, TextureRegion},
+};
 
 pub struct ResourceManager {
     texture_atlas: TextureAtlas,
-	data_files: HashMap<String, String>
+    data_files: HashMap<String, String>,
 }
 
 impl ResourceManager {
     pub fn new() -> Self {
         Self {
             texture_atlas: TextureAtlas::empty(),
-			data_files: HashMap::new()
+            data_files: HashMap::new(),
         }
     }
 

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,11 +1,9 @@
-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]
+    color: [f32; 4],
 }
 
 impl Vertex {
@@ -13,11 +11,11 @@ impl Vertex {
         Self {
             position,
             tex_coords,
-			color
+            color,
         }
     }
 
-	pub fn set_position(&mut self, new_position: [f32;3]) {
+    pub fn set_position(&mut self, new_position: [f32; 3]) {
         self.position = new_position
     }
 
@@ -48,8 +46,8 @@ impl Vertex {
                     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,16 +1,14 @@
-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 {
+        } else {
             error!("Component {:?} already exists", TypeId::of::<T>());
         }
     }
@@ -18,8 +16,7 @@ impl ComponentStorage {
     pub fn deregister_component<T: 'static>(&mut self) {
         if self.contains(&TypeId::of::<T>()) {
             self.remove(&TypeId::of::<T>());
-		}
-		else {
+        } else {
             error!("Component {:?} does not exist", TypeId::of::<T>());
         }
     }
@@ -27,8 +24,7 @@ impl ComponentStorage {
     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 {
+        } else {
             error!("Component {:?} is not registered", TypeId::of::<T>());
         }
     }
@@ -36,8 +32,7 @@ impl ComponentStorage {
     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 {
+        } else {
             error!("Component {:?} is not registered", TypeId::of::<T>());
             None
         }
@@ -46,8 +41,7 @@ impl ComponentStorage {
     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 {
+        } else {
             error!("Component {:?} is not registered", TypeId::of::<T>());
             None
         }
@@ -56,8 +50,7 @@ impl ComponentStorage {
     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 {
+        } else {
             error!("Component {:?} is not registered", TypeId::of::<T>());
             None
         }

examples/hello_world.rs

@@ -1,9 +1,11 @@
 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() {

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())
 }