uniform float time;
uniform vec2 resolution;
uniform sampler2D texture_sampler;
uniform sampler2D texts;

float zoom = 1.;
float gTime = 0.;

int getBeat(void) {
    return floor(abs(time*4) / (60./133) );
}
int getBar(void) {
    return floor(abs(time) / (60./133));
}

vec2 csqr(vec2 a) {
    return vec2(a.x * a.x - a.y * a.y, 2. * a.x * a.y);
}

mat2 rot(float a) {
    return mat2(cos(a), sin(a), -sin(a), cos(a));
}

vec2 iSphere(in vec3 ro, in vec3 rd, in vec4 sph)//from iq
{
    vec3 oc = ro - sph.xyz;
    float b = dot(oc, rd);
    float c = dot(oc, oc) - sph.w * sph.w;
    float h = b * b - c;
    if(h < 0.0)
        return vec2(-1.0);
    h = sqrt(h);
    return vec2(-b - h, -b + h);
}

float map(in vec3 p) {

    float res = 0.;

    vec3 c = p;
    for(int i = 0; i < 10; ++i) {
        p = .7 * abs(p) / dot(p, p) - .7;
        p.yz = csqr(p.yz);
        p = p.zxy;
        res += exp(-19. * abs(dot(p, c)));

    }
    return res / 2.;
}

vec3 raymarch(in vec3 ro, vec3 rd, vec2 tminmax) {
    float t = tminmax.x;
    float dt = .02;
    //float dt = .2 - .195*cos(time*.05);//animated
    vec3 col = vec3(0.);
    float c = 0.;
    for(int i = 0; i < 64; i++) {
        t += dt * exp(-2. * c);
        if(t > tminmax.y)
            break;

        c = map(ro + t * rd);

        col = .99 * col + .08 * vec3(c * c, c, c * c * c);//green	
        //col = .99*col+ .08*vec3(c*c*c, c*c, c);//blue
    }
    return col;
}

void CoolSphere(out vec4 fragColor, in vec2 fragCoord) {
    float time = time;
    vec2 q = fragCoord.xy / resolution.xy;
    vec2 p = -1.0 + 2.0 * q;
    p.x *= resolution.x / resolution.y;
    vec2 m = vec2(0.);
    m -= .5;

    // camera

    vec3 ro = zoom * vec3(4.);
    ro.yz *= rot(m.y);
    ro.xz *= rot(m.x + 0.1 * time);
    vec3 ta = vec3(0.0, 0.0, 0.0);
    vec3 ww = normalize(ta - ro);
    vec3 uu = normalize(cross(ww, vec3(0.0, 1.0, 0.0)));
    vec3 vv = normalize(cross(uu, ww));
    vec3 rd = normalize(p.x * uu + p.y * vv + 4.0 * ww);

    vec2 tmm = iSphere(ro, rd, vec4(0., 0., 0., 2.));

	// raymarch
    vec3 col = raymarch(ro, rd, tmm);
    if(tmm.x < 0.)
        col = texture2D(texture_sampler, rd).rgb;
    else {
        vec3 nor = (ro + tmm.x * rd) / 2.;
        nor = reflect(rd, nor);
        float fre = pow(.5 + clamp(dot(nor, rd), 0.0, 1.0), 3.) * 1.3;
        col += texture2D(texture_sampler, nor).rgb * fre;

    }

	// shade

    col = .5 * (log(1. + col));
    col = clamp(col, 0., 1.);
    fragColor = vec4(col, 1.0);

}

float sdBox(vec3 p, vec3 b) {
    vec3 q = abs(p) - b;
    return length(max(q, 0.0)) + min(max(q.x, max(q.y, q.z)), 0.0);
}

float box(vec3 pos, float scale) {
    pos *= scale;
    float base = sdBox(pos, vec3(.4, .4, .1)) / 1.5;
    pos.xy *= 5.;
    pos.y -= 3.5;
    pos.xy *= rot(.75);
    float result = -base;
    return result;
}

float box_set(vec3 pos, float time) {
    vec3 pos_origin = pos;
    pos = pos_origin;
    pos.y += sin(gTime * 0.4) * 2.5;
    pos.xy *= rot(.8);
    float box1 = box(pos, 2. - abs(sin(gTime * 0.4)) * 1.5);
    pos = pos_origin;
    pos.y -= sin(gTime * 0.4) * 2.5;
    pos.xy *= rot(.8);
    float box2 = box(pos, 2. - abs(sin(gTime * 0.4)) * 1.5);
    pos = pos_origin;
    pos.x += sin(gTime * 0.4) * 2.5;
    pos.xy *= rot(.8);
    float box3 = box(pos, 2. - abs(sin(gTime * 0.4)) * 1.5);
    pos = pos_origin;
    pos.x -= sin(gTime * 0.4) * 2.5;
    pos.xy *= rot(.8);
    float box4 = box(pos, 2. - abs(sin(gTime * 0.4)) * 1.5);
    pos = pos_origin;
    pos.xy *= rot(.8);
    float box5 = box(pos, .5) * 6.;
    pos = pos_origin;
    float box6 = box(pos, .5) * 6.;
    float result = max(max(max(max(max(box1, box2), box3), box4), box5), box6);
    return result;
}

