[clippy] needless_range_loop, too_many_arguments.

Author: wahn

.clippy.toml

@@ -1 +1,2 @@
 single-char-binding-names-threshold = 10
+too-many-arguments-threshold = 15

src/accelerators/bvh.rs

@@ -233,17 +233,17 @@ impl BVHAccel {
         } else {
             // compute bound of primitive centroids, choose split dimension _dim_
             let mut centroid_bounds: Bounds3f = Bounds3f::default();
-            for i in start..end {
-                centroid_bounds = bnd3_union_pnt3(&centroid_bounds, &primitive_info[i].centroid);
+            for item in primitive_info.iter().take(end).skip(start) {
+                centroid_bounds = bnd3_union_pnt3(&centroid_bounds, &item.centroid);
             }
             let dim: u8 = centroid_bounds.maximum_extent();
             // partition primitives into two sets and build children
             let mut mid: usize = (start + end) / 2_usize;
             if centroid_bounds.p_max[dim] == centroid_bounds.p_min[dim] {
                 // create leaf _BVHBuildNode_
                 let first_prim_offset: usize = ordered_prims.len();
-                for i in start..end {
-                    let prim_num: usize = primitive_info[i].primitive_number;
+                for item in primitive_info.iter().take(end).skip(start) {
+                    let prim_num: usize = item.primitive_number;
                     ordered_prims.push(bvh.primitives[prim_num].clone());
                 }
                 node.init_leaf(first_prim_offset, n_primitives, &bounds);
@@ -271,9 +271,9 @@ impl BVHAccel {
                             let n_buckets: usize = 12;
                             let mut buckets: [BucketInfo; 12] = [BucketInfo::default(); 12];
                             // initialize _BucketInfo_ for SAH partition buckets
-                            for i in start..end {
+                            for item in primitive_info.iter().take(end).skip(start) {
                                 let mut b: usize = (n_buckets as Float
-                                    * centroid_bounds.offset(&primitive_info[i].centroid)[dim])
+                                    * centroid_bounds.offset(&item.centroid)[dim])
                                     as usize;
                                 if b == n_buckets {
                                     b = n_buckets - 1;
@@ -282,34 +282,34 @@ impl BVHAccel {
                                 assert!(b < n_buckets, "b < {}", n_buckets);
                                 buckets[b].count += 1;
                                 buckets[b].bounds =
-                                    bnd3_union_bnd3(&buckets[b].bounds, &primitive_info[i].bounds);
+                                    bnd3_union_bnd3(&buckets[b].bounds, &item.bounds);
                             }
                             // compute costs for splitting after each bucket
                             let mut cost: [Float; 11] = [0.0; 11];
-                            for i in 0..(n_buckets - 1) {
+                            for (i, cost_item) in cost.iter_mut().enumerate().take(n_buckets - 1) {
                                 let mut b0: Bounds3f = Bounds3f::default();
                                 let mut b1: Bounds3f = Bounds3f::default();
                                 let mut count0: usize = 0;
                                 let mut count1: usize = 0;
-                                for j in 0..(i + 1) {
-                                    b0 = bnd3_union_bnd3(&b0, &buckets[j].bounds);
-                                    count0 += buckets[j].count;
+                                for item in buckets.iter().take(i + 1) {
+                                    b0 = bnd3_union_bnd3(&b0, &item.bounds);
+                                    count0 += item.count;
                                 }
-                                for j in (i + 1)..n_buckets {
-                                    b1 = bnd3_union_bnd3(&b1, &buckets[j].bounds);
-                                    count1 += buckets[j].count;
+                                for item in buckets.iter().take(n_buckets).skip(i + 1) {
+                                    b1 = bnd3_union_bnd3(&b1, &item.bounds);
+                                    count1 += item.count;
                                 }
-                                cost[i] = 1.0
+                                *cost_item = 1.0
                                     + (count0 as Float * b0.surface_area()
                                         + count1 as Float * b1.surface_area())
                                         / bounds.surface_area();
                             }
                             // find bucket to split at that minimizes SAH metric
                             let mut min_cost: Float = cost[0];
                             let mut min_cost_split_bucket: usize = 0;
-                            for i in 0..(n_buckets - 1) {
-                                if cost[i] < min_cost {
-                                    min_cost = cost[i];
+                            for (i, item) in cost.iter().enumerate().take(n_buckets - 1) {
+                                if item < &min_cost {
+                                    min_cost = *item;
                                     min_cost_split_bucket = i;
                                 }
                             }
@@ -344,8 +344,8 @@ impl BVHAccel {
                             } else {
                                 // create leaf _BVHBuildNode_
                                 let first_prim_offset: usize = ordered_prims.len();
-                                for i in start..end {
-                                    let prim_num: usize = primitive_info[i].primitive_number;
+                                for item in primitive_info.iter().take(end).skip(start) {
+                                    let prim_num: usize = item.primitive_number;
                                     ordered_prims.push(bvh.primitives[prim_num].clone());
                                 }
                                 node.init_leaf(first_prim_offset, n_primitives, &bounds);

src/accelerators/kdtreeaccel.rs

@@ -55,8 +55,8 @@ impl KdAccelNode {
             1 => self.priv_union.one_primitive = prim_nums[0] as i32,
             _ => {
                 self.priv_union.primitive_indices_offset = primitive_indices.len() as i32;
-                for i in 0..np {
-                    primitive_indices.push(prim_nums[i] as i32);
+                for item in prim_nums.iter().take(np) {
+                    primitive_indices.push(*item as i32);
                 }
             }
         }
@@ -179,8 +179,8 @@ impl KdTreeAccel {
         }
         // compute bounds for kd-tree construction
         let mut prim_bounds: Vec<Bounds3f> = Vec::with_capacity(p_len);
-        for i in 0..p_len {
-            let b: Bounds3f = p[i].world_bound();
+        for item in p.iter().take(p_len) {
+            let b: Bounds3f = item.world_bound();
             bounds = bnd3_union_bnd3(&bounds, &b);
             prim_bounds.push(b);
         }
@@ -255,7 +255,7 @@ impl KdTreeAccel {
         &mut self,
         node_num: i32,
         node_bounds: &Bounds3f,
-        all_prim_bounds: &Vec<Bounds3f>,
+        all_prim_bounds: &[Bounds3f],
         prim_nums: &[usize],
         n_primitives: usize,
         depth: i32,
@@ -316,8 +316,8 @@ impl KdTreeAccel {
             // trim edges to 2 * n_primitives
             edges[axis as usize].resize_with(2 * n_primitives, BoundEdge::default);
             // initialize edges for _axis_
-            for i in 0..n_primitives {
-                let pn: usize = prim_nums[i];
+            for (i, item) in prim_nums.iter().enumerate().take(n_primitives) {
+                let pn: usize = *item;
                 let bounds: &Bounds3f = &all_prim_bounds[pn];
                 edges[axis as usize][2 * i] = BoundEdge::new(bounds.p_min[axis], pn, true);
                 edges[axis as usize][2 * i + 1] = BoundEdge::new(bounds.p_max[axis], pn, false);