|
|
|
|
|
|
|
float _NoiseAmplitude; |
|
|
|
float _NoiseLacunarity; |
|
|
|
|
|
|
|
float rand(float v) |
|
|
|
{ |
|
|
|
return frac(sin(v) * 1634242.2341); |
|
|
|
} |
|
|
|
float3 permute(float3 x) { return ((x*34.0) + 1.0)*x % 289.0; } |
|
|
|
float rand(float2 v, float2 o) |
|
|
|
{ |
|
|
|
return rand(dot(v, o)); |
|
|
|
float snoise(float2 v) { |
|
|
|
const float4 C = float4(0.211324865405187, 0.366025403784439, |
|
|
|
-0.577350269189626, 0.024390243902439); |
|
|
|
float2 i = floor(v + dot(v, C.yy)); |
|
|
|
float2 x0 = v - i + dot(i, C.xx); |
|
|
|
float2 i1; |
|
|
|
i1 = (x0.x > x0.y) ? float2(1.0, 0.0) : float2(0.0, 1.0); |
|
|
|
float4 x12 = x0.xyxy + C.xxzz; |
|
|
|
x12.xy -= i1; |
|
|
|
i = i % 289.0; |
|
|
|
float3 p = permute(permute(i.y + float3(0.0, i1.y, 1.0)) |
|
|
|
+ i.x + float3(0.0, i1.x, 1.0)); |
|
|
|
float3 m = max(0.5 - float3(dot(x0, x0), dot(x12.xy, x12.xy), |
|
|
|
dot(x12.zw, x12.zw)), 0.0); |
|
|
|
m = m*m; |
|
|
|
m = m*m; |
|
|
|
float3 x = 2.0 * frac(p * C.www) - 1.0; |
|
|
|
float3 h = abs(x) - 0.5; |
|
|
|
float3 ox = floor(x + 0.5); |
|
|
|
float3 a0 = x - ox; |
|
|
|
m *= 1.79284291400159 - 0.85373472095314 * (a0*a0 + h*h); |
|
|
|
float3 g; |
|
|
|
g.x = a0.x * x0.x + h.x * x0.y; |
|
|
|
g.yz = a0.yz * x12.xz + h.yz * x12.yw; |
|
|
|
return 130.0 * dot(m, g); |
|
|
|
float noise(float2 v, float2 o) |
|
|
|
{ |
|
|
|
float2 p = v; |
|
|
|
float2 i = floor(p); |
|
|
|
float2 f = frac(v); |
|
|
|
float2 u = f*f*(3.0 - 2.0*f); |
|
|
|
float4 permute(float4 x) { return ((x*34.0) + 1.0)*x % 289.0; } |
|
|
|
float4 taylorInvSqrt(float4 r) { return 1.79284291400159 - 0.85373472095314 * r; } |
|
|
|
float f00 = rand(i, o); |
|
|
|
float f01 = rand(i + float2(0.0, 1.0), o); |
|
|
|
float f11 = rand(i + float2(1.0, 1.0), o); |
|
|
|
float f10 = rand(i + float2(1.0, 0.0), o); |
|
|
|
float snoise(float3 v) { |
|
|
|
const float2 C = float2(1.0 / 6.0, 1.0 / 3.0); |
|
|
|
const float4 D = float4(0.0, 0.5, 1.0, 2.0); |
|
|
|
return lerp(f00, f10, u.x) + |
|
|
|
(f01 - f00)* u.y * (1.0 - u.x) + |
|
|
|
(f11 - f10) * u.x * u.y; |
|
|
|
} |
|
|
|
// First corner |
|
|
|
float3 i = floor(v + dot(v, C.yyy)); |
|
|
|
float3 x0 = v - i + dot(i, C.xxx); |
|
|
|
float3 noise3(float2 v) |
|
|
|
{ |
|
|
|
const float2 _O1 = float2(0.734523, 0.235214); |
|
|
|
const float2 _O2 = float2(0.142378, 0.781423); |
|
|
|
const float2 _O3 = float2(0.891253, 0.534342); |
|
|
|
// Other corners |
|
|
|
float3 g = step(x0.yzx, x0.xyz); |
|
|
|
float3 l = 1.0 - g; |
|
|
|
float3 i1 = min(g.xyz, l.zxy); |
|
|
|
float3 i2 = max(g.xyz, l.zxy); |
|
|
|
return float3(noise(v, _O1), noise(v, _O2), noise(v, _O3)); |
|
|
|
} |
|
|
|
// x0 = x0 - 0. + 0.0 * C |
|
|
|
float3 x1 = x0 - i1 + 1.0 * C.xxx; |
|
|
|
float3 x2 = x0 - i2 + 2.0 * C.xxx; |
|
|
|
float3 x3 = x0 - 1. + 3.0 * C.xxx; |
|
|
|
float3 fbm(float2 v, float a, float f) |
|
|
|
{ |
|
|
|
float3 r = float3(0.0, 0.0, 0.0); |
|
|
|
// Permutations |
|
|
|
i = i % 289.0; |
|
|
|
float4 p = permute(permute(permute( |
|
|
|
i.z + float4(0.0, i1.z, i2.z, 1.0)) |
|
|
|
+ i.y + float4(0.0, i1.y, i2.y, 1.0)) |
|
|
|
+ i.x + float4(0.0, i1.x, i2.x, 1.0)); |
|
|
|
for (int i = 0; i < 6 ; ++i) |
|
|
|
{ |
|
|
|
r += a * noise3(v); |
|
|
|
v *= f; |
|
|
|
a *= a; |
|
|
|
} |
|
|
|
// Gradients |
|
|
|
// ( N*N points uniformly over a square, mapped onto an octahedron.) |
|
|
|
float n_ = 1.0 / 7.0; // N=7 |
|
|
|
float3 ns = n_ * D.wyz - D.xzx; |
|
|
|
|
|
|
|
float4 j = p - 49.0 * floor(p * ns.z *ns.z); // mod(p,N*N) |
|
|
|
return r; |
|
|
|
float4 x_ = floor(j * ns.z); |
|
|
|
float4 y_ = floor(j - 7.0 * x_); // mod(j,N) |
|
|
|
|
|
|
|
float4 x = x_ *ns.x + ns.yyyy; |
|
|
|
float4 y = y_ *ns.x + ns.yyyy; |
|
|
|
float4 h = 1.0 - abs(x) - abs(y); |
|
|
|
|
|
|
|
float4 b0 = float4(x.xy, y.xy); |
|
|
|
float4 b1 = float4(x.zw, y.zw); |
|
|
|
|
|
|
|
float4 s0 = floor(b0)*2.0 + 1.0; |
|
|
|
float4 s1 = floor(b1)*2.0 + 1.0; |
|
|
|
float4 sh = -step(h, float4(0.0, 0.0, 0.0, 0.0)); |
|
|
|
|
|
|
|
float4 a0 = b0.xzyw + s0.xzyw*sh.xxyy; |
|
|
|
float4 a1 = b1.xzyw + s1.xzyw*sh.zzww; |
|
|
|
|
|
|
|
float3 p0 = float3(a0.xy, h.x); |
|
|
|
float3 p1 = float3(a0.zw, h.y); |
|
|
|
float3 p2 = float3(a1.xy, h.z); |
|
|
|
float3 p3 = float3(a1.zw, h.w); |
|
|
|
|
|
|
|
//Normalise gradients |
|
|
|
float4 norm = taylorInvSqrt(float4(dot(p0, p0), dot(p1, p1), dot(p2, p2), dot(p3, p3))); |
|
|
|
p0 *= norm.x; |
|
|
|
p1 *= norm.y; |
|
|
|
p2 *= norm.z; |
|
|
|
p3 *= norm.w; |
|
|
|
|
|
|
|
// Mix final noise value |
|
|
|
float4 m = max(0.6 - float4(dot(x0, x0), dot(x1, x1), dot(x2, x2), dot(x3, x3)), 0.0); |
|
|
|
m = m * m; |
|
|
|
return 42.0 * dot(m*m, float4(dot(p0, x0), dot(p1, x1), |
|
|
|
dot(p2, x2), dot(p3, x3))); |
|
|
|
float3 turb(float2 v, float a, float f) |
|
|
|
float3 fbm2x3(float2 v, float a, float f) |
|
|
|
r += a * abs(noise3(v)); |
|
|
|
r += a * float3(snoise(v), snoise(v * 1.18142), snoise(v * 0.974236)); |
|
|
|
v *= f; |
|
|
|
a *= a; |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
float3 ridge(float2 v, float a, float f, float3 n) |
|
|
|
float fbm3(float3 v, float a, float f) |
|
|
|
float3 r = float3(0.0, 0.0, 0.0); |
|
|
|
float r = float(0.0); |
|
|
|
float3 t = n - abs(a * noise3(v)); |
|
|
|
t *= t; |
|
|
|
r += t; |
|
|
|
|
|
|
|
r += a * snoise(v); |
|
|
|
v *= f; |
|
|
|
a *= a; |
|
|
|
} |
|
|
|
|
|
|
|
float4 frag(v2f_customrendertexture IN) : COLOR |
|
|
|
{ |
|
|
|
float2 p = _Size * IN.globalTexcoord.xy; |
|
|
|
float3 s = fbm(p, _NoiseAmplitude, _NoiseLacunarity * (_SinTime.w * 0.1 + 1.0)); |
|
|
|
float3 s = fbm2x3(p, _NoiseAmplitude, _NoiseLacunarity * (_SinTime.w * 0.1 + 1.0)); |
|
|
|
|
|
|
|
float2 distortion = s.xy * _DistortionAmplitude; |
|
|
|
float blur = s.z * (_BlurMaxAmplitude - _BlurMinAmplitude) + _BlurMinAmplitude; |
|
|
|
|
|
|
|
|
|
|
|
float4 frag(v2f_customrendertexture IN) : COLOR |
|
|
|
{ |
|
|
|
float s = _Size * (cos(_Time.w) * 0.1 + 1); |
|
|
|
float s = _Size * (cos(_Time.w * 0.5) * 0.1 + 1); |
|
|
|
float2 distortion = float2(sin(IN.globalTexcoord.y * s) * _DistortionAmplitude, 0); |
|
|
|
float3 n3 = fbm2x3(IN.globalTexcoord.xy * 5, _NoiseAmplitude, _NoiseLacunarity); |
|
|
|
float n = fbm3(n3 + IN.globalTexcoord.xyx + _Time.w * 0.1, _NoiseAmplitude, _NoiseLacunarity); |
|
|
|
float t = sin(n * 5 + _Time.w * 0.5) * 0.5 + 0.5; |
|
|
|
float blur = 0; |
|
|
|
float2 distortion = sin(n3.xy * s) * _DistortionAmplitude; |
|
|
|
|
|
|
|
float blur = (min(t, 1-t) * 2) * (_BlurMaxAmplitude - _BlurMinAmplitude) + _BlurMinAmplitude; |
|
|
|
|
|
|
|
return float4(distortion, blur, 1.0); |
|
|
|
} |
|
|
|
|
Frédéric Vauchelles
7 年前