/*
 * Original shader from: https://www.shadertoy.com/view/wss3zB
 */


#ifdef GL_ES
precision highp float;
#endif

// glslsandbox uniforms
uniform float time;
uniform vec2 resolution;

// shadertoy globals
float iTime = 0.0;
vec3  iResolution = vec3(0.0);

// --------[ Original ShaderToy begins here ]---------- //
// Spiral Offset II - Del 06/01/2018
// watch fullscreen, params have been tweaked to overlap and never loop... :)
// keep watching... :)

#define TAU 6.283185

vec2 rot(vec2 v, float angle)
{
    float c = cos(angle);
    float s = sin(angle);
    return mat2(c, -s, s, c)*v;
}

// IQ UnevenCapsule distance func
float cro(in vec2 a, in vec2 b ) { return a.x*b.y - a.y*b.x; }
float sdUnevenCapsule( in vec2 p, in vec2 pa, in vec2 pb, in float ra, in float rb )
{
    p  -= pa;
    pb -= pa;
    float h = dot(pb,pb);
    vec2  q = vec2( dot(p,vec2(pb.y,-pb.x)), dot(p,pb) )/h;
    
    //-----------
    
    q.x = abs(q.x);
    
    float b = ra-rb;
    vec2  c = vec2(sqrt(h-b*b),b);
    
    float k = cro(c,q);
    float m = dot(c,q);
    float n = dot(q,q);
    
         if( k < 0.0 ) return sqrt(h*(n            )) - ra;
    else if( k > c.x ) return sqrt(h*(n+1.0-2.0*q.y)) - rb;
                       return m                       - ra;
}

float TimerInOut(vec4 v)
{
    return smoothstep(v.y,v.y+v.w,v.x) - smoothstep(v.z-v.w,v.z,v.x);
}
float Stime(float scale)
{
    return fract(iTime*scale)*TAU;
}
float Mtime(float mval)
{
    return mod(iTime,mval);
}

// Trippy spiral calc - Del 06/01/2018
vec2 spiral(vec2 uv,float zoom, float len, float offset,vec2 capoff, float trip, float scount)
{
    float d = length(uv) * zoom;
    d=log(d*trip);
    uv = rot(uv,sin(d*offset)+d*scount);
	float v = 1.0-sdUnevenCapsule(uv,vec2(0.0,0.0)+capoff,vec2(0.4*len,0.0)+capoff,0.0,0.4*len)*14.0;
    return vec2(v,d);	// dx , dy
}

vec2 directionalWaveNormal(vec2 p, float amp, vec2 dir, float freq, float speed, float time, float k)
{	
	float a = dot(p, dir) * freq + time * speed;
	float b = 0.5 * k * freq * amp * pow((sin(a) + 1.0) * 0.5, k) * cos(a);
	return vec2(dir.x * b, dir.y * b);
}

vec3 summedWaveNormal(vec2 p)
{
    float time = iTime;
	vec2 sum = vec2(0.0);
	sum += directionalWaveNormal(p, 0.5, normalize(vec2(1, 1)), 5.0, 1.5, time, 1.0);
	sum += directionalWaveNormal(p, 0.25,normalize(vec2(1.4, 1.0)), 11.0, 2.4, time, 1.5);
	sum += directionalWaveNormal(p, 0.125, normalize(vec2(-0.8, -1.0)), 10.0, 2.0, time, 2.0);
	sum += directionalWaveNormal(p, 0.0625, normalize(vec2(1.3, 1.0)), 15.0, 4.0, time, 2.2);
	sum += directionalWaveNormal(p, 0.03125, normalize(vec2(-1.7, -1.0)), 5.0, 1.8, time, 3.0);
	return normalize(vec3(-sum.x, -sum.y, 1.0));
}
vec3 background(vec2 p)
{
	vec3 normal = summedWaveNormal(p);
	vec3 c = mix(vec3(0.1, 0.15, 0.1), vec3(0.2, 0.25, 0.4),  dot(normal, normalize(vec3(0.2, 0.2, 0.5))) * 0.5 + 0.5);
	c = mix(c, vec3(0.7, 0.9, 1.0), pow(dot(normal, normalize(vec3(-0.4, 0.1, 1.0))) * 0.5 + 0.5, 2.0));
	c = mix(c, vec3(0.95, 0.98, 1.0), pow(dot(normal, normalize(vec3(-0.1, -0.3, 0.5))) * 0.5 + 0.5, 10.0));
    return clamp(c,0.0,1.0);
}

float Bub(vec2 uv,float scale)
{
    float time = iTime*0.75;
    uv.y-=time*2./scale;
    //uv.x += time*0.2;
    uv.x+=sin(uv.y+time*.95)*0.025;	///scale;
	uv*=scale;
    vec2 s=floor(uv);
    vec2 f=fract(uv);
    float k=3.0;
	vec2 p =.5+.35*sin(11.*fract(sin((s+scale)*mat2(7.0,3.0,6.0,5.0))*5.))-f;
    float d=length(p);
    k=min(d,k);
	k=smoothstep(0.0,k,sin(f.x+f.y)*0.01);
   	return k;
}

