<?php
   fn random(uv: vec2<f32>) -> f32 {
       return fract(sin(dot(uv, vec2<f32>(12.9898, 78.233))) * 43758.5453);
   }

<?php
   fn valueNoise(uv: vec2<f32>) -> f32 {
       let cell = floor(uv);
       let frac = fract(uv);
       let randomValues = vec2<f32>(random(cell), random(cell + vec2<f32>(1.0, 0.0)));
       return mix(randomValues.x, randomValues.y, frac.x);
   }

<?php
   fn gradientNoise(uv: vec2<f32>) -> f32 {
       let cell = floor(uv);
       let grad = fract(sin(vec2<f32>(dot(cell, vec2<f32>(127.1, 311.7)), dot(cell + vec2<f32>(1.0, 0.0), vec2<f32>(269.5, 183.3)))) * 43758.5453);
       return dot(grad, fract(uv));
   }

<?php
   fn whiteNoise(uv: vec2<f32>) -> f32 {
       return random(uv);
   }

<?php
   fn uniformNoise(uv: vec2<f32>) -> f32 {
       return step(0.5, random(uv));
   }

<?php
   fn blueNoise(uv: vec2<f32>) -> f32 {
       return smoothstep(0.2, 0.8, random(uv));
   }

<?php
   fn pinkNoise(uv: vec2<f32>) -> f32 {
       return pow(random(uv), 1.0 / 3.0);
   }

<?php
   fn gaussianNoise(uv: vec2<f32>) -> f32 {
       let rand1 = random(uv);
       let rand2 = random(uv + vec2<f32>(1.0, 1.0));
       return sqrt(-2.0 * log(rand1)) * cos(6.283185 * rand2);
   }

<?php
   fn fractalNoise(uv: vec2<f32>, octaves: i32) -> f32 {
       var value = 0.0;
       var frequency = 1.0;
       var amplitude = 1.0;
       for (var i: i32 = 0; i < octaves; i = i + 1) {
           value += fbm(uv * frequency) * amplitude;
           frequency *= 2.0;
           amplitude *= 0.5;
       }
       return value;
   }

<?php
    fn octaveNoise(uv: vec2<f32>, octaves: i32) -> f32 {
        var result = 0.0;
        for (var i: i32 = 0; i < octaves; i = i + 1) {
            result += fbm(uv * pow(2.0, f32(i))) / pow(2.0, f32(i));
        }
        return result;
    }

<?php
    fn fbm(uv: vec2<f32>) -> f32 {
        var value = 0.0;
        var frequency = 1.0;
        var amplitude = 0.5;
        for (var i: i32 = 0; i < 5; i = i + 1) {
            value += gradientNoise(uv * frequency) * amplitude;
            frequency *= 2.0;
            amplitude *= 0.5;
        }
        return value;
    }

<?php
    fn turbulence(uv: vec2<f32>) -> f32 {
        var value = 0.0;
        var frequency = 1.0;
        for (var i: i32 = 0; i < 5; i = i + 1) {
            value += abs(gradientNoise(uv * frequency));
            frequency *= 2.0;
        }
        return value;
    }

<?php
    fn layeredNoise(uv: vec2<f32>, layers: i32) -> f32 {
        var result = 0.0;
        for (var i: i32 = 0; i < layers; i = i + 1) {
            result += gradientNoise(uv * pow(2.0, f32(i))) / pow(2.0, f32(i));
        }
        return result;
    }

<?php
    fn perlinNoise(uv: vec2<f32>) -> f32 {
        let cell = floor(uv);
        let grad = fract(sin(vec2<f32>(dot(cell, vec2<f32>(127.1, 311.7)), dot(cell + vec2<f32>(1.0, 0.0), vec2<f32>(269.5, 183.3)))) * 43758.5453);
        return dot(grad, fract(uv));
    }

<?php
    fn fractalCellularNoise(uv: vec2<f32>, layers: i32) -> f32 {
        var result = 0.0;
        for (var i: i32 = 0; i < layers; i = i + 1) {
            result += voronoiNoise(uv * pow(2.0, f32(i))) / pow(2.0, f32(i));
        }
        return result;
    }

<?php
    fn noiseBlending(uv: vec2<f32>, weight: f32) -> f32 {
        return mix(gradientNoise(uv), voronoiNoise(uv), weight);
    }

<?php
    fn domainWarping(uv: vec2<f32>) -> f32 {
        let warp = fbm(uv);
        return fbm(uv + warp);
    }