float map(vec3 pos, float time) {
    vec3 pos_origin = pos;
    float box_set1 = box_set(pos, time);

    return box_set1;
}

void mainImage2(out vec4 fragColor, in vec2 fragCoord) {
    vec2 p = (fragCoord.xy * 2. - resolution.xy) / min(resolution.x, resolution.y);
    vec3 ro = vec3(0., -0.2, time * 4.);
    vec3 ray = normalize(vec3(p, 1.5));
    ray.xy = ray.xy * rot(sin(time * .03) * 5.);
    ray.yz = ray.yz * rot(sin(time * .05) * .2);
    float t = 0.1;
    vec3 col = vec3(0.);
    float ac = 0.0;

    for(int i = 0; i < 99; i++) {
        vec3 pos = ro + ray * t;
        pos = mod(pos - 2., 4.) - 2.;
        gTime = time - float(i) * 0.01;

        float d = map(pos, time);

        d = max(abs(d), 0.01);
        ac += exp(-d * 23.);

        t += d * 0.55;
    }

    col = vec3(ac * 0.02);

    col += vec3(0., 0.2 * abs(sin(time)), 0.5 + sin(time) * 0.2);

    fragColor = vec4(col, 1.0 - t * (0.02 + 0.02 * sin(time)));
}

vec3 palette(float t)  {
 vec3 a = vec3(0.5, 0.5, 0.5);
 vec3 b = vec3(1.0, 1.0, 1.0);
 vec3 c = vec3(1.0, 1.0, 1.0);
 vec3 d = vec3(0.0, 0.6666, 0.3333);
 return a + b * cos(6.28318 * (c*t+d));
}
 
float rand(vec2 co) {
    float a = 12.9898;
     float b = 78.233;
     float c = 43758.5453;
     float dt= dot(co.xy ,vec2(a,b));
     float sn= mod(dt,3.14);
    return fract(sin(sn) * c);
}

vec3 random(vec2 coord) {    
    float rng = rand(vec2(coord.x+time, coord.y));
    return vec3(0.05, 0.05, 0.05) * rng;
    
}


vec3 wave(vec2 uv, float phase, float _offset, float height, float waveLenght, float color) {   
    float val = -(sin(phase+uv.x*waveLenght+time) + (uv.y*6.+height)+_offset)*0.055;
    val *= 1. + sin(phase + uv.x*waveLenght+time) + (uv.y*6.-height+_offset);    
      //  return smoothstep(0.0, 32.0, val) * palette(color/360.);
    return clamp(val, 0., 1.) * palette(color/360.);
}

vec2 waveTexture(vec2 uv) {
    uv.y = clamp(sin(uv.x*7. + time)/10. + uv.y, 0., 1.)+0.4;
    uv.x += sin(time);
    return uv;
}


void TextScroller(out vec4 fragColor, in vec2 fragCoord )
{
    // Normalized pixel coordinates (from -1 to 1, origo at 0,0)
    vec2 uv = (fragCoord*2. - resolution) / resolution;       
    vec2 uv2 = (fragCoord / resolution);
    vec3 col = vec3(0., 0.3, 0.6);    
    col += texture2D(texts, waveTexture(uv2));
        col += wave(uv, 0., 1., 3., 1., sin(time+0.3)*360.);
    col += wave(uv, sin(time), 0., 3., -1., sin(time-1.2)*120.);    
    col += wave(uv, -3., 0., 3., 1., sin(time+0.5)*90.);
    col += random(uv*2.);
    // Output to screen
    fragColor = vec4(col, 1.);
}

void main(void) {
    if (getBar() <= 32)
        TextScroller(gl_FragColor, gl_FragCoord.xy);
    else  
    {
        mainImage2(gl_FragColor, gl_FragCoord.xy);          
        vec3 l;
        vec2 texttop = vec2(0., -.35), pt = (gl_FragCoord.xy / resolution) - texttop;
        if(pt.y > 0.) {
            l = gl_FragColor + texture2D(texts, pt);
        }

        gl_FragColor = vec4(l * (1.0), 1.0);    
    }
}