1 files changed, 34 insertions, 34 deletions

diff --git a/common/shaders/math/noise.wgsl b/common/shaders/math/noise.wgsl
index 9f99e4a..dd97e02 100644
--- a/common/shaders/math/noise.wgsl
+++ b/common/shaders/math/noise.wgsl
@@ -14,31 +14,31 @@ fn hash_1f(x: f32) -> f32 {
   return fract(v);
 }
 
-// Hash: vec2<f32> -> f32
+// Hash: vec2f -> f32
 // 2D coordinate to single hash value
-fn hash_2f(p: vec2<f32>) -> f32 {
-  var h = dot(p, vec2<f32>(127.1, 311.7));
+fn hash_2f(p: vec2f) -> f32 {
+  var h = dot(p, vec2f(127.1, 311.7));
   return fract(sin(h) * 43758.5453123);
 }
 
-// Hash: vec2<f32> -> vec2<f32>
+// Hash: vec2f -> vec2f
 // 2D coordinate to 2D hash (from Shadertoy 4djSRW)
-fn hash_2f_2f(p: vec2<f32>) -> vec2<f32> {
-  var p3 = fract(vec3<f32>(p.x, p.y, p.x) * vec3<f32>(0.1021, 0.1013, 0.0977));
+fn hash_2f_2f(p: vec2f) -> vec2f {
+  var p3 = fract(vec3f(p.x, p.y, p.x) * vec3f(0.1021, 0.1013, 0.0977));
   p3 += dot(p3, p3.yzx + 33.33);
   return fract((p3.xx + p3.yz) * p3.zy);
 }
 
-// Hash: vec3<f32> -> f32
+// Hash: vec3f -> f32
 // 3D coordinate to single hash value
-fn hash_3f(p: vec3<f32>) -> f32 {
-  var h = dot(p, vec3<f32>(127.1, 311.7, 74.7));
+fn hash_3f(p: vec3f) -> f32 {
+  var h = dot(p, vec3f(127.1, 311.7, 74.7));
   return fract(sin(h) * 43758.5453123);
 }
 
-// Hash: vec3<f32> -> vec3<f32>
+// Hash: vec3f -> vec3f
 // 3D coordinate to 3D hash
-fn hash_3f_3f(p: vec3<f32>) -> vec3<f32> {
+fn hash_3f_3f(p: vec3f) -> vec3f {
   var v = fract(p);
   v += dot(v, v.yxz + 32.41);
   return fract((v.xxy + v.yzz) * v.zyx);
@@ -56,14 +56,14 @@ fn hash_1u(p: u32) -> f32 {
   return bitcast<f32>((P >> 9u) | 0x3f800000u) - 1.0;
 }
 
-// Hash: u32 -> vec2<f32>
-fn hash_1u_2f(p: u32) -> vec2<f32> {
-  return vec2<f32>(hash_1u(p), hash_1u(p + 1423u));
+// Hash: u32 -> vec2f
+fn hash_1u_2f(p: u32) -> vec2f {
+  return vec2f(hash_1u(p), hash_1u(p + 1423u));
 }
 
-// Hash: u32 -> vec3<f32>
-fn hash_1u_3f(p: u32) -> vec3<f32> {
-  return vec3<f32>(hash_1u(p), hash_1u(p + 1423u), hash_1u(p + 124453u));
+// Hash: u32 -> vec3f
+fn hash_1u_3f(p: u32) -> vec3f {
+  return vec3f(hash_1u(p), hash_1u(p + 1423u), hash_1u(p + 124453u));
 }
 
 // ============================================
@@ -72,32 +72,32 @@ fn hash_1u_3f(p: u32) -> vec3<f32> {
 
 // Value Noise: 2D
 // Interpolated grid noise using smoothstep
-fn noise_2d(p: vec2<f32>) -> f32 {
+fn noise_2d(p: vec2f) -> f32 {
   let i = floor(p);
   let f = fract(p);
   let u = f * f * (3.0 - 2.0 * f);
-  let n0 = hash_2f(i + vec2<f32>(0.0, 0.0));
-  let n1 = hash_2f(i + vec2<f32>(1.0, 0.0));
-  let n2 = hash_2f(i + vec2<f32>(0.0, 1.0));
-  let n3 = hash_2f(i + vec2<f32>(1.0, 1.0));
+  let n0 = hash_2f(i + vec2f(0.0, 0.0));
+  let n1 = hash_2f(i + vec2f(1.0, 0.0));
+  let n2 = hash_2f(i + vec2f(0.0, 1.0));
+  let n3 = hash_2f(i + vec2f(1.0, 1.0));
   let ix0 = mix(n0, n1, u.x);
   let ix1 = mix(n2, n3, u.x);
   return mix(ix0, ix1, u.y);
 }
 
 // Value Noise: 3D
-fn noise_3d(p: vec3<f32>) -> f32 {
+fn noise_3d(p: vec3f) -> f32 {
   let i = floor(p);
   let f = fract(p);
   let u = f * f * (3.0 - 2.0 * f);
-  let n000 = hash_3f(i + vec3<f32>(0.0, 0.0, 0.0));
-  let n100 = hash_3f(i + vec3<f32>(1.0, 0.0, 0.0));
-  let n010 = hash_3f(i + vec3<f32>(0.0, 1.0, 0.0));
-  let n110 = hash_3f(i + vec3<f32>(1.0, 1.0, 0.0));
-  let n001 = hash_3f(i + vec3<f32>(0.0, 0.0, 1.0));
-  let n101 = hash_3f(i + vec3<f32>(1.0, 0.0, 1.0));
-  let n011 = hash_3f(i + vec3<f32>(0.0, 1.0, 1.0));
-  let n111 = hash_3f(i + vec3<f32>(1.0, 1.0, 1.0));
+  let n000 = hash_3f(i + vec3f(0.0, 0.0, 0.0));
+  let n100 = hash_3f(i + vec3f(1.0, 0.0, 0.0));
+  let n010 = hash_3f(i + vec3f(0.0, 1.0, 0.0));
+  let n110 = hash_3f(i + vec3f(1.0, 1.0, 0.0));
+  let n001 = hash_3f(i + vec3f(0.0, 0.0, 1.0));
+  let n101 = hash_3f(i + vec3f(1.0, 0.0, 1.0));
+  let n011 = hash_3f(i + vec3f(0.0, 1.0, 1.0));
+  let n111 = hash_3f(i + vec3f(1.0, 1.0, 1.0));
   let ix00 = mix(n000, n100, u.x);
   let ix10 = mix(n010, n110, u.x);
   let ix01 = mix(n001, n101, u.x);
@@ -113,13 +113,13 @@ fn noise_3d(p: vec3<f32>) -> f32 {
 
 // Gyroid function (periodic triply-orthogonal minimal surface)
 // Useful for procedural patterns and cellular structures
-fn gyroid(p: vec3<f32>) -> f32 {
+fn gyroid(p: vec3f) -> f32 {
   return abs(0.04 + dot(sin(p), cos(p.zxy)));
 }
 
 // Fractional Brownian Motion (FBM) 2D
 // Multi-octave noise for natural-looking variation
-fn fbm_2d(p: vec2<f32>, octaves: i32) -> f32 {
+fn fbm_2d(p: vec2f, octaves: i32) -> f32 {
   var value = 0.0;
   var amplitude = 0.5;
   var frequency = 1.0;
@@ -133,7 +133,7 @@ fn fbm_2d(p: vec2<f32>, octaves: i32) -> f32 {
 }
 
 // Fractional Brownian Motion (FBM) 3D
-fn fbm_3d(p: vec3<f32>, octaves: i32) -> f32 {
+fn fbm_3d(p: vec3f, octaves: i32) -> f32 {
   var value = 0.0;
   var amplitude = 0.5;
   var frequency = 1.0;