Operator % has changed, probably current code with it need a fix
// https://www.pcg-random.org/
fn pcg(n: u32) -> u32 {
var h = n * 747796405u + 2891336453u;
h = ((h >> ((h >> 28u) + 4u)) ^ h) * 277803737u;
return (h >> 22u) ^ h;
}
fn pcg2d(p: vec2u) -> vec2u {
var v = p * 1664525u + 1013904223u;
v.x += v.y * 1664525u; v.y += v.x * 1664525u;
v ^= v >> vec2u(16u);
v.x += v.y * 1664525u; v.y += v.x * 1664525u;
v ^= v >> vec2u(16u);
return v;
}
// http://www.jcgt.org/published/0009/03/02/
fn pcg3d(p: vec3u) -> vec3u {
var v = p * 1664525u + 1013904223u;
v.x += v.y*v.z; v.y += v.z*v.x; v.z += v.x*v.y;
v ^= v >> vec3u(16u);
v.x += v.y*v.z; v.y += v.z*v.x; v.z += v.x*v.y;
return v;
}
// http://www.jcgt.org/published/0009/03/02/
fn pcg4d(p: vec4u) -> vec4u {
var v = p * 1664525u + 1013904223u;
v.x += v.y*v.w; v.y += v.z*v.x; v.z += v.x*v.y; v.w += v.y*v.z;
v ^= v >> vec4u(16u);
v.x += v.y*v.w; v.y += v.z*v.x; v.z += v.x*v.y; v.w += v.y*v.z;
return v;
}// https://github.com/Cyan4973/xxHash
// https://www.shadertoy.com/view/Xt3cDn
fn xxhash32(n: u32) -> u32 {
var h32 = n + 374761393u;
h32 = 668265263u * ((h32 << 17) | (h32 >> (32 - 17)));
h32 = 2246822519u * (h32 ^ (h32 >> 15));
h32 = 3266489917u * (h32 ^ (h32 >> 13));
return h32^(h32 >> 16);
}
fn xxhash32_2d(p: vec2u) -> u32 {
let p2 = 2246822519u; let p3 = 3266489917u;
let p4 = 668265263u; let p5 = 374761393u;
var h32 = p.y + p5 + p.x * p3;
h32 = p4 * ((h32 << 17) | (h32 >> (32 - 17)));
h32 = p2 * (h32^(h32 >> 15));
h32 = p3 * (h32^(h32 >> 13));
return h32^(h32 >> 16);
}
fn xxhash32_3d(p: vec3u) -> u32 {
let p2 = 2246822519u; let p3 = 3266489917u;
let p4 = 668265263u; let p5 = 374761393u;
var h32 = p.z + p5 + p.x*p3;
h32 = p4 * ((h32 << 17) | (h32 >> (32 - 17)));
h32 += p.y * p3;
h32 = p4 * ((h32 << 17) | (h32 >> (32 - 17)));
h32 = p2 * (h32^(h32 >> 15));
h32 = p3 * (h32^(h32 >> 13));
return h32^(h32 >> 16);
}
fn xxhash32_4d(p: vec4u) -> u32 {
let p2 = 2246822519u; let p3 = 3266489917u;
let p4 = 668265263u; let p5 = 374761393u;
var h32 = p.w + p5 + p.x * p3;
h32 = p4 * ((h32 << 17) | (h32 >> (32 - 17)));
h32 += p.y * p3;
h32 = p4 * ((h32 << 17) | (h32 >> (32 - 17)));
h32 += p.z * p3;
h32 = p4 * ((h32 << 17) | (h32 >> (32 - 17)));
h32 = p2 * (h32^(h32 >> 15));
h32 = p3 * (h32^(h32 >> 13));
return h32 ^ (h32 >> 16);
}fn rand11(f: f32) -> f32 { return f32(hash11(bitcast<u32>(f))) / f32(0xffffffff); }
fn rand22(f: vec2f) -> vec2f { return vec2f(hash22(bitcast<vec2u>(f))) / f32(0xffffffff); }
fn rand33(f: vec3f) -> vec3f { return vec3f(hash33(bitcast<vec3u>(f))) / f32(0xffffffff); }
fn rand44(f: vec4f) -> vec4f { return vec4f(hash44(bitcast<vec4u>(f))) / f32(0xffffffff); }// On generating random numbers, with help of y= [(a+x)sin(bx)] mod 1", W.J.J. Rey, 22nd European Meeting of Statisticians 1998
fn rand11(n: f32) -> f32 { return fract(sin(n) * 43758.5453123); }
fn rand22(n: vec2f) -> f32 { return fract(sin(dot(n, vec2f(12.9898, 4.1414))) * 43758.5453); }
// WTFPL License
fn noise(p: f32) -> f32 {
let fl = floor(p);
return mix(rand11(fl), rand(fl + 1.), fract(p));
}
// WTFPL License
fn noise2(n: vec2f) -> f32 {
let d = vec2f(0., 1.);
let b = floor(n);
let f = smoothStep(vec2f(0.), vec2f(1.), fract(n));
return mix(mix(rand22(b), rand22(b + d.yx), f.x), mix(rand22(b + d.xy), rand22(b + d.yy), f.x), f.y);
}
// MIT License. © Stefan Gustavson, Munrocket
//
fn mod289(x: vec4f) -> vec4f { return x - floor(x * (1. / 289.)) * 289.; }
fn perm4(x: vec4f) -> vec4f { return mod289(((x * 34.) + 1.) * x); }
fn noise3(p: vec3f) -> f32 {
let a = floor(p);
var d: vec3f = p - a;
d = d * d * (3. - 2. * d);
let b = a.xxyy + vec4f(0., 1., 0., 1.);
let k1 = perm4(b.xyxy);
let k2 = perm4(k1.xyxy + b.zzww);
let c = k2 + a.zzzz;
let k3 = perm4(c);
let k4 = perm4(c + 1.);
let o1 = fract(k3 * (1. / 41.));
let o2 = fract(k4 * (1. / 41.));
let o3 = o2 * d.z + o1 * (1. - d.z);
let o4 = o3.yw * d.x + o3.xz * (1. - d.x);
return o4.y * d.y + o4.x * (1. - d.y);
}
// MIT License. © Stefan Gustavson, Munrocket
//
fn permute4(x: vec4f) -> vec4f { return ((x * 34. + 1.) * x) % vec4f(289.); }
fn fade2(t: vec2f) -> vec2f { return t * t * t * (t * (t * 6. - 15.) + 10.); }
fn perlinNoise2(P: vec2f) -> f32 {
var Pi: vec4f = floor(P.xyxy) + vec4f(0., 0., 1., 1.);
let Pf = fract(P.xyxy) - vec4f(0., 0., 1., 1.);
Pi = Pi % vec4f(289.); // To avoid truncation effects in permutation
let ix = Pi.xzxz;
let iy = Pi.yyww;
let fx = Pf.xzxz;
let fy = Pf.yyww;
let i = permute4(permute4(ix) + iy);
var gx: vec4f = 2. * fract(i * 0.0243902439) - 1.; // 1/41 = 0.024...
let gy = abs(gx) - 0.5;
let tx = floor(gx + 0.5);
gx = gx - tx;
var g00: vec2f = vec2f(gx.x, gy.x);
var g10: vec2f = vec2f(gx.y, gy.y);
var g01: vec2f = vec2f(gx.z, gy.z);
var g11: vec2f = vec2f(gx.w, gy.w);
let norm = 1.79284291400159 - 0.85373472095314 *
vec4f(dot(g00, g00), dot(g01, g01), dot(g10, g10), dot(g11, g11));
g00 = g00 * norm.x;
g01 = g01 * norm.y;
g10 = g10 * norm.z;
g11 = g11 * norm.w;
let n00 = dot(g00, vec2f(fx.x, fy.x));
let n10 = dot(g10, vec2f(fx.y, fy.y));
let n01 = dot(g01, vec2f(fx.z, fy.z));
let n11 = dot(g11, vec2f(fx.w, fy.w));
let fade_xy = fade2(Pf.xy);
let n_x = mix(vec2f(n00, n01), vec2f(n10, n11), vec2f(fade_xy.x));
let n_xy = mix(n_x.x, n_x.y, fade_xy.y);
return 2.3 * n_xy;
}
// MIT License. © Stefan Gustavson, Munrocket
//
fn permute4(x: vec4f) -> vec4f { return ((x * 34. + 1.) * x) % vec4f(289.); }
fn taylorInvSqrt4(r: vec4f) -> vec4f { return 1.79284291400159 - 0.85373472095314 * r; }
fn fade3(t: vec3f) -> vec3f { return t * t * t * (t * (t * 6. - 15.) + 10.); }
fn perlinNoise3(P: vec3f) -> f32 {
var Pi0 : vec3f = floor(P); // Integer part for indexing
var Pi1 : vec3f = Pi0 + vec3f(1.); // Integer part + 1
Pi0 = Pi0 % vec3f(289.);
Pi1 = Pi1 % vec3f(289.);
let Pf0 = fract(P); // Fractional part for interpolation
let Pf1 = Pf0 - vec3f(1.); // Fractional part - 1.
let ix = vec4f(Pi0.x, Pi1.x, Pi0.x, Pi1.x);
let iy = vec4f(Pi0.yy, Pi1.yy);
let iz0 = Pi0.zzzz;
let iz1 = Pi1.zzzz;
let ixy = permute4(permute4(ix) + iy);
let ixy0 = permute4(ixy + iz0);
let ixy1 = permute4(ixy + iz1);
var gx0: vec4f = ixy0 / 7.;
var gy0: vec4f = fract(floor(gx0) / 7.) - 0.5;
gx0 = fract(gx0);
var gz0: vec4f = vec4f(0.5) - abs(gx0) - abs(gy0);
var sz0: vec4f = step(gz0, vec4f(0.));
gx0 = gx0 + sz0 * (step(vec4f(0.), gx0) - 0.5);
gy0 = gy0 + sz0 * (step(vec4f(0.), gy0) - 0.5);
var gx1: vec4f = ixy1 / 7.;
var gy1: vec4f = fract(floor(gx1) / 7.) - 0.5;
gx1 = fract(gx1);
var gz1: vec4f = vec4f(0.5) - abs(gx1) - abs(gy1);
var sz1: vec4f = step(gz1, vec4f(0.));
gx1 = gx1 - sz1 * (step(vec4f(0.), gx1) - 0.5);
gy1 = gy1 - sz1 * (step(vec4f(0.), gy1) - 0.5);
var g000: vec3f = vec3f(gx0.x, gy0.x, gz0.x);
var g100: vec3f = vec3f(gx0.y, gy0.y, gz0.y);
var g010: vec3f = vec3f(gx0.z, gy0.z, gz0.z);
var g110: vec3f = vec3f(gx0.w, gy0.w, gz0.w);
var g001: vec3f = vec3f(gx1.x, gy1.x, gz1.x);
var g101: vec3f = vec3f(gx1.y, gy1.y, gz1.y);
var g011: vec3f = vec3f(gx1.z, gy1.z, gz1.z);
var g111: vec3f = vec3f(gx1.w, gy1.w, gz1.w);
let norm0 = taylorInvSqrt4(
vec4f(dot(g000, g000), dot(g010, g010), dot(g100, g100), dot(g110, g110)));
g000 = g000 * norm0.x;
g010 = g010 * norm0.y;
g100 = g100 * norm0.z;
g110 = g110 * norm0.w;
let norm1 = taylorInvSqrt4(
vec4f(dot(g001, g001), dot(g011, g011), dot(g101, g101), dot(g111, g111)));
g001 = g001 * norm1.x;
g011 = g011 * norm1.y;
g101 = g101 * norm1.z;
g111 = g111 * norm1.w;
let n000 = dot(g000, Pf0);
let n100 = dot(g100, vec3f(Pf1.x, Pf0.yz));
let n010 = dot(g010, vec3f(Pf0.x, Pf1.y, Pf0.z));
let n110 = dot(g110, vec3f(Pf1.xy, Pf0.z));
let n001 = dot(g001, vec3f(Pf0.xy, Pf1.z));
let n101 = dot(g101, vec3f(Pf1.x, Pf0.y, Pf1.z));
let n011 = dot(g011, vec3f(Pf0.x, Pf1.yz));
let n111 = dot(g111, Pf1);
var fade_xyz: vec3f = fade3(Pf0);
let temp = vec4f(f32(fade_xyz.z)); // simplify after chrome bug fix
let n_z = mix(vec4f(n000, n100, n010, n110), vec4f(n001, n101, n011, n111), temp);
let n_yz = mix(n_z.xy, n_z.zw, vec2f(f32(fade_xyz.y))); // simplify after chrome bug fix
let n_xyz = mix(n_yz.x, n_yz.y, fade_xyz.x);
return 2.2 * n_xyz;
}
// MIT License. © Ian McEwan, Stefan Gustavson, Munrocket, Johan Helsing
//
fn mod289(x: vec2f) -> vec2f {
return x - floor(x * (1. / 289.)) * 289.;
}
fn mod289_3(x: vec3f) -> vec3f {
return x - floor(x * (1. / 289.)) * 289.;
}
fn permute3(x: vec3f) -> vec3f {
return mod289_3(((x * 34.) + 1.) * x);
}
// MIT License. © Ian McEwan, Stefan Gustavson, Munrocket
fn simplexNoise2(v: vec2f) -> f32 {
let C = vec4(
0.211324865405187, // (3.0-sqrt(3.0))/6.0
0.366025403784439, // 0.5*(sqrt(3.0)-1.0)
-0.577350269189626, // -1.0 + 2.0 * C.x
0.024390243902439 // 1.0 / 41.0
);
// First corner
var i = floor(v + dot(v, C.yy));
let x0 = v - i + dot(i, C.xx);
// Other corners
var i1 = select(vec2(0., 1.), vec2(1., 0.), x0.x > x0.y);
// x0 = x0 - 0.0 + 0.0 * C.xx ;
// x1 = x0 - i1 + 1.0 * C.xx ;
// x2 = x0 - 1.0 + 2.0 * C.xx ;
var x12 = x0.xyxy + C.xxzz;
x12.x = x12.x - i1.x;
x12.y = x12.y - i1.y;
// Permutations
i = mod289(i); // Avoid truncation effects in permutation
var p = permute3(permute3(i.y + vec3(0., i1.y, 1.)) + i.x + vec3(0., i1.x, 1.));
var m = max(0.5 - vec3(dot(x0, x0), dot(x12.xy, x12.xy), dot(x12.zw, x12.zw)), vec3(0.));
m *= m;
m *= m;
// Gradients: 41 points uniformly over a line, mapped onto a diamond.
// The ring size 17*17 = 289 is close to a multiple of 41 (41*7 = 287)
let x = 2. * fract(p * C.www) - 1.;
let h = abs(x) - 0.5;
let ox = floor(x + 0.5);
let a0 = x - ox;
// Normalize gradients implicitly by scaling m
// Approximation of: m *= inversesqrt( a0*a0 + h*h );
m *= 1.79284291400159 - 0.85373472095314 * (a0 * a0 + h * h);
// Compute final noise value at P
let g = vec3(a0.x * x0.x + h.x * x0.y, a0.yz * x12.xz + h.yz * x12.yw);
return 130. * dot(m, g);
}// MIT License. © Inigo Quilez, Munrocket
// noise2() is any noise here: Value, Perlin, Simplex, Worley
//
var m2: mat2x2f = mat2x2f(vec2f(0.8, 0.6), vec2f(-0.6, 0.8));
fn fbm(p: vec2f) -> f32 {
var f: f32 = 0.;
f = f + 0.5000 * noise2(p); p = m2 * p * 2.02;
f = f + 0.2500 * noise2(p); p = m2 * p * 2.03;
f = f + 0.1250 * noise2(p); p = m2 * p * 2.01;
f = f + 0.0625 * noise2(p);
return f / 0.9375;
}// <https://www.shadertoy.com/view/Xd23Dh>
// by Inigo Quilez
//
fn hash23(p: vec2f) -> vec3f {
let q = vec3f(dot(p, vec2f(127.1, 311.7)),
dot(p, vec2f(269.5, 183.3)),
dot(p, vec2f(419.2, 371.9)));
return fract(sin(q) * 43758.5453);
}
fn voroNoise2(x: vec2f, u: f32, v: f32) -> f32 {
let p = floor(x);
let f = fract(x);
let k = 1. + 63. * pow(1. - v, 4.);
var va: f32 = 0.;
var wt: f32 = 0.;
for(var j: i32 = -2; j <= 2; j = j + 1) {
for(var i: i32 = -2; i <= 2; i = i + 1) {
let g = vec2f(f32(i), f32(j));
let o = hash23(p + g) * vec3f(u, u, 1.);
let r = g - f + o.xy;
let d = dot(r, r);
let ww = pow(1. - smoothStep(0., 1.414, sqrt(d)), k);
va = va + o.z * ww;
wt = wt + ww;
}
}
return va / wt;
}- Stefan Gustavson (http://github.com/ashima/webgl-noise)
- Inigo Quilez (https://iquilezles.org/www/index.htm)
- Patricio Gonzalez Vivo (https://gist.github.com/patriciogonzalezvivo/670c22f3966e662d2f83)
- translate main noises
- add images if possible
- add integer based hash
- revisit, becasue % operator has changed
- Worley noise
- Curl noise https://github.com/atyuwen/bitangent_noise
- Flow noise. In Siggraph 2001 Technical Sketches and Applications, ACM, 187.
- Wobble functions
There does indeed seem to be a bug in simplexNoise2 when used in bevy 0.8
I re-ported another version of gustavson/mcewans permutation stuff to wgsl and mixed it with your code and got it working:
EDIT: On further inspection, I think the bug is actually that the
selecttrue and false arguments have been flipped.It should be