Preview
precision highp float;
#define SHADERTOY 0
#define PI 3.141592654
#define saturate(a) clamp(a, 0., 1.)
#define range(a, b) (step(a, floor(time2)) * step(floor(time2), b))
const int maxIteration = 128;
const float fmaxIteration = float(maxIteration);
uniform float time;
uniform vec2 resolution;
float time0, time1, time2, zoom, a;
int iter;
float box(vec3 p, float b) {
vec3 d = abs(p) - b;
return min(max(d.x, max(d.y, d.z)), 0.0) + length(max(d, 0.0));
}
mat2 rot(float a) {
float c = cos(a), s = sin(a);
return mat2(c, -s, s, c);
}
vec3 hue(float hue) {
vec3 rgb = fract(hue + vec3(0., 2. / 3., 1. / 3.));
rgb = abs(rgb * 2. - 1.);
return clamp(rgb * 3. - 1., 0., 1.);
}
vec3 hsvToRgb(vec3 hsv) { return ((hue(hsv.x) - 1.) * hsv.y + 1.) * hsv.z; }
float hash11(float p) {
vec3 p3 = fract(vec3(p) * .1031);
p3 += dot(p3, p3.yzx + 19.19);
return fract((p3.x + p3.y) * p3.z);
}
mat2 rot1, rot2, rot3, rot4;
vec2 ifs(vec3 p) {
float d1 = 999., d2 = 999.;
float range = .8, radius = .5 * (1. + zoom);
const float maxIter = 8.;
for (int i = int(maxIter); i > 0; i--) {
if (i <= iter) {
break;
}
float ratio = float(i) / maxIter;
float bx = box(p, radius * ratio);
d1 = mix(d1, min(d1, bx), float(i > iter + 1));
d2 = min(d2, bx);
ratio *= ratio;
p.xz = abs(p.xz) - range * ratio * .7;
p.xz *= rot1;
p.yz *= rot3;
p.yx *= rot2;
p.yz = abs(p.yz) - range * ratio * .7;
p.xz *= rot1;
p.yz *= rot4;
p.yx *= rot2;
}
return vec2(d1, d2);
}
float map(vec3 p) {
vec2 d = ifs(p);
return mix(mix(d.y, d.x, a), mix(d.x, d.y, a), step(time0, 5.5));
}
float calcAo(vec3 p, vec3 n) {
float sca = 1.0, occ = 0.0;
for (float i = 0.; i < 5.; i++) {
float hr = 0.05 + i * 0.08;
float dd = map(n * hr + p);
occ += (hr - dd) * sca;
sca *= 0.5;
}
return saturate(1.0 - occ);
}
vec3 intersect(vec3 ro, vec3 ray) {
float t = 0.0;
for (int i = 0; i < maxIteration; i++) {
float res = abs(map(ro + ray * t));
if (res < 0.005) return vec3(t, res, i);
t += res;
}
return vec3(-1.0);
}
vec3 normal(vec3 pos, float e) {
vec2 eps = vec2(1.0, -1.0) * 0.5773 * e;
return normalize(eps.xyy * map(pos + eps.xyy) +
eps.yyx * map(pos + eps.yyx) +
eps.yxy * map(pos + eps.yxy) +
eps.xxx * map(pos + eps.xxx));
}
mat3 createCamera(vec3 ro, vec3 ta, float cr) {
vec3 cw = normalize(ta - ro);
vec3 cp = vec3(sin(cr), cos(cr), 0.0);
vec3 cu = normalize(cross(cw, cp));
vec3 cv = normalize(cross(cu, cw));
return mat3(cu, cv, cw);
}
float hash(vec2 p) { return fract(1e4 * sin(17.0 * p.x + p.y * 0.1) * (0.1 + abs(sin(p.y * 13.0 + p.x)))); }
float noise(vec2 x) {
vec2 i = floor(x), f = fract(x);
float a = hash(i);
float b = hash(i + vec2(1.0, 0.0));
float c = hash(i + vec2(0.0, 1.0));
float d = hash(i + vec2(1.0, 1.0));
vec2 u = f * f * (3.0 - 2.0 * f);
return mix(a, b, u.x) + (c - a) * u.y * (1.0 - u.x) + (d - b) * u.x * u.y;
}
float fbm(vec2 p) {
const mat2 m2 = mat2(0.8, -0.6, 0.6, 0.8);
p.xy += 0.1 * time1;
float f = 0.5000 * noise(p); p = m2 * p * 2.02;
f += 0.2500 * noise(p); p = m2 * p * 2.03;
f += 0.1250 * noise(p); p = m2 * p * 2.01;
f += 0.0625 * noise(p);
return f / 0.9375;
}
vec3 sky(vec3 ro, vec3 ray) {
vec3 col = vec3(0.);
float rd = ray.y + 0.3;
col = mix(col, vec3(2.0, 0.25, 2.0), 0.5 * smoothstep(0.5, 0.8, fbm((ro.xz + ray.xz * (250000.0 - ro.y) / rd) * 0.000008)));
col = mix(col, vec3(0.), pow(1.0 - max(rd, 0.0), 4.0));
col = mix(vec3(0.), col, saturate(time1 * 3. - 4.));
col = mix(col, vec3(0.), saturate(time1 - 5.25));
return col * 1.3;
}
#define edge(start, end, sStart, sEnd, ecol) if (range(start, end) > 0.) { showEdge = 1.; float offs = pos.y - mix(sStart, sEnd, 0.025 + saturate(time2 - start)); edgeColor = ecol; edgeIntensity = mix(0., edgeIntensity, saturate(1. - abs(offs))); col = mix(col, objectColor, saturate(1. - (offs + 1.5))); }
vec3 render(vec2 p) {
float t = time0 * 0.7 - 1.;
float offs = mix(1., hash11(max(1., floor(t * 4.))), smoothstep(0., .5, time0));
vec3 ro = vec3(cos(t * 3.5) * 11., sin(t * 3.9) * 4.5, sin(t * 1.5) * 10.) * 0.7;
t = time1 * 0.7;
offs = mix(mix(1., hash11(max(1., floor(t * 4.))), step(0., time1)), 1., step(4.6, time1));
ro = mix(ro, vec3(cos(t * 1.5) * 11. * offs, sin(t * 2.) * 4. * offs * 2., sin(t * 1.5) * 20. * offs) * 0.9, smoothstep(0.7, 1., time1));
ro = mix(ro, vec3(cos(t * 1.5) * 11., sin(t * 3.9) * 4., sin(t * 1.5) * 10.), smoothstep(4.6, 5.5, time1));
ro = mix(ro, vec3(5., 3., 5.), saturate(time1 - 6.7));
vec3 ta = vec3(0.0, 0.0, (sin(t * 0.55) * 0.5 + 0.5) * 2.0);
ta = mix(ta, vec3(0.), saturate(time1 - 6.7));
mat3 cm = createCamera(ro, ta, 0.);
vec3 ray = cm * normalize(vec3(p, 4.0));
vec3 res = intersect(ro, ray);
if (res.y < -0.5) {
return sky(ro, ray);
}
vec3 pos = ro + ray * res.x;
vec3 nor = normal(pos, 0.008);
float glowIntensity = saturate(pow(abs(1. - abs(dot(nor, ray))), 1.));
vec3 objectColor = (vec3(.003, .001, .0095)
* pow(1. / res.z * 1.5, -1.8) + glowIntensity * vec3(.1, .25, .3)) * res.x * 0.3
* calcAo(pos, nor)
+ sky(ro, normalize(reflect(ray, nor))) * .4 * (1. - zoom);
float a = smoothstep(0.3, 0.7, pow(fract(time0 * 3.), 0.4));
float edgeThreshold = mix(0.02, 0.03, (1. - a) * (1. - zoom));
float edgeIntensity = smoothstep(edgeThreshold - 0.01, edgeThreshold, length(nor - normal(pos, .015)));
float noShade = range(-10., 3.);
vec3 col = mix(objectColor, vec3(0.), noShade);
float showEdge = 0.;
vec3 edgeColor = vec3(1.);
vec3 rainbow = hue(pos.z / 2.);
edge(3., 3.5, -2., 2.2, hue(abs(offs) / 5. + .5) * 2.)
edge(6., 6.5, -3.5, 2., rainbow)
edge(5., 5.5, -3.5, 2., rainbow)
edge(10., 10.5, -3.5, 2., rainbow)
edge(11.5, 12., -3.5, 2.4, rainbow)
if (time2 > 16.5) {
showEdge = 1.;
offs = pos.y - mix(-3.5, 4., saturate(time2 - 16.5));
col = mix(objectColor, vec3(0.), saturate(1. - offs));
edgeIntensity = mix(0., edgeIntensity, saturate(1. - (offs + .6)));
}
col += edgeColor * edgeIntensity * step(1., zoom + noShade + showEdge);
col = mix(col, 1. - col, zoom);
return col;
}
vec2 shake(float t) {
float s = t * 50.0;
return (vec2(hash11(s), hash11(s + 11.0)) * 2.0 - 1.0) * exp(-5.0 * t) * 0.2;
}
vec3 vignette(vec2 p) {
p *= 1.0 - p.yx;
return vec3(1.2, 1.1, .85) * pow(16. * p.x * p.y * (1. - p.x) * (1. - p.y), 0.125);
}
void entryPoint(in vec2 coord, in vec2 resolution, in float time, out vec4 color) {
vec2 p = (coord.xy * 2.0 - resolution.xy) / min(resolution.x, resolution.y);
time -= 3.;
time0 = mod(time * 0.4, 11.);
time1 = time0 - 11. / 4.;
time2 = time1 * 0.7 * 4.;
float t = time0 * 3.;
iter = int(mix(clamp(14. - floor(t), 0., 7.), min(8., floor(t) - 24.), step(24., floor(t))));
a = mix(1., smoothstep(0.3, 0.7, pow(fract(t), 0.4)), step(7.5, t));
t = time1 * 3.;
float angle = step(1.2, time1) * (floor(t + 0.5) + smoothstep(0.3, 0.7, pow(fract(t + 0.5), 0.4)));
rot1 = rot(0.785397);
rot2 = rot(1.7079);
rot3 = rot(angle * 1.2 + 424. + step(7.035716, time0) * 3.);
rot4 = rot(angle * 1.2 + 226.);
zoom = range(8., 9.) + range(11., 11.5);
p = mix(p, vec2(1. + hash11(p.y) * 10., p.y), saturate(time0 - 10.33) * 5.);
p += shake(fract(time1 * 2.)) * 0.10;
p *= 1.0 + 5. * pow(length(p), 1.5) * zoom;
vec3 col = render(p);
col *= vignette(coord.xy / resolution.xy);
col = mix(col, vec3(0.), saturate(time0 - 10.33) * 10. + step(time, 0.));
color = vec4(col, 1.0);
}
void
#if SHADERTOY == 1
mainImage(out vec4 fragColor, in vec2 fragCoord) { entryPoint(fragCoord.xy, iResolution.xy, iTime, fragColor); }
#else
main(void) { entryPoint(gl_FragCoord.xy, resolution.xy, time, gl_FragColor); }
#endif