<?php
    fn flowNoise(uv: vec2<f32>, time: f32) -> f32 {
        let warpedUV = uv + vec2<f32>(sin(time), cos(time));
        return fbm(warpedUV);
    }

<?php
    fn anisotropicNoise(uv: vec2<f32>, direction: vec2<f32>) -> f32 {
        let stretchUV = uv * direction;
        return gradientNoise(stretchUV);
    }

<?php
    fn gradientSquaredNoise(uv: vec2<f32>) -> f32 {
        let grad = gradientNoise(uv);
        return grad * grad;
    }

<?php
    fn angularGradientNoise(uv: vec2<f32>) -> f32 {
        let angle = atan2(uv.y, uv.x) * 0.5 / 3.14159;
        return abs(fract(angle) - 0.5);
    }

<?php
    fn spiralNoise(uv: vec2<f32>, twists: f32) -> f32 {
        let angle = atan2(uv.y, uv.x);
        return abs(sin(angle * twists + length(uv)));
    }

<?php
    fn stripeNoise(uv: vec2<f32>, frequency: f32) -> f32 {
        return abs(sin(uv.x * frequency));
    }

<?php
    fn stripeGradientNoise(uv: vec2<f32>, frequency: f32, minValue: f32, maxValue: f32) -> f32 {
        return mix(minValue, maxValue, abs(sin(uv.x * frequency)));
    }

<?php
    fn directionalVoronoi(uv: vec2<f32>, direction: vec2<f32>) -> f32 {
        let dirUV = uv + direction;
        return voronoiNoise(dirUV);
    }

<?php
    fn voronoiNoise(uv: vec2<f32>) -> f32 {
        let cell = floor(uv);
        let frac = fract(uv);
        
        var minDist = 1.0;
    
        for (var y: i32 = -1; y <= 1; y = y + 1) {
            for (var x: i32 = -1; x <= 1; x = x + 1) {
                let neighbor = cell + vec2<f32>(f32(x), f32(y));
                let point = neighbor + random(neighbor);
                let dist = length(frac - (point - cell));
                minDist = min(minDist, dist);
            }
        }
    
        return minDist;
    }

<?php
    fn worleyNoise(uv: vec2<f32>) -> f32 {
        var minDist: f32 = 1e9;
        var featurePoint: vec2<f32>;
        
        // Generate feature points and calculate distance
        for (var i: i32 = -1; i <= 1; i = i + 1) {
            for (var j: i32 = -1; j <= 1; j = j + 1) {
                featurePoint = floor(uv) + vec2<f32>(f32(i), f32(j)) + fract(sin(vec2<f32>(dot(floor(uv) + vec2<f32>(f32(i), f32(j)), vec2<f32>(12.9898, 78.233))) * 43758.5453));
                var dist: f32 = length(uv - featurePoint);
                if (dist < minDist) {
                    minDist = dist;
                }
            }
        }
        return minDist;
    }

<?php
    fn cellularNoise(uv: vec2<f32>) -> f32 {
        return worleyNoise(uv) - voronoiNoise(uv); // or another combination of functions
    }

<?php
    fn fractalVoronoi(uv: vec2<f32>, octaves: i32) -> f32 {
        var result = 0.0;
        for (var i: i32 = 0; i < octaves; i = i + 1) {
            result += voronoiNoise(uv * pow(2.0, f32(i))) / pow(2.0, f32(i));
        }
        return result;
    }

<?php
    fn spiralVoronoi(uv: vec2<f32>, twists: f32) -> f32 {
        return voronoiNoise(uv + vec2<f32>(sin(twists), cos(twists)));
    }

<?php
    fn noisyVoronoi(uv: vec2<f32>) -> f32 {
        return voronoiNoise(uv) * random(uv);
    }

<?php
    fn ringNoise(uv: vec2<f32>) -> f32 {
        return abs(sin(length(uv) * 10.0));
    }

<?php
    fn radialNoise(uv: vec2<f32>) -> f32 {
        return fract(length(uv) * 5.0);
    }

<?php
    fn rippleNoise(uv: vec2<f32>) -> f32 {
        return sin(length(uv) * 10.0) * 0.5 + 0.5;
    }

<?php
    fn polygonalGridNoise(uv: vec2<f32>, sides: f32) -> f32 {
        let angle = atan2(uv.y, uv.x) + 3.14159;
        let segment = floor(angle / (6.28318 / sides));
        return fract(segment + random(uv));
    }

