clippy fixes

build.rs

@@ -1,3 +1,5 @@
+#![allow(clippy::needless_return)]
+
 use anyhow::*;
 use fs_extra::copy_items;
 use fs_extra::dir::CopyOptions;
@@ -9,8 +11,7 @@ fn main() -> Result<()> {
     let out_dir = env::var("OUT_DIR")?;
     let mut copy_options = CopyOptions::new();
     copy_options.overwrite = true;
-    let mut paths_to_copy = Vec::new();
+    let paths_to_copy = vec!["res/"];
-    paths_to_copy.push("res/");
     copy_items(&paths_to_copy, out_dir, &copy_options)?;
 
     return Ok(());

src/core/camera.rs

@@ -36,12 +36,12 @@ impl Camera {
         aspect: f32,
     ) -> Self {
         Self {
-            position: position,
+            position,
-            pitch: pitch,
+            pitch,
-            yaw: yaw,
+            yaw,
             projection: Projection {
-                aspect: aspect,
+                aspect,
-                fovy: fovy,
+                fovy,
                 znear: 0.1,
                 zfar: 3000.0,
             },
@@ -78,9 +78,9 @@ impl Camera {
             89.0,
         );
         self.yaw += controller.deltax * controller.sensitivity * 0.022;
-        self.yaw = self.yaw % 360.0;
+        self.yaw %= 360.0;
         if self.yaw < 0.0 {
-            self.yaw = 360.0 + self.yaw;
+            self.yaw += 360.0;
         }
 
         let (right, up, forward) = self.get_vecs();
@@ -237,15 +237,12 @@ impl CameraController {
         }
 
         handled = match device_event {
-            None => false,
+            Some(DeviceEvent::MouseMotion { delta }) => {
-            Some(event) => match event {
+                self.deltax += delta.0 as f32;
-                DeviceEvent::MouseMotion { delta } => {
+                self.deltay += delta.1 as f32;
-                    self.deltax += delta.0 as f32;
+                return true;
-                    self.deltay += delta.1 as f32;
+            }
-                    return true;
+            _ => false,
-                }
-                _ => false,
-            },
         };
 
         return handled;

src/core/light.rs

@@ -13,9 +13,9 @@ pub struct LightUniform {
 impl LightUniform {
     pub fn new(position: [f32; 3], color: [f32; 4]) -> Self {
         return LightUniform {
-            position: position,
+            position,
             _padding: 0,
-            color: color,
+            color,
         };
     }
 }

src/core/resources.rs

@@ -1,4 +1,3 @@
-use std::io::{BufReader, Cursor};
 use std::path::PathBuf;
 use wgpu::util::DeviceExt;
 
@@ -11,33 +10,6 @@ pub fn get_resource_path(file_name: &str) -> PathBuf {
         .join(file_name);
 }
 
-pub async fn load_string(file_name: &str) -> anyhow::Result<String> {
-    let path = get_resource_path(file_name);
-    println!("load_string: Loading from {:?}", path.to_str());
-    let txt = std::fs::read_to_string(path)?;
-
-    return Ok(txt);
-}
-
-pub async fn load_binary(file_name: &str) -> anyhow::Result<Vec<u8>> {
-    let path = get_resource_path(file_name);
-    println!("load_binary: Loading from {:?}", path.to_str());
-    let data = std::fs::read(path)?;
-
-    return Ok(data);
-}
-
-pub async fn load_texture(
-    file_name: &str,
-    is_normal_map: bool,
-    device: &wgpu::Device,
-    queue: &wgpu::Queue,
-) -> anyhow::Result<Texture> {
-    println!("load_texture {}", file_name);
-    let data = load_binary(file_name).await?;
-    return Texture::from_bytes(device, queue, &data, file_name, is_normal_map);
-}
-
 pub async fn load_model_gltf(
     file_name: &str,
     device: &wgpu::Device,
@@ -83,7 +55,7 @@ pub async fn load_model_gltf(
             }
 
             if let Some(tangent_attribute) = reader.read_tangents() {
-                println!("gltf: loading tangents from file");
+                // println!("gltf: loading tangents from file");
                 let mut tangent_index = 0;
                 tangent_attribute.for_each(|tangent| {
                     // dbg!(tangent);
@@ -99,7 +71,7 @@ pub async fn load_model_gltf(
                     tangent_index += 1;
                 });
             } else {
-                println!("gltf: no tangents in file, calculating from tris");
+                // println!("gltf: no tangents in file, calculating from tris");
                 // tangents and bitangents from triangles
                 let mut triangles_included = vec![0; vertices.len()];
                 for chunk in indices.chunks(3) {
@@ -192,7 +164,7 @@ pub async fn load_model_gltf(
         let diffuse_index = pbr
             .base_color_texture()
             .map(|tex| {
-                println!("gltf: get diffuse tex");
+                // println!("gltf: get diffuse tex");
                 tex.texture().source().index()
             })
             .unwrap_or(0); // TODO default tex
@@ -221,7 +193,7 @@ pub async fn load_model_gltf(
         let normal_index = material
             .normal_texture()
             .map(|tex| {
-                println!("gltf: get normal tex");
+                // println!("gltf: get normal tex");
                 tex.texture().source().index()
             })
             .unwrap_or(0); // TODO default tex
@@ -246,42 +218,42 @@ pub async fn load_model_gltf(
         )
         .unwrap();
 
-        // metallic + roughness
+        // roughness-metalness
-        let mr_index = pbr
+        let rm_index = pbr
             .metallic_roughness_texture()
             .map(|tex| {
-                println!("gltf: get metallic roughness tex");
+                // println!("gltf: get roughness metalness tex");
                 tex.texture().source().index()
             })
             .unwrap_or(0); // TODO default tex
 
-        let mr_data = &mut images[mr_index];
+        let rm_data = &mut images[rm_index];
-        dbg!(mr_data.format);
+        // dbg!(rm_data.format);
 
-        if mr_data.format == gltf::image::Format::R8G8B8
+        if rm_data.format == gltf::image::Format::R8G8B8
-            || mr_data.format == gltf::image::Format::R16G16B16
+            || rm_data.format == gltf::image::Format::R16G16B16
         {
-            mr_data.pixels =
+            rm_data.pixels =
-                gltf_pixels_to_wgpu(mr_data.pixels.clone(), mr_data.format);
+                gltf_pixels_to_wgpu(rm_data.pixels.clone(), rm_data.format);
         }
 
-        let mr_texture = Texture::from_pixels(
+        let rm_texture = Texture::from_pixels(
             device,
             queue,
-            &mr_data.pixels,
+            &rm_data.pixels,
-            (mr_data.width, mr_data.height),
+            (rm_data.width, rm_data.height),
-            gltf_image_format_stride(mr_data.format),
+            gltf_image_format_stride(rm_data.format),
-            gltf_image_format_to_wgpu(mr_data.format, false),
+            gltf_image_format_to_wgpu(rm_data.format, false),
             Some(file_name),
         )
         .unwrap();
 
         materials.push(Material::new(
             device,
-            &material.name().unwrap_or("Default Material").to_string(),
+            &material.name().unwrap_or("Default Material"),
             diffuse_texture,
             normal_texture,
-            mr_texture,
+            rm_texture,
             pbr.metallic_factor(),
             pbr.roughness_factor(),
             layout,

src/core/texture.rs

@@ -75,7 +75,7 @@ impl Texture {
         return Self::from_pixels(
             device,
             queue,
-            &rgba.to_vec(),
+            &rgba,
             dimensions,
             4,
             if is_normal_map {
@@ -107,12 +107,12 @@ impl Texture {
             mip_level_count: 1,
             sample_count: 1,
             dimension: wgpu::TextureDimension::D2,
-            format: format,
+            format,
             usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
         });
 
-        dbg!(stride);
+        // dbg!(stride);
-        dbg!(dimensions);
+        // dbg!(dimensions);
         queue.write_texture(
             wgpu::ImageCopyTexture {
                 aspect: wgpu::TextureAspect::All,
@@ -120,7 +120,7 @@ impl Texture {
                 mip_level: 0,
                 origin: wgpu::Origin3d::ZERO,
             },
-            &pixels,
+            pixels,
             wgpu::ImageDataLayout {
                 offset: 0,
                 bytes_per_row: std::num::NonZeroU32::new(stride * dimensions.0),

src/core/window.rs

@@ -52,7 +52,7 @@ pub async fn run() {
                         }
                         WindowEvent::Focused(focused) => {
                             window
-                                .set_cursor_grab(if *focused == true {
+                                .set_cursor_grab(if *focused {
                                     winit::window::CursorGrabMode::Confined
                                 } else {
                                     winit::window::CursorGrabMode::None

src/main.rs

@@ -1,3 +1,5 @@
+#![allow(clippy::needless_return)]
+
 mod core;
 mod shaders;
 

src/shaders/wgsl/brdf.wgsl

@@ -57,7 +57,9 @@ fn brdf(
     let denom = 4.0 * max(dot(normal_dir, view_dir), 0.0) * max(dot(normal_dir, light_dir), 0.0) + 0.0001;
     let specular = nom / denom;
 
+    // diffuse
     let k_d = (vec3(1.0) - fresnel) * (1.0 - metalness);
     let n_dot_l = max(dot(normal_dir, light_dir), 0.0);
-    return (k_d * albedo / PI + specular) * n_dot_l;
+    
+    return ((k_d * albedo / PI) + specular) * n_dot_l;
 }