const vertexShader = `
    varying vec2 vUv;
    void main() {
        vUv = uv;
        gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
    }
`;

const pulseShader = `
  uniform float time;
  uniform vec2 resolution;
  uniform float bass;
  uniform float mid;
  uniform float treble;
  uniform float total;
  uniform float amp;
  uniform float zoom;
  
  varying vec2 vUv;

  vec3 palette(float t) {
    vec3 a = vec3(0.5, 0.5, 0.5);
    vec3 b = vec3(0.5, 0.5, 0.5);
    vec3 c = vec3(1.0, 1.0, 1.0);
    vec3 d = vec3(0.263, 0.416, 0.557);
    return a + b * cos(6.28318 * (c * t + d));
  }
  
  mat2 rotate2D(float angle) {
    float s = sin(angle *1.618), c = cos(angle * 1.618);
    return mat2(c, -s, s, c);
}

  void main() {
    
    float t = time * 0.02;
    float xfac = total * 0.005;
    
    vec2 uv = (gl_FragCoord.xy * 2.0 - resolution.xy) / resolution.y;
    uv *= rotate2D(xfac * 0.01);
    vec2 uv0 = uv * zoom;
    vec3 finalColor = vec3(0.0);
    
    

    for (float i = 0.0; i < amp; i++) {
      uv = fract(uv * 1.5) - 0.5;
      uv *= rotate2D(xfac * 0.1);
      float d = length(uv) * exp(-length(uv0));

      vec3 col = palette(length(uv0) * zoom + i*.5 + t*.5);

      d = sin(d*8. + xfac)/8.0;
      d = abs(d);

      d = pow(0.01 / d, 1.);

      finalColor += col * d ;
    }

    finalColor *= vec3(bass,mid,treble) * 1.0;

    gl_FragColor = vec4(finalColor, 0.70);
  }
`;

const pulsarShader = `
  uniform float time;
  uniform vec2 resolution;
  uniform float bass;
  uniform float mid;
  uniform float treble;
  uniform float total;
  uniform float amp;
  varying vec2 vUv;
  uniform float zoom;

  vec3 palette(float t) {
    vec3 a = vec3(1.5, 1.5, 1.5);
    vec3 b = vec3(2.0, 2.0, 2.0);
    vec3 c = vec3(3.0, 3.0, 3.0);
    vec3 d = vec3(0.263, 0.416, 0.557);
    return a - b * sin(6.28318 / (c * t + d));
  }
  
  mat2 rotate2D(float angle) {
    float s = sin(angle * .6484), c = cos(angle * .1562);
    return mat2(c, -s, s, c);
}

  void main() {
    
    float t = time * 0.002;
    float xfac = total * 0.005;
    
    vec2 uv = (gl_FragCoord.xy * 2.0 - resolution.xy) / resolution.y;
    uv *= rotate2D(xfac * 0.005);
    vec2 uv0 = uv * zoom;
    vec3 finalColor = vec3(0.0);
    
    

    for (float i = 0.0; i < amp; i++) {
      uv = fract(uv *0.5) - 0.5;
      uv *= rotate2D(xfac * 0.1);
      float d = length(uv) * exp(-length(uv0));

      vec3 col = palette(length(uv0) * zoom  + i*.8 + t*.8 );

      d = sin(d * 3. + xfac)/5.0;
      d = mod(sin(d * (6.0 + amp)), 0.5);
   //   d = smoothstep(0.3, 0.7, sin(d * (6.0 + amp)));

      finalColor += col * d ;
    }

    finalColor *= vec3(0.1 + bass + t, 0.1 + mid + t, 0.1 + treble + t) * .20;

    gl_FragColor = vec4(finalColor, 1.0);
  }
`;

