Add back gridmode and do some clippy lints.

Author: raldone01

.vscode/settings.json

@@ -1,3 +1,4 @@
 {
   "rust-analyzer.cargo.targetDir": true,
+  //"rust-analyzer.check.command": "clippy",
 }

Cargo.toml

@@ -51,6 +51,29 @@ opt-level = 3
 opt-level = 0
 
 [workspace.lints.clippy]
+# disabled because shader code does this often
+cast_precision_loss = "allow"
+cast_possible_truncation = "allow"
+excessive_precision = "allow"
+missing_const_for_fn = "allow"
+many_single_char_names = "allow"
+similar_names = "allow"
+too_many_arguments = "allow"
+suboptimal_flops = "allow"
+too_many_lines = "allow"
+cognitive_complexity = "allow"
+# disabled because of rust gpu limitatoins
+manual_range_contains = "allow" # Rust gpu does not like the core range checks
+needless_range_loop = "allow"   # Rust gpu does not like iterators very much
+manual_swap = "allow"           # Rust gpu does not like the core swap function
+# temporarily disabled rules
+inline_always = "allow"                # need some hard numbers for this
+unreadable_literal = "allow"           # Maybe fix this?
+useless_let_if_seq = "allow"           # Maybe fix this?
+used_underscore_items = "allow"        # Maybe fix this?
+no_effect_underscore_binding = "allow" # Maybe fix this?
+
+# standard rules for idiomatic Rust code
 let_and_return = "allow"
 needless_lifetimes = "allow"
 option_if_let_else = "allow"

shaders/src/lib.rs

@@ -5,42 +5,120 @@ use shader_prelude::*;
 pub mod shaders;
 pub mod shared_data;
 
+// Compute optimal grid layout (rows, cols) for cell count while attempting to keep the aspect ratio close to the provided aspect ratio.
+fn optimal_grid(cell_count: usize, aspect: Vec2) -> (usize, usize) {
+    // Handle edge cases for 0 or 1 cells.
+    if cell_count == 0 {
+        return (0, 0);
+    }
+    if cell_count == 1 {
+        return (1, 1);
+    }
+
+    // The target aspect ratio (width / height). Add a small epsilon to avoid division by zero.
+    let target_aspect = aspect.x / (aspect.y + f32::EPSILON);
+
+    let mut best_layout = (1, cell_count);
+    let mut min_aspect_diff = f32::INFINITY;
+
+    // Iterate through all possible row counts from 1 to cell_count.
+    // This is a simple and robust way to find the global optimum.
+    for rows in 1..=cell_count {
+        // Calculate the number of columns needed to fit all cells for the current row count.
+        // This is equivalent to `ceil(cell_count / rows)`.
+        let cols = cell_count.div_ceil(rows);
+
+        // The aspect ratio of the current grid layout.
+        let grid_aspect = cols as f32 / rows as f32;
+
+        // Calculate the difference from the target aspect ratio.
+        let diff = (grid_aspect - target_aspect).abs();
+
+        // If this layout is better than the best one we've found so far, update it.
+        if diff < min_aspect_diff {
+            min_aspect_diff = diff;
+            best_layout = (rows, cols);
+        }
+    }
+
+    best_layout
+}
+
 #[inline(always)]
