Update to latest rust-gpu and deps

Note this currently depends on a git version of winit
as they are changing apis in the next release.

Author: LegNeato

Cargo.lock

@@ -2,7 +2,7 @@
 name = "shadertoys-wgpu"
 version = "0.0.0"
 authors = []
-edition = "2018"
+edition = "2021"
 
 [features]
 default = ["use-compiled-tools"]
@@ -11,10 +11,15 @@ use-compiled-tools = ["spirv-builder/use-compiled-tools"]
 
 [dependencies]
 shared = { path = "shared" }
-futures = { version = "0.3", default-features = false, features = ["std", "executor"] }
-wgpu = "0.6.0"
-winit = { version = "0.23", features = ["web-sys"] }
-wgpu-subscriber = "0.1.0"
+futures = { version = "0.3", default-features = false, features = [
+    "std",
+    "executor"
+] }
+wgpu = { version = "23.0.1", features = ["spirv"] }
+winit = { git = "https://github.com/rust-windowing/winit.git", rev = "a0464ae83b880899b6fb5a25a2fe0d6447fd487a" }
+bytemuck = "1.20.0"
+env_logger = "0.11.6"
+ouroboros = "0.18.5"
 
 [build-dependencies]
 spirv-builder = { version = "*", default-features = false }
@@ -23,8 +28,10 @@ spirv-builder = { version = "*", default-features = false }
 members = ["shaders"]
 
 [patch.crates-io]
-spirv-builder = { git = "https://github.com/EmbarkStudios/rust-gpu", rev = "a173208d803aeac9295464df703c53d987db2664" }
-spirv-std = { git = "https://github.com/EmbarkStudios/rust-gpu", rev = "a173208d803aeac9295464df703c53d987db2664" }
+#spirv-builder = { path = "../rust-gpu/crates/spirv-builder" }
+spirv-builder = { git = "https://github.com/Rust-GPU/rust-gpu", rev = "6e2c84d4fe64e32df4c060c5a7f3e35a32e45421" }
+spirv-std = { git = "https://github.com/Rust-GPU/rust-gpu", rev = "6e2c84d4fe64e32df4c060c5a7f3e35a32e45421" }
+
 
 # Compile build-dependencies in release mode with
 # the same settings as regular dependencies.
@@ -43,3 +50,6 @@ opt-level = 3
 # a long time (10 minutes if itself was optimized, over an hour otherwise).
 [profile.release.package."shadertoys-shaders"]
 opt-level = 0
+
+[workspace.lints.rust]
+unexpected_cfgs = { level = "allow", check-cfg = ['cfg(target_arch, values("spirv"))'] }

Cargo.toml

@@ -1,9 +1,9 @@
-use spirv_builder::SpirvBuilder;
+use spirv_builder::{MetadataPrintout, SpirvBuilder};
 use std::error::Error;
 
