wip: clippy opts

src/assets/car_asset.rs

@@ -8,7 +8,7 @@ use bevy::{
 // Use support/car to load car asset with mesh and textures...
 #[derive(Asset, TypePath)]
 pub struct CarAsset {
-    body: Handle<Mesh>,
+    _body: Handle<Mesh>,
     // #[asset(key = "combined_image")]
     // combined_image: Handle<Image>,
     // #[asset(key = "tree_standard_material")]

src/support/actor.rs

@@ -183,6 +183,6 @@ impl Actor {
 
     pub fn load_from<P: AsRef<std::path::Path>>(filename: P) -> Result<Actor> {
         let mut file = BufReader::new(File::open(filename)?);
-        Ok(Actor::load(&mut file)?)
+        Actor::load(&mut file)
     }
 }

src/support/car.rs

@@ -55,7 +55,7 @@ fn expect_match(input: &mut impl Iterator<Item = String>, text: &str) -> Result<
 
 /// Parse a three-component vector from a comma-separated string.
 #[throws]
-fn parse_vector(line: &String) -> Vector3<f32> {
+fn parse_vector(line: &str) -> Vector3<f32> {
     let line: Result<Vec<f32>, _> = line.split(',').map(|i| i.trim().parse::<f32>()).collect();
     let line = line?;
     Vector3::from((line[0], line[1], line[2]))
@@ -281,10 +281,10 @@ fn read_mechanics_v4(input: &mut impl Iterator<Item = String>) -> Result<Mechani
 
 fn read_meshes<P: AsRef<Path>>(
     fname: P,
-    load_models: &Vec<String>,
+    load_models: &[String],
     car_meshes: &mut HashMap<String, Mesh>,
 ) -> Result<()> {
-    let mut load_models = load_models.clone();
+    let mut load_models: Vec<String> = load_models.to_vec();
     load_models.sort();
     load_models.dedup();
     debug!("Models to load: {:?}", load_models);
@@ -359,7 +359,7 @@ impl Car {
 
         let mut input_lines = description_file
             .lines()
-            .filter_map(|line| line.ok())
+            .map_while(Result::ok)
             .filter(|line| !line.starts_with("//")) // Skip whole-line comments
             .filter(|line| !line.is_empty()) // Skip empty lines
             // Separate in-line comments from data
@@ -437,14 +437,11 @@ impl Car {
 
         let load_actors: HashMap<isize, String> = read_vector(&mut input_lines)?
             .iter()
-            .map(|act| act.split(","))
+            .map(|act| act.split(','))
             .map(|mut split| {
                 (
                     split.next().and_then(|id| id.parse().ok()).unwrap_or(0),
-                    split
-                        .next()
-                        .map(|x| String::from(x))
-                        .unwrap_or_else(|| "".into()),
+                    split.next().map(String::from).unwrap_or_else(|| "".into()),
                 )
             })
             .collect();
@@ -511,8 +508,7 @@ impl Car {
         }
         let version = mechanics
             .split(" version ")
-            .skip(1)
-            .next()
+            .nth(1)
             .map(|x| x.parse())
             .ok_or(anyhow!("Bad input data"))??;
 
@@ -551,13 +547,10 @@ impl Car {
         // Read meshes referenced from actor file
         load_models.clear();
         for actor in car_actors.traverse() {
-            match actor.data() {
-                &ActorNode::MeshfileRef(ref name) => {
-                    if !car_meshes.contains_key(name) {
-                        load_models.push(name.clone())
-                    }
+            if let ActorNode::MeshfileRef(name) = actor.data() {
+                if !car_meshes.contains_key(name) {
+                    load_models.push(name.clone())
                 }
-                _ => (),
             }
         }
 
@@ -567,8 +560,7 @@ impl Car {
         //
         // Materials
         //
-        let mut load_materials: HashSet<String> =
-            load_materials.iter().map(|s| s.clone()).collect();
+        let mut load_materials: HashSet<String> = load_materials.iter().cloned().collect();
         debug!("Materials to load: {:?}", load_materials);
 
         let mut car_materials = HashMap::<String, Material>::new();
@@ -595,7 +587,7 @@ impl Car {
         for x in 0..palette.units {
             trace!(
                 "Palette alpha {}",
-                palette.data[(x * palette.unit_bytes + 0) as usize]
+                palette.data[(x * palette.unit_bytes/*+ 0*/) as usize]
             );
         }
 
@@ -610,7 +602,7 @@ impl Car {
             info!("### Opening pixelmap {:?}", pix_file_name);
             let pix = PixelMap::load_from(pix_file_name)?;
             for pmap in pix {
-                let pmap = pmap.remap_via_palette(&palette)?;
+                let pmap = pmap.remap_via_palette(palette)?;
                 car_textures.insert(pmap.name.clone(), pmap);
             }
         }

src/support/mesh.rs

@@ -27,10 +27,10 @@ pub struct UvCoord {
 
 impl UvCoord {
     pub fn load<R: ReadBytesExt>(rdr: &mut R) -> Result<UvCoord> {
-        let mut uv = UvCoord::default();
-        uv.u = rdr.read_f32::<BigEndian>()?;
-        uv.v = rdr.read_f32::<BigEndian>()?;
-        Ok(uv)
+        Ok(UvCoord {
+            u: rdr.read_f32::<BigEndian>()?,
+            v: rdr.read_f32::<BigEndian>()?,
+        })
     }
 }
 
@@ -45,13 +45,15 @@ pub struct Face {
 
 impl Face {
     pub fn load<R: ReadBytesExt>(rdr: &mut R) -> Result<Face> {
-        let mut s = Face::default();
-        s.v1 = rdr.read_u16::<BigEndian>()?;
-        s.v2 = rdr.read_u16::<BigEndian>()?;
-        s.v3 = rdr.read_u16::<BigEndian>()?;
-        s.flags = rdr.read_u16::<BigEndian>()?;
+        let f = Face {
+            v1: rdr.read_u16::<BigEndian>()?,
+            v2: rdr.read_u16::<BigEndian>()?,
+            v3: rdr.read_u16::<BigEndian>()?,
+            flags: rdr.read_u16::<BigEndian>()?,
+            material_id: 0,
+        };
         rdr.read_i8()?; // something, no idea yet, might be related to flags
-        Ok(s)
+        Ok(f)
     }
 }
 
@@ -106,15 +108,13 @@ impl Mesh {
             }
         }
 
-        if fmlist.len() > 0 && m.faces.len() == fmlist.len() {
-            for i in 0..m.faces.len() {
-                m.faces[i].material_id = fmlist[i];
-            }
+        for (i, fm) in fmlist.iter().enumerate().take(m.faces.len()) {
+            m.faces[i].material_id = *fm;
         }
 
-        for n in 0..uvcoords.len() {
+        for (n, uvcoord) in uvcoords.iter().enumerate() {
             // Carma uses 0.0,0.0 for the top left corner, OpenGL for the bottom left.
-            m.vertices[n].tex_coords = [uvcoords[n].u, 1.0 - uvcoords[n].v];
+            m.vertices[n].tex_coords = [uvcoord.u, 1.0 - uvcoord.v];
         }
 
         m.calc_normals();

src/support/mod.rs

@@ -135,7 +135,7 @@ pub fn path_subst<P: AsRef<Path>>(
     fn inner<P: AsRef<Path>>(filepath: P, newdir: P, newext: Option<String>) -> Result<PathBuf> {
         let fname = filepath.as_ref().file_name();
         let mut dir = filepath.as_ref().to_path_buf();
-        if let Some(_) = fname {
+        if fname.is_some() {
             dir.pop(); // remove file name
         }
         dir.pop(); // remove parent dir

src/support/render_manager.rs

@@ -30,7 +30,7 @@ pub struct RenderManager {
     program: Program,
 }
 
-fn debug_tree(name: &String, actor_name: &String, stack: &Vec<Matrix4<f32>>) {
+fn debug_tree(name: &String, actor_name: &String, stack: &[Matrix4<f32>]) {
     debug!("{} for {}: stack depth {}", name, actor_name, stack.len());
     for x in stack.iter().rev() {
         debug!(".. {:?}", x);
@@ -56,7 +56,7 @@ impl RenderManager {
     }
 
     fn debug_indices(&self) {
-        for (name, _indices) in &self.indices {
+        for name in self.indices.keys() {
             trace!("Indices for {}:", name);
             // for () in &indices {
             //     trace!("  ", )
@@ -80,11 +80,8 @@ impl RenderManager {
     // of texture ID to the rect region, scale u,v appropriately in vertices.
     // In theory, whole of the game could fit in 4096x4096 megatex.
     fn bind_textures(&mut self, actor_name: &String, car: &Car, display: &Display) {
-        for (&mat, _) in &self.indices[actor_name] {
-            let textures = self
-                .bound_textures
-                .entry(actor_name.clone())
-                .or_insert(HashMap::new());
+        for &mat in self.indices[actor_name].keys() {
+            let textures = self.bound_textures.entry(actor_name.clone()).or_default();
             if mat == 0 {
                 RenderManager::bind_default_texture(textures, mat, display);
             } else {
@@ -115,12 +112,9 @@ impl RenderManager {
 
     pub fn prepare_car(&mut self, car: &Car, display: &Display) {
         for actor in car.actors.traverse() {
-            match actor.data() {
-                &ActorNode::MeshfileRef(ref name) => {
-                    debug!("Actor meshfile {}", name);
-                    self.prepare_car_actor(name, car, display);
-                }
-                _ => (),
+            if let ActorNode::MeshfileRef(name) = actor.data() {
+                debug!("Actor meshfile {}", name);
+                self.prepare_car_actor(name, car, display);
             }
         }
     }
@@ -137,9 +131,7 @@ impl RenderManager {
         let mut partitioned_by_material = HashMap::<u16, Vec<u16>>::new();
 
         for face in faces {
-            let indices = partitioned_by_material
-                .entry(face.material_id)
-                .or_insert(Vec::new());
+            let indices = partitioned_by_material.entry(face.material_id).or_default();
             indices.push(face.v1);
             indices.push(face.v2);
             indices.push(face.v3);
@@ -161,7 +153,7 @@ impl RenderManager {
                 .map(|(key, item)| {
                     (
                         *key,
-                        IndexBuffer::new(display, PrimitiveType::TrianglesList, &item).unwrap(),
+                        IndexBuffer::new(display, PrimitiveType::TrianglesList, item).unwrap(),
                     )
                 })
                 .collect(),
@@ -184,8 +176,8 @@ impl RenderManager {
         let mut actor_name = String::new();
 
         for actor in car.actors.traverse() {
-            match actor.data() {
-                &ActorNode::Actor { ref name, visible } => {
+            match *actor.data() {
+                ActorNode::Actor { ref name, visible } => {
                     actor_name = name.clone();
                     v = visible;
 
@@ -201,14 +193,14 @@ impl RenderManager {
 
                     debug_tree(&String::from("Actor"), &actor_name, &transform_stack);
                 }
-                &ActorNode::MeshfileRef(ref name) => {
+                ActorNode::MeshfileRef(ref name) => {
                     debug_tree(&format!("Mesh {}", name), &actor_name, &transform_stack);
                     if v {
                         trace!("Drawing actor {}", name);
-                        self.draw_actor(name, &transform_stack.last().unwrap(), target, camera);
+                        self.draw_actor(name, transform_stack.last().unwrap(), target, camera);
                     }
                 }
-                &ActorNode::Transform(t) => {
+                ActorNode::Transform(t) => {
                     let transform = Matrix4::from_translation(Vector3 {
                         x: t[9],
                         y: t[10],
@@ -255,7 +247,7 @@ impl RenderManager {
             ..Default::default()
         };
 
-        let model: [[f32; 4]; 4] = model.clone().into();
+        let model: [[f32; 4]; 4] = (*model).into();
 
         for (mat, indices) in &self.indices[mesh_name] {
             let uniforms = uniform! {

src/support/resource.rs

@@ -29,9 +29,10 @@ struct ChunkHeader {
 
 impl ChunkHeader {
     pub fn load<R: ReadBytesExt>(source: &mut R) -> Result<ChunkHeader> {
-        let mut h = ChunkHeader::default();
-        h.chunk_type = source.read_u32::<BigEndian>()?;
-        h.size = source.read_u32::<BigEndian>()?;
+        let h = ChunkHeader {
+            chunk_type: source.read_u32::<BigEndian>()?,
+            size: source.read_u32::<BigEndian>()?,
+        };
         debug!("Loaded chunk type {} size {}", h.chunk_type, h.size);
         Ok(h)
     }
@@ -146,8 +147,8 @@ impl Chunk {
             support::MATERIAL_DESC_CHUNK => {
                 trace!("Reading material descriptor...");
                 let mut params = [0f32; 12];
-                for i in 0..12 {
-                    params[i] = source.read_f32::<BigEndian>()?;
+                for i in &mut params {
+                    *i = source.read_f32::<BigEndian>()?;
                 }
                 let name = read_c_string(source)?;
                 trace!("... {}", name);
@@ -259,13 +260,13 @@ impl Chunk {
             support::ACTOR_TRANSFORM_CHUNK => {
                 trace!("Reading actor transform...");
                 let mut params = [0f32; 12];
-                for i in 0..12 {
-                    params[i] = source.read_f32::<BigEndian>()?;
+                for i in &mut params {
+                    *i = source.read_f32::<BigEndian>()?;
                 }
                 for row in 0..4 {
                     trace!(
                         "[{} {} {}]",
-                        params[row * 3 + 0],
+                        params[row * 3/*+ 0*/],
                         params[row * 3 + 1],
                         params[row * 3 + 2]
                     );

src/support/texture.rs

@@ -98,7 +98,7 @@ impl PixelMap {
                 ); // B
                 pm.data.push(
                     255 - palette.data
-                        [(self.data[i as usize] as u32 * palette.unit_bytes + 0) as usize],
+                        [(self.data[i as usize] as u32 * palette.unit_bytes/* + 0*/) as usize],
                 ); // A
                 if self.name == "BGLSPIKE.PIX" {
                     trace!("spike alpha {}", pm.data.last().unwrap());