// 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 );

}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.