Hexagon Dive Shader

HexTunnel.glsl

#ifdef GL_ES
precision mediump float;
#endif

uniform float time;
uniform vec2 resolution;
uniform float u_value;
uniform float u_value2;
uniform float u_value3;
uniform float u_value4;

#define iTime time
#define iResolution resolution

#define FAR 1e3
#define INFINITY 1e32
#define FOV 35.0

float hash12(vec2 p) {
    float h = dot(p, vec2(127.1, 311.7));	
    return fract(sin(h) * 43758.5453123);
}

float noise_3(in vec3 p) {
    vec3 i = floor(p);
    vec3 f = fract(p);	
    vec3 u = 1.0 - (--f) * f * f * f * -f;
    
    vec2 ii = i.xy + i.z * vec2(5.0);
    float a = hash12(ii + vec2(0.0, 0.0));
    float b = hash12(ii + vec2(1.0, 0.0));    
    float c = hash12(ii + vec2(0.0, 1.0));
    float d = hash12(ii + vec2(1.0, 1.0)); 
    float v1 = mix(mix(a, b, u.x), mix(c, d, u.x), u.y);
    
    ii += vec2(5.0);
    a = hash12(ii + vec2(0.0, 0.0));
    b = hash12(ii + vec2(1.0, 0.0));    
    c = hash12(ii + vec2(0.0, 1.0));
    d = hash12(ii + vec2(1.0, 1.0));
    float v2 = mix(mix(a, b, u.x), mix(c, d, u.x), u.y);
        
    return max(mix(v1, v2, u.z), u_value * 6.0 - 0.2);
}

float fbm(vec3 x) {
    float r = 0.0;
    float w = 1.0, s = 1.0;
    for (int i = 0; i < 4; i++) {
        w *= 0.25;
        s *= 3.0;
        r += w * noise_3(s * x);
    }
    return r;
}

float yC(float x) {
    return cos(x * -0.134) * sin(x * 0.13) * 15.0 + fbm(vec3(x * 0.1, 0.0, 0.0) * 55.4);
}

struct geometry {
    float dist;
    vec3 hit;
    int iterations;
};

float fCylinderInf(vec3 p, float r) {
    return length(p.xz) - r;
}

geometry map(vec3 p) {
    p.x -= yC(p.y * 0.1) * 3.0;
    p.z += yC(p.y * 0.01) * 4.0;
    
    float n = pow(abs(fbm(p * 0.06)) * 15.0, 1.3);
    float s = fbm(p * 0.015 + vec3(0.0, iTime * 0.34 * u_value2 * 0.15, 0.2)) * 128.0;
    
    geometry obj;
    obj.dist = max(0.0, -fCylinderInf(p, s + 18.0 - n));
    
    p.x -= sin(p.y * 0.02) * 34.0 + cos(p.z * 0.01) * 62.0;
    obj.dist = max(obj.dist, -fCylinderInf(p, s + 28.0 + n * 2.0));
    
    return obj;
}

geometry trace(vec3 o, vec3 d) {
    float omega = 1.3;
    float t = 10.0;
    float candidate_error = INFINITY;
    float candidate_t = t;
    float previousRadius = 0.0;
    float stepLength = 0.0;
    float pixelRadius = 1.0 / 1000.0;
    
    geometry mp = map(o);
    float functionSign = mp.dist < 0.0 ? -1.0 : +1.0;
    
    for (int i = 0; i < 100; ++i) {
        mp = map(d * t + o);
        mp.iterations = i;
        float signedRadius = functionSign * mp.dist;
        float radius = abs(signedRadius);
        bool sorFail = omega > 1.0 && (radius + previousRadius) < stepLength;
        
        if (sorFail) {
            stepLength -= omega * stepLength;
            omega = 1.0;
        } else {
            stepLength = signedRadius * omega;
        }
        previousRadius = radius;
        float error = radius / t;
        
        if (!sorFail && error < candidate_error) {
            candidate_t = t;
            candidate_error = error;
        }
        
        if (!sorFail && error < pixelRadius || t > FAR) break;
        t += stepLength * 0.5;
    }
    
    mp.dist = candidate_t;
    if (t > FAR || candidate_error > pixelRadius) mp.dist = INFINITY;
    return mp;
}