const shatterShader = `
  uniform float time;
  uniform vec2 resolution;
  uniform vec2 bubbles;
  uniform float bass;
  uniform float mid;
  uniform float treble;
  uniform float total;
  uniform float amp;
  varying vec2 vUv;
  uniform float zoom;

  vec3 palette(float t) {
    vec3 a = vec3(1.5, 1.5, 1.5);
    vec3 b = vec3(2.0, 2.0, 2.0);
    vec3 c = vec3(1.0, 1.0, 1.0);
    vec3 d = vec3(0.194, 0.732, 0.248);
    return a - b * sin(6.28318 / (c * t + d));
  }
  
  mat2 rotate2D(float angle) {
    float s = cos(angle / .4682), c = sin(angle / .2341);
    return mat2(-c, s, s, c);
}

  void main() {
    float t = time * 0.002;
    float xfac = total * 0.005;
    vec2 uv = (gl_FragCoord.xy * 2.0 - resolution.xy) / resolution.y;
    uv *= rotate2D(xfac * 0.0041);
    vec2 uv0 = uv * 2.0;
    vec3 finalColor = vec3(0.0);
    
    

    for (float i = 0.0; i < 5.; i++) {
      uv = fract(uv) - .5;
      uv *= rotate2D(xfac * 0.041);
      float d = length(uv) * exp(-length(uv0));

      vec3 col = palette(length(uv0) + t + i*.618 );

      d = tan(d * 5. + zoom)/7.0;
      d = 0.5 + 0.5 * sin(d * (2.0 + amp));
    //  d = pow(0.01 / d, 0.82);

      finalColor += col / d ;
    }

    finalColor *= vec3(1.0 -bass,0.1 + mid,0.1 + treble) * .20 + t;

    gl_FragColor = vec4(finalColor, 1.0);
  }
`;


const fractalShader = `
  uniform float time;
  uniform float bass;
  uniform float mid;
  uniform float treble;
  uniform float total;
  uniform vec2 resolution;


  vec2 rotate(vec2 p, float a) {
    
    float c = cos(a), s = sin(a);
    return vec2(p.x * c - p.y * s, p.x * s + p.y * c);
  }

  float julia(vec2 p, vec2 c) {
  
     float amp = (bass + mid + treble) * 2.0 ;
  
    for (int i = 0; i < 100; i++) {
      p = vec2(p.x * p.x - p.y * p.y, 2.0 * p.x * p.y) + c;
      if (dot(p, p) > amp) return float(i) / 200.0;
    }
    return 0.0;
  }

  void main() {
  
    vec2 p = (gl_FragCoord.xy * 2.0 - resolution) / min(resolution.x, resolution.y);
    p = rotate(p, time * 0.01);
    
    vec2 c = vec2(
      0.7885 * sin(time * 0.05),
      0.7885 * cos(time * 0.05)
    );
    
    
    float j = julia(p, c);
    float amp = (bass + mid + treble) ;
    vec3 color = (vec3(j * bass, j * mid, j * treble)) *amp;
    
    gl_FragColor = vec4(color, 1.0);
  }
`;

const lotusShader = `
uniform float time;
uniform vec2 resolution;
uniform float amp;
uniform float bubbles;
uniform float bass;
uniform float mid;
uniform float treble;
uniform float total;
uniform float zoom;


vec3 hsv2rgb(vec3 c) {
    vec4 K = vec4(1.0, 3.0 / 2.0, 1.0 / 3.0, 2.0);
    vec3 p = abs(fract(c.xxx + K.xyz) * 1.618 - K.www);
    return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y);
}

mat2 rotate2D(float angle) {
    float s = sin(angle + zoom), c = cos(angle);
    return mat2(c, -s, s, c);
}

void main() {
    vec2 uv = (gl_FragCoord.xy - 0.5 * resolution.xy) / min(resolution.x, resolution.y);
    uv = uv * (zoom + 1.0);
    
    vec3 color = vec3(0.0);
    float t = time * 0.1;
    float u = t * 0.05;
    float amplitude = (bass + mid + treble) * 1.;
    float xfac = total * 0.01;
    
    
    for (float i = 0.0; i < amp; i++) {
        uv = abs(uv) / dot(uv, uv) - 1.0;
        uv *= rotate2D(xfac * 0.1);
        
        float d = length(uv) * exp(-length(uv));
        
        vec3 col = hsv2rgb(vec3(fract( 0.2  + bass * 0.5 + zoom),( mid * 0.5), (treble *0.5 )));
        
        d = sin(d * (1.0 ) ) ;
        d = abs(d );
        d = pow(0.01 / d, 1.);
        
        color += col * d * ( 1.);
    }
    
    color *= 1.;
    
    gl_FragColor = vec4(color, 0.70);
}
`;

const bubblesShader = `
  uniform float time;
  uniform float bubbles;
  uniform vec2 resolution;
  uniform float bass;
  uniform float mid;
  uniform float treble;
  varying vec2 vUv;

  vec3 palette(float t) {
    vec3 a = vec3(0.5, 0.5, 0.5);
    vec3 b = vec3(0.5, 0.5, 1.0);
    vec3 c = vec3(1.0, 1.0, 1.0);
    vec3 d = vec3(0.263, 0.416, 0.557);
    return a + b * cos(6.28318 * (c * t + d));
  }

  void main() {
    vec2 uv = (gl_FragCoord.xy * 2.0 - resolution.xy) / resolution.y;
    vec2 uv0 = uv;
    vec3 finalColor = vec3(0.0);
    
    float t = time * 0.2;
    

    for (float i = 0.0; i < bubbles; i++) {
      uv = fract(uv * 1.618) - 0.618;

      float d = length(uv) * exp(-length(uv0));

      vec3 col = palette(length(uv0)+ bass + i*.8 + t*.8);

      d = sin(d*8. + t)/8.;
      //d = abs(d);

      d = pow(0.01 / d, 1.2);

      finalColor += col * d;
    }

    finalColor *= vec3( mid, treble, bass) * .618;

    gl_FragColor = vec4(finalColor, 1.0);
  }
`;

