mirror of
https://github.com/CookieCollective/Live-Coding-Sources.git
synced 2025-08-09 15:41:45 +02:00
first part of 2019-01-30 showdown
This commit is contained in:
Leon
155
2019-01-30/Nusan_300119.glsl
Normal file
155
2019-01-30/Nusan_300119.glsl
Normal file
@ -0,0 +1,155 @@
|
||||
#version 410 core
|
||||
|
||||
uniform float fGlobalTime; // in seconds
|
||||
uniform vec2 v2Resolution; // viewport resolution (in pixels)
|
||||
|
||||
uniform sampler1D texFFT; // towards 0.0 is bass / lower freq, towards 1.0 is higher / treble freq
|
||||
uniform sampler1D texFFTSmoothed; // this one has longer falloff and less harsh transients
|
||||
uniform sampler1D texFFTIntegrated; // this is continually increasing
|
||||
uniform sampler2D texChecker;
|
||||
uniform sampler2D texNoise;
|
||||
uniform sampler2D texTex1;
|
||||
uniform sampler2D texTex2;
|
||||
uniform sampler2D texTex3;
|
||||
uniform sampler2D texTex4;
|
||||
|
||||
layout(location = 0) out vec4 out_color; // out_color must be written in order to see anything
|
||||
|
||||
#define time fGlobalTime
|
||||
|
||||
float sph(vec3 p, float r) {
|
||||
return length(p)-r;
|
||||
}
|
||||
|
||||
float box(vec3 p, vec3 s){
|
||||
vec3 ap=abs(p)-s;
|
||||
return length(max(vec3(0), ap)) + min(0, max(ap.x, max(ap.y,ap.z)));
|
||||
}
|
||||
|
||||
mat2 rot(float a) {
|
||||
float ca=cos(a);
|
||||
float sa=sin(a);
|
||||
return mat2(ca,sa,-sa,ca);
|
||||
}
|
||||
|
||||
|
||||
float smin( float a, float b, float h) {
|
||||
float k=clamp((a-b)/h*0.5+0.5,0,1);
|
||||
return mix(a,b,k) - k*(1-k)*h;
|
||||
}
|
||||
|
||||
float rnd(float t) {
|
||||
return fract(sin(t*456.232)*8956.233);
|
||||
}
|
||||
|
||||
float curve(float t, float d) {
|
||||
float g=t/d;
|
||||
return mix(rnd(floor(g)),rnd(floor(g)+1), pow(smoothstep(0,1,fract(g)), 10));
|
||||
|
||||
}
|
||||
|
||||
float mat = 0;
|
||||
float map(vec3 p) {
|
||||
|
||||
vec3 bp=p;
|
||||
|
||||
p.y += pow(abs(sin(time))*3,2);
|
||||
vec3 rp = p;
|
||||
|
||||
|
||||
float scale = abs(curve(time, 0.8)-0.5)*2;
|
||||
scale = smoothstep(0,1,scale);
|
||||
scale += 0.3;
|
||||
for(int i=0; i<5; ++i) {
|
||||
rp = p;
|
||||
float t1 = time * 0.7;
|
||||
p -= 0.2*scale+i*0.2*scale;
|
||||
p.xy *= rot(t1*0.7);
|
||||
p -= 0.3*scale+i*0.3*scale;
|
||||
p.yz *= rot(t1);
|
||||
p=abs(p);
|
||||
p -= 0.4*scale+i*0.5*scale;
|
||||
}
|
||||
|
||||
float b = box(p, vec3(0.5,0.3,0.7));
|
||||
float b2 = box(rp, vec3(0.5,0.5,10.0)*1);
|
||||
float b3 = max(b, -b2);
|
||||
|
||||
float ground = 1-bp.y;
|
||||
ground=smin(ground, -b3, -5.5);
|
||||
|
||||
mat = b3<ground?1:0;
|
||||
|
||||
return min(b3,ground );
|
||||
}
|
||||
|
||||
vec3 norm(vec3 p) {
|
||||
vec2 off=vec2(0.01,0);
|
||||
return normalize(map(p)-vec3(map(p-off.xyy),map(p-off.yxy),map(p-off.yyx)));
|
||||
}
|
||||
|
||||
void cam(inout vec3 p) {
|
||||
float t1=time*0.2;
|
||||
p.yz *= rot(0.5);
|
||||
p.xz *= rot(t1);
|
||||
}
|
||||
|
||||
void main(void)
|
||||
{
|
||||
vec2 uv = vec2(gl_FragCoord.x / v2Resolution.x, gl_FragCoord.y / v2Resolution.y);
|
||||
uv -= 0.5;
|
||||
uv /= vec2(v2Resolution.y / v2Resolution.x, 1);
|
||||
|
||||
uv.x += (curve(time, 0.7)-0.5)*0.3;
|
||||
|
||||
uv.y += (curve(time, 0.9)-0.5)*0.2;
|
||||
|
||||
vec3 s=vec3(0,0,-25);
|
||||
vec3 r=normalize(vec3(-uv, 0.5 + curve(time, 1.3)*0.5));
|
||||
|
||||
cam(s);
|
||||
cam(r);
|
||||
|
||||
s.y -= 3;
|
||||
|
||||
vec3 col=vec3(0);
|
||||
|
||||
vec3 l = normalize(vec3(-0.7,-1.0,-0.5));
|
||||
|
||||
vec3 p=s;
|
||||
float prod=1;
|
||||
float none=1;
|
||||
float at=0;
|
||||
for(int i=0; i<100; ++i) {
|
||||
float d=map(p);
|
||||
if(d<0.001) {
|
||||
float curmat=mat;
|
||||
vec3 n=norm(p);
|
||||
vec3 h=normalize(l-r);
|
||||
float f=pow(1-max(0, dot(n, -r)),2);
|
||||
vec3 diff=mix(vec3(.7,0.3,0.2), vec3(0.3), curmat);
|
||||
col += prod*diff*max(0, dot(n, l)) * (0.2 + 1.5*pow(max(0,dot(n,h)),7));
|
||||
col += prod*0.2*vec3(0.3,0.3,1.0) * f * 2 * (-n.y*0.5+0.5);
|
||||
|
||||
prod *= 1.0*f+0.5;
|
||||
r=reflect(r,n);
|
||||
d=0.1;
|
||||
none=0;
|
||||
// break;
|
||||
}
|
||||
if(d>100) {
|
||||
none=0;
|
||||
break;
|
||||
}
|
||||
p+=r*d;
|
||||
at += 0.3*exp(-d*1.9);
|
||||
}
|
||||
col += none * vec3(0.2,0.2,0.5);
|
||||
col += at*0.008*vec3(1,0.7,0.2);
|
||||
|
||||
col *= 5;
|
||||
col = 1-exp(-col);
|
||||
col = pow(col, vec3(1.2));
|
||||
|
||||
out_color = vec4(col, 1);
|
||||
}
|
||||
87
2019-01-30/anatole 1.glsl
Normal file
87
2019-01-30/anatole 1.glsl
Normal file
@ -0,0 +1,87 @@
|
||||
#version 410 core
|
||||
|
||||
uniform float fGlobalTime; // in seconds
|
||||
uniform vec2 v2Resolution; // viewport resolution (in pixels)
|
||||
|
||||
uniform sampler1D texFFT; // towards 0.0 is bass / lower freq, towards 1.0 is higher / treble freq
|
||||
uniform sampler1D texFFTSmoothed; // this one has longer falloff and less harsh transients
|
||||
uniform sampler1D texFFTIntegrated; // this is continually increasing
|
||||
uniform sampler2D texChecker;
|
||||
uniform sampler2D texNoise;
|
||||
uniform sampler2D texTex1;
|
||||
uniform sampler2D texTex2;
|
||||
uniform sampler2D texTex3;
|
||||
uniform sampler2D texTex4;
|
||||
|
||||
layout(location = 0) out vec4 out_color; // out_color must be written in order to see anything
|
||||
|
||||
|
||||
#define time fGlobalTime
|
||||
vec4 plas( vec2 v, float time )
|
||||
{
|
||||
float c = 0.5 + sin( v.x * 10.0 ) + cos( sin( time + v.y ) * 20.0 );
|
||||
return vec4( sin(c * 0.2 + cos(time)), c * 0.15, cos( c * 0.1 + time / .4 ) * .25, 1.0 );
|
||||
}
|
||||
|
||||
float map( vec3 p) {
|
||||
float d = dot( cos(p.xyz), sin(p.zxy)) + cos(p.y*20.)*.01+.75;
|
||||
d = min(d, length(p.xy+vec2(cos(p.z)-1., sin(p.z)))-.1);
|
||||
return d;
|
||||
}
|
||||
|
||||
mat2 rot(float v)
|
||||
{
|
||||
float a = cos(v);
|
||||
float b = sin(v);
|
||||
|
||||
return mat2(a,b,-b,a);
|
||||
}
|
||||
|
||||
void main(void)
|
||||
{
|
||||
vec2 uv = vec2(gl_FragCoord.x / v2Resolution.x, gl_FragCoord.y / v2Resolution.y);
|
||||
vec2 v = uv;
|
||||
uv -= 0.5;
|
||||
uv /= vec2(v2Resolution.y / v2Resolution.x, 1);
|
||||
uv = uv*2.;
|
||||
float impuls = pow(texture2D(texNoise, vec2(0., time*1.1)).r, 10.)*5000.;
|
||||
uv.x += impuls * (texture2D(texNoise, vec2(uv.y, time*.1)).g*2.-1.)*.3;
|
||||
|
||||
uv = abs(uv);
|
||||
uv = rot(time*.5) * uv;
|
||||
uv = abs(uv);
|
||||
uv = rot(-time*.25) * uv;
|
||||
uv = abs(uv);
|
||||
uv += vec2(cos(time)*.1);
|
||||
uv = rot(-time*.175) * uv;
|
||||
uv = abs(uv);
|
||||
uv = rot(time*.175) * uv;
|
||||
uv = abs(uv);
|
||||
uv = rot(-time*.25) * uv;
|
||||
uv = abs(uv);
|
||||
|
||||
uv = mix(uv, v*2.-1., max(0.,cos(time*.1)));
|
||||
|
||||
vec3 ro = vec3(1., 0., fGlobalTime);
|
||||
vec3 rd = normalize( vec3(uv, 1.));
|
||||
|
||||
vec3 p = ro;
|
||||
|
||||
for(int i=0; i<64; i++) {
|
||||
p += rd * map(p);
|
||||
}
|
||||
vec3 col = vec3(1.,.7,.3) * max(0.,map(p)-map(p+vec3(-1.,-.7,.25)*.5))*3.;
|
||||
col += vec3(v.x*cos(time),1.+uv.y*.5*sin(time)-v.x*.5,.5) * (1.-exp(-length(ro-p)*.1));
|
||||
col *= 2.*mix(vec3(cos(uv.x+time*.1),cos(uv.y+uv.x+time),sin(time))*.5+.5, vec3(1.), 1.-5.*impuls) * exp(-length(ro-p)*.1);
|
||||
|
||||
if( abs(cos(length(uv)-time*.82)) < .1) {
|
||||
col = col.brg;
|
||||
}
|
||||
if( abs(sin(length(uv+.5)+time*.82)) < .1) {
|
||||
col = col.gbr;
|
||||
}
|
||||
|
||||
col *= pow(v.x*v.y*(1.-v.x)*(1.-v.y), .15);
|
||||
|
||||
out_color = vec4(col, 1.);
|
||||
}
|
||||
135
2019-01-30/anatole 2.glsl
Normal file
135
2019-01-30/anatole 2.glsl
Normal file
@ -0,0 +1,135 @@
|
||||
#version 410 core
|
||||
|
||||
uniform float fGlobalTime; // in seconds
|
||||
uniform vec2 v2Resolution; // viewport resolution (in pixels)
|
||||
|
||||
uniform sampler1D texFFT; // towards 0.0 is bass / lower freq, towards 1.0 is higher / treble freq
|
||||
uniform sampler1D texFFTSmoothed; // this one has longer falloff and less harsh transients
|
||||
uniform sampler1D texFFTIntegrated; // this is continually increasing
|
||||
uniform sampler2D texChecker;
|
||||
uniform sampler2D texNoise;
|
||||
uniform sampler2D texTex1;
|
||||
uniform sampler2D texTex2;
|
||||
uniform sampler2D texTex3;
|
||||
uniform sampler2D texTex4;
|
||||
|
||||
layout(location = 0) out vec4 out_color; // out_color must be written in order to see anything
|
||||
|
||||
#define time fGlobalTime
|
||||
mat2 rot(float v)
|
||||
{
|
||||
float a = cos(v);
|
||||
float b = sin(v);
|
||||
|
||||
return mat2(a,b,-b,a);
|
||||
}
|
||||
|
||||
|
||||
float fbm( vec2 p )
|
||||
{
|
||||
float d = texture2D(texNoise, p).r *.5;
|
||||
d += texture2D(texNoise, p*2.).r *.25;
|
||||
d += texture2D(texNoise, p*4.).r *.125;
|
||||
|
||||
return d;
|
||||
|
||||
}
|
||||
|
||||
float flotte(vec3 p)
|
||||
{
|
||||
//p.xy = rot(p.z)*p.xy;
|
||||
return -abs(p.y)+.7 + fbm(p.xz*.1)*.1;
|
||||
}
|
||||
|
||||
float terrain( vec3 p )
|
||||
{
|
||||
p.xy = rot(p.z)*p.xy;
|
||||
float d = -abs(p.y)-1.;
|
||||
d += fbm(p.xz*.05)*10.;
|
||||
|
||||
return d;
|
||||
}
|
||||
|
||||
float map(vec3 p)
|
||||
{
|
||||
|
||||
float d = min(terrain(p), flotte(p));
|
||||
|
||||
return d*.6;
|
||||
}
|
||||
|
||||
|
||||
vec3 normal(vec3 p)
|
||||
{
|
||||
vec2 eps = vec2(0.01, 0.);
|
||||
float d = map(p);
|
||||
vec3 n;
|
||||
n.x = d - map(p-eps.xyy);
|
||||
n.y = d - map(p-eps.yxy);
|
||||
n.z = d - map(p-eps.yyx);
|
||||
|
||||
return normalize(n);
|
||||
}
|
||||
vec3 raymarch(vec3 ro, vec3 rd)
|
||||
{
|
||||
|
||||
vec3 p = ro;
|
||||
|
||||
for(int i=0; i<64; i++)
|
||||
{
|
||||
p += rd * map(p);
|
||||
}
|
||||
|
||||
return p;
|
||||
}
|
||||
|
||||
vec3 shade(vec3 ro, vec3 rd, vec3 p , vec3 n)
|
||||
{
|
||||
|
||||
vec3 ld = normalize(vec3(0.5,1.,1.));
|
||||
vec3 albedo = mix(vec3(.2,.1,.1)*2., vec3(0.5,1.,0.), pow(abs(n.y), 4.));
|
||||
|
||||
float shad = step(1.,length(raymarch(p+ld*.1, ld)-p));
|
||||
vec3 dif = vec3(1.,.7,.1) * max( dot(n, ld), 0.) ;
|
||||
vec3 amb = vec3(0.,0.,.1);
|
||||
|
||||
vec3 col = albedo * (dif+amb);
|
||||
|
||||
|
||||
return col;
|
||||
|
||||
}
|
||||
|
||||
|
||||
void main(void)
|
||||
{
|
||||
vec2 uv = vec2(gl_FragCoord.x / v2Resolution.x, gl_FragCoord.y / v2Resolution.y);
|
||||
uv -= 0.5;
|
||||
uv *= 2.;
|
||||
uv /= vec2(v2Resolution.y / v2Resolution.x, 1);
|
||||
|
||||
vec3 ro = vec3(0.,0.,time);
|
||||
vec3 rd = normalize( vec3(uv, 1.));
|
||||
|
||||
rd.xy = rot(time*.1) * rd.xy;
|
||||
vec3 p = raymarch(ro,rd);
|
||||
vec3 n = normal(p);
|
||||
vec3 col = shade(ro,rd,p,n);
|
||||
if(flotte(p)<terrain(p))
|
||||
{
|
||||
vec3 rro = p;
|
||||
vec3 rrd = reflect(rd,n);
|
||||
|
||||
vec3 rp = raymarch(rro+rrd*.1,rrd);
|
||||
vec3 rn = normal(rp);
|
||||
|
||||
vec3 rcol = shade(rro, rp, rp, rn);
|
||||
|
||||
col = vec3(.5,1.,2.)*rcol;
|
||||
}
|
||||
|
||||
col = mix(col, vec3(1.), 1.-exp(-length(p-ro)*.1));
|
||||
|
||||
col = pow(col, vec3(1./2.2));
|
||||
out_color = vec4(col, 1.);
|
||||
}
|
||||
130
2019-01-30/gregory 1.glsl
Normal file
130
2019-01-30/gregory 1.glsl
Normal file
@ -0,0 +1,130 @@
|
||||
#version 410 core
|
||||
|
||||
uniform float fGlobalTime; // in seconds
|
||||
uniform vec2 v2Resolution; // viewport resolution (in pixels)
|
||||
|
||||
uniform sampler1D texFFT; // towards 0.0 is bass / lower freq, towards 1.0 is higher / treble freq
|
||||
uniform sampler1D texFFTSmoothed; // this one has longer falloff and less harsh transients
|
||||
uniform sampler1D texFFTIntegrated; // this is continually increasing
|
||||
uniform sampler2D texChecker;
|
||||
uniform sampler2D texNoise;
|
||||
uniform sampler2D texTex1;
|
||||
uniform sampler2D texTex2;
|
||||
uniform sampler2D texTex3;
|
||||
uniform sampler2D texTex4;
|
||||
|
||||
#define iTime fGlobalTime
|
||||
#define SPEED 3.
|
||||
|
||||
vec3 palette(float x) {
|
||||
float wave = sin(2. * iTime) * 0.5 + 0.5;
|
||||
vec3 a = vec3(1);
|
||||
vec3 b = vec3(wave);
|
||||
vec3 c = vec3(.5,.5, wave);
|
||||
vec3 d = vec3(.3, .6, 1);
|
||||
return a + b * cos(c + d * x);
|
||||
}
|
||||
|
||||
mat2 rot2d(float a) {
|
||||
float c = cos(a);
|
||||
float s = sin(a);
|
||||
|
||||
return mat2(c, s, -s, c);
|
||||
}
|
||||
|
||||
float GetDistSphere(vec3 p, vec4 sphere) {
|
||||
return length(p - sphere.xyz) - sphere.w;
|
||||
}
|
||||
|
||||
float GetDistSphereRep(vec3 p, vec4 sphere, vec3 rep) {
|
||||
vec3 q = mod(p, rep) - 0.5 * rep;
|
||||
return GetDistSphere(q, sphere);
|
||||
}
|
||||
|
||||
float GetDist(vec3 p) {
|
||||
// p.xy *= rot2d((iTime / 100.) * p.z / 50.);
|
||||
// p.xy *= rot2d(p.x * p.y) ;
|
||||
p.xy *= rot2d(p.x) ;
|
||||
vec4 sphere = vec4(0, 0, .5, .4);
|
||||
// float d = GetDistSphere(p, sphere);
|
||||
vec3 rep = vec3(3, 3, 2);
|
||||
float d = GetDistSphereRep(p, sphere, rep);
|
||||
return d;
|
||||
}
|
||||
|
||||
float RayMarch(vec3 ro, vec3 rd) {
|
||||
float d = 0.;
|
||||
|
||||
for (int i = 0; i < 100; i++) {
|
||||
vec3 p = ro + d * rd;
|
||||
float dScene = GetDist(p);
|
||||
d += dScene;
|
||||
|
||||
if (dScene < 0.01 || dScene > 100.) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return d;
|
||||
}
|
||||
|
||||
vec3 GetNormal(vec3 p) {
|
||||
vec2 e = vec2(0.01, 0);
|
||||
|
||||
vec3 n = GetDist(p) - vec3(
|
||||
GetDist(p - e.xyy),
|
||||
GetDist(p - e.yxy),
|
||||
GetDist(p - e.yyx)
|
||||
);
|
||||
|
||||
return normalize(n);
|
||||
}
|
||||
|
||||
float GetLight(vec3 p) {
|
||||
vec3 light = vec3(0, 3, iTime * SPEED + 1);
|
||||
vec3 toLight = light - p;
|
||||
vec3 n = GetNormal(p);
|
||||
float dif = dot(n, normalize(toLight));
|
||||
|
||||
return dif;
|
||||
}
|
||||
|
||||
layout(location = 0) out vec4 out_color; // out_color must be written in order to see anything
|
||||
|
||||
vec4 plas( vec2 v, float time )
|
||||
{
|
||||
float c = 0.5 + sin( v.x * 10.0 ) + cos( sin( time + v.y ) * 20.0 );
|
||||
return vec4( sin(c * 0.2 + cos(time)), c * 0.15, cos( c * 0.1 + time / .4 ) * .25, 1.0 );
|
||||
}
|
||||
void main(void)
|
||||
{
|
||||
vec2 uv = vec2(gl_FragCoord.x / v2Resolution.x, gl_FragCoord.y / v2Resolution.y);
|
||||
uv -= 0.5;
|
||||
uv /= vec2(v2Resolution.y / v2Resolution.x, 1);
|
||||
uv *= 2.;
|
||||
vec3 col = vec3(0.);
|
||||
|
||||
vec3 ro = vec3(0, sin(iTime), iTime * SPEED);
|
||||
|
||||
vec3 rd = normalize(vec3(uv.x, uv.y, 1));
|
||||
|
||||
float d = RayMarch(ro, rd);
|
||||
vec3 p = ro + d * rd;
|
||||
float dif = GetLight(p);
|
||||
col = vec3(dif * palette(p.z / 100.));
|
||||
// col = n;
|
||||
out_color = vec4(col, 1.);
|
||||
}
|
||||
|
||||
/* vec2 m;
|
||||
m.x = atan(uv.x / uv.y) / 3.14;
|
||||
m.y = 1 / length(uv) * .2;
|
||||
float d = m.y;
|
||||
|
||||
float f = texture( texFFT, d ).r * 100;
|
||||
m.x += sin( fGlobalTime ) * 0.1;
|
||||
m.y += fGlobalTime * 0.25;
|
||||
|
||||
vec4 t = plas( m * 3.14, fGlobalTime ) / d;
|
||||
t = clamp( t, 0.0, 1.0 );
|
||||
out_color = f + t;*/
|
||||
98
2019-01-30/lamogui 1.glsl
Normal file
98
2019-01-30/lamogui 1.glsl
Normal file
@ -0,0 +1,98 @@
|
||||
#version 410 core
|
||||
|
||||
uniform float fGlobalTime; // in seconds
|
||||
uniform vec2 v2Resolution; // viewport resolution (in pixels)
|
||||
|
||||
uniform sampler1D texFFT; // towards 0.0 is bass / lower freq, towards 1.0 is higher / treble freq
|
||||
uniform sampler1D texFFTSmoothed; // this one has longer falloff and less harsh transients
|
||||
uniform sampler1D texFFTIntegrated; // this is continually increasing
|
||||
uniform sampler2D texChecker;
|
||||
uniform sampler2D texNoise;
|
||||
uniform sampler2D texTex1;
|
||||
uniform sampler2D texTex2;
|
||||
uniform sampler2D texTex3;
|
||||
uniform sampler2D texTex4;
|
||||
|
||||
layout(location = 0) out vec4 out_color; // out_color must be written in order to see anything
|
||||
|
||||
float h(vec2 p)
|
||||
{
|
||||
return cos(p.x + sin(0.1* p.x + cos( p.x))) + 0.1 * sin( 2.6 * p.y);
|
||||
}
|
||||
|
||||
float g(vec3 q, vec3 p)
|
||||
{
|
||||
q.y += 10.0 * texture(texFFTIntegrated, 0.01).x;
|
||||
float per = 3.0;
|
||||
vec2 id = q.xz / per + per * 0.5;
|
||||
q = mod(q, per) - 0.5 * per;
|
||||
return 1.0 - length(q);
|
||||
}
|
||||
|
||||
|
||||
float map(vec3 p)
|
||||
{
|
||||
float d = p.y + 2.0 - h(p.xz);
|
||||
d = min(d, g(p, p));
|
||||
return d;
|
||||
return cos(p.x) + cos(p.y) + cos(p.z);
|
||||
}
|
||||
|
||||
vec3 rm(vec3 ro, vec3 rd, out float st)
|
||||
{
|
||||
st = 1.0;
|
||||
vec3 p = ro;
|
||||
for (float i = 0.0; i < 64.0; i++)
|
||||
{
|
||||
float d = map(p);
|
||||
if (abs(d) < 0.01)
|
||||
{
|
||||
st = i / 64.0;
|
||||
break;
|
||||
}
|
||||
p += d * rd * 0.9;
|
||||
}
|
||||
return p;
|
||||
}
|
||||
|
||||
vec3 shade(vec3 ro, vec3 p, float st)
|
||||
{
|
||||
float t = exp(-distance(ro, p) * 0.1);
|
||||
vec3 c = vec3(t) * (1.0 - st);
|
||||
c *= mix(texture(texChecker, p.xz).xyz, c, 1.0 -t);
|
||||
c = mix(vec3(0.0, 2.0, 2.0), c, 2.0* t);
|
||||
//c = vec3(exp(-distance(ro, p) * 0.1));
|
||||
return c;
|
||||
}
|
||||
|
||||
vec3 n(vec3 p)
|
||||
{
|
||||
vec2 e = vec2(0.001, 0.0);
|
||||
return normalize(vec3(map(p + e.xyy) - map(p - e.xyy),
|
||||
map(p + e.yxy) - map(p - e.yxy),
|
||||
map(p + e.yyx) - map(p - e.yyx)));
|
||||
}
|
||||
|
||||
void main(void)
|
||||
{
|
||||
vec2 uv = vec2(gl_FragCoord.x / v2Resolution.x, gl_FragCoord.y / v2Resolution.y);
|
||||
uv -= 0.5;
|
||||
uv.x *= v2Resolution.x/v2Resolution.y;
|
||||
|
||||
|
||||
vec3 ro = vec3(0.0, 0.0, fGlobalTime);
|
||||
vec3 rd = normalize(vec3(uv, 1.0));
|
||||
float st = 1.0;
|
||||
vec3 p = rm(ro, rd, st);
|
||||
vec3 c = shade(ro, p , st);
|
||||
|
||||
vec3 n = n(p);
|
||||
vec3 rd2 = reflect(rd, n);
|
||||
vec3 ro2 = p + 0.1 * n;
|
||||
vec3 p2 = rm(ro, rd2, st);
|
||||
c = shade(ro, p2, st);
|
||||
//c = mix(c, shade(ro, p2, st), 0.8);
|
||||
//c = mix(c, vec3(0.0, 1.0 ,1.0), distance(ro, p));
|
||||
|
||||
out_color = vec4(c, 1.0);
|
||||
}
|
||||
154
2019-01-30/shader - volumetric light scattering.glsl
Normal file
154
2019-01-30/shader - volumetric light scattering.glsl
Normal file
@ -0,0 +1,154 @@
|
||||
#version 410 core
|
||||
|
||||
uniform float fGlobalTime; // in seconds
|
||||
uniform vec2 v2Resolution; // viewport resolution (in pixels)
|
||||
|
||||
uniform sampler1D texFFT; // towards 0.0 is bass / lower freq, towards 1.0 is higher / treble freq
|
||||
uniform sampler1D texFFTSmoothed; // this one has longer falloff and less harsh transients
|
||||
uniform sampler1D texFFTIntegrated; // this is continually increasing
|
||||
uniform sampler2D texChecker;
|
||||
uniform sampler2D texNoise;
|
||||
uniform sampler2D texTex1;
|
||||
uniform sampler2D texTex2;
|
||||
uniform sampler2D texTex3;
|
||||
uniform sampler2D texTex4;
|
||||
|
||||
layout(location = 0) out vec4 out_color; // out_color must be written in order to see anything
|
||||
|
||||
#define time fGlobalTime
|
||||
|
||||
float sph(vec3 p, float r) {
|
||||
return length(p)-r;
|
||||
}
|
||||
|
||||
float box(vec2 p, float s) {
|
||||
vec2 ap=abs(p)-s;
|
||||
return min(0,max(ap.x,ap.y));
|
||||
}
|
||||
|
||||
float cyl(vec2 p, float r) {
|
||||
return length(p)-r;
|
||||
}
|
||||
|
||||
mat2 rot(float a) {
|
||||
float ca=cos(a);
|
||||
float sa=sin(a);
|
||||
return mat2(ca,sa,-sa,ca);
|
||||
}
|
||||
|
||||
float map(vec3 p) {
|
||||
|
||||
float a=abs(sph(p,1.0))-0.2;
|
||||
|
||||
float c=10000;
|
||||
for(int i=0; i<5; ++i) {
|
||||
|
||||
float t1=time+i;
|
||||
p.xy *= rot(t1);
|
||||
p.yz *= rot(t1*0.7);
|
||||
//p.xy=abs(p.xy);
|
||||
//p-=0.1+i*0.1;
|
||||
|
||||
c=min(c,cyl(p.xz, 0.2+0.7*exp(-fract(time*0.2))));
|
||||
|
||||
}
|
||||
|
||||
return max(a, -c);
|
||||
}
|
||||
|
||||
vec3 norm(vec3 p) {
|
||||
vec2 off=vec2(0.01,0);
|
||||
return normalize(map(p)-vec3(map(p-off.xyy), map(p-off.yxy), map(p-off.yyx)));
|
||||
}
|
||||
|
||||
float rnd(vec2 t) {
|
||||
return fract(dot(sin(t*vec2(745.232,456.278)+t.yx*vec2(423.251,895.655)), vec2(7458.232)));
|
||||
}
|
||||
|
||||
float rnd(float t) {
|
||||
return fract(sin(t*445.789)*8956.555);
|
||||
}
|
||||
|
||||
float curve(float t, float d) {
|
||||
float g=t/d;
|
||||
return mix(rnd(floor(g)), rnd(floor(g)+1), pow(smoothstep(0,1,fract(g)), 10));
|
||||
}
|
||||
|
||||
void main(void)
|
||||
{
|
||||
vec2 uv = vec2(gl_FragCoord.x / v2Resolution.x, gl_FragCoord.y / v2Resolution.y);
|
||||
uv -= 0.5;
|
||||
uv /= vec2(v2Resolution.y / v2Resolution.x, 1);
|
||||
|
||||
uv.x += (curve(time, 1.7)-0.5)*0.5;
|
||||
uv.y += (curve(time, 1.2)-0.5)*0.3;
|
||||
|
||||
vec3 s=vec3(0,0, -7);
|
||||
vec3 r=normalize(vec3(-uv, 0.2+curve(time, 0.7)));
|
||||
|
||||
vec3 p=s;
|
||||
float dd=0;
|
||||
for(int i=0; i<50; ++i) {
|
||||
float d=map(p);
|
||||
if(d<0.001) {
|
||||
break;
|
||||
}
|
||||
if(dd>60) break;
|
||||
p+=r*d;
|
||||
dd+=d;
|
||||
}
|
||||
|
||||
vec3 pl=vec3(0);
|
||||
vec3 l=normalize(vec3(pl-p));
|
||||
|
||||
int steps=30;
|
||||
float maxdist=25;
|
||||
float stepsize=maxdist/steps;
|
||||
vec3 rd=r*stepsize;
|
||||
vec3 np =s + rd * (rnd(uv)+2);
|
||||
float at=0;
|
||||
|
||||
float rand = rnd(uv+17.52);
|
||||
for(int i=0; i<steps; ++i) {
|
||||
|
||||
float shad=1;
|
||||
float st=0;
|
||||
int shadstep=20;
|
||||
|
||||
vec3 lightd = (l-np)/shadstep;
|
||||
vec3 lightp = np + rand * lightd;
|
||||
for(int j=0; j<shadstep; ++j) {
|
||||
float shadm = map(lightp);
|
||||
if(shadm<0.01) {
|
||||
shad=0;
|
||||
break;
|
||||
}
|
||||
lightp += lightd;
|
||||
}
|
||||
|
||||
float len = length(np-pl);
|
||||
at += shad*0.04/(pow(len,1.7));
|
||||
if(length(np-s)>dd) break;
|
||||
np+=rd;
|
||||
}
|
||||
|
||||
vec3 n=norm(p);
|
||||
|
||||
|
||||
vec3 col = vec3(0);
|
||||
col += max(0, dot(n,l));
|
||||
col += at * vec3(1,.5,0.7)*2;
|
||||
|
||||
|
||||
float t2 = time*0.7 + curve(time, 0.9)*2.0;
|
||||
col.xy *= rot(t2);
|
||||
col.yz *= rot(t2*1.3);
|
||||
col.xz *= rot(t2*0.7);
|
||||
|
||||
col = abs(col);
|
||||
col *= 10;
|
||||
col = 1-exp(-col);
|
||||
col = pow(col, vec3(1.5));
|
||||
|
||||
out_color = vec4(col, 1);
|
||||
}
|
||||
Reference in New Issue
Block a user