<?php
    fn crosshatchNoise(uv: vec2<f32>, frequency: f32) -> f32 {
        let lineX = step(0.5, sin(uv.x * frequency) * 0.5 + 0.5);
        let lineY = step(0.5, sin(uv.y * frequency) * 0.5 + 0.5);
        return lineX * lineY;
    }

<?php
    fn starburstNoise(uv: vec2<f32>) -> f32 {
        return abs(sin(atan2(uv.y, uv.x) * 10.0));
    }

<?php
    fn circularWaveNoise(uv: vec2<f32>, time: f32) -> f32 {
        return sin(length(uv) * 10.0 - time);
    }

<?php
    fn spiralGradientNoise(uv: vec2<f32>, frequency: f32, amplitude: f32) -> f32 {
        let angle = atan2(uv.y, uv.x);
        let dist = length(uv);
    
        // Create a spiral pattern with frequency and amplitude controls
        let spiral = sin(angle * frequency + dist * amplitude);
        
        // Blend the spiral pattern with noise
        let noise = random(uv);
        
        // Fade the effect based on distance
        let fade = smoothstep(0.0, 1.0, dist);
    
        // Combine the spiral and noise with the fade
        return mix(noise, spiral, fade);
    }

<?php
    fn plasmaNoise(uvin: vec2<f32>) -> f32 {
        var scale:f32 = 0.1;
        var time: f32 = 0.5;
        var uv = uvin*scale;
        let layer1 = sin(uv.x * 10.0 + time) * cos(uv.y * 10.0 + time);
        let layer2 = sin(uv.x * 20.0 + uv.y * 20.0 + time * 2.0) * 0.5;
        let layer3 = cos(uv.x * 40.0 - uv.y * 40.0 + time * 4.0) * 0.25;
        
        let noise = layer1 + layer2 + layer3;
        
        return noise * 0.5 + 0.5; // Normalize to range [0, 1]
    }

<?php
    fn interferenceNoise(uv: vec2<f32>) -> f32 {
        return sin(uv.x * 5.0) + cos(uv.y * 5.0);
    }

<?php
    fn checkerboardNoise(uv: vec2<f32>) -> f32 {
        let check = floor(uv.x) + floor(uv.y);
        return fract(sin(check) * 43758.5453);
    }

<?php
    fn hexagonalNoise(uv: vec2<f32>) -> f32 {
        // Constants to define hexagonal grid
        let k = vec2<f32>( sqrt(3.0), 1.0);
        
        // Transform UV coordinates to hexagonal grid space
        let uv_hex = vec2<f32>(
            uv.x * k.x + uv.y * k.y,
            uv.y * k.x - uv.x * k.y
        );
    
        // Calculate hexagonal cell coordinates
        let cell = floor(uv_hex);
        let f = fract(uv_hex);
        
        // Calculate noise values for the corners of the hexagon
        let corners = array<vec2<f32>, 6>(
            vec2<f32>(0.0, 0.0),
            vec2<f32>(1.0, 0.0),
            vec2<f32>(0.5, 0.866),
            vec2<f32>(-0.5, 0.866),
            vec2<f32>(-1.0, 0.0),
            vec2<f32>(-0.5, -0.866)
        );
    
        var noise_value: f32 = 0.0;
        var min_distance: f32 = 1e10;
    
        for (var i: u32 = 0u; i < 6u; i = i + 1u) {
            let corner = cell + corners[i];
            let dist = distance(uv_hex, corner);
            
            if (dist < min_distance) {
                min_distance = dist;
                noise_value = fract(sin(dot(corner, vec2<f32>(12.9898, 78.233))) * 43758.5453);
            }
        }
    
        return noise_value;
    }

<?php
    fn offsetNoise(uv: vec2<f32>, time: f32) -> f32 {
        return random(uv + time);
    }

<?php
    fn warpedNoise(uv: vec2<f32>, time: f32) -> f32 {
        let warpedUV = uv + sin(time + uv) * 0.5;
        return random(warpedUV);
    }

<?php
    fn seamlessNoise(uv: vec2<f32>) -> f32 {
        let repeatUV = fract(uv);
        return random(repeatUV);
    }

<?php
    fn textureDistortionNoise(uv: vec2<f32>, time: f32) -> f32 {
        let distortedUV = uv + sin(uv + time) * 0.1;
        return random(distortedUV);
    }