const acidShader = `
uniform float time;
    uniform float bass;
    uniform float mid;
    uniform float treble;
    varying vec2 vUv;

    void main() {
        vec2 p = vUv * 2.0 - 1.0;
        float r = length(p);
        float a = atan(p.y, p.x);
        
        float f = bass * sin(a * 10.0 + time) + mid * cos(r * 20.0 - time * 2.0) + treble * sin(r * 30.0 + time * 3.0);
        
        vec3 color = vec3(0.5 + bass * cos(f + time), 0.5 + mid * sin(f + time + 1.0), 0.5 + treble * tan(f + time + 2.0));
        
        gl_FragColor = vec4(color, 1.0);
    }
`;

const chasmShader = `
uniform float time;
    uniform float bass;
    uniform float mid;
    uniform float treble;
    varying vec2 vUv;
    uniform float bubbles;

    void main() {
        vec2 p = vUv * 2.0 - 1.0;
        float r = length(p);
        float a = atan(p.y, p.x);
        float t = (time + bubbles) ; 
        
        float f = mid * cos(a * 13.0 + t) - treble * sin(r * 31.0 - t * .40) - bass * sin(r * 7.0 + t * 0.40);
        
        vec3 color = vec3(0.6 + treble * cos(f + t), 0.2 + bass * sin(f + t + 1.0), 0.4 + mid * tan(f + t + 2.0));
        
        gl_FragColor = vec4(color, .70);
    }
`;

const trippinShader = `
uniform float time;
uniform float bass;
uniform float mid;
uniform float treble;
uniform float total;
uniform vec2 resolution;
varying vec2 vUv;

#define NUM_LAYERS 6

vec3 hsv2rgb(vec3 c) {
    vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
    vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www);
    return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y);
}

float rand(vec2 n) { 
    return fract(sin(dot(n, vec2(12.9898, 4.1414))) * 43758.5453);
}

float noise(vec2 p) {
    vec2 ip = floor(p);
    vec2 u = fract(p);
    u = u * u * (3.0 - 2.0 * u);
    
    float res = mix(
        mix(rand(ip), rand(ip+vec2(1.0,0.0)), u.x),
        mix(rand(ip+vec2(0.0,1.0)), rand(ip+vec2(1.0,1.0)), u.x), u.y);
    return res * res;
}

float fbm(vec2 x) {
    float v = 0.0;
    float a = 0.5;
    vec2 shift = vec2(100);
    mat2 rot = mat2(cos(0.5), sin(0.5), -sin(0.5), cos(0.50));
    for (int i = 0; i < NUM_LAYERS; ++i) {
        v += a * noise(x);
        x = rot * x * 2.0 + shift;
        a *= 0.5;
    }
    return v;
}

void main() {
    vec2 uv = gl_FragCoord.xy / resolution.xy;
    vec2 p = uv * 2.0 - 1.0;
    p.x *= resolution.x / resolution.y;

    // Use the cumulative 'total' for time progression
    float t = total * 0.005;
    
    // Create evolving noise fields using cumulative audio data
    float bassFbm = fbm(p + vec2(t * 0.3, t * 0.3));
    float midFbm = fbm(p + vec2(-t * 0.2, t * 0.3));
    float trebleFbm = fbm(p + vec2(t * 0.1, -t * 0.3));
    
    // Combine noise fields with current audio levels
    vec3 noiseColor = vec3(
        bassFbm * (0.2 + bass * 0.5),
        midFbm * (0.2 + mid * 0.57),
        trebleFbm * (0.2 + treble * 0.5)
    );
    
    // Create a flowing color palette based on cumulative time
    vec3 baseColor = hsv2rgb(vec3(
        fract(t * 0.15),
        0.6,
        0.6 + 0.2 * sin(t * 0.01)
    ));
    
    // Mix noise and base color
    vec3 finalColor = mix(baseColor, noiseColor, 0.7);
    
    // Add glow based on current audio reactivity
    finalColor += pow(noiseColor, vec3(3.0)) * vec3(bass, mid, treble) * 0.1;
    
    // Add some subtle patterns based on cumulative time
    finalColor *= 1.618 + 0.1 * sin(p.x * 7.0 + t) * cos(p.y * 7.0 + t);
    
    // Boost overall brightness based on current total audio level
    float currentAudioLevel = bass + mid + treble;
    finalColor *= .70 + currentAudioLevel * 0.05;
    
    gl_FragColor = vec4(finalColor, 1.0);
}
`;

