Clippy lints and code quality.

Author: raldone01

shaders/src/shaders/a_lot_of_spheres.rs

@@ -77,7 +77,7 @@ fn intersect_plane(ro: Vec3, rd: Vec3, height: f32, dist: &mut f32) -> bool {
     }
 
     let mut d: f32 = -(ro.y - height) / rd.y;
-    d = d.min(100000.0);
+    d = d.min(100_000.0);
     if d > 0.0 {
         *dist = d;
         return true;

shaders/src/shaders/a_question_of_time.rs

@@ -75,7 +75,7 @@ fn stroke(d: f32, w: f32, s: f32, i: f32) -> f32 {
 }
 // a simple palette
 fn pal(d: f32) -> Vec3 {
-    0.5 * ((6.283 * d * vec3(2.0, 2.0, 1.0) + vec3(0.0, 1.4, 0.0)).cos() + Vec3::ONE)
+    0.5 * ((TAU * d * vec3(2.0, 2.0, 1.0) + vec3(0.0, 1.4, 0.0)).cos() + Vec3::ONE)
 }
 // 2d rotation matrix
 fn uvr_rotate(a: f32) -> Mat2 {
@@ -100,7 +100,7 @@ fn apollonian(uv: Vec2) -> Vec3 {
     // a DEC is a configuration of 4 circles tangent to each other
     // the easiest way to build the initial one it to construct a symetric Steiner Chain.
     // http://mathworld.wolfram.com/SteinerChain.html
-    let a: f32 = 6.283 / 3.;
+    let a: f32 = TAU / 3.;
     let ra: f32 = 1.0 + (a * 0.5).sin();
     let rb: f32 = 1.0 - (a * 0.5).sin();
     dec[0] = vec3(0.0, 0.0, -1.0 / ra);

shaders/src/shaders/apollonian.rs

@@ -180,7 +180,7 @@ impl State {
             }
         }
 
-        tot = tot / (AA * AA) as f32;
+        tot /= (AA * AA) as f32;
 
         *frag_color = tot.extend(1.0);
     }

shaders/src/shaders/atmosphere_system_test.rs

@@ -77,12 +77,12 @@ struct _Plane {
 
 fn rotate_around_x(angle_degrees: f32) -> Mat3 {
     let angle: f32 = angle_degrees.to_radians();
-    let _sin: f32 = angle.sin();
-    let _cos: f32 = angle.cos();
-    Mat3::from_cols_array(&[1.0, 0.0, 0.0, 0.0, _cos, -_sin, 0.0, _sin, _cos])
+    let sin: f32 = angle.sin();
+    let cos: f32 = angle.cos();
+    Mat3::from_cols_array(&[1.0, 0.0, 0.0, 0.0, cos, -sin, 0.0, sin, cos])
 }
 
-fn get_primary_ray(cam_local_point: Vec3, cam_origin: &mut Vec3, cam_look_at: &mut Vec3) -> Ray {
+fn get_primary_ray(cam_local_point: Vec3, cam_origin: &Vec3, cam_look_at: &Vec3) -> Ray {
     let fwd: Vec3 = (*cam_look_at - *cam_origin).normalize();
     let mut up: Vec3 = vec3(0.0, 1.0, 0.0);
     let right: Vec3 = up.cross(fwd);
@@ -94,7 +94,7 @@ fn get_primary_ray(cam_local_point: Vec3, cam_origin: &mut Vec3, cam_look_at: &m
     }
 }
 
-fn isect_sphere(ray: Ray, sphere: Sphere, t0: &mut f32, t1: &mut f32) -> bool {
+fn isect_sphere(ray: Ray, sphere: &Sphere, t0: &mut f32, t1: &mut f32) -> bool {
     let rc: Vec3 = sphere.origin - ray.origin;
     let radius2: f32 = sphere.radius * sphere.radius;
     let tca: f32 = rc.dot(ray.direction);
@@ -160,7 +160,7 @@ const NUM_SAMPLES_LIGHT: i32 = 8;
 fn get_sun_light(ray: Ray, optical_depth_r: &mut f32, optical_depth_m: &mut f32) -> bool {
     let mut t0: f32 = 0.0;
     let mut t1: f32 = 0.0;
-    isect_sphere(ray, ATMOSPHERE, &mut t0, &mut t1);
+    isect_sphere(ray, &ATMOSPHERE, &mut t0, &mut t1);
 
     let mut march_pos: f32 = 0.0;
     let march_step: f32 = t1 / NUM_SAMPLES_LIGHT as f32;
@@ -185,7 +185,7 @@ impl State {
         // "pierce" the atmosphere with the viewing ray
         let mut t0: f32 = 0.0;
         let mut t1: f32 = 0.0;
-        if !isect_sphere(ray, ATMOSPHERE, &mut t0, &mut t1) {
+        if !isect_sphere(ray, &ATMOSPHERE, &mut t0, &mut t1) {
             return Vec3::ZERO;
         }
 
@@ -286,10 +286,10 @@ impl State {
 
             col = self.get_incident_light(ray);
         } else {
-            let mut eye: Vec3 = vec3(0.0, EARTH_RADIUS + 1.0, 0.0);
-            let mut look_at: Vec3 = vec3(0.0, EARTH_RADIUS + 1.5, -1.0);
+            let eye: Vec3 = vec3(0.0, EARTH_RADIUS + 1.0, 0.0);
+            let look_at: Vec3 = vec3(0.0, EARTH_RADIUS + 1.5, -1.0);
 
-            let ray: Ray = get_primary_ray(point_cam, &mut eye, &mut look_at);
+            let ray: Ray = get_primary_ray(point_cam, &eye, &look_at);
 
             if ray.direction.dot(vec3(0.0, 1.0, 0.0)) > 0.0 {
                 col = self.get_incident_light(ray);

shaders/src/shaders/bubble_buckey_balls.rs

@@ -69,10 +69,6 @@ impl<C0, C1> State<C0, C1> {
 // **************************************************************************
 // CONSTANTS
 
-const PI: f32 = 3.14159;
-const TWO_PI: f32 = 6.28318;
-const _PI_OVER_TWO: f32 = 1.570796;
-const ONE_OVER_PI: f32 = 0.318310;
 const GR: f32 = 1.61803398;
 
 const SMALL_FLOAT: f32 = 0.0001;
@@ -94,11 +90,11 @@ const BOND_MATL: f32 = 3.0;
 // Range of outputs := ([-1.,-1.,-1.] -> [1.,1.,1.])
 
 fn rotate_around_y_axis(point: Vec3, cosangle: f32, sinangle: f32) -> Vec3 {
-    return vec3(
+    vec3(
         point.x * cosangle + point.z * sinangle,
         point.y,
         point.x * -sinangle + point.z * cosangle,
-    );
+    )
 }
 
 // Rotate the input point around the x-axis by the angle given as a
@@ -129,9 +125,9 @@ fn _cartesian_to_polar(p: Vec3) -> Vec2 {
 
 fn mergeobjs(a: Vec2, b: Vec2) -> Vec2 {
     if a.x < b.x {
-        return a;
+        a
     } else {
-        return b;
+        b
     }
 
     // XXX: Some architectures have bad optimization paths
@@ -152,7 +148,7 @@ fn segmentdf(p: Vec3, a: Vec3, b: Vec3, r: f32) -> f32 {
     let ba: Vec3 = b - a;
     let mut t: f32 = ba.dot(p - a) / SMALL_FLOAT.max(ba.dot(ba));
     t = t.clamp(0., 1.);
-    return (ba * t + a - p).length() - r;
+    (ba * t + a - p).length() - r
 }
 
 // **************************************************************************
@@ -277,7 +273,7 @@ impl<C0, C1> State<C0, C1> {
         if t > maxd {
             material = -1.0;
         }
-        return vec2(t, material);
+        vec2(t, material)
     }
 }
 
@@ -341,7 +337,7 @@ impl<C0, C1> State<C0, C1> {
         let cosrotx: f32 = rotx.cos();
         let sinrotx: f32 = rotx.sin();
 
-        let roty: f32 = TWO_PI * click.x + 0.05 * self.time;
+        let roty: f32 = TAU * click.x + 0.05 * self.time;
         let cosroty: f32 = roty.cos();
         let sinroty: f32 = roty.sin();
 
@@ -465,10 +461,10 @@ impl<C0: SampleCube, C1: SampleCube> State<C0, C1> {
         if ndl > 0. {
             let frk: f32 = 0.5 + 2.0 * costd * costd * surf.roughness;
             let diff: Vec3 = surf.basecolor
-                * ONE_OVER_PI
+                * FRAC_1_PI
                 * (1. + (frk - 1.) * pow5(1. - costl))
                 * (1. + (frk - 1.) * pow5(1. - costv));
-            //let diff: Vec3 = surf.basecolor * ONE_OVER_PI; // lambert
+            //let diff: Vec3 = surf.basecolor * FRAC_1_PI; // lambert
 
             // D(h) factor
             // using the GGX approximation where the gamma factor is 2.

shaders/src/shaders/filtering_procedurals.rs

@@ -411,13 +411,12 @@ impl Inputs {
                 ddy_uvw = uvw + uvw.dfdy();
             }
             // shading
-            let mate: Vec3;
 
-            if p.x > th {
-                mate = sample_texture(uvw, nor, mid);
+            let mate = if p.x > th {
+                sample_texture(uvw, nor, mid)
             } else {
-                mate = sample_texture_with_filter(uvw, ddx_uvw, ddy_uvw, nor, mid);
-            }
+                sample_texture_with_filter(uvw, ddx_uvw, ddy_uvw, nor, mid)
+            };
 
             // lighting
             let lin: Vec3 = do_lighting(pos, nor, occ, rd);

shaders/src/shaders/flappy_bird.rs

@@ -102,7 +102,7 @@ const PIPE_BOTTOM: f32 = 39.0; // px
 const PIPE_HOLE_HEIGHT: f32 = 12.0; // px
 
 // const PIPE_OUTLINE_COLOR: Vec4 = RGB(84, 56, 71);
-const PIPE_OUTLINE_COLOR: Vec4 = vec4(84 as f32 / 255.0, 56 as f32 / 255.0, 71 as f32 / 255.0, 1.0);
+const PIPE_OUTLINE_COLOR: Vec4 = vec4(84.0 / 255.0, 56.0 / 255.0, 71.0 / 255.0, 1.0);
 
 // gameplay consts
 const HORZ_PIPE_DISTANCE: f32 = 100.0; // px;
@@ -1237,7 +1237,7 @@ impl State {
         }
     }
 
-    pub fn main_image(&mut self, frag_color: &mut Vec4, frag_coord: Vec2) {
+    fn main_image(&mut self, frag_color: &mut Vec4, frag_coord: Vec2) {
         let level_pixel: Vec2 = self.get_level_pixel(frag_coord);
 
         self.frag_color = rgb(113, 197, 207); // draw the blue sky background

shaders/src/shaders/geodesic_tiling.rs

@@ -86,14 +86,18 @@ fn p_r(p: &mut Vec2, a: f32) {
 fn p_reflect(p: &mut Vec3, plane_normal: Vec3, offset: f32) -> f32 {
     let t: f32 = p.dot(plane_normal) + offset;
     if t < 0.0 {
-        *p = *p - (2. * t) * plane_normal;
+        *p -= (2. * t) * plane_normal;
     }
     t.sign_gl()
 }
 
 fn smax(a: f32, b: f32, r: f32) -> f32 {
     let m: f32 = a.max(b);
     if (-a < r) && (-b < r) {
+        #[expect(
+            clippy::imprecise_flops,
+            reason = "Rust GPU does not yet support hypot from libm"
+        )]
         m.max(-(r - ((r + a) * (r + a) + (r + b) * (r + b)).sqrt()))
     } else {
         m
@@ -141,14 +145,10 @@ impl State {
 // Adapted from mattz https://www.shadertoy.com/view/4d2GzV
 // --------------------------------------------------------
 
-const SQRT3: f32 = 1.7320508075688772;
 const I3: f32 = 0.5773502691896258;
 
 const CART2HEX: Mat2 = mat2(vec2(1.0, 0.0), vec2(I3, 2.0 * I3));
-const HEX2CART: Mat2 = mat2(vec2(1.0, 0.0), vec2(-0.5, 0.5 * SQRT3));
-
-const _PHI: f32 = 1.618033988749895;
-const _TAU: f32 = 6.283185307179586;
+const HEX2CART: Mat2 = mat2(vec2(1.0, 0.0), vec2(-0.5, 0.5 * SQRT_3));
 
 struct TriPoints {
     a: Vec2,
@@ -272,7 +272,7 @@ impl State {
 // --------------------------------------------------------
 
 fn pal(t: f32, a: Vec3, b: Vec3, c: Vec3, d: Vec3) -> Vec3 {
-    a + b * (6.28318 * (c * t + d)).cos()
+    a + b * (TAU * (c * t + d)).cos()
 }
 
 fn spectrum(n: f32) -> Vec3 {
@@ -307,11 +307,9 @@ impl State {
                 xy.y = mouse.y;
             }
         }
-        let rx: f32;
-        let ry: f32;
 
-        rx = (xy.y + 0.5) * PI;
-        ry = (-xy.x) * 2.0 * PI;
+        let rx = (xy.y + 0.5) * PI;
+        let ry = (-xy.x) * 2.0 * PI;
 
         spherical_matrix(rx, ry)
     }

shaders/src/shaders/heart.rs

@@ -29,15 +29,15 @@ struct Inputs {
 impl Inputs {
     fn main_image(&self, frag_color: &mut Vec4, frag_coord: Vec2) {
         let mut p: Vec2 =
-            (2.0 * frag_coord - self.resolution.xy()) / (self.resolution.y.min(self.resolution.x));
+            (2.0 * frag_coord - self.resolution.xy()) / (self.resolution.xy().min_element());
 
         // background color
         let bcol: Vec3 = vec3(1.0, 0.8, 0.7 - 0.07 * p.y) * (1.0 - 0.25 * p.length());
 
         // animate
         let tt: f32 = self.time.rem_euclid(1.5) / 1.5;
         let mut ss: f32 = tt.powf(0.2) * 0.5 + 0.5;
-        ss = 1.0 + ss * 0.5 * (tt * 6.2831 * 3.0 + p.y * 0.5).sin() * (-tt * 4.0).exp();
+        ss = 1.0 + ss * 0.5 * (tt * TAU * 3.0 + p.y * 0.5).sin() * (-tt * 4.0).exp();
         p *= vec2(0.5, 1.5) + ss * vec2(0.5, -0.5);
 
         // shape
@@ -51,7 +51,7 @@ impl Inputs {
             d = 0.5;
         } else {
             p.y -= 0.25;
-            let a: f32 = p.x.atan2(p.y) / 3.141593;
+            let a: f32 = p.x.atan2(p.y) / PI;
             r = p.length();
             let h: f32 = a.abs();
             d = (13.0 * h - 22.0 * h * h + 10.0 * h * h * h) / (6.0 - 5.0 * h);

shaders/src/shaders/luminescence.rs

@@ -93,10 +93,6 @@ const _LF: Vec3 = vec3(1.0, 0.0, 0.0);
 const UP: Vec3 = vec3(0.0, 1.0, 0.0);
 const _FW: Vec3 = vec3(0.0, 0.0, 1.0);
 
-const _HALF_PI: f32 = 1.570796326794896619;
-const PI: f32 = 3.141592653589793238;
-const TWO_PI: f32 = 6.283185307179586;
-
 const ACCENT_COLOR1: Vec3 = vec3(1.0, 0.1, 0.5);
 const SECOND_COLOR1: Vec3 = vec3(0.1, 0.5, 1.0);
 const ACCENT_COLOR2: Vec3 = vec3(1.0, 0.5, 0.1);
@@ -110,7 +106,7 @@ fn _n2(x: f32, y: f32) -> f32 {
 }
 
 fn n3(mut p: Vec3) -> f32 {
-    p = (p * 0.3183099 + Vec3::splat(0.1)).fract_gl();
+    p = (p * FRAC_1_PI + Vec3::splat(0.1)).fract_gl();
     p *= 17.0;
     (p.x * p.y * p.z * (p.x + p.y + p.z)).fract_gl()
 }
@@ -215,7 +211,7 @@ fn sd_sphere(p: Vec3, pos: Vec3, s: f32) -> f32 {
 
 // From http://mercury.sexy/hg_sdf
 fn p_mod_polar(p: &mut Vec2, repetitions: f32, fix: f32) -> Vec2 {
-    let angle: f32 = TWO_PI / repetitions;
+    let angle: f32 = TAU / repetitions;
     let mut a: f32 = p.y.atan2(p.x) + angle / 2.;
     let r: f32 = p.length();
     let _c: f32 = (a / angle).floor();
@@ -332,14 +328,13 @@ impl State {
         let n: f32 = n3(id);
 
         let mut o: De = De::default();
-        o.m = 0.0;
 
-        let mut x: f32 = (p.y + n * TWO_PI) * 1. + t;
+        let mut x: f32 = (p.y + n * TAU) * 1. + t;
         let r: f32 = 1.;
 
         let pump: f32 = (x + x.cos()).cos() + (2.0 * x).sin() * 0.2 + (4.0 * x).sin() * 0.02;
 
-        x = t + n * TWO_PI;
+        x = t + n * TAU;
         p.y -= ((x + x.cos()).cos() + (2.0 * x).sin() * 0.2) * 0.6;
         p = (p.xz() * (1.0 + pump * 0.2)).extend(p.y).xzy();
 
@@ -350,7 +345,7 @@ impl State {
         o.m = 1.0;
 
         if p.y < 0.5 {
-            let sway: f32 = (t + p.y + n * TWO_PI).sin() * smoothstep(0.5, -3.0, p.y) * n * 0.3;
+            let sway: f32 = (t + p.y + n * TAU).sin() * smoothstep(0.5, -3.0, p.y) * n * 0.3;
             p.x += sway * n; // add some sway to the tentacles
             p.z += sway * (1. - n);
 
@@ -466,21 +461,21 @@ impl State {
 
         p.y *= scale;
 
-        let mut s2: f32 = 5. * p.x / TWO_PI;
+        let mut s2: f32 = 5. * p.x / TAU;
         let _id: f32 = s2.floor();
         s2 = s2.fract_gl();
         let ep: Vec2 = vec2(s2 - 0.5, p.y - 0.6);
         let ed: f32 = ep.length();
         let e: f32 = b(0.35, 0.45, 0.05, ed);
 
-        let mut s: f32 = sin(s2 * TWO_PI * 15.0);
+        let mut s: f32 = sin(s2 * TAU * 15.0);
         s = s * s;
         s = s * s;
-        s *= smoothstep(1.4, -0.3, uv.y - (s2 * TWO_PI).cos() * 0.2 + 0.3)
+        s *= smoothstep(1.4, -0.3, uv.y - (s2 * TAU).cos() * 0.2 + 0.3)
             * smoothstep(-0.6, -0.3, uv.y);
 
         let t: f32 = self.inputs.time * 5.0;
-        let mask: f32 = sin(p.x * TWO_PI * 2.0 + t);
+        let mask: f32 = sin(p.x * TAU * 2.0 + t);
         s *= mask * mask * 2.0;
 
         s + e * pump * 2.0
@@ -595,7 +590,7 @@ impl State {
         self.accent = mix(ACCENT_COLOR1, ACCENT_COLOR2, sin(t * 15.456));
         self.bg = mix(SECOND_COLOR1, SECOND_COLOR2, sin(t * 7.345231));
 
-        let turn: f32 = (0.1 - m.x) * TWO_PI;
+        let turn: f32 = (0.1 - m.x) * TAU;
         let s: f32 = turn.sin();
         let c: f32 = turn.cos();
         let rot_x: Mat3 = Mat3::from_cols_array(&[c, 0.0, s, 0.0, 1.0, 0.0, s, 0.0, -c]);

shaders/src/shaders/mandelbrot_smooth.rs

@@ -69,7 +69,7 @@ impl Inputs {
         // equivalent optimized smooth interation count
         let sl: f32 = l - z.dot(z).log2().log2() + 4.0;
 
-        let al: f32 = smoothstep(-0.1, 0.0, (self.time * 0.5 * 6.2831).sin());
+        let al: f32 = smoothstep(-0.1, 0.0, (self.time * 0.5 * TAU).sin());
         mix(l, sl, al)
     }