<?php
    fn dynamicNoise(uv: vec2<f32>, time: f32) -> f32 {
        let dynamicUV = uv + time * 0.1;
        return random(dynamicUV);
    }

<?php
    fn timeVaryingVoronoi(uv: vec2<f32>, time: f32) -> f32 {
        let timeShiftedUV = uv + time * 0.1;
        return voronoiNoise(timeShiftedUV);
    }

<?php
    fn animatedGradientNoise(uv: vec2<f32>, time: f32) -> f32 {
        let angle = time + atan2(uv.y, uv.x);
        let gradient = vec2<f32>(cos(angle), sin(angle));
        return dot(uv, gradient);
    }

<?php
    fn tileableNoise(uv: vec2<f32>) -> f32 {
        return random(fract(uv));
    }

<?php
    fn gradientRidgeNoise(uv: vec2<f32>) -> f32 {
        let gradient = gradientNoise(uv);
        return abs(gradient) * 2.0 - 1.0;
    }

<?php
    fn multiscaleNoise(uv: vec2<f32>, scales: i32) -> f32 {
        var result = 0.0;
        for (var i: i32 = 0; i < scales; i = i + 1) {
            result += random(uv * pow(2.0, f32(i))) / pow(2.0, f32(i));
        }
        return result;
    }

<?php
    fn spectralNoise(uv: vec2<f32>, frequency: f32) -> f32 {
        return random(uv * frequency);
    }

<?php
    fn blobNoise(uv: vec2<f32>, size: f32) -> f32 {
        var minDist: f32 = 0.0; // Initialize with a large value
        
        for (var y: i32 = -1; y <= 1; y = y + 1) {
            for (var x: i32 = -1; x <= 1; x = x + 1) {
                let neighbor = vec2<f32>(f32(x), f32(y));
                let point = floor(uv) + neighbor + random(floor(uv) + neighbor);
                let dist = length(uv - point) * 2.0;
                if ( dist < 1.5 && minDist==0.0)
                {
                    minDist = 8.0;
                }
                minDist = min(minDist, dist) ;
            }
        }
    
        return exp(-minDist / size);
    }

<?php
    fn pointClusterNoise(uv: vec2<f32>) -> f32 {
        return step(0.5, random(uv));
    }

<?php
    fn crystalNoise(uv: vec2<f32>) -> f32 {
        var minDist: f32 = 1.0; // Initialize with a large value
        var facet: vec2<f32> = vec2<f32>(0.0, 0.0);
    
        for (var y: i32 = -1; y <= 1; y = y + 1) {
            for (var x: i32 = -1; x <= 1; x = x + 1) {
                let neighbor = vec2<f32>(f32(x), f32(y));
                let point = floor(uv) + neighbor + random(floor(uv) + neighbor);
                let dist = length(uv - point);
                
                if (dist < minDist) {
                    minDist = dist;
                    facet = point;
                }
            }
        }
    
        let angle = atan2(uv.y - facet.y, uv.x - facet.x);
        return abs(sin(angle * 10.0));
    }

<?php
    fn waveletNoise(uv: vec2<f32>, scale: f32) -> f32 {
        let noise = sin(uv.x * scale + random(uv) * scale) * cos(uv.y * scale + random(uv.yx) * scale);
        return abs(noise);
    }

<?php
    fn ridgedFBM(uv: vec2<f32>, octaves: i32) -> f32 {
        var result = 0.0;
        var amplitude = 1.0;
        for (var i: i32 = 0; i < octaves; i = i + 1) {
            result += amplitude * (1.0 - abs(fbm(uv * pow(2.0, f32(i))))) / pow(2.0, f32(i));
            amplitude *= 0.5;
        }
        return result;
    }

<?php
    fn sparseConvolutionNoise(uv: vec2<f32>) -> f32 {
        var scale: f32 = 2.0;
        var total: f32 = 0.0;
        var weight: f32 = 0.0;
    
        for (var y: i32 = -1; y <= 1; y = y + 1) {
            for (var x: i32 = -1; x <= 1; x = x + 1) {
                let neighbor = vec2<f32>(f32(x), f32(y));
                let offset = random(neighbor) * scale;
                let point = uv + neighbor + offset;
    
                let value = random(point);
                let dist = length(neighbor);
                let influence = 1.0 / (1.0 + dist);
                
                total += value * influence;
                weight += influence;
            }
        }
    
        return total / weight;
    }