-fn build_shader(path_to_create: &str) -> Result<(), Box<dyn Error>> {
-    SpirvBuilder::new(path_to_create)
-        .spirv_version(1, 0)
+fn build_shader(path_to_crate: &str) -> Result<(), Box<dyn Error>> {
+    let _result = SpirvBuilder::new(path_to_crate, "spirv-unknown-vulkan1.2")
+        .print_metadata(MetadataPrintout::Full)
         .build()?;
     Ok(())
 }

build.rs

@@ -0,0 +1,3 @@
+[toolchain]
+channel = "nightly-2024-11-22"
+components = ["rust-src", "rustc-dev", "llvm-tools"]

rust-toolchain

@@ -2,11 +2,14 @@
 name = "shadertoys-shaders"
 version = "0.0.0"
 authors = []
-edition = "2018"
+edition = "2021"
 
 [lib]
 crate-type = ["dylib"]
 
 [dependencies]
-spirv-std = "*"
+spirv-std = { git = "https://github.com/Rust-GPU/rust-gpu", rev = "6e2c84d4fe64e32df4c060c5a7f3e35a32e45421" }
 shared = { path = "../shared" }
+
+[lints]
+workspace = true

rust-toolchain.toml

@@ -12,7 +12,7 @@
 //! ```
 
 use shared::*;
-use spirv_std::glam::{const_mat2, vec2, vec3, Mat2, Vec2, Vec3, Vec3Swizzles, Vec4};
+use spirv_std::glam::{mat2, vec2, vec3, Mat2, Vec2, Vec3, Vec3Swizzles, Vec4};
 
 // Note: This cfg is incorrect on its surface, it really should be "are we compiling with std", but
 // we tie #[no_std] above to the same condition, so it's fine.
@@ -41,7 +41,7 @@ const SPEED: f32 = 0.5;
 // math functions
 //
 
-const _MR: Mat2 = const_mat2!([0.84147, 0.54030, 0.54030, -0.84147]);
+const _MR: Mat2 = mat2(vec2(0.84147, 0.54030), vec2(0.54030, -0.84147));
 fn hash(n: f32) -> f32 {
     (n.sin() * 43758.5453).gl_fract()
 }
@@ -135,16 +135,16 @@ impl Inputs {
         *dist = MAXDISTANCE;
         let mut distcheck: f32 = 0.0;
 
-        let mut sphere_center: Vec3 = Vec3::zero();
+        let mut sphere_center: Vec3 = Vec3::ZERO;
         let mut col: Vec3;
-        let mut normalcheck: Vec3 = Vec3::zero();
+        let mut normalcheck: Vec3 = Vec3::ZERO;
         if intersect_plane(ro, rd, 0.0, &mut distcheck) && distcheck < MAXDISTANCE {
             *dist = distcheck;
             *material = 1;
             *normal = vec3(0.0, 1.0, 0.0);
-            col = Vec3::one();
+            col = Vec3::ONE;
         } else {
-            col = Vec3::zero();
+            col = Vec3::ZERO;
         }
 
         // trace grid
@@ -159,7 +159,7 @@ impl Inputs {
             if *material > 1 || ro.xz().distance(pos.xz()) > *dist + GRIDSIZE {
                 break;
             }
-            let mut offset: Vec2 = Vec2::zero();
+            let mut offset: Vec2 = Vec2::ZERO;
             get_sphere_offset(pos.xz(), &mut offset);
 
             self.get_moving_sphere_position(pos.xz(), -offset, &mut sphere_center);
@@ -187,7 +187,7 @@ impl Inputs {
             i += 1;
         }
 
-        let mut color: Vec3 = Vec3::zero();
+        let mut color: Vec3 = Vec3::ZERO;
         if *material > 0 {
             *intersection = ro + rd * *dist;
             let map: Vec2 = (intersection.xz() / GRIDSIZE).floor() * GRIDSIZE;
@@ -200,10 +200,10 @@ impl Inputs {
                     let mut y = 0;
                     while y < 3 {
                         let mapoffset: Vec2 = map + vec2([c.x, c.y, c.z][x], [c.x, c.y, c.z][y]);
-                        let mut offset: Vec2 = Vec2::zero();
+                        let mut offset: Vec2 = Vec2::ZERO;
                         get_sphere_offset(mapoffset, &mut offset);
                         let lcolor: Vec3 = get_sphere_color(mapoffset);
-                        let mut lpos: Vec3 = Vec3::zero();
+                        let mut lpos: Vec3 = Vec3::ZERO;
                         self.get_moving_sphere_position(mapoffset, -offset, &mut lpos);
 
                         let mut shadow: f32 = 1.0;
@@ -220,10 +220,10 @@ impl Inputs {
 
                                     let smapoffset: Vec2 =
                                         map + vec2([c.x, c.y, c.z][x], [c.x, c.y, c.z][y]);
-                                    let mut soffset: Vec2 = Vec2::zero();
+                                    let mut soffset: Vec2 = Vec2::ZERO;
                                     get_sphere_offset(smapoffset, &mut soffset);
-                                    let mut slpos: Vec3 = Vec3::zero();
-                                    let mut sn: Vec3 = Vec3::zero();
+                                    let mut slpos: Vec3 = Vec3::ZERO;
+                                    let mut sn: Vec3 = Vec3::ZERO;
                                     get_sphere_position(smapoffset, soffset, &mut slpos);
                                     let mut sd: f32 = 0.0;
                                     if intersect_unit_sphere(
@@ -285,8 +285,8 @@ impl Inputs {
         let mut rd: Vec3 = (p.x * cu + p.y * cv + 1.5 * cw).normalize();
         // raytrace
         let mut material: i32 = 0;
-        let mut normal: Vec3 = Vec3::zero();
-        let mut intersection: Vec3 = Vec3::zero();
+        let mut normal: Vec3 = Vec3::ZERO;
+        let mut intersection: Vec3 = Vec3::ZERO;
         let mut dist: f32 = 0.0;
 
         let mut col: Vec3 = self.trace(
@@ -312,7 +312,7 @@ impl Inputs {
         }
 
         col = col.powf_vec(vec3(EXPOSURE, EXPOSURE, EXPOSURE));
-        col = col.clamp(Vec3::zero(), Vec3::one());
+        col = col.clamp(Vec3::ZERO, Vec3::ONE);
         // vigneting
         col *= 0.25 + 0.75 * (16.0 * q.x * q.y * (1.0 - q.x) * (1.0 - q.y)).powf(0.15);
 

shaders/Cargo.toml

@@ -62,7 +62,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 * ((6.283 * 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 {
@@ -83,7 +83,7 @@ fn apollonian(uv: Vec2) -> Vec3 {
     // the algorithm is recursive and must start with a initial descartes configuration
     // each vec3 represents a circle with the form vec3(centerx, centery, 1./radius)
     // the signed inverse radius is also called the bend (refer to the article above)
-    let mut dec: [Vec3; 4] = [Vec3::zero(), Vec3::zero(), Vec3::zero(), Vec3::zero()];
+    let mut dec: [Vec3; 4] = [Vec3::ZERO, Vec3::ZERO, Vec3::ZERO, Vec3::ZERO];
     // 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
@@ -155,7 +155,7 @@ fn apollonian(uv: Vec2) -> Vec3 {
 
 impl Inputs {
     fn scene(&self, mut uv: Vec2, ms: Vec4) -> Vec3 {
-        let mut ci: Vec2 = Vec2::zero();
+        let mut ci: Vec2 = Vec2::ZERO;
 
         // drag your mouse to apply circle inversion
         if ms.y != -2.0 && ms.w > -2.0 {

shaders/src/a_lot_of_spheres.rs

@@ -33,7 +33,7 @@ impl State {
     pub fn new(inputs: Inputs) -> Self {
         State {
             inputs,
-            orb: Vec4::zero(),
+            orb: Vec4::ZERO,
         }
     }
 }
@@ -101,7 +101,7 @@ impl State {
 
     fn render(&mut self, ro: Vec3, rd: Vec3, anim: f32) -> Vec3 {
         // trace
-        let mut col: Vec3 = Vec3::zero();
+        let mut col: Vec3 = Vec3::ZERO;
         let t: f32 = self.trace(ro, rd, anim);
         if t > 0.0 {
             let tra: Vec4 = self.orb;
@@ -121,7 +121,7 @@ impl State {
             brdf += 1.0 * vec3(0.40, 0.40, 0.40) * bac * ao;
 
             // material
-            let mut rgb: Vec3 = Vec3::one();
+            let mut rgb: Vec3 = Vec3::ONE;
             rgb = mix(rgb, vec3(1.0, 0.80, 0.2), (6.0 * tra.y).clamp(0.0, 1.0));
             rgb = mix(
                 rgb,
@@ -139,7 +139,7 @@ impl State {
     pub fn main_image(&mut self, frag_color: &mut Vec4, frag_coord: Vec2) {
         let time: f32 = self.inputs.time * 0.25 + 0.01 * self.inputs.mouse.x;
         let anim: f32 = 1.1 + 0.5 * smoothstep(-0.3, 0.3, (0.1 * self.inputs.time).cos());
-        let mut tot: Vec3 = Vec3::zero();
+        let mut tot: Vec3 = Vec3::ZERO;
 
         let mut jj = 0;
         while jj < AA {

shaders/src/a_question_of_time.rs

@@ -11,7 +11,7 @@
 //! ```
 
 use shared::*;
-use spirv_std::glam::{const_vec3, vec2, vec3, Mat3, Vec2, Vec3, Vec3Swizzles, Vec4};
+use spirv_std::glam::{vec2, vec3, Mat3, Vec2, Vec3, Vec3Swizzles, Vec4};
 
 // Note: This cfg is incorrect on its surface, it really should be "are we compiling with std", but
 // we tie #[no_std] above to the same condition, so it's fine.
@@ -38,7 +38,7 @@ impl State {
     }
 }
 
-const PI: f32 = 3.14159265359;
+use core::f32::consts::PI;
 
 #[derive(Copy, Clone)]
 struct Ray {
@@ -93,8 +93,8 @@ fn isect_sphere(ray: Ray, sphere: Sphere, t0: &mut f32, t1: &mut f32) -> bool {
 }
 
 // scattering coefficients at sea level (m)
-const BETA_R: Vec3 = const_vec3!([5.5e-6, 13.0e-6, 22.4e-6]); // Rayleigh
-const BETA_M: Vec3 = const_vec3!([21e-6, 21e-6, 21e-6]); // Mie
+const BETA_R: Vec3 = vec3(5.5e-6, 13.0e-6, 22.4e-6); // Rayleigh
+const BETA_M: Vec3 = vec3(21e-6, 21e-6, 21e-6); // Mie
 
 // scale height (m)
 // thickness of the atmosphere if its density were uniform
@@ -133,7 +133,7 @@ const ATMOSPHERE_RADIUS: f32 = 6420e3; // (m)
 const SUN_POWER: f32 = 20.0;
 
 const ATMOSPHERE: Sphere = Sphere {
-    origin: Vec3::zero(),
+    origin: Vec3::ZERO,
     radius: ATMOSPHERE_RADIUS,
     _material: 0,
 };
@@ -172,7 +172,7 @@ impl State {
         let mut t0: f32 = 0.0;
         let mut t1: f32 = 0.0;
         if !isect_sphere(ray, ATMOSPHERE, &mut t0, &mut t1) {
-            return Vec3::zero();
+            return Vec3::ZERO;
         }
 
         let march_step: f32 = t1 / NUM_SAMPLES as f32;
@@ -199,8 +199,8 @@ impl State {
         let mut optical_depth_r: f32 = 0.0;
         let mut optical_depth_m: f32 = 0.0;
 
-        let mut sum_r: Vec3 = Vec3::zero();
-        let mut sum_m: Vec3 = Vec3::zero();
+        let mut sum_r: Vec3 = Vec3::ZERO;
+        let mut sum_m: Vec3 = Vec3::ZERO;
         let mut march_pos: f32 = 0.0;
 
         let mut i = 0;
@@ -247,7 +247,7 @@ impl State {
         let aspect_ratio: Vec2 = vec2(self.inputs.resolution.x / self.inputs.resolution.y, 1.0);
         let fov: f32 = 45.0.deg_to_radians().tan();
         let point_ndc: Vec2 = frag_coord / self.inputs.resolution.xy();
-        let point_cam: Vec3 = ((2.0 * point_ndc - Vec2::one()) * aspect_ratio * fov).extend(-1.0);
+        let point_cam: Vec3 = ((2.0 * point_ndc - Vec2::ONE) * aspect_ratio * fov).extend(-1.0);
 
         let col: Vec3;