vec3 Bubbles(vec2 uv,float head,float d)
{
	float c = Bub(uv,30.)*.3;
	c+=Bub(uv,20.)*.5;
	c+=Bub(uv,15.)*.8;
	c+=Bub(uv,10.);
	c+=Bub(uv,8.);
	c+=Bub(uv,6.);
	c+=Bub(uv,5.);
    vec3 scol = vec3(clamp(c*0.3,0.0,0.3));
    return scol;
}

vec3 checks(vec2 p)
{
    //p*=1.0+(sin(p.y+p.x+Stime(0.25))*0.15);
    //float f = mod( floor(5.5*p.x) + floor(5.5*p.y), 2.0);
    //vec3 col = 0.05 + 0.1*f+0.2*vec3(0.1,0.1,0.1);
    //return col;
    
    float d = length(p);
    float head = 1.0-length(p);
    d+=(0.5+sin(iTime*2.0)*0.5)*0.25;
    p *= 0.25;
    return Bubbles(p*(d+0.5), head,d);
}

vec3 hsv2rgb_smooth( in vec3 c )
{
    vec3 rgb = clamp( abs(mod(c.x*6.0+vec3(0.0,4.0,2.0),6.0)-3.0)-1.0, 0.0, 1.0 );

	rgb = rgb*rgb*(3.0-2.0*rgb); // cubic smoothing	

	return c.z * mix( vec3(1.0), rgb, c.y);
}

void mainImage( out vec4 fragColor, in vec2 fragCoord )
{
    vec2 uv = (fragCoord.xy - 0.5 * iResolution.xy) / iResolution.y;

    // Create some blends over time...
    float t1 = TimerInOut(vec4(Mtime(9.6),1.0, 7.2, 1.8));
    float t2 = TimerInOut(vec4(Mtime(12.0),1.0, 9.0, 1.5));
    float t3 = TimerInOut(vec4(Mtime(21.0),6.0, 14.2, 2.8));
    float t4 = TimerInOut(vec4(Mtime(60.0),15.0,45.0,1.0));
    float t5 = TimerInOut(vec4(Mtime(85.0),57.0, 67.0, 3.1));
    float t6 = TimerInOut(vec4(Mtime(123.0),77.0,101.0,10.0));
    float t7 = TimerInOut(vec4(Mtime(50.0),28.0,45.0,3.5));
    float t8 = TimerInOut(vec4(Mtime(20.0),1.0,13.0,3.1));
    float t9 = TimerInOut(vec4(Mtime(200.0),100.0,199.0,0.5));
    float t10 = TimerInOut(vec4(Mtime(45.0),21.0,31.0,0.75));

    // various spiral modifiers applied over time
    float t = Stime(0.4);
    float offset = 25.0 * t1;
	float zoom = 1.0 + (sin(Stime(0.17))*0.5) * t2;
    vec2 capoff = vec2(sin(uv.y*4.0+Stime(0.125))*0.25, sin(uv.x*2.0+Stime(0.25))*0.75) * t3;
    float m = 0.48+sin(Stime(0.15)+uv.y+uv.x)*0.5;
    float trip = 1.0-(m*t4);
    float scmod = sin(Stime(0.176));
    float scount = 5.0+((3.0+(scmod*5.0))*t5);
    
    // debug... (disable effects)
    //scount = 5.0;
    //offset=0.0;
    //zoom = 1.0;
    //trip = 1.0;
    //capoff = vec2(0.0);
    
	vec2 dist = spiral(uv, zoom, t, offset, capoff, trip, scount);
	
    float distmod = 0.49+sin(dist.x*0.34+dist.y*1.6+sin(Stime(.1)))*0.5;
    dist.x = mix(dist.x, dist.x*distmod, t10);
	
	
	float v2 = smoothstep(0.5-0.1,0.5+0.1,dist.x);
	float v = mix(v2,clamp(dist.x,0.0,3.0), t6);
    //vec3 col = vec3(v*1.0-l/t);
    vec3 col1 = checks(uv);	////vec3(0.0,0.0,0.2);
    vec3 col2 = vec3(1.0,0.6,0.5);
    // rainbow flavour...
    col2 = mix(col2,hsv2rgb_smooth(vec3(fract(iTime*0.1)+dist.x*0.1,1.0,v)),t9);
	
    vec3 col3 = background(uv);	//vec3(0.5,0.7,0.5);
    col1 = mix(col1,col3*0.3, t7);
    col2 = mix(col2,col3, t8);
    vec3 col = mix(col1,col2,v*1.0-dist.y/t);

    // vignette
 	vec2 q = fragCoord/iResolution.xy;
    col *= 0.3 + 0.7*pow(16.0*q.x*q.y*(1.0-q.x)*(1.0-q.y),0.25);    
    
    fragColor = vec4(col, 1.0);
}
// --------[ Original ShaderToy ends here ]---------- //

void main(void)
{
    iTime = time;
    iResolution = vec3(resolution, 0.0);

    mainImage(gl_FragColor, gl_FragCoord.xy);
}