Merge pull request #1 from DGriffin91/main

Updated shaders to use glam functions for making vecs

Author: eddyb

shaders/src/a_lot_of_spheres.rs

@@ -12,7 +12,7 @@
 //! ```
 
 use shared::*;
-use spirv_std::glam::{const_mat2, Mat2, Vec2, Vec3, Vec3Swizzles, Vec4};
+use spirv_std::glam::{const_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.
@@ -46,16 +46,16 @@ fn hash(n: f32) -> f32 {
     (n.sin() * 43758.5453).gl_fract()
 }
 fn _hash2(n: f32) -> Vec2 {
-    (Vec2::new(n, n + 1.0).sin() * Vec2::new(2.1459123, 3.3490423)).gl_fract()
+    (vec2(n, n + 1.0).sin() * vec2(2.1459123, 3.3490423)).gl_fract()
 }
 fn hash2_vec(n: Vec2) -> Vec2 {
-    (Vec2::new(n.x * n.y, n.x + n.y).sin() * Vec2::new(2.1459123, 3.3490423)).gl_fract()
+    (vec2(n.x * n.y, n.x + n.y).sin() * vec2(2.1459123, 3.3490423)).gl_fract()
 }
 fn _hash3(n: f32) -> Vec3 {
-    (Vec3::new(n, n + 1.0, n + 2.0).sin() * Vec3::new(3.5453123, 4.1459123, 1.3490423)).gl_fract()
+    (vec3(n, n + 1.0, n + 2.0).sin() * vec3(3.5453123, 4.1459123, 1.3490423)).gl_fract()
 }
 fn hash3_vec(n: Vec2) -> Vec3 {
-    (Vec3::new(n.x, n.y, n.x + 2.0).sin() * Vec3::new(3.5453123, 4.1459123, 1.3490423)).gl_fract()
+    (vec3(n.x, n.y, n.x + 2.0).sin() * vec3(3.5453123, 4.1459123, 1.3490423)).gl_fract()
 }
 
 //
@@ -98,7 +98,7 @@ fn intersect_unit_sphere(ro: Vec3, rd: Vec3, sph: Vec3, dist: &mut f32, normal:
 //
 
 fn get_sphere_offset(grid: Vec2, center: &mut Vec2) {
-    *center = (hash2_vec(grid + Vec2::new(43.12, 1.23)) - Vec2::splat(0.5)) * (GRIDSIZESMALL);
+    *center = (hash2_vec(grid + vec2(43.12, 1.23)) - Vec2::splat(0.5)) * (GRIDSIZESMALL);
 }
 
 impl Inputs {
@@ -110,15 +110,15 @@ impl Inputs {
         let y: f32 = s * MAXHEIGHT * (4.0 * t * (1. - t)).abs();
         let offset: Vec2 = grid + sphere_offset;
 
-        *center = Vec3::new(offset.x, y, offset.y) + 0.5 * Vec3::new(GRIDSIZE, 2.0, GRIDSIZE);
+        *center = vec3(offset.x, y, offset.y) + 0.5 * vec3(GRIDSIZE, 2.0, GRIDSIZE);
     }
 }
 fn get_sphere_position(grid: Vec2, sphere_offset: Vec2, center: &mut Vec3) {
     let offset: Vec2 = grid + sphere_offset;
-    *center = Vec3::new(offset.x, 0.0, offset.y) + 0.5 * Vec3::new(GRIDSIZE, 2.0, GRIDSIZE);
+    *center = vec3(offset.x, 0.0, offset.y) + 0.5 * vec3(GRIDSIZE, 2.0, GRIDSIZE);
 }
 fn get_sphere_color(grid: Vec2) -> Vec3 {
-    hash3_vec(grid + Vec2::new(43.12 * grid.y, 12.23 * grid.x)).normalize()
+    hash3_vec(grid + vec2(43.12 * grid.y, 12.23 * grid.x)).normalize()
 }
 
 impl Inputs {
@@ -141,7 +141,7 @@ impl Inputs {
         if intersect_plane(ro, rd, 0.0, &mut distcheck) && distcheck < MAXDISTANCE {
             *dist = distcheck;
             *material = 1;
-            *normal = Vec3::new(0.0, 1.0, 0.0);
+            *normal = vec3(0.0, 1.0, 0.0);
             col = Vec3::one();
         } else {
             col = Vec3::zero();
@@ -194,13 +194,12 @@ impl Inputs {
 
             if *material == 1 || *material == 3 {
                 // lightning
-                let c: Vec3 = Vec3::new(-GRIDSIZE, 0.0, GRIDSIZE);
+                let c: Vec3 = vec3(-GRIDSIZE, 0.0, GRIDSIZE);
                 let mut x = 0;
                 while x < 3 {
                     let mut y = 0;
                     while y < 3 {
-                        let mapoffset: Vec2 =
-                            map + Vec2::new([c.x, c.y, c.z][x], [c.x, c.y, c.z][y]);
+                        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();
                         get_sphere_offset(mapoffset, &mut offset);
                         let lcolor: Vec3 = get_sphere_color(mapoffset);
@@ -220,7 +219,7 @@ impl Inputs {
                                     }
 
                                     let smapoffset: Vec2 =
-                                        map + Vec2::new([c.x, c.y, c.z][x], [c.x, c.y, c.z][y]);
+                                        map + vec2([c.x, c.y, c.z][x], [c.x, c.y, c.z][y]);
                                     let mut soffset: Vec2 = Vec2::zero();
                                     get_sphere_offset(smapoffset, &mut soffset);
                                     let mut slpos: Vec3 = Vec3::zero();
@@ -252,7 +251,7 @@ impl Inputs {
                 }
             } else {
                 // emitter
-                color = (1.5 + normal.dot(Vec3::new(0.5, 0.5, -0.5))) * get_sphere_color(map);
+                color = (1.5 + normal.dot(vec3(0.5, 0.5, -0.5))) * get_sphere_color(map);
             }
         }
         color
@@ -264,14 +263,14 @@ impl Inputs {
         p.x *= self.resolution.x / self.resolution.y;
 
         // camera
-        let ce: Vec3 = Vec3::new(
+        let ce: Vec3 = vec3(
             (0.232 * self.time).cos() * 10.0,
             6. + 3.0 * (0.3 * self.time).cos(),
             GRIDSIZE * (self.time / SPEED),
         );
         let ro: Vec3 = ce;
         let ta: Vec3 = ro
-            + Vec3::new(
+            + vec3(
                 -(0.232 * self.time).sin() * 10.,
                 -2.0 + (0.23 * self.time).cos(),
                 10.0,
@@ -280,7 +279,7 @@ impl Inputs {
         let roll: f32 = -0.15 * (0.5 * self.time).sin();
         // camera tx
         let cw: Vec3 = (ta - ro).normalize();
-        let cp: Vec3 = Vec3::new(roll.sin(), roll.cos(), 0.0);
+        let cp: Vec3 = vec3(roll.sin(), roll.cos(), 0.0);
         let cu: Vec3 = (cw.cross(cp)).normalize();
         let cv: Vec3 = (cu.cross(cw)).normalize();
         let mut rd: Vec3 = (p.x * cu + p.y * cv + 1.5 * cw).normalize();
@@ -312,7 +311,7 @@ impl Inputs {
                 );
         }
 
-        col = col.powf_vec(Vec3::new(EXPOSURE, EXPOSURE, EXPOSURE));
+        col = col.powf_vec(vec3(EXPOSURE, EXPOSURE, EXPOSURE));
         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/src/a_question_of_time.rs

@@ -27,7 +27,9 @@
 //! ```
 
 use shared::*;
-use spirv_std::glam::{Mat2, Vec2, Vec2Swizzles, Vec3, Vec3Swizzles, Vec4, Vec4Swizzles};
+use spirv_std::glam::{
+    vec2, vec3, Mat2, Vec2, Vec2Swizzles, Vec3, Vec3Swizzles, Vec4, Vec4Swizzles,
+};
 
 // 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.
@@ -60,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::new(2.0, 2.0, 1.0) + Vec3::new(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 {
@@ -72,7 +74,7 @@ fn inversion(uv: Vec2, r: f32) -> Vec2 {
 }
 // seeded random number
 fn hash(s: Vec2) -> f32 {
-    ((s.dot(Vec2::new(12.9898, 78.2333))).sin() * 43758.5453123).gl_fract()
+    ((s.dot(vec2(12.9898, 78.2333))).sin() * 43758.5453123).gl_fract()
 }
 
 // this is an algorithm to construct an apollonian packing with a descartes configuration
@@ -88,12 +90,12 @@ fn apollonian(uv: Vec2) -> Vec3 {
     let a: f32 = 6.283 / 3.;
     let ra: f32 = 1.0 + (a * 0.5).sin();
     let rb: f32 = 1.0 - (a * 0.5).sin();
-    dec[0] = Vec3::new(0.0, 0.0, -1.0 / ra);
+    dec[0] = vec3(0.0, 0.0, -1.0 / ra);
     let radius: f32 = 0.5 * (ra - rb);
     let bend: f32 = 1.0 / radius;
     let mut i = 1;
     while i < 4 {
-        dec[i] = Vec3::new((i as f32 * a).cos(), (i as f32 * a).sin(), bend);
+        dec[i] = vec3((i as f32 * a).cos(), (i as f32 * a).sin(), bend);
         // if the point is in one of the starting circles we have already found our solution
         if (uv - dec[i].xy()).length() < radius {
             return (uv - dec[i].xy()).extend(radius);
@@ -232,8 +234,8 @@ impl Inputs {
                 pal(0.85),
                 stroke(
                     sdf_rect(
-                        uvrh + Vec2::new(uv_apo.z - (uv_apo.z * 0.8), 0.0),
-                        uv_apo.z * Vec2::new(0.4, 0.03),
+                        uvrh + vec2(uv_apo.z - (uv_apo.z * 0.8), 0.0),
+                        uv_apo.z * vec2(0.4, 0.03),
                     ),
                     uv_apo.z * 0.01,
                     0.005,
@@ -245,8 +247,8 @@ impl Inputs {
                 pal(0.9),
                 fill(
                     sdf_rect(
-                        uvrm + Vec2::new(uv_apo.z - (uv_apo.z * 0.65), 0.0),
-                        uv_apo.z * Vec2::new(0.5, 0.002),
+                        uvrm + vec2(uv_apo.z - (uv_apo.z * 0.65), 0.0),
+                        uv_apo.z * vec2(0.5, 0.002),
                     ),
                     0.005,
                     1.0,
@@ -275,7 +277,7 @@ impl Inputs {
                 0.05,
                 1.0,
             );
-            let size: Vec2 = uv_apo.z * Vec2::new(0.45, 0.08);
+            let size: Vec2 = uv_apo.z * vec2(0.45, 0.08);
             c = mix(
                 c,
                 pal(0.55 - r * 0.6),
@@ -293,7 +295,7 @@ impl Inputs {
             );
         // drawing the screws
         } else {
-            let size: Vec2 = uv_apo.z * Vec2::new(0.5, 0.1);
+            let size: Vec2 = uv_apo.z * vec2(0.5, 0.1);
             c = mix(
                 c,
                 pal(0.85 - (uv_apo.z * 2.0)),

shaders/src/apollonian.rs

@@ -11,7 +11,7 @@
 //! ```
 
 use shared::*;
-use spirv_std::glam::{Vec2, Vec2Swizzles, Vec3, Vec3Swizzles, Vec4};
+use spirv_std::glam::{vec2, vec3, Vec2, Vec2Swizzles, 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.
@@ -91,7 +91,7 @@ impl State {
     fn calc_normal(&mut self, pos: Vec3, t: f32, s: f32) -> Vec3 {
         let precis: f32 = 0.001 * t;
 
-        let e: Vec2 = Vec2::new(1.0, -1.0) * precis;
+        let e: Vec2 = vec2(1.0, -1.0) * precis;
         (e.xyy() * self.map(pos + e.xyy(), s)
             + e.yyx() * self.map(pos + e.yyx(), s)
             + e.yxy() * self.map(pos + e.yxy(), s)
@@ -109,27 +109,23 @@ impl State {
             let nor: Vec3 = self.calc_normal(pos, t, anim);
 
             // lighting
-            let light1: Vec3 = Vec3::new(0.577, 0.577, -0.577);
-            let light2: Vec3 = Vec3::new(-0.707, 0.000, 0.707);
+            let light1: Vec3 = vec3(0.577, 0.577, -0.577);
+            let light2: Vec3 = vec3(-0.707, 0.000, 0.707);
             let key: f32 = light1.dot(nor).clamp(0.0, 1.0);
             let bac: f32 = (0.2 + 0.8 * light2.dot(nor)).clamp(0.0, 1.0);
             let amb: f32 = 0.7 + 0.3 * nor.y;
             let ao: f32 = (tra.w * 2.0).clamp(0.0, 1.0).powf(1.2);
 
-            let mut brdf: Vec3 = 1.0 * Vec3::new(0.40, 0.40, 0.40) * amb * ao;
-            brdf += 1.0 * Vec3::new(1.00, 1.00, 1.00) * key * ao;
-            brdf += 1.0 * Vec3::new(0.40, 0.40, 0.40) * bac * ao;
+            let mut brdf: Vec3 = 1.0 * vec3(0.40, 0.40, 0.40) * amb * ao;
+            brdf += 1.0 * vec3(1.00, 1.00, 1.00) * key * ao;
+            brdf += 1.0 * vec3(0.40, 0.40, 0.40) * bac * ao;
 
             // material
             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,
-                Vec3::new(1.0, 0.80, 0.2),
-                (6.0 * tra.y).clamp(0.0, 1.0),
-            );
-            rgb = mix(
-                rgb,
-                Vec3::new(1.0, 0.55, 0.0),
+                vec3(1.0, 0.55, 0.0),
                 (1.0 - 2.0 * tra.z).clamp(0.0, 1.0).powf(8.0),
             );
 
@@ -149,23 +145,23 @@ impl State {
         while jj < AA {
             let mut ii = 0;
             while ii < AA {
-                let q: Vec2 = frag_coord + Vec2::new(ii as f32, jj as f32) / AA as f32;
+                let q: Vec2 = frag_coord + vec2(ii as f32, jj as f32) / AA as f32;
                 let p: Vec2 = (2.0 * q - self.inputs.resolution.xy()) / self.inputs.resolution.y;
 
                 // camera
-                let ro: Vec3 = Vec3::new(
+                let ro: Vec3 = vec3(
                     2.8 * (0.1 + 0.33 * time).cos(),
                     0.4 + 0.30 * (0.37 * time).cos(),
                     2.8 * (0.5 + 0.35 * time).cos(),
                 );
-                let ta: Vec3 = Vec3::new(
+                let ta: Vec3 = vec3(
                     1.9 * (1.2 + 0.41 * time).cos(),
                     0.4 + 0.10 * (0.27 * time).cos(),
                     1.9 * (2.0 + 0.38 * time).cos(),
                 );
                 let roll: f32 = 0.2 * (0.1 * time).cos();
                 let cw: Vec3 = (ta - ro).normalize();
-                let cp: Vec3 = Vec3::new(roll.sin(), roll.cos(), 0.0);
+                let cp: Vec3 = vec3(roll.sin(), roll.cos(), 0.0);
                 let cu: Vec3 = cw.cross(cp).normalize();
                 let cv: Vec3 = cu.cross(cw).normalize();
                 let rd: Vec3 = (p.x * cu + p.y * cv + 2.0 * cw).normalize();
@@ -191,11 +187,7 @@ impl State {
         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 col: Vec3 = self.render(
-            frag_ray_ori + Vec3::new(0.82, 1.2, -0.3),
-            freag_ray_dir,
-            anim,
-        );
+        let col: Vec3 = self.render(frag_ray_ori + vec3(0.82, 1.2, -0.3), freag_ray_dir, anim);
         *frag_color = col.extend(1.0);
     }
 }

shaders/src/clouds.rs

@@ -1,7 +1,7 @@
 //! Ported to Rust from <https://www.shadertoy.com/view/4tdSWr>
 
 use shared::*;
-use spirv_std::glam::{const_mat2, const_vec3, Mat2, Vec2, Vec3, Vec3Swizzles, Vec4};
+use spirv_std::glam::{const_mat2, const_vec3, 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.
@@ -26,10 +26,7 @@ const SKY_COLOUR2: Vec3 = const_vec3!([0.4, 0.7, 1.0]);
 const M: Mat2 = const_mat2!([1.6, 1.2, -1.2, 1.6]);
 
 fn hash(mut p: Vec2) -> Vec2 {
-    p = Vec2::new(
-        p.dot(Vec2::new(127.1, 311.7)),
-        p.dot(Vec2::new(269.5, 183.3)),
-    );
+    p = vec2(p.dot(vec2(127.1, 311.7)), p.dot(vec2(269.5, 183.3)));
     Vec2::splat(-1.0) + 2.0 * (p.sin() * 43758.5453123).gl_fract()
 }
 
@@ -39,15 +36,15 @@ fn noise(p: Vec2) -> f32 {
     let i: Vec2 = (p + Vec2::splat((p.x + p.y) * K1)).floor();
     let a: Vec2 = p - i + Vec2::splat((i.x + i.y) * K2);
     let o: Vec2 = if a.x > a.y {
-        Vec2::new(1.0, 0.0)
+        vec2(1.0, 0.0)
     } else {
-        Vec2::new(0.0, 1.0)
+        vec2(0.0, 1.0)
     }; //vec2 of = 0.5 + 0.5*vec2(sign(a.x-a.y), sign(a.y-a.x));
     let b: Vec2 = a - o + Vec2::splat(K2);
     let c: Vec2 = a - Vec2::splat(1.0 - 2.0 * K2);
-    let h: Vec3 = (Vec3::splat(0.5) - Vec3::new(a.dot(a), b.dot(b), c.dot(c))).max(Vec3::zero());
+    let h: Vec3 = (Vec3::splat(0.5) - vec3(a.dot(a), b.dot(b), c.dot(c))).max(Vec3::zero());
     let n: Vec3 = (h * h * h * h)
-        * Vec3::new(
+        * vec3(
             a.dot(hash(i + Vec2::zero())),
             b.dot(hash(i + o)),
             c.dot(hash(i + Vec2::splat(1.0))),
@@ -74,7 +71,7 @@ fn fbm(mut n: Vec2) -> f32 {
 impl Inputs {
     pub fn main_image(&self, frag_color: &mut Vec4, frag_coord: Vec2) {
         let p: Vec2 = frag_coord / self.resolution.xy();
-        let mut uv: Vec2 = p * Vec2::new(self.resolution.x / self.resolution.y, 1.0);
+        let mut uv: Vec2 = p * vec2(self.resolution.x / self.resolution.y, 1.0);
         let mut time: f32 = self.time * SPEED;
         let q: f32 = fbm(uv * CLOUD_SCALE * 0.5);
 
@@ -94,7 +91,7 @@ impl Inputs {
 
         //noise shape
         let mut f: f32 = 0.0;
-        uv = p * Vec2::new(self.resolution.x / self.resolution.y, 1.0);
+        uv = p * vec2(self.resolution.x / self.resolution.y, 1.0);
         uv *= CLOUD_SCALE;
         uv -= Vec2::splat(q - time);
         weight = 0.7;
@@ -112,7 +109,7 @@ impl Inputs {
         //noise colour
         let mut c: f32 = 0.0;
         time = self.time * SPEED * 2.0;
-        uv = p * Vec2::new(self.resolution.x / self.resolution.y, 1.0);
+        uv = p * vec2(self.resolution.x / self.resolution.y, 1.0);
         uv *= CLOUD_SCALE * 2.0;
         uv -= Vec2::splat(q - time);
         weight = 0.4;
@@ -128,7 +125,7 @@ impl Inputs {
         //noise ridge colour
         let mut c1: f32 = 0.0;
         time = self.time * SPEED * 3.0;
-        uv = p * Vec2::new(self.resolution.x / self.resolution.y, 1.0);
+        uv = p * vec2(self.resolution.x / self.resolution.y, 1.0);
         uv *= CLOUD_SCALE * 3.0;
         uv -= Vec2::splat(q - time);
         weight = 0.4;
@@ -145,7 +142,7 @@ impl Inputs {
 
         let skycolour: Vec3 = mix(SKY_COLOUR2, SKY_COLOUR1, p.y);
         let cloudcolour: Vec3 =
-            Vec3::new(1.1, 1.1, 0.9) * (CLOUD_DARK + CLOUD_LIGHT * c).clamp(0.0, 1.0);
+            vec3(1.1, 1.1, 0.9) * (CLOUD_DARK + CLOUD_LIGHT * c).clamp(0.0, 1.0);
 
         f = CLOUD_COVER + CLOUD_ALPHA * f * r;