file_id.diz
// 1. goto https://glslsandbox.com/e
// 2. paste this code
// reflected structure by musk for TDF 2021
#extension GL_OES_standard_derivatives : enable
precision highp float;
uniform sampler2D backbuffer;
uniform float time;
uniform vec2 mouse;
uniform vec2 resolution;
vec3 col_1, col_2;
mat2 rotate(float a){
float c=cos(a), s=sin(a);
return mat2(
+c, +s,
-s, +c
);
}
float ss_noise(float seed){
vec2 s = gl_FragCoord.xy;
return fract(
(sin(dot(s,s)*0.2531+dot(s.xy,s.yx)*0.31343+dot(s,vec2(31.541+fract(seed*50.1191),54.932-fract(seed*30.1191)))-fract(seed*1.7191)))*765.4567
);
}
vec3 sphere_noise(float seed){
vec3 n;
for (int i=0; i<3; i++){
n = (vec3(ss_noise(seed+.93), ss_noise(seed+.31), ss_noise(seed+.56))-vec3(.5))*2.0;
if (length(n) < 1.0) {
return n;
}
}
return n;
}
float df(vec3 p)//distance function
{
//float d=1.0-abs(p.y);
float t = time;
p.x+=t*0.07;
p.z+=t*.03;
float s = length(p);
p.y=abs(p.y);
p.y-=5.0;
float d = 0.5-p.y;
for (int i=0; i<10; i++)
{
float fi = float(i);
p+=vec3(1.25-fi,0.0,1.75+fi);
vec3 pm;
float rep = 10.0+sin(fi*2.0+1.0)*4.0;
pm.xz = mod(p.xz+vec2(rep*.5),vec2(rep))-vec2(rep*.5);
float width = 1.0+sin(fi)*.8;
float height = 2.0+cos(fi)*1.1;
float offset = -0.5+cos(fi)*1.8;
vec3 df = abs(vec3(pm.x,p.y+1.0/width,pm.z))-vec3(width,height,width);
float box = max(max(df.x,df.y),df.z);
//float box=length(vec3(pm.x,p.y,pm.z))-1.0;
d = min(d,box);
}
return d;
}
vec3 nf(vec3 p, float d){
vec2 e = vec2(0,d);
return normalize(vec3(
df(vec3(p+e.yxx))-df(vec3(p-e.yxx)),
df(vec3(p+e.xyx))-df(vec3(p-e.xyx)),
df(vec3(p+e.xxy))-df(vec3(p-e.xxy))
));
}
float pat(vec3 p){
float q = 2.0*(abs(fract(df(p+vec3(3.))*13.0)-.5));
float dq2 = df(p-vec3(1))*.1;
float q2 = smoothstep(.2,.3, (abs(fract(dq2*32.0)-0.5)*2.0));
float q3 = smoothstep(.2,.3, (abs(fract(dq2*16.0)-0.5)*2.0));
float q4 = smoothstep(.2,.3, (abs(fract(dq2*16.0)-0.5)*2.0));
return smoothstep(.7,.8,q)*q2*q3;
}
float fat_pat(vec3 p){
float q = 2.0*(abs(fract(df(p+vec3(3.))*8.0)-.5));
float dq2 = df(p-vec3(1))*.1;
float q2 = smoothstep(.2,.3, (abs(fract(dq2*32.0)-0.5)*2.0));
float q3 = smoothstep(.2,.3, (abs(fract(dq2*16.0)-0.5)*2.0));
float q4 = smoothstep(.2,.3, (abs(fract(dq2*16.0)-0.5)*2.0));
return smoothstep(-.1,.6,q)*q2*q3;
}
float wave(float x){
return max(.0, (1./(3.+sin(x)+sin(x*2.)))-.3);
}
vec3 ef(vec3 p){
float pt = pat(p);
return max(vec3(.0), pt*col_1*20.0*(wave((p.x+p.z)*.6+time)))
+max(vec3(.0), pt*col_2*20.0*(wave((p.x-p.z)*.125+time)));
}
vec3 fat_ef(vec3 p){
float pt = fat_pat(p);
return max(vec3(.0), pt*col_1*20.0*(sin((p.x+p.z)*.5+time)-.5))
+max(vec3(.0), pt*col_2*20.0*(sin((p.x-p.z)*.125+time)-.5));
}
vec3 decode_color(vec3 frag){
return frag.xyz / (vec3(1.431)-frag);
}
vec3 encode_color(vec3 color){
return (vec3(1.431)*color)/(vec3(1)+color);
}
void main( void ) {
col_1 = mix( vec3(.9,.1,.1), vec3(.2,.5,.9), smoothstep(-.5,.5,sin(time*.167)) );
col_2 = mix( vec3(.7,.3,.1), vec3(.9,.9,.9), smoothstep(-.5,.5,sin(time*.134)) );
vec2 uv = gl_FragCoord.xy / resolution.xy;
vec2 nuv = (uv-0.5)*2.0;
vec3 color = vec3(0.0);
float it_count, dist = ss_noise(time)*.1;
vec3 pos = vec3(0,0,4);
vec2 smpn = vec2(ss_noise(time+1.),ss_noise(time+2.));
vec3 dir = normalize(vec3((gl_FragCoord.xy+smpn-resolution.xy*.5)/resolution.yy, -0.4));
dir.z += pow(length(dir),2.0)*0.4;
dir = normalize(dir);
dir.xy *= rotate(.1);
dir.xz *= rotate(+time*.025);
pos.xz *= rotate(-time*.025);
for (int it=0; it<100; it+=1){
float d = df(pos+dist*dir);
dist += d;
if (d<1e-3) break;
it_count = float(it);
}
vec3 pos_2 = pos+dist*dir;
vec3 norm_outline = nf(pos_2, 48.0*dist/resolution.y);
vec3 norm = nf(pos_2, 2.0*dist/resolution.y);
vec3 em_2 = ef(pos_2);
float pat_2 = pat(pos_2);
float refl_2 = mix(pow(clamp(1.0+dot(norm, dir),.0,1.),4.0),1.0,0.2);
// specular
vec3 dir_2 = normalize(reflect(dir, norm + max(.0,.005-pat_2)*sphere_noise(time+93.1)));
float dist_2 = ss_noise(time+.43)*.1+.1;
for (int it=0; it<50; it++){
float d = df(pos_2+dist_2*dir_2);
dist_2 += d;
if (d<1e-3) break;
}
vec3 pos_3 = pos_2+dist_2*dir_2;
vec3 em_3 = ef(pos_3);
vec3 em = em_2;
vec3 specular = em_3;
// diffuse
float diffuse_count = .0;
vec3 diffuse_color = vec3(.0);
for (int dic=0; dic<10; dic++){
vec3 d_dir=normalize(norm + .75*sphere_noise(1.0+dot(pos_2,diffuse_color)-time+diffuse_count));
float d_dist = (1.0/dot(norm, d_dir))*.005;
for (int dit=0; dit<10; dit++){
float d = df(pos_2+d_dir*d_dist);
d_dist += d;
if (d<1e-3) break;
}
diffuse_count += 1.0;
diffuse_color += ef(pos_2+d_dir*d_dist);
}
diffuse_color *= mix(1.0, .5,pat_2)/diffuse_count;
color = mix(diffuse_color +mix(em_2, em_2*vec3(.8,.6,.4), pat_2), specular, refl_2);
// color = vec3(refl_2);
color *= (1.0-1.4*length(uv-vec2(0.5)))*2.0;
// color = diffuse_color; //dbg
// color = vec3(pat_2); //dbg
// color = vec3(vec3(0.1,.2,.3)*it_count*0.4); //dbg maytbe
float out_dist = .01;
float outline = 1.0-clamp((1.0-df(pos_2+norm_outline*out_dist)/out_dist)*4.0, 0.0, 1.0);
outline = mix(outline, 1.0, pow(smoothstep(16.,64.,dist),0.0));
//color = vec3(outline); //dbg maybe transition
vec4 last_frag = (texture2D(backbuffer, uv+nuv*0.005)*vec4(.45,.25,.05,0.25) + texture2D(backbuffer, uv-nuv*0.005)*vec4(.05,.25,.45,0.25))*2.0;
vec4 last_n0_frag = texture2D(backbuffer, (gl_FragCoord.xy + vec2(1,0)) / resolution.xy);
vec4 last_n1_frag = texture2D(backbuffer, (gl_FragCoord.xy - vec2(1,0)) / resolution.xy);
vec4 last_n2_frag = texture2D(backbuffer, (gl_FragCoord.xy + vec2(0,1)) / resolution.xy);
vec4 last_n3_frag = texture2D(backbuffer, (gl_FragCoord.xy - vec2(0,1)) / resolution.xy);
vec3 last_color = decode_color(last_frag.rgb);
vec3 last_n0_color = decode_color(last_n0_frag.rgb) * last_n0_frag.a;
vec3 last_n1_color = decode_color(last_n1_frag.rgb) * last_n1_frag.a;
vec3 last_n2_color = decode_color(last_n2_frag.rgb) * last_n2_frag.a;
vec3 last_n3_color = decode_color(last_n3_frag.rgb) * last_n3_frag.a;
float last_n_weight_sum = last_n0_frag.a + last_n1_frag.a + last_n2_frag.a + last_n3_frag.a;
vec3 last_n_color = (last_n0_color + last_n1_color + last_n2_color + last_n3_color) / last_n_weight_sum;
float last_n_weight = last_n_weight_sum / 4.0;
color = max(vec3(0), color);
color = mix(color, last_color, smoothstep(0.,1.,0.55*outline+dist*.001));
// color += em;
if (last_n_weight > 1e-2){
color = mix(color, last_n_color, smoothstep(.0,.9,outline*.55*last_n_weight+dist*0.0025));
}
color += vec3((ss_noise(time+9.34)-0.5)*0.005);
gl_FragColor = vec4( encode_color(color), outline );
}