Untitled

precision mediump float;
uniform float iTime;
uniform vec2 iResolution;

float Pi = 6.28318530718; 

float Directions = 16.0;
float Quality = 3.0;
float Size = 64.0; 

vec2 Radius = Size/iResolution.xy;

float opSmoothUnion( float d1, float d2, float k ) {
    float h = clamp( 0.5 + 0.5*(d2-d1)/k, 0.0, 1.0 );
    return mix( d2, d1, h ) - k*h*(1.0-h);
}

float sdSphere( vec3 p, float s ) {
  return length(p) - s;
} 

float map(vec3 p) {
  float d = 2.0;
  for (int i = 0; i < 6; i++) {
    float fi = float(i);
    float time = iTime * (fract(fi * 412.531 + 0.513) - 0.5) * 0.6;
    d = opSmoothUnion(
        sdSphere(p + sin(time + fi * vec3(52.5126, 64.62744, 632.25)) * vec3(2.0, 2.0, 0.8), mix(0.5, 1.0, fract(fi * 412.531 + 0.5124))),
        d,
        0.4
    );
  }
  return d;
}

vec3 calcNormal( in vec3 p ) {
    const float h = 1e-5;
    const vec2 k = vec2(1,-1);
    return normalize( k.xyy*map( p + k.xyy*h ) + 
                      k.yyx*map( p + k.yyx*h ) + 
                      k.yxy*map( p + k.yxy*h ) + 
                      k.xxx*map( p + k.xxx*h ) );
}

vec4 renderMetaballs(vec2 fragCoord) {
    vec2 uv = fragCoord / iResolution.xy;
    vec3 rayOri = vec3((uv - 0.5) * vec2(iResolution.x / iResolution.y, 1.0) * 2.0, 1.5);
    vec3 rayDir = vec3(0.5, 0.2, -1.0);
    
    float depth = 0.0;
    vec3 p;
    
    for(int i = 0; i < 32; i++) {
        p = rayOri + rayDir * depth;
        float dist = map(p);
        depth += dist;
        if (dist < 1e-6) {
            break;
        }
    }
    
    depth = min(6.0, depth);
    vec3 n = calcNormal(p);
    float b = max(0.0, dot(n, vec3(0.577)));

    vec3 color = vec3(0.15, b * 1.0, 1.0);
    color *= exp(-depth * 0.3);

    return vec4(color, 1.0 - (depth - 0.5) / 2.0);
}

void mainImage(out vec4 fragColor, in vec2 fragCoord) {
    vec4 metaballs = renderMetaballs(fragCoord);
    
    vec4 blurredColor = vec4(0.0);
    
    // Blur calculations
    for(float d = 0.0; d < Pi; d += Pi / Directions) {
        for(float i = 1.0 / Quality; i <= 1.0; i += 1.0 / Quality) {
            vec2 offset = vec2(cos(d), sin(d)) * Radius * i;
            blurredColor += renderMetaballs(fragCoord + offset * iResolution.xy);
        }
    }
    
    blurredColor /= Quality * Directions - 15.0;
    
    fragColor = mix(metaballs, blurredColor, 0.5);
}

void main() {
    mainImage(gl_FragColor, gl_FragCoord.xy);
}