Rustfmt most of the code

But don't accept the suggestions that make the code harder to read.

Author: ruuda

src/aabb.rs

@@ -53,7 +53,9 @@ impl Aabb {
 
     /// Returns the smalles axis-aligned bounding box that contains all input
     /// points.
-    pub fn enclose_points<'a, I>(points: I) -> Aabb where I: IntoIterator<Item = &'a SVector3> {
+    pub fn enclose_points<'a, I>(points: I) -> Aabb
+        where I: IntoIterator<Item = &'a SVector3>
+    {
         let mut it = points.into_iter();
         let &first = it.next().expect("enclosure must encluse at least one point");
 
@@ -69,7 +71,9 @@ impl Aabb {
     }
 
     /// Returns the smallest bounding box that contains all input boxes.
-    pub fn enclose_aabbs<'a, I>(aabbs: I) -> Aabb where I: IntoIterator<Item = &'a Aabb> {
+    pub fn enclose_aabbs<'a, I>(aabbs: I) -> Aabb
+        where I: IntoIterator<Item = &'a Aabb>
+    {
         let mut it = aabbs.into_iter();
         let first = it.next().expect("enclosure must enclose at least one AABB");
 

src/bench.rs

@@ -89,7 +89,9 @@ pub fn unit_squaternions(n: usize) -> Vec<SQuaternion> {
         // Use rejection sampling because I do not know how to sample a 4D unit
         // sphere uniformly.
         let norm_squared = a * a + b * b + c * c + d * d;
-        if norm_squared > 1.0 { continue }
+        if norm_squared > 1.0 {
+            continue;
+        }
 
         let norm = norm_squared.sqrt();
         let q = SQuaternion::new(a / norm, b / norm, c / norm, d / norm);
@@ -175,33 +177,33 @@ pub fn triangles(n: usize) -> Vec<Triangle> {
     let v1s = svectors_on_unit_sphere(n);
     let v2s = svectors_on_unit_sphere(n);
     v0s.iter()
-       .zip(v1s.iter().zip(v2s.iter()))
-       .map(|(&v0, (&v1, &v2))| Triangle::new(v0, v1, v2, SMaterial::white()))
-       .collect()
+        .zip(v1s.iter().zip(v2s.iter()))
+        .map(|(&v0, (&v1, &v2))| Triangle::new(v0, v1, v2, SMaterial::white()))
+        .collect()
 }
 
 /// Generates n bounding boxes with two vertices on the unit sphere.
 pub fn aabbs(n: usize) -> Vec<Aabb> {
     let v0s = svectors_on_unit_sphere(n);
     let v1s = svectors_on_unit_sphere(n);
     v0s.iter()
-       .zip(v1s.iter())
-       .map(|(&v0, &v1)| Aabb::new(SVector3::min(v0, v1), SVector3::max(v0, v1)))
-       .collect()
+        .zip(v1s.iter())
+        .map(|(&v0, &v1)| Aabb::new(SVector3::min(v0, v1), SVector3::max(v0, v1)))
+        .collect()
 }
 
 /// Generates n mrays originating from a sphere of radius 10, pointing inward.
 pub fn mrays_inward(n: usize) -> Vec<MRay> {
     let origins = mvectors_on_unit_sphere(n);
     let dests = mvectors_on_unit_sphere(n);
     origins.iter()
-           .zip(dests.iter())
-           .map(|(&from, &to)| {
-               let origin = from * Mf32::broadcast(10.0);
-               let direction = (to - origin).normalized();
-               MRay::new(origin, direction)
-           })
-           .collect()
+        .zip(dests.iter())
+        .map(|(&from, &to)| {
+            let origin = from * Mf32::broadcast(10.0);
+            let direction = (to - origin).normalized();
+            MRay::new(origin, direction)
+        })
+        .collect()
 }
 
 /// Generates n mrays originating from a sphere of radius 10, pointing inward.
@@ -210,14 +212,14 @@ pub fn mrays_inward_coherent(n: usize) -> Vec<MRay> {
     let origins = svectors_on_unit_sphere(n);
     let dests = mvectors_on_unit_sphere(n);
     origins.iter()
-           .zip(dests.iter())
-           .map(|(&from, &to)| {
-               let origin = MVector3::broadcast(from * 10.0);
-               let dest = to * Mf32::broadcast(0.5);
-               let direction = (dest - origin).normalized();
-               MRay::new(origin, direction)
-           })
-           .collect()
+        .zip(dests.iter())
+        .map(|(&from, &to)| {
+            let origin = MVector3::broadcast(from * 10.0);
+            let dest = to * Mf32::broadcast(0.5);
+            let direction = (dest - origin).normalized();
+            MRay::new(origin, direction)
+        })
+        .collect()
 }
 
 #[test]

src/bvh.rs

@@ -162,7 +162,9 @@ impl InterimNode {
             let num_tris = self.triangles.len();
             if bins[index].triangles.len() > num_tris / 8 && num_tris > bins.len() {
                 // Clear the bins before trying again.
-                for bin in &mut bins[..] { bin.clear(); }
+                for bin in &mut bins[..] {
+                    bin.clear();
+                }
                 return self.bin_triangles_uniform(bins, axis);
             }
         }
@@ -201,8 +203,8 @@ impl InterimNode {
     /// Returs the bounding box enclosing the bin bounding boxes.
     fn enclose_bins(bins: &[Bin]) -> Aabb {
         let aabbs = bins.iter()
-                        .filter(|bin| bin.triangles.len() > 0)
-                        .map(|bin| bin.aabb.as_ref().unwrap());
+            .filter(|bin| bin.triangles.len() > 0)
+            .map(|bin| bin.aabb.as_ref().unwrap());
 
         Aabb::enclose_aabbs(aabbs)
     }
@@ -213,9 +215,12 @@ impl InterimNode {
     }
 
     /// Returns the cheapest split and its cost.
-    fn find_cheapest_split<'a, H>(&self, heuristic: &H, bins: &[Bin<'a>])
-                              -> (f32, Vec<&'a TriangleRef>, Vec<&'a TriangleRef>)
-                              where H: Heuristic {
+    fn find_cheapest_split<'a, H>(&self,
+                                  heuristic: &H,
+                                  bins: &[Bin<'a>])
+                                  -> (f32, Vec<&'a TriangleRef>, Vec<&'a TriangleRef>)
+        where H: Heuristic
+    {
         let mut best_split_at = 0;
         let mut best_split_cost = 0.0;
         let mut is_first = true;
@@ -257,10 +262,12 @@ impl InterimNode {
 
     /// Splits the node if that is would be beneficial according to the
     /// heuristic.
-    fn split<H>(&mut self, heuristic: &H) where H: Heuristic {
+    fn split<H>(&mut self, heuristic: &H)
+        where H: Heuristic
+    {
         // If there is only one triangle, splitting does not make sense.
         if self.triangles.len() <= 1 {
-            return
+            return;
         }
 
         let (best_split_cost, left_tris, right_tris) = {
@@ -286,7 +293,9 @@ impl InterimNode {
                     }
                 }
 
-                for bin in &mut bins[..] { bin.clear(); }
+                for bin in &mut bins[..] {
+                    bin.clear();
+                }
             }
 
             // Something must have set the cost.
@@ -301,7 +310,7 @@ impl InterimNode {
         // one.
         let no_split_cost = heuristic.tris_cost(self.triangles.len());
         if no_split_cost < best_split_cost {
-            return
+            return;
         }
 
         let left_node = InterimNode::from_triangle_refs(left_tris);
@@ -313,7 +322,9 @@ impl InterimNode {
     }
 
     /// Recursively splits the node, constructing the BVH.
-    fn split_recursive<H>(&mut self, heuristic: &H) where H: Heuristic {
+    fn split_recursive<H>(&mut self, heuristic: &H)
+        where H: Heuristic
+    {
         use rayon;
         self.split(heuristic);
 
@@ -396,8 +407,10 @@ impl InterimNode {
             nodes.push(BvhNode::new());
 
             // Recursively crystallize the child nodes.
-            self.children[0].crystallize(source_triangles, nodes, sorted_triangles, child_index + 0);
-            self.children[1].crystallize(source_triangles, nodes, sorted_triangles, child_index + 1);
+            self.children[0]
+                .crystallize(source_triangles, nodes, sorted_triangles, child_index + 0);
+            self.children[1]
+                .crystallize(source_triangles, nodes, sorted_triangles, child_index + 1);
 
             nodes[into_index].index = child_index as u32;
             nodes[into_index].len = 0;
@@ -474,9 +487,10 @@ impl BvhNode {
 impl Bvh {
     pub fn build(source_triangles: &[Triangle]) -> Bvh {
         // Actual triangles are not important to the BVH, convert them to AABBs.
-        let trirefs = (0..).zip(source_triangles.iter())
-                           .map(|(i, tri)| TriangleRef::from_triangle(i, tri))
-                           .collect();
+        let trirefs = (0..)
+            .zip(source_triangles.iter())
+            .map(|(i, tri)| TriangleRef::from_triangle(i, tri))
+            .collect();
 
         let mut root = InterimNode::from_triangle_refs(trirefs);
 
@@ -534,20 +548,19 @@ impl Bvh {
         let mut triangles = Vec::new();
 
         for mesh in meshes {
-            let mesh_triangles = mesh.triangles.iter().map(
-                |ref tri| {
-                    let (i0, i1, i2) = tri.vertices;
-                    let v0 = mesh.vertices[i0 as usize];
-                    let v1 = mesh.vertices[i1 as usize];
-                    let v2 = mesh.vertices[i2 as usize];
-                    let mut triangle = Triangle::new(v0, v1, v2, tri.material);
-                    if let Some((tx0, tx1, tx2)) = tri.tex_coords {
-                        triangle.uv0 = mesh.tex_coords[tx0 as usize];
-                        triangle.uv1 = mesh.tex_coords[tx1 as usize];
-                        triangle.uv2 = mesh.tex_coords[tx2 as usize];
-                    }
-                    triangle
-                });
+            let mesh_triangles = mesh.triangles.iter().map(|ref tri| {
+                let (i0, i1, i2) = tri.vertices;
+                let v0 = mesh.vertices[i0 as usize];
+                let v1 = mesh.vertices[i1 as usize];
+                let v2 = mesh.vertices[i2 as usize];
+                let mut triangle = Triangle::new(v0, v1, v2, tri.material);
+                if let Some((tx0, tx1, tx2)) = tri.tex_coords {
+                    triangle.uv0 = mesh.tex_coords[tx0 as usize];
+                    triangle.uv1 = mesh.tex_coords[tx1 as usize];
+                    triangle.uv2 = mesh.tex_coords[tx2 as usize];
+                }
+                triangle
+            });
             triangles.extend(mesh_triangles);
         }
 
@@ -573,7 +586,10 @@ impl Bvh {
     /// Also returns the number of AABBs intersected and the number of triangles
     /// intersected.
     #[inline(always)]
-    pub fn intersect_nearest_impl(&self, ray: &MRay, mut isect: MIntersection) -> (MIntersection, u32, u32) {
+    pub fn intersect_nearest_impl(&self,
+                                  ray: &MRay,
+                                  mut isect: MIntersection)
+                                  -> (MIntersection, u32, u32) {
         // Keep a stack of nodes that still need to be intersected. This does
         // involve a heap allocation, but that is not so bad. Using a small
         // on-stack vector from the smallvec crate (which falls back to heap
@@ -610,7 +626,7 @@ impl Bvh {
             // intersection, then nothing inside the node can yield
             // a closer intersection, so we can skip the node.
             if aabb_isect.is_further_away_than(isect.distance, ray.active) {
-                continue
+                continue;
             }
 
             if node.len == 0 {

src/main.rs

@@ -144,10 +144,12 @@ fn main() {
                 // blur.
                 renderer.set_time(time, 0.0);
             }
-            Action::None => { }
+            Action::None => {}
         }
 
-        if render_realtime { renderer.set_time(time, time_delta); }
+        if render_realtime {
+            renderer.set_time(time, time_delta);
+        }
         renderer.update_scene();
 
         // When rendering in accumulation mode, first copy the current state

src/material.rs

@@ -225,7 +225,8 @@ fn diffuse_brdf(isect: &MIntersection, ray_in: &MRay) -> MVector3 {
     let modulation = Mf32::broadcast(0.5 / consts::PI) * cos_theta;
 
     debug_assert!(modulation.all_finite());
-    debug_assert!(modulation.all_sign_bits_positive(), "color modulation cannot be negative");
+    debug_assert!(modulation.all_sign_bits_positive(),
+                  "color modulation cannot be negative");
 
     MVector3::new(modulation, modulation, modulation)
 }
@@ -241,9 +242,7 @@ fn diffuse_brdf(isect: &MIntersection, ray_in: &MRay) -> MVector3 {
 /// so the cosine distribution still does a decent job, and it is much cheaper
 /// to sample from than a distribution specific for the Blinn-Phong BRDF.
 #[inline(always)]
-fn continue_path_brdf(isect: &MIntersection,
-                      rng: &mut Rng)
-                      -> MRay {
+fn continue_path_brdf(isect: &MIntersection, rng: &mut Rng) -> MRay {
     // Bounce in a random direction in the hemisphere around the surface
     // normal, with a cosine-weighted distribution, for a diffuse bounce.
     let dir_z = rng.sample_hemisphere_vector();
@@ -268,10 +267,7 @@ fn pd_brdf(isect: &MIntersection, ray: &MRay) -> Mf32 {
 }
 
 /// Continues the path of a photon by sampling a point on a surface.
-fn continue_path_direct_sample(scene: &Scene,
-                               isect: &MIntersection,
-                               rng: &mut Rng)
-                               -> MRay {
+fn continue_path_direct_sample(scene: &Scene, isect: &MIntersection, rng: &mut Rng) -> MRay {
     let ds = scene.get_direct_sample(rng);
     let direction = (ds.position - isect.position).normalized();
 
@@ -329,7 +325,8 @@ fn pd_direct_sample(scene: &Scene, ray: &MRay) -> Mf32 {
         pd_total = (pd_total + pd).pick(pd_total, sample_isect.mask);
 
         debug_assert!(pd_total.all_finite());
-        debug_assert!(pd_total.all_sign_bits_positive(), "probability density must be positive");
+        debug_assert!(pd_total.all_sign_bits_positive(),
+                      "probability density must be positive");
     });
 
     // So far we computed the probability density per triangle, but we picked
@@ -421,7 +418,7 @@ pub fn continue_path(material: MMaterial,
     let new_ray = MRay {
         origin: new_ray.origin.pick(ray.origin, active),
         direction: new_ray.direction.pick(ray.direction, active),
-        active: active
+        active: active,
     };
 
     let white = MVector3::new(Mf32::one(), Mf32::one(), Mf32::one());
@@ -456,7 +453,8 @@ fn microfacet_brdf(material: MMaterial,
         f_color
     };
 
-    debug_assert!(d.all_sign_bits_positive(), "surface normal density must not be negative");
+    debug_assert!(d.all_sign_bits_positive(),
+                  "surface normal density must not be negative");
 
     // Compute the final microfacet transmission. The factor
     // 4 * dot(n, l) * dot(n, v) has been absorbed into the geometry factor,
@@ -493,7 +491,8 @@ fn microfacet_fresnel(incoming: MVector3, half_way: MVector3, color: MVector3) -
 /// distribution".)
 fn microfacet_normal_dist(half_way: MVector3,
                           isect: &MIntersection,
-                          glossiness_exponent_index: Mi32) -> Mf32 {
+                          glossiness_exponent_index: Mi32)
+                          -> Mf32 {
     // Compute powers of the cosine.
     let c1 = half_way.dot(isect.normal);
     let c2 = c1 * c1;

src/quaternion.rs

@@ -264,7 +264,9 @@ fn bench_interpolate_1000(b: &mut test::Bencher) {
         let ((q0, q1), &t) = it.next().unwrap();
         for _ in 0..100 {
             unroll_10! {{
-                test::black_box(test::black_box(q0).interpolate(test::black_box(q1), test::black_box(t)));
+                test::black_box(
+                    test::black_box(q0)
+                    .interpolate(test::black_box(q1), test::black_box(t)));
             }};
         }
     });

src/random.rs

@@ -35,7 +35,6 @@ pub struct Rng {
 }
 
 impl Rng {
-
     /// Creates a new random number generator.
     ///
     /// The generator is seeded from three 32-bit integers, suggestively called
@@ -62,11 +61,12 @@ impl Rng {
         // powers of two.
         let seed = seed.wrapping_add(seed % 9358246936573323101);
 
-        let primes = Mu64(14491630826648200009, 13149596372461506851, 6119410235796056053, 14990141545859273719);
+        let primes = Mu64(14491630826648200009,
+                          13149596372461506851,
+                          6119410235796056053,
+                          14990141545859273719);
 
-        Rng {
-            state: Mu64(seed, seed, seed, seed) * primes,
-        }
+        Rng { state: Mu64(seed, seed, seed, seed) * primes }
     }
 
     /// Updates the state and returns the old state.