4kintro/shader.glsl

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(iTime*.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)));
}

void main(void) {
    if (getBar() <= 8)
        CoolSphere(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);

}