+#[must_use]
 pub fn fs(constants: &ShaderConstants, mut frag_coord: Vec2) -> Vec4 {
-    let resolution = vec3(
-        constants.width as f32 as f32,
-        constants.height as f32 as f32,
-        0.0,
-    );
+    let resolution = vec3(constants.width as f32, constants.height as f32, 0.0);
     let time = constants.time;
     let mut mouse = vec4(
-        constants.drag_end_x as f32,
-        constants.drag_end_y as f32,
-        constants.drag_start_x as f32,
-        constants.drag_start_y as f32,
+        constants.drag_end_x,
+        constants.drag_end_y,
+        constants.drag_start_x,
+        constants.drag_start_y,
     );
     if mouse != Vec4::ZERO {
         mouse.y = resolution.y - mouse.y;
         mouse.w = resolution.y - mouse.w;
     }
-    if !(constants.mouse_left_pressed == 1) {
+    if constants.mouse_left_pressed != 1 {
         mouse.z *= -1.0;
     }
-    if !(constants.mouse_left_clicked == 1) {
+    if constants.mouse_left_clicked != 1 {
         mouse.w *= -1.0;
     }
 
     frag_coord.x %= resolution.x;
     frag_coord.y = resolution.y - frag_coord.y % resolution.y;
 
-    let shader_input = ShaderInput {
-        resolution,
-        time,
-        frag_coord,
-        mouse,
-    };
-    let mut shader_output = &mut ShaderResult { color: Vec4::ZERO };
-    shaders::render_shader(constants.shader_to_show, &shader_input, &mut shader_output);
+    let shader_count = shaders::SHADER_DEFINITIONS.len();
+
+    let shader_index;
+    let shader_input: ShaderInput;
+    let shader_output = &mut ShaderResult { color: Vec4::ZERO };
+
+    if constants.grid == 0 {
+        shader_input = ShaderInput {
+            resolution,
+            time,
+            frag_coord,
+            mouse,
+        };
+        shader_index = constants.shader_to_show as usize;
+    } else {
+        // Render all shaders in a grid layout
+        // ignore shader_to_show
+        let (rows, cols) = optimal_grid(shader_count, vec2(resolution.x, resolution.y));
+
+        let cell_width = resolution.x / cols as f32;
+        let cell_height = resolution.y / rows as f32;
+
+        #[expect(clippy::cast_sign_loss)]
+        let col = (frag_coord.x / cell_width).floor() as usize;
+        #[expect(clippy::cast_sign_loss)]
+        let row = (frag_coord.y / cell_height).floor() as usize;
+        shader_index = row + col * rows;
+
+        let cell_resolution = vec3(cell_width, cell_height, 0.0);
+        let cell_frag_coord = vec2(
+            (col as f32).mul_add(-cell_width, frag_coord.x),
+            (row as f32).mul_add(-cell_height, frag_coord.y),
+        );
+        let cell_mouse = mouse / vec4(cols as f32, rows as f32, cols as f32, rows as f32);
+
+        shader_input = ShaderInput {
+            resolution: cell_resolution,
+            time,
+            frag_coord: cell_frag_coord,
+            mouse: cell_mouse,
+        };
+    }
+
+    if shader_index < shader_count {
+        shaders::render_shader(shader_index as u32, &shader_input, shader_output);
+    } else {
+        // If the shader index is out of bounds, just return a default color
+        shader_output.color = Vec4::new(0.0, 0.0, 0.0, 1.0);
+    }
+
     let color = shader_output.color;
     Vec3::powf(color.truncate(), 2.2).extend(color.w)
 }

shaders/src/shader_prelude.rs

@@ -1,7 +1,8 @@
 pub use core::f32::consts::{FRAC_1_PI, FRAC_PI_2, PI};
 use core::ops::{Add, Mul, Sub};
 pub const TWO_PI: f32 = 2.0 * PI;
-pub const SQRT3: f32 = 1.7320508075688772;
+/// We can't use the `f32::consts::SQRT_3` constant here because it is an unstable library feature
+pub const SQRT_3: f32 = 1.732_050_807_568_877_2;
 
 pub use crate::shared_data::ShaderConstants;
 pub use spirv_std::{
@@ -82,7 +83,7 @@ pub fn saturate(a: f32) -> f32 {
 #[must_use]
 pub fn acos_approx(v: f32) -> f32 {
     let x = v.abs();
-    let mut res = -0.155972 * x + 1.56467; // p(x)
+    let mut res = (-0.155_972_f32).mul_add(x, 1.56467); // p(x)
     res *= (1.0f32 - x).sqrt();
 
     if v >= 0.0 {
@@ -98,7 +99,7 @@ pub fn smoothstep(edge0: f32, edge1: f32, x: f32) -> f32 {
     // Scale, bias and saturate x to 0..1 range
     let x = saturate((x - edge0) / (edge1 - edge0));
     // Evaluate polynomial
-    x * x * (3.0 - 2.0 * x)
+    x * x * 2.0f32.mul_add(-x, 3.0)
 }
 
 #[inline(always)]
@@ -136,12 +137,12 @@ pub trait FloatExt {
 
 impl FloatExt for f32 {
     #[inline]
-    fn fract_gl(self) -> f32 {
+    fn fract_gl(self) -> Self {
         self - self.floor()
     }
 
     #[inline]
-    fn rem_euclid(self, rhs: f32) -> f32 {
+    fn rem_euclid(self, rhs: Self) -> Self {
         let r = self % rhs;
         if r < 0.0 {
             r + rhs.abs()
@@ -151,7 +152,7 @@ impl FloatExt for f32 {
     }
 
     #[inline]
-    fn sign_gl(self) -> f32 {
+    fn sign_gl(self) -> Self {
         if self < 0.0 {
             -1.0
         } else if self == 0.0 {
@@ -162,7 +163,7 @@ impl FloatExt for f32 {
     }
 
     #[inline]
-    fn step(self, x: f32) -> f32 {
+    fn step(self, x: Self) -> Self {
         if x < self {
             0.0
         } else {
@@ -190,69 +191,69 @@ pub trait VecExt {
 
 impl VecExt for Vec2 {
     #[inline]
-    fn sin(self) -> Vec2 {
+    fn sin(self) -> Self {
         vec2(self.x.sin(), self.y.sin())
     }
 
     #[inline]
-    fn cos(self) -> Vec2 {
+    fn cos(self) -> Self {
         vec2(self.x.cos(), self.y.cos())
     }
 
     #[inline]
-    fn powf_vec(self, p: Vec2) -> Vec2 {
+    fn powf_vec(self, p: Self) -> Self {
         vec2(self.x.powf(p.x), self.y.powf(p.y))
     }
 
     #[inline]
-    fn sqrt(self) -> Vec2 {
+    fn sqrt(self) -> Self {
         vec2(self.x.sqrt(), self.y.sqrt())
     }
 
     #[inline]
-    fn ln(self) -> Vec2 {
+    fn ln(self) -> Self {
         vec2(self.x.ln(), self.y.ln())
     }
 
     #[inline]
-    fn step(self, other: Vec2) -> Vec2 {
+    fn step(self, other: Self) -> Self {
         vec2(self.x.step(other.x), self.y.step(other.y))
     }
 
     #[inline]
-    fn sign_gl(self) -> Vec2 {
+    fn sign_gl(self) -> Self {
         vec2(self.x.sign_gl(), self.y.sign_gl())
     }
 }
 
 impl VecExt for Vec3 {
     #[inline]
-    fn sin(self) -> Vec3 {
+    fn sin(self) -> Self {
         vec3(self.x.sin(), self.y.sin(), self.z.sin())
     }
 
     #[inline]
-    fn cos(self) -> Vec3 {
+    fn cos(self) -> Self {
         vec3(self.x.cos(), self.y.cos(), self.z.cos())
     }
 
     #[inline]
-    fn powf_vec(self, p: Vec3) -> Vec3 {
+    fn powf_vec(self, p: Self) -> Self {
         vec3(self.x.powf(p.x), self.y.powf(p.y), self.z.powf(p.z))
     }
 
     #[inline]
-    fn sqrt(self) -> Vec3 {
+    fn sqrt(self) -> Self {
         vec3(self.x.sqrt(), self.y.sqrt(), self.z.sqrt())
     }
 
     #[inline]
-    fn ln(self) -> Vec3 {
+    fn ln(self) -> Self {
         vec3(self.x.ln(), self.y.ln(), self.z.ln())
     }
 
     #[inline]
-    fn step(self, other: Vec3) -> Vec3 {
+    fn step(self, other: Self) -> Self {
         vec3(
             self.x.step(other.x),
             self.y.step(other.y),
@@ -261,24 +262,24 @@ impl VecExt for Vec3 {
     }
 
     #[inline]
-    fn sign_gl(self) -> Vec3 {
+    fn sign_gl(self) -> Self {
         vec3(self.x.sign_gl(), self.y.sign_gl(), self.z.sign_gl())
     }
 }
 
 impl VecExt for Vec4 {
     #[inline]
-    fn sin(self) -> Vec4 {
+    fn sin(self) -> Self {
         vec4(self.x.sin(), self.y.sin(), self.z.sin(), self.w.sin())
     }
 
     #[inline]
-    fn cos(self) -> Vec4 {
+    fn cos(self) -> Self {
         vec4(self.x.cos(), self.y.cos(), self.z.cos(), self.w.cos())
     }
 
     #[inline]
-    fn powf_vec(self, p: Vec4) -> Vec4 {
+    fn powf_vec(self, p: Self) -> Self {
         vec4(
             self.x.powf(p.x),
             self.y.powf(p.y),
@@ -288,17 +289,17 @@ impl VecExt for Vec4 {
     }
 
     #[inline]
-    fn sqrt(self) -> Vec4 {
+    fn sqrt(self) -> Self {
         vec4(self.x.sqrt(), self.y.sqrt(), self.z.sqrt(), self.w.sqrt())
     }
 
     #[inline]
-    fn ln(self) -> Vec4 {
+    fn ln(self) -> Self {
         vec4(self.x.ln(), self.y.ln(), self.z.ln(), self.w.ln())
     }
 
     #[inline]
-    fn step(self, other: Vec4) -> Vec4 {
+    fn step(self, other: Self) -> Self {
         vec4(
             self.x.step(other.x),
             self.y.step(other.y),
@@ -308,7 +309,7 @@ impl VecExt for Vec4 {
     }
 
     #[inline]
-    fn sign_gl(self) -> Vec4 {
+    fn sign_gl(self) -> Self {
         vec4(
             self.x.sign_gl(),
             self.y.sign_gl(),

shaders/src/shaders/a_lot_of_spheres.rs

@@ -25,7 +25,7 @@ pub fn shader_fn(render_instruction: &ShaderInput, render_result: &mut ShaderRes
         frag_coord,
         ..
     } = render_instruction;
-    Inputs { resolution, time }.main_image(color, frag_coord)
+    Inputs { resolution, time }.main_image(color, frag_coord);
 }
 
 pub struct Inputs {
@@ -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;