uniform float brightness;
uniform vec2 iResolution;
uniform float time; // For animation
// Simplex noise function
return x - floor(x * (1.0 / 289.0)) * 289.0;
return x - floor(x * (1.0 / 289.0)) * 289.0;
return mod289(((x*34.0)+1.0)*x);
vec4 taylorInvSqrt(vec4 r) {
return 1.79284291400159 - 0.85373472095314 * r;
const vec2 C = vec2(1.0/6.0, 1.0/3.0);
const vec4 D = vec4(0.0, 0.5, 1.0, 2.0);
vec3 i = floor(v + dot(v, C.yyy) );
vec3 x0 = v - i + dot(i, C.xxx) ;
vec3 g = step(x0.yzx, x0.xyz);
vec3 i1 = min(g.xyz, l.zxy);
vec3 i2 = max(g.xyz, l.zxy);
vec3 x1 = x0 - i1 + C.xxx;
vec3 x2 = x0 - i2 + C.yyy;
vec4 p = permute( permute( permute(
i.z + vec4(0.0, i1.z, i2.z, 1.0 ))
+ i.y + vec4(0.0, i1.y, i2.y, 1.0 ))
+ i.x + vec4(0.0, i1.x, i2.x, 1.0 ));
vec3 ns = n_ * D.wyz - D.xzx;
vec4 j = p - 49.0 * floor(p * ns.z * ns.z);
vec4 x_ = floor(j * ns.z);
vec4 y_ = floor(j - 7.0 * x_);
vec4 x = x_ * ns.x + ns.yyyy;
vec4 y = y_ * ns.x + ns.yyyy;
vec4 h = 1.0 - abs(x) - abs(y);
vec4 b0 = vec4( x.xy, y.xy );
vec4 b1 = vec4( x.zw, y.zw );
vec4 s0 = floor(b0)*2.0 + 1.0;
vec4 s1 = floor(b1)*2.0 + 1.0;
vec4 sh = -step(h, vec4(0.0));
vec4 a0 = b0.xzyw + s0.xzyw*sh.xxyy ;
vec4 a1 = b1.xzyw + s1.xzyw*sh.zzww ;
vec3 p0 = vec3(a0.xy,h.x);
vec3 p1 = vec3(a0.zw,h.y);
vec3 p2 = vec3(a1.xy,h.z);
vec3 p3 = vec3(a1.zw,h.w);
vec4 norm = taylorInvSqrt(vec4(dot(p0,p0), dot(p1,p1), dot(p2,p2), dot(p3,p3)));
vec4 m = max(0.6 - vec4(dot(x0,x0), dot(x1,x1), dot(x2,x2), dot(x3,x3)), 0.0);
return 42.0 * dot(m*m, vec4(dot(p0,x0), dot(p1,x1), dot(p2,x2), dot(p3,x3)));
// Using simplex as a placeholder for Perlin noise
return step(0.5, fract(p.x) + fract(p.y) + fract(p.z));
for (int k = -1; k <= 1; k++)
for (int j = -1; j <= 1; j++)
for (int i = -1; i <= 1; i++) {
vec3 cell = vec3(float(i), float(j), float(k));
vec3 pos = cell + fract(sin(dot(cell + id, vec3(37.0, 17.0, 29.0))) * 43758.5453);
d = min(d, length(pos - fract(p)));
for (int k = -1; k <= 1; k++)
for (int j = -1; j <= 1; j++)
for (int i = -1; i <= 1; i++) {
vec3 cell = vec3(float(i), float(j), float(k));
vec3 pos = cell + fract(sin(dot(cell + id, vec3(37.0, 17.0, 29.0))) * 43758.5453);
d = min(d, length(pos - fract(p)));
float blisteredTurbulence(vec3 p) {
return abs(perlin(p) - 0.5) * 2.0;
return perlin(p * 2.0) - 0.5;
float cellNoise(vec3 p) {
return voronoi(p); // Using voronoi as cell noise
float displacedVoronoi(vec3 p) {
return voronoi(p + perlin(p * 0.5));
// FBM (Fractal Brownian Motion)
for (int i = 0; i < 5; i++) {
value += amplitude * perlin(p);
return perlin(p) * perlin(p * 0.5);
return fract(perlin(p) * 10.0);
return fract(perlin(p * 0.5) * 5.0);
return 1.0 - abs(perlin(p));
return step(0.5, perlin(p));
float randomNoise(vec3 p) {
return fract(sin(dot(p, vec3(12.9898, 78.233, 45.164))) * 43758.5453);
return perlin(p) * step(0.5, fract(p.x * p.y));
float turbulence(vec3 p) {
return abs(perlin(p * 2.0));
float wavyTurbulence(vec3 p) {
return sin(perlin(p) * 3.14);
float applyContrast(float color, float contrast) {
return (color - 0.5) * max(contrast, 0.0) + 0.5;
float applyBrightness(float color, float brightness) {
return color + brightness;
vec2 uv = gl_FragCoord.xy / iResolution.xy;
vec3 p = vec3(uv * frequency * scale, time * speed); // Adding z-axis using time
} else if (noiseType == 1) {
} else if (noiseType == 2) {
} else if (noiseType == 3) {
} else if (noiseType == 4) {
} else if (noiseType == 5) {
n = blisteredTurbulence(p);
} else if (noiseType == 6) {
} else if (noiseType == 7) {
} else if (noiseType == 8) {
} else if (noiseType == 9) {
} else if (noiseType == 10) {
} else if (noiseType == 11) {
} else if (noiseType == 12) {
} else if (noiseType == 13) {
} else if (noiseType == 14) {
} else if (noiseType == 15) {
} else if (noiseType == 16) {
} else if (noiseType == 17) {
} else if (noiseType == 18) {
} else if (noiseType == 19) {
n = clamp(n, lowClip, highClip);
// Apply brightness and contrast
n = applyContrast(n, contrast);
n = applyBrightness(n, brightness);
fragColor = vec4(vec3(n), 1.0);