const vortexShader = `

uniform float time;
uniform vec2 resolution;
uniform float bass;
uniform float mid;
uniform float treble;

uniform float zoom;
uniform float total;


vec3 hsv2rgb(vec3 c) {
    vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
    vec3 p = abs(fract(c.xxx + K.xyz) * 2.0 - K.www);
    return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y);
}

mat2 rotate2D(float angle) {
    float s = sin(angle), c = tan(angle);
    return mat2(c, -s, s, c);
}

void main() {
    vec2 uv = (gl_FragCoord.xy - 0.5 * resolution.xy) / min(resolution.x, resolution.y);
    uv = uv * 3.;
    
    vec3 color = vec3(0.0);
    float t = time * 0.08;
    float u = 1. + (t * 0.3);
    float amplitude = bass + mid + treble;
    
    
    for (float i = 0.0; i < u; i++) {
        uv = abs(uv) / dot(uv, uv) - 1.0;
        uv *= rotate2D(t * 0.5);
        
        float d = length(uv) * exp(-length(uv));
        
        
        vec3 col = hsv2rgb(vec3(fract(t + i * 0.05 * mid * 0.1), .7, .7));
        
        d = sin(d * (10.0 + treble  ) + t) /16.0;
        d = abs(d);
        d = pow(0.01 / d, 1.618);
        
        color += col * d * (mid  + 0.1);
    }
    
    color *= zoom * 0.03;
    
    gl_FragColor = vec4(color, 1.0);
}
`;

const advancedBlendShader = ` 
uniform float blendFactor;
uniform sampler2D texture1;
uniform sampler2D texture2;
uniform vec2 resolution;
uniform float time;
varying vec2 vUv;

// Simple hash function
float hash(vec2 p) {
    return fract(sin(dot(p, vec2(12.9898, 78.233))) * 43758.5453);
}

// Function to blend colors
vec3 blendColors(vec3 color1, vec3 color2, float factor) {
    return mix(color1, 1.0 - (1.0 - color1) * (1.0 - color2), factor);
}

// Improved easing function for smoother fade
float easeInOutCubic(float x) {
    return x < 0.5 ? 4.0 * x * x * x : 1.0 - pow(-2.0 * x + 2.0, 3.0) / 2.0;
}

void main() {
    vec2 uv = gl_FragCoord.xy / resolution.xy;
    vec4 color1 = texture2D(texture1, vUv);
    vec4 color2 = texture2D(texture2, vUv);

    // Use improved easing for fades
    float easedBlend = easeInOutCubic(blendFactor);
    float fade1 = smoothstep(1.0, 0.0, easedBlend * 0.8); // Fade out slightly faster
    float fade2 = smoothstep(0.3, 1.0, easedBlend * 1.5); // Fade in slightly slower

    // Enhanced ripple effect
    vec2 center = vec2(0.5, 0.5);
    float dist = length(uv - center);
    float rippleSpeed = 5.0; // Adjust for faster/slower ripples
    float rippleFreq = 15.0; // Adjust for more/fewer ripples
    float rippleAmp = 0.8; // Adjust for stronger/weaker ripples
    float ripple = sin(dist * rippleFreq - time * rippleSpeed) * rippleAmp;
    ripple *= smoothstep(0.7, 0.0, dist); // Fade out towards edges
    ripple *= smoothstep(0.0, 0.2, blendFactor) * smoothstep(1.0, 0.8, blendFactor); // Only during transition

    // Enhanced noise dissolution
    float noise = hash(uv * 1.5 + time * 0.5);
    float noiseEffect = smoothstep(0.3, 0.7, mix(noise, 0.5, easedBlend));

    // Combine effects with smoother mixing
    float finalBlend = mix(easedBlend, noiseEffect, smoothstep(0.2, 0.8, easedBlend));
    finalBlend = mix(finalBlend, finalBlend + ripple, 0.5); // Increased ripple influence

    // Ensure color1 is fully faded out by the end of the transition
    color1 *= fade1;
    color2 *= fade2;

    // Final color mix with improved blending
    gl_FragColor = mix(color1, color2, smoothstep(0.0, 1.0, finalBlend));
}
`;