// Shader 2 brightness mask
float shader2Mask(vec2 fragCoord, vec2 res, float t) {
    vec2 p;
    float i = 0.0, g = 0.0, d = 2.0;
    for (float j = 0.0; j < 128.0; j++) {
        i += 1.0;
        if (d <= 0.001) break;
        p = (fragCoord - 0.5 * res) / res.y * g + vec2(0.3) * mat2(cos(g * 2.0), -sin(g * 2.0), sin(g * 2.0), cos(g * 2.0));
        g += d = -(length(p) - 2.0 + g / 9.0) / 2.0;
    }
    p = vec2(atan(p.x, p.y), g) * 8.28 + t * 2.0;
    p = abs(fract(p + vec2(0.0, 0.5 * ceil(p.x))) - 0.5);
    float m = 30.0 / i - 0.5 / step(0.9, 1.0 - abs(max(p.x * 1.5 + p.y, p.y * 2.0) - 1.0));
    return clamp(m, 0.0, 1.0);
}

// God rays using radial sampling from light center
float computeGodRays(vec2 uv, float maskVal, vec2 lightOrigin) {
    float rays = 0.0;
    vec2 dir = lightOrigin - uv;
    float weight = 1.0;
    float totalWeight = 0.0;

    for (int i = 0; i < 32; i++) {
        uv += dir * 0.02;
        float m = shader2Mask(uv * iResolution.xy, iResolution.xy, iTime);
        rays += m * weight;
        totalWeight += weight;
        weight *= 0.95;
    }

    return clamp(rays / totalWeight, 0.0, 1.0);
}

void mainImage(out vec4 fragColor, in vec2 fragCoord) {
    vec2 ouv = fragCoord.xy / iResolution.xy;
    vec2 uv = ouv - 0.5;
    uv *= tan(radians(FOV) / 2.0) * 4.0;

    float mask = shader2Mask(fragCoord.xy, iResolution.xy, iTime);

    vec3 vuv = normalize(vec3(0.5, 0.5, cos(iTime - 2.5) * u_value2 * 2.5));
    vec3 ro = vec3(0.0, 30.0 - iTime * 40.0 + u_value4 * 5.0, -0.1);
    ro.x += yC(ro.y * 0.1) * 3.0;
    ro.z -= yC(ro.y * 0.01) * 4.0;

    vec3 vrp = vec3(0.0, 50.0 + iTime * 100.0, 2.0);
    vrp.x += yC(vrp.y * 0.001) * 3.0;
    vrp.z -= yC(vrp.y * 0.001) * 4.0;

    vec3 vpn = normalize(vrp - ro);
    vec3 u = normalize(cross(vuv, vpn));
    vec3 v = cross(vpn, u);
    vec3 scrCoord = (ro + vpn) + uv.x * u * iResolution.x / iResolution.y + uv.y * v;
    vec3 rd = normalize(scrCoord - ro);

    vec3 sceneColor = vec3(u_value);

    geometry tr = trace(ro, rd);
    tr.hit = ro + rd * tr.dist;

    vec3 col = vec3(1.0, 0.5, 0.4) * fbm(tr.hit.xzy * 0.01) * 20.0;
    col.b *= fbm(tr.hit * 0.01) * 10.0;

    sceneColor += min(0.8, float(tr.iterations) / u_value3) * col + col * 0.03;
    sceneColor *= 1.0 + 0.9 * (abs(fbm(tr.hit * 0.002 + 3.0) * 10.0) * fbm(vec3(0.0, 0.0, iTime * 0.05) * 2.0));
    sceneColor = pow(sceneColor, vec3(0.8 + u_value4 * 0.6)) * 0.6;

    vec3 steamColor1 = vec3(u_value4 * 1.2, 0.4, 0.5);
    vec3 rro = ro;
    ro = tr.hit;

    float distC = tr.dist, f = 0.0;
    for (float i = 0.0; i < 24.0; i++) {
        rro = ro - rd * distC;
        f += fbm(rro * vec3(0.1) * 0.3) * 0.1;
        distC -= 3.0;
        if (distC < 3.0) break;
    }

    sceneColor += steamColor1 * pow(abs(f * 1.5), 3.0) * 4.0;

    float invMask = clamp(mask, 0.0, 1.0);
    vec3 masked = clamp(sceneColor * invMask, 0.0, 1.0);
    float rays = computeGodRays(ouv, invMask, vec2(0.5));
    vec3 lightColor = vec3(0.6, 0.8, 1.2);
    vec3 finalColor = masked + rays * lightColor * 1.5;

    fragColor = vec4(finalColor, 1.0);
}

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