refactor(engine): fix portion of clippy lints

3 files changed, 75 insertions, 94 deletions

diff --git a/engine/src/rendering/backend/opengl.rs b/engine/src/rendering/backend/opengl.rs
index 8b887b3..0a04d6e 100644
--- a/engine/src/rendering/backend/opengl.rs
+++ b/engine/src/rendering/backend/opengl.rs
@@ -419,7 +419,7 @@ impl BackendShaderBinding
                 );
             }
             BackendShaderBinding::Texture(texture) => {
-                texture.bind_to_texture_unit(gl_context, binding_index.0)
+                texture.bind_to_texture_unit(gl_context, binding_index.0);
             }
         }
     }
@@ -542,10 +542,9 @@ fn prepare_windows(
 
         let window_handle = match window
             .as_ref()
-            .map(|window| unsafe {
+            .and_then(|window| unsafe {
                 windowing_context.get_window_as_handle(&window.wid())
             })
-            .flatten()
             .transpose()
         {
             Ok(window_handle) => window_handle,
@@ -555,7 +554,7 @@ fn prepare_windows(
             }
         };
 
-        let (new_window_creation_attrs, gl_config) = match DisplayBuilder::new()
+        let (new_window_creation_attrs, gl_config) = match DisplayBuilder::default()
             .with_window_attributes(window_creation_attrs.clone())
             .build(
                 window_handle,
@@ -638,7 +637,7 @@ fn init_window_graphics(
             };
 
         let Ok(window_inner_size) =
-            PhysicalSize::<NonZero<u32>>::try_convert_from(window.inner_size.clone())
+            PhysicalSize::<NonZero<u32>>::try_convert_from(window.inner_size)
         else {
             tracing::error!(
                 "Cannot create a surface for a window with a width/height of 0",
@@ -669,7 +668,7 @@ fn init_window_graphics(
         let gl_context = match graphics_ctx.gl_context.get_or_try_insert_with_fn(|| {
             create_gl_context(
                 &window_gl_config.gl_config,
-                &graphics_props,
+                graphics_props,
                 window_handle,
                 &window_surface,
             )
@@ -684,10 +683,10 @@ fn init_window_graphics(
         if let Err(err) = gl_context.make_current(&window_surface) {
             tracing::error!("Failed to make GL context current: {err}");
             continue;
-        };
+        }
 
         if let Err(err) = gl_set_viewport(
-            &gl_context,
+            gl_context,
             &Vec2 { x: 0, y: 0 }.into(),
             &opengl_bindings::data_types::Dimens {
                 width: window.inner_size.width,
@@ -697,26 +696,22 @@ fn init_window_graphics(
             tracing::error!("Failed to set viewport: {err}");
         }
 
-        set_enabled(
-            &gl_context,
-            Capability::DepthTest,
-            graphics_props.depth_test,
-        );
+        set_enabled(gl_context, Capability::DepthTest, graphics_props.depth_test);
 
         set_enabled(
-            &gl_context,
+            gl_context,
             Capability::MultiSample,
             graphics_props.multisampling_sample_cnt.is_some(),
         );
 
         if graphics_props.debug {
-            enable(&gl_context, Capability::DebugOutput);
-            enable(&gl_context, Capability::DebugOutputSynchronous);
+            enable(gl_context, Capability::DebugOutput);
+            enable(gl_context, Capability::DebugOutputSynchronous);
 
-            set_debug_message_callback(&gl_context, opengl_debug_message_cb);
+            set_debug_message_callback(gl_context, opengl_debug_message_cb);
 
             match set_debug_message_control(
-                &gl_context,
+                gl_context,
                 None,
                 None,
                 None,
@@ -739,7 +734,7 @@ fn init_window_graphics(
             window_ent_id,
             (Surface {
                 id: surface_id,
-                size: window.inner_size.clone(),
+                size: window.inner_size,
             },),
         );
 
@@ -747,7 +742,7 @@ fn init_window_graphics(
             surface_id,
             GraphicsContextSurface {
                 window_surface,
-                size: window.inner_size.clone(),
+                size: window.inner_size,
             },
         );
     }
@@ -927,7 +922,7 @@ fn handle_commands(
 
                 program.activate(gl_context);
 
-                for (binding_index, binding) in bindings.iter() {
+                for (binding_index, binding) in bindings {
                     binding.bind(gl_context, binding_index);
                 }
 
@@ -945,7 +940,7 @@ fn handle_commands(
                     backend_resources,
                     object_store,
                     gl_context,
-                    shader_object_id.clone(),
+                    shader_object_id,
                     &binding_location,
                     binding_value,
                 );
@@ -1097,7 +1092,7 @@ fn handle_commands(
             Command::CreateMesh { obj_id, mesh, usage: mesh_usage } => {
                 let mesh = match &mesh {
                     AssetOrValue::Asset(mesh_asset) => {
-                        let Some(mesh) = assets.get(&mesh_asset) else {
+                        let Some(mesh) = assets.get(mesh_asset) else {
                             tracing::error!(
                                 asset_id=?mesh_asset.id(),
                                 "Mesh asset does not exist"
@@ -1116,7 +1111,7 @@ fn handle_commands(
                         obj_id,
                         || {
                             Ok(BackendResource::Mesh {
-                                mesh: GraphicsMesh::new(gl_context, &mesh, mesh_usage)?,
+                                mesh: GraphicsMesh::new(gl_context, mesh, mesh_usage)?,
                                 vertex_attrs_updated_for_shader: None,
                             })
                         },
@@ -1201,7 +1196,7 @@ fn handle_commands(
 
                 if let Err(err) = draw_mesh(gl_context, graphics_mesh, &draw_mesh_opts) {
                     tracing::error!("Failed to draw mesh: {err}");
-                };
+                }
             }
             Command::UpdateDrawProperties(properties, update_flags) => {
                 update_draw_properties(
@@ -1237,7 +1232,7 @@ fn create_gl_context(
     }
     .map_err(CreateGlContextError::CreateGlutinContext)?;
 
-    MaybeCurrentContextWithFns::new(glutin_context, &surface)
+    MaybeCurrentContextWithFns::new(glutin_context, surface)
         .map_err(CreateGlContextError::MakeContextCurrent)
 }
 
@@ -1519,8 +1514,8 @@ fn update_framebuffer_properties(
     }
 }
 
-fn set_shader_binding<'backend_resources>(
-    backend_resources: &'backend_resources mut BackendResourceStore,
+fn set_shader_binding(
+    backend_resources: &mut BackendResourceStore,
     object_store: &ObjectStore,
     gl_context: &MaybeCurrentContextWithFns,
     shader_object_id: ObjectId,
@@ -1549,14 +1544,11 @@ fn set_shader_binding<'backend_resources>(
             None => return None,
         };
 
-        if let Some(prev_binding) =
+        // TODO: Textures should probably also be handled somehow here
+        if let Some(BackendShaderBinding::Uniform(prev_binding_uniform_buf)) =
             shader_bindings.remove(ShaderBindingIndex(binding_location.binding_index))
         {
-            // TODO: Textures should probably also be handled somehow here
-            if let BackendShaderBinding::Uniform(prev_binding_uniform_buf) = prev_binding
-            {
-                prev_binding_uniform_buf.delete(gl_context);
-            }
+            prev_binding_uniform_buf.delete(gl_context);
         }
 
         return Some(
@@ -1588,27 +1580,27 @@ fn set_shader_binding<'backend_resources>(
         None => return None,
     };
 
-    let binding = match shader_bindings
-        .get(ShaderBindingIndex(binding_location.binding_index))
-        .cloned()
+    let binding = if let Some(binding @ BackendShaderBinding::Uniform(_)) =
+        shader_bindings
+            .get(ShaderBindingIndex(binding_location.binding_index))
+            .cloned()
     {
-        Some(binding @ BackendShaderBinding::Uniform(_)) => binding,
-        Some(_) | None => {
-            let uniform_buf = GlBuffer::<u8>::new(gl_context);
+        binding
+    } else {
+        let uniform_buf = GlBuffer::<u8>::new(gl_context);
 
-            uniform_buf
-                .init(
-                    gl_context,
-                    binding_location.binding_size,
-                    opengl_bindings::buffer::Usage::Dynamic,
-                )
-                .unwrap();
+        uniform_buf
+            .init(
+                gl_context,
+                binding_location.binding_size,
+                opengl_bindings::buffer::Usage::Dynamic,
+            )
+            .unwrap();
 
-            shader_bindings
-                .entry(ShaderBindingIndex(binding_location.binding_index))
-                .set_or_insert_with(|| BackendShaderBinding::Uniform(uniform_buf))
-                .clone()
-        }
+        shader_bindings
+            .entry(ShaderBindingIndex(binding_location.binding_index))
+            .set_or_insert_with(|| BackendShaderBinding::Uniform(uniform_buf))
+            .clone()
     };
 
     let BackendShaderBinding::Uniform(binding_uniform_buf) = &binding else {
@@ -1828,8 +1820,7 @@ fn create_shader_program(
             stage: ShaderStage::Vertex,
             entrypoint: vs_entry_point_reflection
                 .name()
-                .map(|name| name.to_string().into())
-                .unwrap_or("(none)".into()),
+                .map_or("(none)".into(), |name| name.to_string().into()),
         })?;
 
     let (fs_entry_point_index, fs_entry_point_reflection) = shader_program_reflection
@@ -1849,15 +1840,14 @@ fn create_shader_program(
             stage: ShaderStage::Fragment,
             entrypoint: fs_entry_point_reflection
                 .name()
-                .map(|name| name.to_string().into())
-                .unwrap_or("(none)".into()),
+                .map_or("(none)".into(), |name| name.to_string().into()),
         })?;
 
     let vertex_shader = GlShader::new(current_context, ShaderKind::Vertex);
 
     vertex_shader.set_source(
         current_context,
-        &vertex_shader_entry_point_code.as_str().unwrap(),
+        vertex_shader_entry_point_code.as_str().unwrap(),
     )?;
 
     vertex_shader.compile(current_context)?;
@@ -1866,7 +1856,7 @@ fn create_shader_program(
 
     fragment_shader.set_source(
         current_context,
-        &fragment_shader_entry_point_code.as_str().unwrap(),
+        fragment_shader_entry_point_code.as_str().unwrap(),
     )?;
 
     fragment_shader.compile(current_context)?;
@@ -1938,7 +1928,7 @@ fn opengl_debug_message_cb(
         _ => {
             emit_log_with_message!(tracing::Level::WARN);
         }
-    };
+    }
 }
 
 #[inline]
diff --git a/engine/src/rendering/backend/opengl/glutin_compat.rs b/engine/src/rendering/backend/opengl/glutin_compat.rs
index 27f82ad..0bdfcd2 100644
--- a/engine/src/rendering/backend/opengl/glutin_compat.rs
+++ b/engine/src/rendering/backend/opengl/glutin_compat.rs
@@ -66,12 +66,6 @@ pub struct DisplayBuilder
 
 impl DisplayBuilder
 {
-    /// Create new display builder.
-    pub fn new() -> Self
-    {
-        Default::default()
-    }
-
     /// The preference in picking the configuration.
     #[allow(dead_code)]
     pub fn with_preference(mut self, preference: ApiPreference) -> Self
@@ -153,7 +147,7 @@ impl DisplayBuilder
             config_picker_fn(gl_configs).ok_or(Error::NoConfigPicked)?;
 
         let window_attrs = cfg_select! {
-            windows => { self.window_attributes }
+            windows => self.window_attributes,
             _ => {
                 finalize_window_creation_attrs(self.window_attributes, &picked_gl_config)
             }
@@ -179,39 +173,36 @@ pub enum Error
     WindowRequired,
 }
 
+#[allow(unused_variables)]
 fn create_display(
     display_handle: &DisplayHandle<'_>,
-    _api_preference: ApiPreference,
-    _raw_window_handle: Option<RawWindowHandle>,
+    api_preference: ApiPreference,
+    raw_window_handle: Option<RawWindowHandle>,
 ) -> Result<Display, GlutinError>
 {
     let preference = cfg_select! {
-        windows => {
-            match _api_preference {
-                ApiPreference::PreferEgl => {
-                    DisplayApiPreference::EglThenWgl(_raw_window_handle)
-                }
-                ApiPreference::FallbackEgl => {
-                    DisplayApiPreference::WglThenEgl(_raw_window_handle)
-                }
+        windows => match _api_preference {
+            ApiPreference::PreferEgl => {
+                DisplayApiPreference::EglThenWgl(_raw_window_handle)
             }
-        }
-        target_os = "linux" => {
-            match _api_preference {
-                ApiPreference::PreferEgl => DisplayApiPreference::EglThenGlx(Box::new(
-                    crate::windowing::window::platform::x11::register_xlib_error_hook,
-                )),
-                ApiPreference::FallbackEgl => DisplayApiPreference::GlxThenEgl(Box::new(
-                    crate::windowing::window::platform::x11::register_xlib_error_hook,
-                )),
+            ApiPreference::FallbackEgl => {
+                DisplayApiPreference::WglThenEgl(_raw_window_handle)
             }
-        }
-        target_os = "macos" => { DisplayApiPreference::Cgl }
+        },
+        target_os = "linux" => match api_preference {
+            ApiPreference::PreferEgl => DisplayApiPreference::EglThenGlx(Box::new(
+                crate::windowing::window::platform::x11::register_xlib_error_hook,
+            )),
+            ApiPreference::FallbackEgl => DisplayApiPreference::GlxThenEgl(Box::new(
+                crate::windowing::window::platform::x11::register_xlib_error_hook,
+            )),
+        },
+        target_os = "macos" => DisplayApiPreference::Cgl,
     };
 
     let handle = display_handle.as_raw();
 
-    unsafe { Ok(Display::new(handle, preference)?) }
+    unsafe { Display::new(handle, preference) }
 }
 
 /// Finalize [`Window`] creation by applying the options from the [`Config`], be
@@ -235,7 +226,8 @@ fn finalize_window_creation_attrs(
     if let Some(x11_visual) = glutin::platform::x11::X11GlConfigExt::x11_visual(gl_config)
     {
         return attributes.with_x_visual_id(Some(
-            x11_visual.visual_id() as crate::windowing::window::XVisualID
+            crate::windowing::window::XVisualID::try_from(x11_visual.visual_id())
+                .expect("X visual ID is too large"),
         ));
     }
 
diff --git a/engine/src/rendering/backend/opengl/graphics_mesh.rs b/engine/src/rendering/backend/opengl/graphics_mesh.rs
index 43cd254..899f50f 100644
--- a/engine/src/rendering/backend/opengl/graphics_mesh.rs
+++ b/engine/src/rendering/backend/opengl/graphics_mesh.rs
@@ -69,8 +69,7 @@ impl GraphicsMesh
                     max_value,
                 } => {
                     panic!(
-                        "Size of vertex ({}) is too large. Must be less than {max_value}",
-                        value
+                        "Size of vertex ({value}) is too large. Must be less than {max_value}"
                     );
                 }
             }
@@ -86,7 +85,7 @@ impl GraphicsMesh
             vertex_arr.bind_element_buffer(current_context, &index_buffer);
 
             return Ok(Self {
-                vertex_buffer: vertex_buffer,
+                vertex_buffer,
                 vertex_attr_props: mesh.vertex_buf().vertex_attr_props().to_vec(),
                 last_max_vertex_attr_index: 0,
                 index_buffer: Some(index_buffer),
@@ -99,7 +98,7 @@ impl GraphicsMesh
         }
 
         Ok(Self {
-            vertex_buffer: vertex_buffer,
+            vertex_buffer,
             vertex_attr_props: mesh.vertex_buf().vertex_attr_props().to_vec(),
             last_max_vertex_attr_index: 0,
             index_buffer: None,
@@ -135,7 +134,7 @@ impl GraphicsMesh
                 .map_err(Error::StoreIndicesFailed)?;
 
             self.vertex_arr
-                .bind_element_buffer(current_context, &index_buffer);
+                .bind_element_buffer(current_context, index_buffer);
 
             self.element_cnt = indices
                 .len()