Satisfy clippy, fix rerun-if-changed

20 files changed, 124 insertions, 157 deletions

diff --git a/crates/teleia/build.rs b/crates/teleia/build.rs
index 57dba5b..aeb074e 100644
--- a/crates/teleia/build.rs
+++ b/crates/teleia/build.rs
@@ -1,5 +1,5 @@
 fn main() {
-    println!("cargo::rerun-if-changed=flake.lock");
+    println!("cargo::rerun-if-changed=../../flake.lock");
     match &*std::env::var("CARGO_CFG_TARGET_ARCH").unwrap() {
         "x86_64" => if let Ok(p) = std::env::var("LIBCOLONQ_PIT_NATIVE") {
             println!("cargo::rustc-link-search={}", p);
diff --git a/crates/teleia/src/audio.rs b/crates/teleia/src/audio.rs
index 3fdb64f..000e696 100644
--- a/crates/teleia/src/audio.rs
+++ b/crates/teleia/src/audio.rs
@@ -142,6 +142,7 @@ pub struct Context {
 
 #[cfg(not(target_arch = "wasm32"))]
 impl Context {
+    #[allow(clippy::new_without_default)]
     pub fn new() -> Self {
         Self {
             manager: kira::manager::AudioManager::new(kira::manager::AudioManagerSettings::default())
@@ -201,7 +202,7 @@ impl Audio {
     ) -> Option<AudioPlayingHandle>
     {
         let sd = if let Some((ss, se)) = looping {
-            let start = if let Some(s) = ss { s } else { 0.0 };
+            let start = ss.unwrap_or(0.0);
             if let Some(e) = se {
                 self.data.loop_region(start..e)
             } else {
@@ -251,7 +252,7 @@ impl Assets {
 
     pub fn play_music(&mut self, name: &str, start: Option<f64>, end: Option<f64>) {
         if let Some(s) = &mut self.music_handle {
-            let _ = s.stop(&self.ctx);
+            s.stop(&self.ctx);
         }
         if let Some(a) = self.audio.get(name) {
             match a.play(&mut self.ctx, Some((start, end))) {
diff --git a/crates/teleia/src/font.rs b/crates/teleia/src/font.rs
index 0f18cd7..822705c 100644
--- a/crates/teleia/src/font.rs
+++ b/crates/teleia/src/font.rs
@@ -106,14 +106,14 @@ impl Bitmap {
                 texcoords.push(tcbase + glam::Vec2::new(cwidth, cheight));
                 texcoords.push(tcbase + glam::Vec2::new(cwidth, 0.0));
                 texcoords.push(tcbase);
-                let c = if let Some(c) = params.color.get(if params.color.len() == 0 { 0 } else { i % params.color.len() }) {
+                let c = if let Some(c) = params.color.get(if params.color.is_empty() { 0 } else { i % params.color.len() }) {
                     *c
                 } else {
                     glam::Vec3::new(1.0, 1.0, 1.0)
                 };
                 colors.push(c); colors.push(c); colors.push(c); colors.push(c);
-                indices.push(idx + 0); indices.push(idx + 1); indices.push(idx + 2);
-                indices.push(idx + 0); indices.push(idx + 3); indices.push(idx + 2);
+                indices.push(idx); indices.push(idx + 1); indices.push(idx + 2);
+                indices.push(idx); indices.push(idx + 3); indices.push(idx + 2);
                 cur.x += sdims.x; 
             }
         }
@@ -188,7 +188,7 @@ impl Bitmap {
         st.bind_2d(ctx, &st.shader_text_bitmap);
         let dims = glam::Vec2::new(self.char_width as f32, self.char_height as f32);
         let fpos = pos + glam::Vec2::new(-dims.x / 2.0, dims.y / 2.0);
-        st.shader_text_bitmap.set_position_text_bitmap(ctx, st, &self, &fpos);
+        st.shader_text_bitmap.set_position_text_bitmap(ctx, st, self, &fpos);
         self.render_text_parameterized(ctx, st, text, params);
     }
 }
diff --git a/crates/teleia/src/framebuffer.rs b/crates/teleia/src/framebuffer.rs
index e4cd529..cfc8ac1 100644
--- a/crates/teleia/src/framebuffer.rs
+++ b/crates/teleia/src/framebuffer.rs
@@ -86,8 +86,8 @@ impl Framebuffer {
             Self {
                 tex: Some(tex),
                 fbo: Some(fbo),
-                dims: dims.clone(),
-                offsets: offsets.clone(),
+                dims: *dims,
+                offsets: *offsets,
             }
         }
     }
diff --git a/crates/teleia/src/level2d/tiled.rs b/crates/teleia/src/level2d/tiled.rs
index 9e5e4e7..24d3205 100644
--- a/crates/teleia/src/level2d/tiled.rs
+++ b/crates/teleia/src/level2d/tiled.rs
@@ -92,11 +92,12 @@ pub struct Asset {
     tileset: Tileset,
     texture: texture::Texture,
 }
+#[derive(Default)]
 pub struct Assets {
     entries: HashMap<String, Asset>,
 }
 impl Assets {
-    pub fn new() -> Self { Self { entries: HashMap::new() } }
+    pub fn new() -> Self { Self::default() }
     pub fn load(&mut self, ctx: &context::Context, nm: &str, ts: &str, img: &[u8]) -> Erm<()> {
         let ass = Asset {
             tileset: Tileset::new(ts)?,
@@ -118,7 +119,7 @@ impl Assets {
                 ))
             }
         }
-        return erm(Err::GIDNotFound(gid));
+        erm(Err::GIDNotFound(gid))
     }
 }
 
@@ -165,7 +166,7 @@ impl LevelRenderer {
             layers.push(LayerRenderer::new(ctx)?);
         }
         let shader = shader::Shader::new_nolib(
-            &ctx,
+            ctx,
             include_str!("../assets/shaders/tiled/vert.glsl"),
             include_str!("../assets/shaders/tiled/frag.glsl"),
         );
@@ -210,8 +211,8 @@ impl LevelRenderer {
                 texcoords.push(uvbase + glam::Vec2::new(twidth, theight));
                 texcoords.push(uvbase + glam::Vec2::new(twidth, 0.0));
                 texcoords.push(uvbase);
-                indices.push(i + 0); indices.push(i + 1); indices.push(i + 2);
-                indices.push(i + 0); indices.push(i + 3); indices.push(i + 2);
+                indices.push(i); indices.push(i + 1); indices.push(i + 2);
+                indices.push(i); indices.push(i + 3); indices.push(i + 2);
             }
         }
         let index_bytes: Vec<u8> = indices.iter().flat_map(|x| x.to_ne_bytes()).collect();
diff --git a/crates/teleia/src/lib.rs b/crates/teleia/src/lib.rs
index 1ff82e1..864a9e2 100644
--- a/crates/teleia/src/lib.rs
+++ b/crates/teleia/src/lib.rs
@@ -133,7 +133,7 @@ where
         w as f32, h as f32, options,
     )));
     let game = Box::leak(Box::new(gnew(ctx)));
-    let st = Box::leak(Box::new(state::State::new(&ctx)));
+    let st = Box::leak(Box::new(state::State::new(ctx)));
 
     unsafe {
         CTX = Some(ctx as _);
@@ -152,30 +152,30 @@ where
         ctx.glfw.borrow_mut().poll_events();
         for (_, event) in glfw::flush_messages(&events) {
             match event {
-                glfw::WindowEvent::Size(_, _) => st.handle_resize(&ctx),
+                glfw::WindowEvent::Size(_, _) => st.handle_resize(ctx),
                 glfw::WindowEvent::Focus(false) => {
                     st.keys = state::Keys::new();
                 },
                 glfw::WindowEvent::CursorPos(x, y) => {
-                    st.mouse_moved(&ctx, x as f32, y as f32, game)?;
+                    st.mouse_moved(ctx, x as f32, y as f32, game)?;
                 }
                 glfw::WindowEvent::MouseButton(_, glfw::Action::Press, _) => {
-                    st.mouse_pressed(&ctx, game)?;
+                    st.mouse_pressed(ctx, game)?;
                 },
                 glfw::WindowEvent::MouseButton(_, glfw::Action::Release, _) => {
-                    st.mouse_released(&ctx, game)?;
+                    st.mouse_released(ctx, game)?;
                 },
                 glfw::WindowEvent::Key(key, _, glfw::Action::Press, _) => {
-                    st.key_pressed(&ctx, game, state::Keycode::new(key))?;
+                    st.key_pressed(ctx, game, state::Keycode::new(key))?;
                 },
                 glfw::WindowEvent::Key(key, _, glfw::Action::Release, _) => {
-                    st.key_released(&ctx, game, state::Keycode::new(key))?;
+                    st.key_released(ctx, game, state::Keycode::new(key))?;
                 },
                 _ => {},
             }
         }
         if ctx.resize_necessary() {
-            st.handle_resize(&ctx);
+            st.handle_resize(ctx);
         }
         // if let Some(f) = &mut st.request {
         //     match std::future::Future::poll(f.as_mut(), &mut st.waker_ctx) {
@@ -189,8 +189,8 @@ where
         //         },
         //     }
         // }
-        st.run_update(&ctx, game)?;
-        st.run_render(&ctx, game)?;
+        st.run_update(ctx, game)?;
+        st.run_render(ctx, game)?;
         ctx.window.borrow_mut().swap_buffers();
     }
     Ok(())
diff --git a/crates/teleia/src/mesh.rs b/crates/teleia/src/mesh.rs
index 7209de1..16a4380 100644
--- a/crates/teleia/src/mesh.rs
+++ b/crates/teleia/src/mesh.rs
@@ -20,10 +20,10 @@ pub struct Mesh {
 impl Mesh {
     pub fn build(
         ctx: &context::Context,
-        vertices: &Vec<f32>,
-        indices: &Vec<u32>,
-        snormals: &Option<Vec<f32>>,
-        stexcoords: &Option<Vec<f32>>,
+        vertices: &[f32],
+        indices: &[u32],
+        snormals: Option<&[f32]>,
+        stexcoords: Option<&[f32]>,
     ) -> Self {
         unsafe {
             let vao = ctx.gl.create_vertex_array().expect("failed to initialize vao");
@@ -35,7 +35,7 @@ impl Mesh {
                 glow::ARRAY_BUFFER,
                 std::slice::from_raw_parts(
                     vertices.as_ptr() as _,
-                    vertices.len() * std::mem::size_of::<f32>(),
+                    std::mem::size_of_val(vertices),
                 ),
                 glow::STATIC_DRAW,
             );
@@ -48,7 +48,7 @@ impl Mesh {
                 glow::ELEMENT_ARRAY_BUFFER,
                 std::slice::from_raw_parts(
                     indices.as_ptr() as _,
-                    indices.len() * std::mem::size_of::<f32>(),
+                    std::mem::size_of_val(indices),
                 ),
                 glow::STATIC_DRAW,
             );
@@ -60,7 +60,7 @@ impl Mesh {
                     glow::ARRAY_BUFFER,
                     std::slice::from_raw_parts(
                         normals.as_ptr() as _,
-                        normals.len() * std::mem::size_of::<f32>(),
+                        std::mem::size_of_val(normals),
                     ),
                     glow::STATIC_DRAW,
                 );
@@ -75,7 +75,7 @@ impl Mesh {
                     glow::ARRAY_BUFFER,
                     std::slice::from_raw_parts(
                         texcoords.as_ptr() as _,
-                        texcoords.len() * std::mem::size_of::<f32>(),
+                        std::mem::size_of_val(texcoords),
                     ),
                     glow::STATIC_DRAW,
                 );
@@ -111,8 +111,8 @@ impl Mesh {
             ctx,
             &mesh.positions,
             &mesh.indices,
-            &Some(mesh.normals),
-            &Some(mesh.texcoords),
+            Some(&mesh.normals),
+            Some(&mesh.texcoords),
         )
     }
 
diff --git a/crates/teleia/src/net/fig.rs b/crates/teleia/src/net/fig.rs
index 9dfbea8..0d5e16d 100644
--- a/crates/teleia/src/net/fig.rs
+++ b/crates/teleia/src/net/fig.rs
@@ -61,10 +61,10 @@ impl BinaryClient {
     fn pop_incoming_message(&mut self) -> Option<BinaryMessage> {
         let mut reader = std::io::Cursor::new(&self.in_buf);
         let event_len = reader.read_u32::<byteorder::LE>().ok()?;
-        let mut event = vec![0 as u8; event_len as usize];
+        let mut event = vec![0; event_len as usize];
         reader.read_exact(&mut event).ok()?;
         let data_len = reader.read_u32::<byteorder::LE>().ok()?;
-        let mut data = vec![0 as u8; data_len as usize];
+        let mut data = vec![0; data_len as usize];
         reader.read_exact(&mut data).ok()?;
         let len = reader.position() as usize;
         self.in_buf.drain(..len);
diff --git a/crates/teleia/src/net/ws/client/native.rs b/crates/teleia/src/net/ws/client/native.rs
index 3b8502c..e2e30a7 100644
--- a/crates/teleia/src/net/ws/client/native.rs
+++ b/crates/teleia/src/net/ws/client/native.rs
@@ -7,16 +7,14 @@ use crate::{utils, Erm, WrapErr};
 
 const KEY: usize = 42;
 
+type ClientChannels = (Sender<Message>, Receiver<Message>);
+#[derive(Default)]
 pub struct Client {
-    channels: Arc<Mutex<Option<(Sender<Message>, Receiver<Message>)>>>,
+    channels: Arc<Mutex<Option<ClientChannels>>>,
 }
 
 impl Client {
-    pub fn new() -> Self {
-        Self {
-            channels: Arc::new(Mutex::new(None)),
-        }
-    }
+    pub fn new() -> Self { Self::default() }
     pub fn connect(&mut self, url: &str) {
         let (mut socket, _resp) = if let Ok(v) = tungstenite::connect(url) { v } else {
             log::warn!("failed to connect to websocket: {}", url);
diff --git a/crates/teleia/src/net/ws/server.rs b/crates/teleia/src/net/ws/server.rs
index 7cd0cf8..7ce335a 100644
--- a/crates/teleia/src/net/ws/server.rs
+++ b/crates/teleia/src/net/ws/server.rs
@@ -12,18 +12,15 @@ const ACCEPT_KEY: usize = 1;
 type ClientId = usize;
 type ClientMessage = (ClientId, Message);
 
+type ServerChannels = (Sender<ClientMessage>, Receiver<ClientMessage>);
+#[derive(Default)]
 pub struct Server {
     clients: Arc<Mutex<HashMap<ClientId, tungstenite::WebSocket<TcpStream>>>>,
-    channels: Arc<Mutex<Option<(Sender<ClientMessage>, Receiver<ClientMessage>)>>>,
+    channels: Arc<Mutex<Option<ServerChannels>>>,
 }
 
 impl Server {
-    pub fn new() -> Self {
-        Self {
-            clients: Arc::new(Mutex::new(HashMap::new())),
-            channels: Arc::new(Mutex::new(None)),
-        }
-    }
+    pub fn new() -> Self { Self::default() }
     pub fn start(&mut self, addr: &str) {
         let recv_clients_ref = self.clients.clone();
         let send_clients_ref = self.clients.clone();
diff --git a/crates/teleia/src/renderer.rs b/crates/teleia/src/renderer.rs
index 49a7913..27ffbb6 100644
--- a/crates/teleia/src/renderer.rs
+++ b/crates/teleia/src/renderer.rs
@@ -141,9 +141,9 @@ impl<A: Assets> Renderer<A> {
             }
         }
         match mode {
-            ShaderMode::TwoDimension => st.bind_2d(ctx, &self.assets.shader(shader)),
-            ShaderMode::ThreeDimension => st.bind_3d(ctx, &self.assets.shader(shader)),
-            ShaderMode::ThreeDimensionOrth => st.bind_3d_orth(ctx, &self.assets.shader(shader)),
+            ShaderMode::TwoDimension => st.bind_2d(ctx, self.assets.shader(shader)),
+            ShaderMode::ThreeDimension => st.bind_3d(ctx, self.assets.shader(shader)),
+            ShaderMode::ThreeDimensionOrth => st.bind_3d_orth(ctx, self.assets.shader(shader)),
         }
         self.shader = BoundShader::Shader(shader, mode)
     }
diff --git a/crates/teleia/src/scene.rs b/crates/teleia/src/scene.rs
index 6c9ab9a..0c1c25e 100644
--- a/crates/teleia/src/scene.rs
+++ b/crates/teleia/src/scene.rs
@@ -92,7 +92,7 @@ impl Scene {
             buffers.get(b.index()).map(|gltf::buffer::Data(bytes)| bytes.as_slice())
         };
         let objects = gltf.meshes().map(|m| {
-            let primitives = m.primitives().filter_map(|p| {
+            let primitives = m.primitives().map(|p| {
                 let mode = match p.mode() {
                     gltf::mesh::Mode::Points => glow::POINTS,
                     gltf::mesh::Mode::Lines => glow::LINES,
@@ -196,7 +196,7 @@ impl Scene {
                     ctx.gl.vertex_attrib_pointer_f32(mesh::ATTRIB_WEIGHT, 4, glow::FLOAT, false, vertex_size, offset_of!(Vertex, weights) as _);
 
 
-                    Some(Primitive {
+                    Primitive {
                         mesh: mesh::Mesh {
                             vao,
                             mode,
@@ -205,7 +205,7 @@ impl Scene {
                             index_offset: 0,
                         },
                         material: p.material().index().unwrap(),
-                    })
+                    }
                 }
             }).collect();
             Object {
@@ -230,7 +230,7 @@ impl Scene {
                     0,
                     glow::RGBA,
                     glow::UNSIGNED_BYTE,
-                    Some(&i.as_bytes()),
+                    Some(i.as_bytes()),
                 );
                 ctx.gl.generate_mipmap(glow::TEXTURE_2D);
                 texture::Texture { tex, width: i.width() as i32, height: i.height() as i32 }
@@ -378,21 +378,18 @@ impl Scene {
                 } else {
                     (c.keyframes.len() - 1, 0)
                 };
-                match &c.values {
-                    ChannelValues::Rotation(vs) => {
-                        let prevt = c.keyframes[previ];
-                        let nextt = c.keyframes[nexti];
-                        let prev = vs[previ];
-                        let next = vs[nexti];
-                        let new = prev.slerp(next, (time - prevt) / (nextt - prevt));
-                        let (scale, _, trans) = self.nodes[c.target].transform.to_scale_rotation_translation();
-                        self.nodes[c.target].transform = glam::Mat4::from_scale_rotation_translation(
-                            scale,
-                            new,
-                            trans,
-                        );
-                    },
-                    _ => {},
+                if let ChannelValues::Rotation(vs) = &c.values {
+                    let prevt = c.keyframes[previ];
+                    let nextt = c.keyframes[nexti];
+                    let prev = vs[previ];
+                    let next = vs[nexti];
+                    let new = prev.slerp(next, (time - prevt) / (nextt - prevt));
+                    let (scale, _, trans) = self.nodes[c.target].transform.to_scale_rotation_translation();
+                    self.nodes[c.target].transform = glam::Mat4::from_scale_rotation_translation(
+                        scale,
+                        new,
+                        trans,
+                    );
                 }
             }
         }
diff --git a/crates/teleia/src/script.rs b/crates/teleia/src/script.rs
index a7e3584..d7bc54e 100644
--- a/crates/teleia/src/script.rs
+++ b/crates/teleia/src/script.rs
@@ -23,8 +23,9 @@ impl std::error::Error for Error {}
 type PitNativeFunc = extern "C" fn(rt: *mut PitRuntime, args: PitValue, data: *mut PitNativeFuncData) -> PitValue;
 #[repr(C)]
 struct PitNativeFuncDataShim { _data: () }
+type BoxedNativeFuncClosure = Box<dyn FnMut(&mut Runtime, Value) -> Value>;
 struct PitNativeFuncData {
-    f: Box<dyn FnMut(&mut Runtime, Value) -> Value>,
+    f: BoxedNativeFuncClosure,
 }
 extern "C" fn unwrap_nativefunc(rt: *mut PitRuntime, args: PitValue, data: *mut PitNativeFuncData) -> PitValue {
     unsafe {
diff --git a/crates/teleia/src/script/bencode.rs b/crates/teleia/src/script/bencode.rs
index 260ffed..061e381 100644
--- a/crates/teleia/src/script/bencode.rs
+++ b/crates/teleia/src/script/bencode.rs
@@ -127,7 +127,7 @@ impl Value {
             Self::Integer(i) => w.write_all(format!("i{}e", i).as_bytes()).map_err(Error::IO)?,
             Self::Bytestring(bs) => {
                 w.write_all(format!("{}:", bs.len()).as_bytes()).map_err(Error::IO)?;
-                w.write_all(&bs).map_err(Error::IO)?;
+                w.write_all(bs).map_err(Error::IO)?;
             },
             Self::List(xs) => {
                 w.write_all(b"l").map_err(Error::IO)?;
diff --git a/crates/teleia/src/script/nrepl.rs b/crates/teleia/src/script/nrepl.rs
index b35fdf6..6c0f281 100644
--- a/crates/teleia/src/script/nrepl.rs
+++ b/crates/teleia/src/script/nrepl.rs
@@ -1,7 +1,7 @@
 use super::bencode;
 use crate::{Erm, WrapErr, script, utils};
 
-use std::io::{BufReader, Read, Write};
+use std::io::{BufReader};
 use std::collections::{BTreeMap, HashMap};
 use std::net::{TcpListener, TcpStream};
 use std::sync::mpsc::{Sender, Receiver, channel};
@@ -26,18 +26,14 @@ impl ClientConnection {
     }
 }
 
+type ServerChannels = (Sender<ClientMessage>, Receiver<ClientMessage>);
+#[derive(Default)]
 pub struct Server {
     clients: Arc<Mutex<HashMap<ClientId, ClientConnection>>>,
-    channels: Arc<Mutex<Option<(Sender<ClientMessage>, Receiver<ClientMessage>)>>>,
+    channels: Arc<Mutex<Option<ServerChannels>>>,
 }
-
 impl Server {
-    pub fn new() -> Self {
-        Self {
-            clients: Arc::new(Mutex::new(HashMap::new())),
-            channels: Arc::new(Mutex::new(None)),
-        }
-    }
+    pub fn new() -> Self { Self::default() }
     pub fn start(&mut self, addr: &str) {
         let recv_clients_ref = self.clients.clone();
         let send_clients_ref = self.clients.clone();
@@ -178,7 +174,7 @@ impl Server {
                     ].into_iter()),
                     b"eval" => {
                         if let Some(bencode::Value::Bytestring(code)) = d.get(&b"code"[..]) {
-                            let scode = str::from_utf8(&code)
+                            let scode = str::from_utf8(code)
                                 .or(utils::erm_msg("failed to decode utf-8"))?;
                             let expr = rt.parse(scode)?;
                             let v = rt.eval(expr)?;
diff --git a/crates/teleia/src/shader.rs b/crates/teleia/src/shader.rs
index d707416..857e8d0 100644
--- a/crates/teleia/src/shader.rs
+++ b/crates/teleia/src/shader.rs
@@ -4,8 +4,8 @@ use glow::HasContext;
 
 use crate::{context, font, mesh, state};
 
-const COMMON_VERT: &'static str = include_str!("assets/shaders/common/vert.glsl");
-const COMMON_FRAG: &'static str = include_str!("assets/shaders/common/frag.glsl");
+const COMMON_VERT: &str = include_str!("assets/shaders/common/vert.glsl");
+const COMMON_FRAG: &str = include_str!("assets/shaders/common/frag.glsl");
 
 #[derive(Clone)]
 pub struct Shader {
@@ -19,7 +19,7 @@ impl Shader {
             let program = ctx.gl.create_program()?;
 
             let vert = ctx.gl.create_shader(glow::VERTEX_SHADER)?;
-            ctx.gl.shader_source(vert, &vsrc);
+            ctx.gl.shader_source(vert, vsrc);
             ctx.gl.compile_shader(vert);
             if !ctx.gl.get_shader_compile_status(vert) {
                 return Err(format!(
@@ -30,7 +30,7 @@ impl Shader {
             ctx.gl.attach_shader(program, vert);
 
             let frag = ctx.gl.create_shader(glow::FRAGMENT_SHADER)?;
-            ctx.gl.shader_source(frag, &fsrc);
+            ctx.gl.shader_source(frag, fsrc);
             ctx.gl.compile_shader(frag);
             if !ctx.gl.get_shader_compile_status(frag) {
                 return Err(format!(
@@ -214,18 +214,18 @@ impl Shader {
     }
 
     pub fn set_position_3d(&self, ctx: &context::Context, _st: &state::State, position: &glam::Mat4) {
-        self.set_mat4(&ctx, "position", &position);
-        self.set_mat4(&ctx, "normal_matrix", &position.inverse().transpose());
+        self.set_mat4(ctx, "position", position);
+        self.set_mat4(ctx, "normal_matrix", &position.inverse().transpose());
     }
 
     pub fn set_position_2d_helper(&self, ctx: &context::Context, st: &state::State, pos: &glam::Vec2, dims: &glam::Vec2, rot: &glam::Quat) {
         let halfwidth = dims.x / 2.0;
         let halfheight = dims.y / 2.0;
         self.set_mat4(
-            &ctx, "position",
+            ctx, "position",
             &glam::Mat4::from_scale_rotation_translation(
                 glam::Vec3::new(halfwidth, halfheight, 1.0),
-                rot.clone(),
+                *rot,
                 glam::Vec3::new(
                     -st.render_dims.x / 2.0 + pos.x + halfwidth,
                     st.render_dims.y / 2.0 - pos.y - halfheight,
diff --git a/crates/teleia/src/state.rs b/crates/teleia/src/state.rs
index 047ec45..d45bab7 100644
--- a/crates/teleia/src/state.rs
+++ b/crates/teleia/src/state.rs
@@ -39,29 +39,13 @@ pub enum Key {
     Start, Select,
     Debug,
 }
+#[derive(Default)]
 pub struct Keys {
     pub pressed: EnumMap<Key, bool>,
     pub new: EnumMap<Key, bool>,
 }
 impl Keys {
-    pub fn new() -> Self {
-        Self {
-            pressed: enum_map! {
-                Key::Up => false, Key::Down => false, Key::Left => false, Key::Right => false,
-                Key::A => false, Key::B => false, Key::X => false, Key::Y => false,
-                Key::L => false, Key::R => false,
-                Key::Start => false, Key::Select => false,
-                Key::Debug => false,
-            },
-            new: enum_map! {
-                Key::Up => false, Key::Down => false, Key::Left => false, Key::Right => false,
-                Key::A => false, Key::B => false, Key::X => false, Key::Y => false,
-                Key::L => false, Key::R => false,
-                Key::Start => false, Key::Select => false,
-                Key::Debug => false,
-            },
-        }
-    }
+    pub fn new() -> Self { Self::default() }
     pub fn up(&self) -> bool { self.pressed[Key::Up] }
     pub fn down(&self) -> bool { self.pressed[Key::Down] }
     pub fn left(&self) -> bool { self.pressed[Key::Left] }
@@ -324,7 +308,7 @@ impl State {
         dir: &glam::Vec3,
         up: &glam::Vec3,
     ) {
-        self.camera = (pos.clone(), dir.clone(), up.clone());
+        self.camera = (*pos, *dir, *up);
     }
 
     pub fn bind_framebuffer(&mut self, ctx: &context::Context, fb: &framebuffer::Framebuffer) {
@@ -333,11 +317,11 @@ impl State {
     }
 
     pub fn bind_render_framebuffer(&mut self, ctx: &context::Context) {
-        self.render_framebuffer.bind(&ctx); self.render_dims = self.render_framebuffer.dims;
+        self.render_framebuffer.bind(ctx); self.render_dims = self.render_framebuffer.dims;
     }
 
     pub fn bind_screen(&mut self, ctx: &context::Context) {
-        self.screen.bind(&ctx); self.render_dims = self.screen.dims;
+        self.screen.bind(ctx); self.render_dims = self.screen.dims;
     }
 
     pub fn set_lighting(
@@ -347,7 +331,7 @@ impl State {
         color: &glam::Vec3,
         dir: &glam::Vec3,
     ) {
-        self.lighting = (ambient.clone(), color.clone(), dir.clone());
+        self.lighting = (*ambient, *color, *dir);
     }
 
     pub fn add_point_light(
@@ -359,9 +343,9 @@ impl State {
     ) {
         self.point_lights.push(
             PointLight {
-                pos: pos.clone(),
-                color: color.clone(),
-                attenuation: attenuation.clone(),
+                pos: *pos,
+                color: *color,
+                attenuation: *attenuation,
             },
         );
     }
@@ -395,7 +379,7 @@ impl State {
             &self.lighting.2.normalize(),
         );
         shader.set_i32(
-            ctx, &format!("light_count"),
+            ctx, "light_count",
             plc as _,
         );
     }
@@ -410,17 +394,17 @@ impl State {
         if plc > 0 {
             let lpos: Vec<_> = self.point_lights.iter().take(plc).map(|l| l.pos).collect();
             shader.set_vec3_array(
-                ctx, &format!("light_pos[0]"),
+                ctx, "light_pos[0]",
                 &lpos,
             );
             let lcolor: Vec<_> = self.point_lights.iter().take(plc).map(|l| l.color).collect();
             shader.set_vec3_array(
-                ctx, &format!("light_color[0]"),
+                ctx, "light_color[0]",
                 &lcolor,
             );
             let lattenuation: Vec<_> = self.point_lights.iter().take(plc).map(|l| l.attenuation).collect();
             shader.set_vec2_array(
-                ctx, &format!("light_attenuation[0]"),
+                ctx, "light_attenuation[0]",
                 &lattenuation,
             );
         }
@@ -436,7 +420,7 @@ impl State {
 
     pub fn bind_2d(&self, ctx: &context::Context, shader: &shader::Shader) {
         shader.bind(ctx);
-        shader.set_mat4(&ctx, "projection", &glam::Mat4::IDENTITY);
+        shader.set_mat4(ctx, "projection", &glam::Mat4::IDENTITY);
         shader.set_mat4(
             ctx, "view",
             &glam::Mat4::from_scale(
@@ -457,7 +441,7 @@ impl State {
     {
         if self.audio.is_none() {
             self.audio = Some(audio::Assets::new(|actx| {
-                game.initialize_audio(ctx, &self, actx)
+                game.initialize_audio(ctx, self, actx)
             }));
         }
         Ok(())
@@ -542,11 +526,7 @@ impl State {
 
     /// Return the first keybinding for the given virtual key
     pub fn keybinding_for(&self, k: Key) -> Option<String> {
-        if let Some(kc) = self.keybindings.get_by_right(&k) {
-            Some(format!("{}", kc))
-        } else {
-            None
-        }
+        self.keybindings.get_by_right(&k).map(|kc| format!("{}", kc))
     }
 
     pub fn rebind_key(&mut self, k: Key) {
@@ -557,7 +537,7 @@ impl State {
         let now = now(ctx);
         if now > self.nextframe {
             while self.nextframe < now { // find the next target frame that isn't in the past
-                self.nextframe = self.nextframe + DELTA_TIME;
+                self.nextframe += DELTA_TIME;
             }
             self.tick += 1;
             self.frames_this_second += 1;
@@ -586,8 +566,8 @@ impl State {
             }
         );
         ctx.clear();
-        self.shader_upscale.bind(&ctx);
-        self.render_framebuffer.bind_texture(&ctx);
+        self.shader_upscale.bind(ctx);
+        self.render_framebuffer.bind_texture(ctx);
         ctx.render_no_geometry();
         #[cfg(all(debug_assertions, not(target_arch = "wasm32")))]
         {
diff --git a/crates/teleia/src/texture.rs b/crates/teleia/src/texture.rs
index 727eec2..e20ae05 100644
--- a/crates/teleia/src/texture.rs
+++ b/crates/teleia/src/texture.rs
@@ -69,7 +69,7 @@ impl Texture {
             .expect("failed to decode image")
             .into_rgba8();
         let pixels = rgba.as_bytes();
-        self.upload_rgba8(ctx, rgba.width() as i32, rgba.height() as i32, &pixels);
+        self.upload_rgba8(ctx, rgba.width() as i32, rgba.height() as i32, pixels);
     }
 
     pub fn upload_rgba8(&mut self, ctx: &context::Context, width: i32, height: i32, data: &[u8]) {
diff --git a/crates/teleia/src/utils.rs b/crates/teleia/src/utils.rs
index 272a09b..83fe8c0 100644
--- a/crates/teleia/src/utils.rs
+++ b/crates/teleia/src/utils.rs
@@ -119,7 +119,7 @@ impl Cardinal {
 
     pub fn turn_by(&self, o: Self) -> Self {
         match o {
-            Self::North => self.clone(),
+            Self::North => *self,
             Self::South => self.turn_cw().turn_cw(),
             Self::West => self.turn_cw(),
             Self::East => self.turn_ccw(),
@@ -138,10 +138,10 @@ pub fn lerp(a: f32, b: f32, t: f32) -> f32 {
     a + t.clamp(0.0, 1.0) * (b - a)
 }
 
-pub fn dir_lerp(a: &glam::Vec3, b: glam::Vec3, t: f32) -> glam::Vec3 {
+pub fn dir_lerp(a: glam::Vec3, b: glam::Vec3, t: f32) -> glam::Vec3 {
     let dirrotaxis = a.cross(b).normalize();
     let dirrotangle = a.angle_between(b);
     let dirrotfull = glam::Quat::from_axis_angle(dirrotaxis, dirrotangle);
     let dirrot = glam::Quat::IDENTITY.slerp(dirrotfull, t);
-    dirrot.mul_vec3(a.clone())
+    dirrot.mul_vec3(a)
 }
diff --git a/crates/teleia_macros/src/lib.rs b/crates/teleia_macros/src/lib.rs
index 9e358d9..d8ee109 100644
--- a/crates/teleia_macros/src/lib.rs
+++ b/crates/teleia_macros/src/lib.rs
@@ -24,7 +24,7 @@ impl Designator {
         }
     }
     fn enum_entry(&self, _fnm: &str) -> String {
-        format!("{}", self.parts.join(" ").to_upper_camel_case())
+        self.parts.join(" ").to_upper_camel_case().to_string()
     }
     fn load_expr(&self, fnm: &str) -> Option<String> {
         let i = format!("assets/{}/{}", fnm, self.parts.join("/"));
@@ -54,14 +54,12 @@ impl Field {
     fn new(base: &str, nm: &str) -> Self {
         let mut entries = HashSet::new();
         let fbase = format!("{}{}", base, nm);
-        for mf in WalkDir::new(&fbase) {
-            if let Ok(f) = mf {
-                if f.file_type().is_file() {
-                    entries.insert(Designator::new(
-                        &fbase, f.path(),
-                        nm == "shaders" || nm == "materials",
-                    ));
-                }
+        for f in WalkDir::new(&fbase).into_iter().flatten() {
+            if f.file_type().is_file() {
+                entries.insert(Designator::new(
+                    &fbase, f.path(),
+                    nm == "shaders" || nm == "materials",
+                ));
             }
         }
         Self {
@@ -100,20 +98,18 @@ struct AssetData {
 impl AssetData {
     fn new(base: &str) -> Self {
         let mut fields = Vec::new();
-        let dirs = std::fs::read_dir(base).expect(&format!("failed to read assets directory: {}", base));
+        let dirs = std::fs::read_dir(base).unwrap_or_else(|_| panic!("failed to read assets directory: {}", base));
         let (mut has_meshes, mut has_textures, mut has_materials, mut has_shaders) = (false, false, false, false);
-        for dir in dirs {
-            if let Ok(d) = dir {
-                let nm = d.file_name().into_string().unwrap();
-                fields.push(Field::new(base, &nm));
-                match &*nm {
-                    "meshes" => has_meshes = true,
-                    "textures" => has_textures = true,
-                    "materials" => has_materials = true,
-                    "shaders" => has_shaders = true,
-                    _ => {},
-                };
-            }
+        for d in dirs.flatten() {
+            let nm = d.file_name().into_string().unwrap();
+            fields.push(Field::new(base, &nm));
+            match &*nm {
+                "meshes" => has_meshes = true,
+                "textures" => has_textures = true,
+                "materials" => has_materials = true,
+                "shaders" => has_shaders = true,
+                _ => {},
+            };
         }
         if !has_meshes { fields.push(Field { nm: "meshes".to_owned(), entries: HashSet::new() }); }
         if !has_textures { fields.push(Field { nm: "textures".to_owned(), entries: HashSet::new() }); }
@@ -160,5 +156,5 @@ pub fn generate_assets(s: TokenStream) -> TokenStream {
     let manifest = env::var("CARGO_MANIFEST_DIR").expect("failed to get manifest path");
     let assets = AssetData::new(&format!("{}/{}", manifest, base));
     // println!("{}", assets.generate());
-    format!("{}", assets.generate()).parse().expect("failed to parse generate_assets result")
+    assets.generate().to_string().parse().expect("failed to parse generate_assets result")
 }