float random (vec2 uv) {
    return fract(sin(dot(uv, vec2(12.9898,78.233))) * 43758.5453123);
}

float simple_noise_value(vec2 uv) {
    vec2 i = floor(uv);
    vec2 f = fract(uv);
    f = f * f * (3.0 - 2.0 * f);

    vec2 c0 = i + vec2(0.0, 0.0);
    vec2 c1 = i + vec2(1.0, 0.0);
    vec2 c2 = i + vec2(0.0, 1.0);
    vec2 c3 = i + vec2(1.0, 1.0);
    float r0 = random(c0);
    float r1 = random(c1);
    float r2 = random(c2);
    float r3 = random(c3);

    float bottomOfGrid = mix(r0, r1, f.x);
    float topOfGrid = mix(r2, r3, f.x);
    return mix(bottomOfGrid, topOfGrid, f.y);
}

float simple_noise(vec2 uv) {
    float t = 0.0;
    for (int i = 0; i < 3; i++) {
        float freq = pow(2.0, float(i));
        float amp = pow(0.5, float(3 - i));
        t += simple_noise_value(uv / freq) * amp;
    }
    return t;
}

float white_noise(float x) {
    return fract(sin(x * 12.9898) * 43758.5453);
}

vec2 white_noise(vec2 x) {
    return fract(sin(x * vec2(12.9898, 78.233)) * 43758.5453);
}

vec3 white_noise(vec3 x) {
    return fract(sin(x * vec3(12.9898, 78.233, 45.164)) * 43758.5453);
}

float voronoi_noise(vec2 uv) {
    vec2 indexUV = floor(uv);
    vec2 fractUV = fract(uv);
    
    float minDist = 1.0;  
    
    for (int y = -1; y <= 1; y++) {
        for (int x = -1; x <= 1; x++) {
            vec2 neighbor = vec2(float(x), float(y));
            float rand = random(indexUV + neighbor);
            vec2 point = vec2(rand, rand);
            vec2 diff = neighbor + point - fractUV;
            float dist = length(diff);
            minDist = min(minDist, dist);
        }
    }
    
    return minDist;
}

vec4 perlin_noise_permute(vec4 x) {
    return mod((34.0 * x + 1.0) * x, 289.0);
}

vec2 perlin_noise_fade(vec2 t) {
    return t * t * t * (t * (t * 6.0 - 15.0) + 10.0);
}

float perlin_noise(vec2 P) {
    vec4 Pi = floor(P.xyxy) + vec4(0.0, 0.0, 1.0, 1.0);
    vec4 Pf = fract(P.xyxy) - vec4(0.0, 0.0, 1.0, 1.0);
    Pi = mod(Pi, 289.0);
    vec4 ix = Pi.xzxz;
    vec4 iy = Pi.yyww;
    vec4 fx = Pf.xzxz;
    vec4 fy = Pf.yyww;
    vec4 i = perlin_noise_permute(perlin_noise_permute(ix) + iy);
    vec4 gx = 2.0 * fract(i * 0.0243902) - 1.0;
    vec4 gy = abs(gx) - 0.5;
    vec4 tx = floor(gx + 0.5);
    gx = gx - tx;
    vec2 g00 = vec2(gx.x, gy.x);
    vec2 g10 = vec2(gx.y, gy.y);
    vec2 g01 = vec2(gx.z, gy.z);
    vec2 g11 = vec2(gx.w, gy.w);
    vec4 norm = 1.79284291400159 - 0.85373472095314 * vec4(dot(g00, g00), dot(g01, g01), dot(g10, g10), dot(g11, g11));
    g00 *= norm.x;
    g01 *= norm.y;
    g10 *= norm.z;
    g11 *= norm.w;
    float n00 = dot(g00, vec2(fx.x, fy.x));
    float n10 = dot(g10, vec2(fx.y, fy.y));
    float n01 = dot(g01, vec2(fx.z, fy.z));
    float n11 = dot(g11, vec2(fx.w, fy.w));
    vec2 fade_xy = perlin_noise_fade(Pf.xy);
    vec2 n_x = mix(vec2(n00, n01), vec2(n10, n11), fade_xy.x);
    float n_xy = mix(n_x.x, n_x.y, fade_xy.y);
    return 2.3 * n_xy * 0.5 + 0.5;
}

float turbulence_noise(vec2 uv, float octaves) {
    float result = 0.0;
    float frequency = 1.0;
    float amplitude = 0.5;
    int octaves_i = int(octaves);
    
    for (int i = 0; i < octaves_i; i++) {
        result += perlin_noise(uv * frequency) * amplitude;
        frequency *= 2.0;
        amplitude *= 0.5;
    }
    
    return result;
}