From 125db09c1d3f0dcaa6e67e87965f3d3a304ef335 Mon Sep 17 00:00:00 2001 From: Leon Date: Thu, 2 Apr 2020 00:18:54 +0200 Subject: [PATCH] upload live stream sessions --- 2020-03-19/Flopine.glsl | 111 ++++++++++++++++++++++++++++++++ 2020-03-19/Readme.md | 8 +++ 2020-03-19/Sixclones.glsl | 100 +++++++++++++++++++++++++++++ 2020-03-19/alkama.glsl | 132 ++++++++++++++++++++++++++++++++++++++ 2020-03-19/anton.glsl | 96 +++++++++++++++++++++++++++ 2020-03-19/bruce.glsl | 29 +++++++++ 2020-03-19/cookie.glsl | 39 +++++++++++ 2020-03-19/evvvvil.glsl | 109 +++++++++++++++++++++++++++++++ 2020-03-19/lamogui.glsl | 66 +++++++++++++++++++ 2020-03-19/nusan.glsl | 122 +++++++++++++++++++++++++++++++++++ 2020-03-19/ponk.glsl | 105 ++++++++++++++++++++++++++++++ 2020-03-26/Readme.md | 8 +++ 2020-03-26/Wrighter.glsl | 108 +++++++++++++++++++++++++++++++ 2020-03-26/alkama.glsl | 107 ++++++++++++++++++++++++++++++ 2020-03-26/anton.glsl | 87 +++++++++++++++++++++++++ 2020-03-26/bruce.glsl | 31 +++++++++ 2020-03-26/cookie.glsl | 60 +++++++++++++++++ 2020-03-26/flopine.glsl | 124 +++++++++++++++++++++++++++++++++++ 2020-03-26/lamogui.glsl | 83 ++++++++++++++++++++++++ 2020-03-26/nusan.glsl | 111 ++++++++++++++++++++++++++++++++ 2020-03-26/ponk.glsl | 106 ++++++++++++++++++++++++++++++ 21 files changed, 1742 insertions(+) create mode 100644 2020-03-19/Flopine.glsl create mode 100644 2020-03-19/Readme.md create mode 100644 2020-03-19/Sixclones.glsl create mode 100644 2020-03-19/alkama.glsl create mode 100644 2020-03-19/anton.glsl create mode 100644 2020-03-19/bruce.glsl create mode 100644 2020-03-19/cookie.glsl create mode 100644 2020-03-19/evvvvil.glsl create mode 100644 2020-03-19/lamogui.glsl create mode 100644 2020-03-19/nusan.glsl create mode 100644 2020-03-19/ponk.glsl create mode 100644 2020-03-26/Readme.md create mode 100644 2020-03-26/Wrighter.glsl create mode 100644 2020-03-26/alkama.glsl create mode 100644 2020-03-26/anton.glsl create mode 100644 2020-03-26/bruce.glsl create mode 100644 2020-03-26/cookie.glsl create mode 100644 2020-03-26/flopine.glsl create mode 100644 2020-03-26/lamogui.glsl create mode 100644 2020-03-26/nusan.glsl create mode 100644 2020-03-26/ponk.glsl diff --git a/2020-03-19/Flopine.glsl b/2020-03-19/Flopine.glsl new file mode 100644 index 0000000..b2a99aa --- /dev/null +++ b/2020-03-19/Flopine.glsl @@ -0,0 +1,111 @@ +#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 PI 3.141592 +#define TAU (2.*PI) + +#define time fGlobalTime + +mat2 rot (float a) +{return mat2 (cos(a),sin(a),-sin(a),cos(a));} + +void mo (inout vec2 p, vec2 d) +{ + p = abs(p)-d; + if (p.y>p.x) p = p.yx; +} + +void moda (inout vec2 p, float rep) +{ + float per = TAU/rep; + float a = atan(p.y,p.x); + float l = length(p); + a = mod(a,per)-per*0.5; + p = vec2(cos(a),sin(a))*l; +} + +float prim1 (vec3 p,float size) +{ + p *= size; + p.yz *= rot(time); + //p.xz *= rot(time); + float c = length(p.xz) -1.; + mo(p.xz,vec2(0.9)); + moda(p.xz, 3.); + mo(p.yz,vec2(0.2)); + moda(p.xy, 8.); + mo(p.xy,vec2(0.1)); + return max(-c,dot(p,normalize(vec3(0.5,.5,3.)))) / (size); +} + +float fractal (vec3 p) +{ + float s = 1.; + float d = prim1(p,s); + for (int i=1; i<4; i++) + { + float ratio =float( i)/3.; + s -= 0.3; + p.xz *= rot(time*ratio); + d = min(d, prim1(p,s)); + } + return d; +} + +float g1 = 0.; +float SDF (vec3 p) +{ + float sphe = length(p)-(2.+texture(texNoise, p.xy*5).x); + g1 += 0.01/(0.01+sphe*sphe); + return max(-(length(p+vec3(0.,0.,12.))-3.),min(sphe,fractal(p))); +} + +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); + + vec3 ro = vec3(0.001,0.001,-12.), + rd = normalize(vec3(uv,1.)), + col = vec3(0.), + p = ro; + + float shad = 0.; + bool hit = false; + + for (float i=0.; i<64.; i++) + { + float d = SDF(p); + if (d<0.001) + { + hit = true; + shad = i/64.; + break; + } + p += d*rd*0.8; + } + if (hit) + + { + col = vec3(1.-shad); + col += g1*vec3(.8,.1,0.9)*0.7; + } + + + out_color = vec4(sqrt(col),1.); +} \ No newline at end of file diff --git a/2020-03-19/Readme.md b/2020-03-19/Readme.md new file mode 100644 index 0000000..491077c --- /dev/null +++ b/2020-03-19/Readme.md @@ -0,0 +1,8 @@ +# Performances + +On March 19th, 2020 on [Cookie Live Stream](https://www.twitch.tv/videos/570598632). + +## Software + +- [Bonzomatic](https://github.com/TheNuSan/Bonzomatic/) +- [TidalCycles](https://tidalcycles.org/) diff --git a/2020-03-19/Sixclones.glsl b/2020-03-19/Sixclones.glsl new file mode 100644 index 0000000..ca0a03b --- /dev/null +++ b/2020-03-19/Sixclones.glsl @@ -0,0 +1,100 @@ +#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 P 3.14159 +#define TP 2.0 * P +#define HP 0.5 * P +#define QP 0.25 * P + +#define t fGlobalTime +#define ht 0.5 * t +#define tt 0.1 * t + +#define S(a, b, t) smoothstep(a, b, t) + +float map01(float n, float stop2, float start2) { + return (0.5 * n + 0.5) * stop2 + start2; +} + +float circleSDF(vec2 uv) { + return length(uv); +} + +float rectSDF(vec2 uv, vec2 s) { + return max(abs(uv.x / s.x), abs(uv.y / s.y)); +} + +vec2 rotate2d(vec2 uv, float a) { + return uv * mat2(cos(a), sin(-a), cos(a), sin(a)); +} + +float fill(float x, float s) { + return 1.0 - step(s, x); +} + +float fill(float x, float s, float p) { + p *= 0.01; + return 1.0 - S(s - p, s + p, x); +} + +float stroke(float x, float s, float w, float p) { + p *= 0.01; + return clamp( + S(s - p, s + p, x - 0.5 * w) * S(s + p, s - p, x + 0.5 * w), + 0.0, 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); + + float n = 8.0; + vec2 gv = fract(n * uv); + vec2 id = floor(n * uv); + + vec3 color = vec3(0.0); + + float offset = mix( + map01(sin(-t + P * gv.x - cos(ht + P * id.x) - sin(P * gv.y)), QP, HP), + map01(cos(t + TP * gv.x), 0.0, TP), + step(0.5, mod(ht, 2.0)) + ); + float np = map01( + sin(t + P * uv.x + sin(-t + TP * uv.y) + P * gv.x + offset), + 6.0, 10.0 * uv.x + 4.0 + mod(ht, 0.5)); + vec2 size = vec2( + map01(cos(t + P * uv.x + 0.5 * sin(t + TP * id.x)), 0.5, 2.0), + map01(sin(t - QP * uv.y + cos(-ht + TP * (uv.x + uv.y))), 0.5, 2.0) + ); + float rect = rectSDF(rotate2d(uv, ht + cos(t + P * uv.x)), size); + vec3 pre = vec3( + 0.0, + map01(cos(t), 15.0, 20.0), + map01(sin(t), 15.0, 20.0) + ); + float circ = circleSDF(uv); + float circf = fill(circ, map01(sin(t + P * uv.x + sin(-t + 5.0 * P * uv.y) + cos(t + P * (id.x - 0.5))), 0.25, 0.75)); + color.r += fill(fract(-t + np * rect), 0.5, 10.0*cos(t + P * gv.x) + 15.0); + color.g += fill(fract(-t + np * rect), 0.5, 10.0*sin(t + TP * gv.y + sin(-t)) + pre.y); + color.b += fill(fract(-t + np * rect), 0.5, 10.0*sin(t + cos(-t + TP * uv.x)) + pre.z); + color *= circf; + + out_color = vec4(color, 1.0); +} \ No newline at end of file diff --git a/2020-03-19/alkama.glsl b/2020-03-19/alkama.glsl new file mode 100644 index 0000000..01a991b --- /dev/null +++ b/2020-03-19/alkama.glsl @@ -0,0 +1,132 @@ +#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 + +const float pi = acos(-1); + +float tt = .4*mod(fGlobalTime, pi*100.); +float rt = floor(tt); +float ft = fract(tt); +float t = rt + ft*ft; + +mat2 rot(float a) { float c=cos(a), s=sin(a); return mat2(c,s,-s, c); } +float torus(vec3 p, float r, float s) { vec2 b=vec2(length(p.xy)-r, p.z); return length(b)-s; } + +vec2 moda(vec2 p, float r) { + r = 2*pi/r; + float a = mod(atan(p.y, p.x), r) - r*.5; + return vec2(cos(a), sin(a))*length(p); +} + +float glowAccumulator = 0; +float scene(vec3 p) { + vec3 po = p; + + p.y = mod(p.y+t, 2.)-1.; + + p.xz *= rot(tt); + + p.xz = moda(p.xz, 4. + (mod(tt*2, 5))); + p.yz = moda(p.yz, 4. + (mod(tt*2, 7))); + + float tr = torus(p, 2.+.5*sin(tt), .01); + float pl = dot(abs(p), vec3(0, .4, 1.))-.1; + float o = max(tr, pl)-.2; + + // lets make it glow even more :D + po.y -= sin(10*t+po.y); + po.xz += .2*sin(2*t+po.y); + float glo = length(po.xz)-.2; + po = p; + po.y += .05*sin(10*t+po.x*po.z); + glo = min(glo, length(po.yz))-.01; + glowAccumulator+= .03/(.01+abs(glo)); + + return min(o, max(glo, .01)); +} + +vec3 getCamera(vec2 pixelCoord, vec3 origin, vec3 target, float zoom) { + vec3 forward = normalize(target-origin); + vec3 side = normalize(cross(vec3(0,1,0), forward)); + vec3 up = normalize(cross(forward, side)); + return normalize(forward*zoom+pixelCoord.x*side+pixelCoord.y*up); +} + +vec3 calculateNormalUsingGradientsAt(vec3 p) { + vec2 eps = vec2(0, .001); + return normalize(vec3(scene(p) - vec3(scene(p-eps.yxx), scene(p-eps.xyx), scene(p-eps.xxy)))); +} + +#define fakeAmbiantOcclusion(a) clamp(scene(hitPoint+normalAtHitpoint*a)/a, 0., 1.) +#define fakeSubSurfaceScattering(a) smoothstep(0., 1., scene(hitPoint+lightDirection*a)/a) +void main(void) +{ + vec2 currentPixelCoord = (gl_FragCoord.xy / v2Resolution.xy - .5) * vec2(v2Resolution.x/v2Resolution.y, 1); + + vec3 eye = (15+5*cos(t+sin(t))) * vec3(0, 0, .5); + vec3 target = vec3(0); + target.xz += vec2(sin(t), cos(t)); + target.y += 6*sin(t); + + + float idx = mod(floor(tt*5), 11); + if(idx == 0) { + currentPixelCoord.x = abs(currentPixelCoord.x); + } + if(idx == 1) { + currentPixelCoord = abs(currentPixelCoord); + } + if(idx > 2 || idx < 6) { + currentPixelCoord *= 1. - length(currentPixelCoord)*.7; + } + if(idx > 6) { + currentPixelCoord /= 1. - length(currentPixelCoord)*.10; + } + + vec3 rayDirection = getCamera(currentPixelCoord, eye, target, .8); + + float clouds = texture(texNoise, .7*abs(vec2(atan(rayDirection.y, rayDirection.z), rayDirection.x))).r; + vec3 color = vec3(pow(1.8*clouds, 4)); + + vec3 lightPosition = 10*vec3(1,1,-1); + + float hitDistance = 0; + vec3 hitPoint = eye; // < start from eye position + int i = 0; + for(i=0; i<300; i++) { + float closestHit = scene(hitPoint)*.7; + if(abs(closestHit)<.001) { + vec3 normalAtHitpoint = calculateNormalUsingGradientsAt(hitPoint); + vec3 lightDirection = normalize(lightPosition-hitPoint); + float diffuse = max(0, dot(normalAtHitpoint, lightDirection)); + float specular = pow(max(0, dot(rayDirection, reflect(lightDirection, normalAtHitpoint))), 50); + color = vec3(diffuse)*fakeSubSurfaceScattering(.4); + color *= .2+.2*(fakeAmbiantOcclusion(.1)+fakeAmbiantOcclusion(.3)); + color += vec3(specular); + break; + + } + if(hitDistance>100.) break; + + hitDistance += closestHit; + hitPoint += rayDirection * closestHit; + } + color += vec3(1.4, .1, .5)*pow(i * .007, .9); + + color += vec3(.0002+.0001*sin(t*10))*pow(glowAccumulator, 3)*normalize(acos(-rayDirection)); + + out_color = vec4(color, 1); +} \ No newline at end of file diff --git a/2020-03-19/anton.glsl b/2020-03-19/anton.glsl new file mode 100644 index 0000000..6d4be07 --- /dev/null +++ b/2020-03-19/anton.glsl @@ -0,0 +1,96 @@ +#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 iTime fGlobalTime +#define REP(p, r) (mod(p + r * .5, r) - r * .5) + +mat2 rotation(float angle) +{ + float cosA = cos(angle); float sinA = sin(angle); + return mat2(cosA, -sinA, sinA, cosA); + } + +float map(vec3 position) +{ + vec3 cp = position; + + + position.xz *= rotation(iTime * .1 + position.y *.0125); + + position.z -=iTime * 2.; + + +position = REP(position, 15.); + + + float distan = length(position) - 2.; + + position = cp; + + distan = max(distan, -length(position.xy) + (1. + sin(position.z - iTime) * .5)); + + + return distan; + } + + vec3 norm(vec3 p) + { + vec2 e = vec2(.01,.0); + float v = map(p); + return normalize(vec3(v - map(p + e.xyy), + v - map(p + e.yxy), + v - map(p + e.yyx))); + } + +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); + + vec3 ro = vec3(0.,0.,-10.); + vec3 cp = ro; + vec3 rd = normalize(vec3(uv, 1.)); + + float cd = 0., st = 0., di = 0.; + + for(;st < 1.; st += 1. / 128.) + { + cd = map(cp); + if(abs(cd) < .01 || cd > 10.) + { + break; + } + + cp += rd * cd; + di += cd; + } + + out_color = vec4(0.); + if(cd < .01) + { + vec3 normal = norm(cp); + + out_color = vec4(normal, 0.) * di; + cp *= .01; + out_color.rg *= rotation(cp.y + iTime); + out_color.gb *= rotation(cp.z + iTime * .5); + out_color.br *= rotation(cp.x + iTime * .25); + out_color *= exp(-di * .0125); + + out_color = sqrt(out_color); + } +} \ No newline at end of file diff --git a/2020-03-19/bruce.glsl b/2020-03-19/bruce.glsl new file mode 100644 index 0000000..0dffca0 --- /dev/null +++ b/2020-03-19/bruce.glsl @@ -0,0 +1,29 @@ +#version 410 core +uniform float fGlobalTime; +uniform vec2 v2Resolution; +uniform sampler1D texFFT; +uniform sampler2D texNoise; +uniform sampler2D texTex1; +layout(location = 0) out vec4 out_color; +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); + vec2 m; + m.x = atan(uv.x / uv.y) / 3.14; + vec4 fromage = texture(texNoise, uv-m+sin(fGlobalTime)+0.5); + float raclette = uv.x ; + uv += pow(length(uv), raclette* fromage.x); + m.y = 1 / length(uv) * .2; + float r = sqrt(dot(uv,uv)); + float w = (sin(fGlobalTime)+ 3.0*cos(fGlobalTime + 15.0*m.y)/2.0); + float col = 0.0; + float d = pow(dot(uv,uv),12.*cos(fGlobalTime)+0.975); + col = .1/length(mod(uv, 1.0)-sin(fGlobalTime*d*w*m)+0.41); + float coscoscos = cos(d) + cos(m.x) + cos(fromage.r); + col += smoothstep(-2., 2., d-fromage.g+mod(uv,2.0).r * coscoscos); + + float camembert = fromage.r * m.y+r * abs(sin(uv.x)); + out_color = vec4(camembert, fromage.r, col,1.0)*vec4(0.5,camembert,0.9,1.0); +} \ No newline at end of file diff --git a/2020-03-19/cookie.glsl b/2020-03-19/cookie.glsl new file mode 100644 index 0000000..a687a75 --- /dev/null +++ b/2020-03-19/cookie.glsl @@ -0,0 +1,39 @@ +#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 cookie; +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 a) { float c=cos(a),s=sin(a); return mat2(c,-s,s,c); } + +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.y *= -1.0; + float d = length(uv); + uv *= 2. + 0.2 * sin(time + d*4.); + uv *= rot(sin(time*2.-d*2.)*.2); + uv += 0.5; + + + vec4 color = texture(cookie, uv); + color.rgb = mix(vec3(0), vec3(1), color.a); + + out_color = color; +} \ No newline at end of file diff --git a/2020-03-19/evvvvil.glsl b/2020-03-19/evvvvil.glsl new file mode 100644 index 0000000..8406f95 --- /dev/null +++ b/2020-03-19/evvvvil.glsl @@ -0,0 +1,109 @@ +#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 +vec2 s,v,e=vec2(.00035,-.00035);float t,tt,b,bb,g,g2;vec3 np,bp,pp,po,no,al,ld; +float bo(vec3 p, vec3 r){p=abs(p)-r;return(max(max(p.x,p.y),p.z));} +mat2 r2 (float r){ return mat2(cos(r),sin(r),-sin(r),cos(r));} +vec4 c=vec4(0,5,15,.2); +vec2 fb( vec3 p ) +{ + vec2 h,t=vec2(bo(p,vec3(2,5,1)),5); + t.x=abs(t.x)-.2; + t.x=max(t.x,p.z-0.3); + + h=vec2(bo(p,vec3(2,5,1)),6); + h.x=abs(h.x)-.1; + h.x=max(h.x,p.z-0.6); + + t=t.x100) break; + t.x+=h.x;t.y=h.y; + } + if(t.x>100) t.y=0; + return t; +} +#define a(d) clamp(mp(po+no*d).x/d,0.,1.) +#define s(d) smoothstep(0.,1.,mp(po+ld*d).x/d) +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); + //float f = texture( texFFT, d ).r * 100; +tt=mod(fGlobalTime,62.83); + + vec3 ro=mix(vec3(1),vec3(-1,-1,1),ceil(sin(tt*.4)))*vec3(cos(tt*.2)*3,5,-20.), + cw=normalize(vec3(0)-ro), + cu=normalize(cross(cw,vec3(0,1,0))), + cv=normalize(cross(cu,cw)), + rd=mat3(cu,cv,cw)*normalize(vec3(uv,.5)),co,fo; + co=fo=vec3(.1)-length(uv)*.1; + ld=normalize(vec3(.2,.3,-.4)); + + s=tr(ro,rd);t=s.x; + if(s.y>0){ + po=ro+rd*t; + no=normalize(e.xyy*mp(po+e.xyy).x+ + e.yyx*mp(po+e.yyx).x+ + e.yxy*mp(po+e.yxy).x+ + e.xxx*mp(po+e.xxx).x);al=vec3(.1,.2,.4); + if(s.y<5) al=vec3(0); + if(s.y>5) al=vec3(1); + float dif=max(0,dot(no,ld)), + fr=pow(1+dot(no,rd),4), + sp=pow(max(dot(reflect(-ld,no),-rd),0),30); + co=mix(sp+al*(a(.1)*a(.4)+.2)*(dif+s(2)+s(4)),fo,min(fr,.5)); + co=mix(fo,co,exp(-.0001*t*t*t)); + } + out_color = vec4(pow(co+g*.2+g2*vec3(.1,.2,.4)*.2,vec3(.45)),1); +} \ No newline at end of file diff --git a/2020-03-19/lamogui.glsl b/2020-03-19/lamogui.glsl new file mode 100644 index 0000000..b304771 --- /dev/null +++ b/2020-03-19/lamogui.glsl @@ -0,0 +1,66 @@ +#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 + +mat2 r(float a ){ + float c = cos(a); + float s = sin(a); + + return mat2(c, s, -s, c); +} + + +float map(vec3 p) { + vec3 g = p; + g.xy = r(p.z*0.1) * g.xy; + vec3 prout = g; + float d = cos(g.x) + cos(g.y) + cos(g.z); + + float s = 10.0; + g *= s; + d = max(d, (cos(g.x) + cos(g.y) + cos(g.z) ) /s); + d = min(d, p.y + 0.2 - 0.1 * texture(texNoise, p.xz).r - 0.1 * cos(fGlobalTime + 2.0*p.z + 2.632 * p.x)); + return min(d, prout.y + 1.0 + 0.7 *texture(texNoise, p.xz * 0.2).r - 0.1 * cos(fGlobalTime + 2.0*prout.z + 2.632 * prout.x)); +} + + +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); + + float v = cos(fGlobalTime*3.0); + + vec3 ro = vec3(0.0,0.2 * abs(v),fGlobalTime); + vec3 rd = normalize(vec3(uv, 0.7 - length(uv))); + vec3 p = ro; + + float st = 1.0; + for ( float i = 0.; i< 127.; ++i) { + float d = map(p); + if (abs(d) < 0.01) { + st = i / 127.0; + break; + } + p += rd * d; + } + + uv = uv *0.8+ 0.2* r(fGlobalTime * 10.0) * uv; + + vec3 color = vec3((uv +0.5) * (st), 0.1) * (1.0) + (vec3(uv, 0.1) * exp( -0.1 * distance(p,ro))) + (vec3(uv, 0.1) * (1.0 -exp( -0.1 * distance(p,ro)))); + out_color = vec4(color, 0.0); +} \ No newline at end of file diff --git a/2020-03-19/nusan.glsl b/2020-03-19/nusan.glsl new file mode 100644 index 0000000..b50e336 --- /dev/null +++ b/2020-03-19/nusan.glsl @@ -0,0 +1,122 @@ +#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 time = fGlobalTime; + +mat2 rot(float a) { + float ca=cos(a); + float sa=sin(a); + return mat2(ca,sa,-sa,ca); +} + +float box(vec3 p, vec3 s) { + p=abs(p)-s; + return max(p.x, max(p.y,p.z)); +} + +float rnd(float t) { + + return fract(sin(t*421.522)*742.512); +} + +float curve(float t, float d) { + t/=d; + return mix(rnd(floor(t)), rnd(floor(t)+1), pow(smoothstep(0,1,fract(t)),10)); +} + +vec3 fractal(vec3 p, float t1) { + + p.xz *= rot(sin(p.y*0.2+time)*0.5); + p.yz *= rot(sin(p.x*0.3+time*1.3)*1.5); + + for(int i=0; i<7; ++i){ + float t=i + t1*0.1 + curve(t1,0.4)*0.5 + p.x*(0.1+sin(curve(t1,0.2)+t1*0.3)*0.2); + p.xz *= rot(t); + p.xy *= rot(t*0.7); + p.xz = abs(p.xz) - vec2(3,3)*(0.2+i*0.1)*0.7; + } + + return p; +} + +float at1=0; +float at2=0; +float map(vec3 p) { + + + vec3 p2 = fractal(p+vec3(0,0,0), 12.7+time); + vec3 p3 = fractal(p+vec3(0,2,0), 15.7+time*0.7); + + float d=box(p2, vec3(3,2,0.1)); + float d2=box(p3, vec3(3,2,0.1)); + + + d=min(d, max(-p.y,length(p.xz)-0.2)); + + at1 = d; + at2 = d2; + + d=min(d,d2); + + d=max(d,0.1); + + + return d; +} + +void cam(inout vec3 p) { + + + float t=time*0.2 + curve(time, 1.7)*3.0; + p.yz *= rot(sin(t*1.3)*0.3+0.6); + p.xz *= rot(t); + +} + +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.5; + + vec3 s=vec3(0,0,-30); + float fov = 0.9+curve(time, 0.7); + vec3 r=normalize(vec3(-uv, fov)); + + cam(s); + cam(r); + + vec3 col=vec3(0); + + vec3 p=s; + for(int i=0; i<100; ++i) { + float d=map(p); + if(d<0.001) break; + if(d>200.0) break; + p+=r*d; + //col += vec3(0.2,0.4,0.9)*0.01/(0.1+abs(d)); + col += vec3(0.2,0.4,0.9)*0.004/(0.1+abs(at1)); + col += vec3(0.9,0.3,0.2)*0.004/(0.1+abs(at2)); + } + + col *= 1.2-length(uv); + + + out_color = vec4(col,1); +} \ No newline at end of file diff --git a/2020-03-19/ponk.glsl b/2020-03-19/ponk.glsl new file mode 100644 index 0000000..9c3f9de --- /dev/null +++ b/2020-03-19/ponk.glsl @@ -0,0 +1,105 @@ +#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 cookie; +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 +#define repeat(p,r) (mod(p,r)-r/2.) + +mat2 rot (float a) { float c=cos(a),s=sin(a); return mat2(c,-s,s,c); } +vec3 lookat (vec3 eye, vec3 at, vec2 uv, float fov) { + vec3 forward = normalize(at-eye); + vec3 right = normalize(cross(forward, vec3(0,1,0))); + vec3 up = normalize(cross(right, forward)); + return normalize(forward * fov + right * uv.x + up * uv.y); +} + +float map (vec3 pos) { + + vec3 p0 = pos; + float cell = 6.; + float iz = floor(pos.z/cell); + //pos.z = repeat(pos.z + time, cell); + //pos.xz *= rot(time); + //pos.xy *= rot(time); + float scene = 1.0; + float range = 2.0;// + 1.0 * sin(time); + float a = 1.0; + float falloff = 1.2; + const float count = 7.; + for (float index = count; index > 0.; --index) { + pos.xz *= rot(time*.05/a); + //pos.yz *= rot(sin(time)*0.2); + pos = abs(pos)-range*a; + //scene = min(scene, length(pos)-0.5*a); + scene = min(scene, max(pos.x,max(pos.y,pos.z))); + a /= falloff; + } + scene = max(-scene,0.); + //pos = repeat(pos, .1); + //scene = max(scene, -length(pos.xy)+.05); + //scene = max(scene, -length(p0.xy)+1.0); + + pos = p0; + //pos.z = repeat(pos.z + time, cell); + a = 1.0; + float shape = 1.; + for (float index = 4.; index > 0.; --index) { + pos.xz *= rot(time*.2); + pos.yz *= rot(time*2.); + pos.xz = abs(pos.xz)-.3*a; + shape = min(shape, length(pos.xy)-0.2*a); + a /= falloff; + } + //shape = max(shape, length(p0)-.5); + //scene = min(scene, shape); + + //scene = max(scene, length(p0)-2.); + return scene; +} + +vec3 getNormal (vec3 p) { + vec2 e = vec2(0.001,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 /= vec2(v2Resolution.y / v2Resolution.x, 1); + + vec3 eye = vec3(0,0.,-2); + vec3 ray = lookat(eye, vec3(0.,sin(time*.2)*.5,0), uv, .5); + float total = 0.0; + float shade = 0.0; + const float count = 100.; + for (float index = count; index > 0.; --index) { + float dist = map(eye+ray*total); + if (dist < 0.001) { + shade = index/count; + break; + } + dist *= .9; + total += dist; + } + vec3 color = vec3(shade); + vec3 normal = getNormal(eye+ray*total); + color = vec3(.3)*clamp(dot(normal, normalize(vec3(0,1,-1))),0.,1.); + color += vec3(.9)*pow(clamp(dot(normal, -ray),0.,1.), 8.); + color *= shade; + out_color = vec4(color,1); +} \ No newline at end of file diff --git a/2020-03-26/Readme.md b/2020-03-26/Readme.md new file mode 100644 index 0000000..eb6ac6a --- /dev/null +++ b/2020-03-26/Readme.md @@ -0,0 +1,8 @@ +# Performances + +On March 26th, 2020 on [Cookie Live Stream](https://www.twitch.tv/videos/576039130). + +## Software + +- [Bonzomatic](https://github.com/TheNuSan/Bonzomatic/) +- [TidalCycles](https://tidalcycles.org/) diff --git a/2020-03-26/Wrighter.glsl b/2020-03-26/Wrighter.glsl new file mode 100644 index 0000000..8c7b5d4 --- /dev/null +++ b/2020-03-26/Wrighter.glsl @@ -0,0 +1,108 @@ +#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 sdBox(vec2 p, vec2 s){ + p = abs(p) - s; + return max(p.x, p.y); +} + +float xor(float x,float y){ + return float(int(x)*int(y)); + } + +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.xy *= rot(time*0.00004 + q.y*0.01); + + vec3 col = vec3(0); + vec2 p = uv; + #define pal(a,b,c,d,e) (a + b*sin(c*d + e)) + #define rot(x) mat2(cos(x),-sin(x),sin(x),cos(x)) + + float d = 10e7; + vec2 q = vec2(10.*atan(p.x,p.y)/6.28, length(p)); + + q.y = log(q.y) + time*1.11 + texture(texFFT, 0.1).x*10.5 ; + + float id = floor(q.y*10.); + q.xy *= rot(time*0.00004 + q.y*0.0001); + q = sin(q*3.); + q = sin(q*1. + time); + + float a = 0.; + + + for(float i = 0.; i < 20.; i++){ + + //q = abs(q); + if(q.x < q.y) + q.xy = q.yx; + + float m = 100.; + float x = xor(q.y*m,q.x*m); + + q.x *= 1. ; + + + if(mod(x*2., 1.) < 1.){ + //float circ = exp(-length(sin(q*1. + time))*20.); + float circ = exp(-length(sin(q*1. + time))*20.); + col += circ * pal(0.5,1.,vec3(0.2,0.3,0.5), 0.7 ,0.4 + id*0.5); + //d = min(d, length(q) - 10.5); + + } + q -= 0.15; + q -= 0.5; + if(mod(i,3. ) == 0 && x > 0.4){ + d = min(d, sdBox(mod(q,1.) - 0.5, vec2(0.9))); + a += x; + } + else{ + d = max(d, -sdBox(mod(q,1.) - 0.5, vec2(0.3))); + a += x; + } + q.xy *= rot(0.125*3.14); + + } + + + + col += smoothstep(0.001,0., d); + + if(d < 0.001) + col *= pal(0.1,1.,vec3(0.2,0.3,0.5), 0.7 ,0.4 + floor(id)*1. + time); + + + + col = col; + col = max(col, 0.); + + + + + out_color += col.xyzy; + +} \ No newline at end of file diff --git a/2020-03-26/alkama.glsl b/2020-03-26/alkama.glsl new file mode 100644 index 0000000..9287ed8 --- /dev/null +++ b/2020-03-26/alkama.glsl @@ -0,0 +1,107 @@ +#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 + +// Hellow from Alkama's Lab +// _ _ +// ,,,(O.O),,, +// + +#define sat(a) clamp(a, 0., 1.) +#define ao(a) sat(sc(p+n*a)/a) +#define ss(a) smoothstep(0., 1., sc(p+ld*a)/a) + +const float pi = acos(-1); +const vec2 e = vec2(.001, 0); +const vec3 ro = vec3(0,2,-8.5); + +float tt=mod(.4*fGlobalTime, 40.*pi); +float t = tt; + +float torus(vec3 p, float r, float s) { + vec2 b = vec2(length(p.xy)-r, p.z); + return length(b)-s; +} +float box(vec3 p, vec3 s) { vec3 b=abs(p)-s; return max(max(b.x, b.y), b.z); } +mat2 rot(float a) { float c=cos(a),s=sin(a); return mat2(c,s,-s,c); } +vec2 moda(vec2 p, float r) { + r = 2*pi/r; + float a=mod(atan(p.y, p.x), r) -r*.5; + return vec2(cos(a),sin(a))*length(p); +} +float sc(vec3 p) { + vec3 po = p; + + float k = t*.1; + p.xz *= rot(sin(cos(k)*pi+k)*pi); + p.xy += .3*sin(t*.5)*sin(p.yz+tt*5); + + vec3 off = .1*(2*texture(texNoise, p.xz*.5).xyz-1); + p+=off; + + for(int i=0; i<5+floor(mod(tt*.5, 8)); i++) { + p = abs(p); + p.xy *= rot(pi*.1); + p.yz *= rot(pi*.1); + p -= (i+1)*.08+.05*sin(t); + } + p.xz = moda(p.xz, 23.); + p.yz = moda(p.yz, 22.); + + float tr= torus(p*.12, 1.23, .13); + + p.xz *= rot(-t); + p.xy *= rot(-tt); + + float b = box(p, vec3(5., .2+.19*sin(tt), 1)); + + float camex=length(po+off-ro) - 1.5; + + return max(min(b, tr), -camex); +} +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); + + vec3 tg = vec3(1.5*sin(t),0.5*cos(t*2),0); + float z = .7 + .2*sin(tt*2); + vec3 f= normalize(tg-ro); + vec3 s=normalize(cross(vec3(.3*sin(tt),1,0), f)); + vec3 u=normalize(cross(f,s)); + vec3 rd = f*z+uv.x*s+uv.y*u; // << ohohhoho not normalizing that! + vec3 col = vec3(0); + float d=0; + vec3 p = ro; + for(int i = 0; i<300; i++) { + float h = sc(p); + if(h<.001) { + vec3 n=normalize(vec3(sc(p)-vec3(sc(p-e.xyy), sc(p-e.yxy), sc(p-e.yyx)))); + vec3 ld = normalize(20*vec3(1,1,-1) - p); + float fr = sat(pow(max(0., 1.+dot(n,rd)), 2.)); + vec3 bg = normalize(acos(sat(rd))*vec3(1.2, .8, 1.5))*(log(d)*i*.004); + vec3 fg = vec3((ao(.1)+ao(.3))*.1 + ss(.2)*.75); + col = fr*mix(fg, bg, fr)+bg; + break; + } + if(d>100.) break; + d+=h; + p+=rd*h; + } + col *= sat(1.3-pow(length(uv), 2.)); + out_color = vec4(col, 1.); +} \ No newline at end of file diff --git a/2020-03-26/anton.glsl b/2020-03-26/anton.glsl new file mode 100644 index 0000000..db31b5d --- /dev/null +++ b/2020-03-26/anton.glsl @@ -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 REP(p,r) (mod(p + r/2.,r) - r/2.) + +#define iTime (fGlobalTime) + +mat2 rot(float a) +{ + float ca = cos(a); float sa = sin(a); + return mat2(ca,-sa,sa,ca); + } + +float map(vec3 p) +{ + + vec3 cp = p; + + + float dist = p.y + 1.; + + p.xy *= rot(p.z * .01 - iTime * .001); + dist = cos(p.x) + cos(p.y) + cos(p.z); + p = cp; + + + //p += iTime; + // p = REP(p , 17.); + + float cu = max(max(p.x,p.y),p.z); + + dist = min(dist, cu); + + p = cp; + + dist = max(dist, -length(p) + 10.); + + return dist; + } + +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); + + vec3 cp = vec3(0.,5.,-10.); + vec3 rd = normalize(vec3(uv, 1.)); + + float st = 0.; float cd = 0.; float di = 0.; + for(; st < 1.; st += 1./256.) + { + cd = map(cp); + if(abs(cd) < .01 || cd > 30.) + { + break; + } + + + cd = min(cd, 1.); + cp.xz *= rot(sin(st * .001 + iTime * .0025)); + cp += rd * cd; + cp += normalize(vec3(0.,0.,-5.) - cp) * pow(length(vec3(0.,0.,-5.) - cp), 1. + sin(iTime) * .5) * .001; + di += cd; + } + + + float f = 1. - st; + out_color = (vec4(sin(di * .02), cos(di * .003 + .2), sin(di+ iTime) , 1.) * .5 + .5) * exp(-di * .05); + + out_color = pow(out_color,vec4(.4545)); +} \ No newline at end of file diff --git a/2020-03-26/bruce.glsl b/2020-03-26/bruce.glsl new file mode 100644 index 0000000..06dfbe9 --- /dev/null +++ b/2020-03-26/bruce.glsl @@ -0,0 +1,31 @@ +#version 410 core + +uniform float fGlobalTime; +uniform vec2 v2Resolution; +uniform sampler1D texFFT; +uniform sampler2D texNoise; +uniform sampler2D texTex1; + +layout(location = 0) out vec4 out_color; +#define time fGlobalTime + +void main(void) +{ + vec2 uv = vec2(gl_FragCoord.x / v2Resolution.x, gl_FragCoord.y / v2Resolution.y) * 4.0; + uv -= 1.95;// + abs(sin(time)-0.99); + uv /= vec2(v2Resolution.y / v2Resolution.x, 1); +vec3 c = vec3(0.2); + float r = length(uv)*2.0 + (sin(time) -0.5) ; + float a = atan(uv.y, uv.x); + float f = abs(cos (a * 5.)); + vec3 col = vec3(0.0); + for(int i=0;i<3;i++) { + uv += length(uv); + col[i] = 0.01/length(abs(mod(uv,1.)-0.24)); + + } + col = 1.0 - normalize(col*col); + c -= fract(uv.x +time); + c -= vec3( 0.5 - smoothstep(f, f * cos(r*time*0.03), r) ); + out_color = vec4( vec3(c.r + col.r,col.g * sin(time)-0.6,c.b + col.b), 1.0); +} \ No newline at end of file diff --git a/2020-03-26/cookie.glsl b/2020-03-26/cookie.glsl new file mode 100644 index 0000000..eab50c3 --- /dev/null +++ b/2020-03-26/cookie.glsl @@ -0,0 +1,60 @@ +#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 cookie; +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 a) { float c=cos(a),s=sin(a); return mat2(c,-s,s,c); } +float random (in vec2 st) { return fract(sin(dot(st.xy, vec2(12.9898,78.233)))* 43758.5453123); } +vec3 hsv2rgb(vec3 c) +{ + vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0); + vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www); + return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y); +} + +void main(void) +{ + vec2 uv = vec2(gl_FragCoord.x / v2Resolution.x, gl_FragCoord.y / v2Resolution.y); + vec2 loduv = v2Resolution.xy/16.0; + uv -= 0.5; + uv /= vec2(v2Resolution.y / v2Resolution.x, 1); + uv.y *= -1.0; + float d = length(uv); + uv *= 1. + 1. * sin(d*2.+2.);// + uv.x*10.); + uv *= rot((pow(sin(time*2.-d*2.)*0.5+0.5, 8.))*2.); + uv += 0.5; + + + //uv = floor(uv*loduv)/loduv; + vec4 color = texture(cookie, uv); + color.rgb = mix(vec3(0), vec3(1), color.a); + uv = 2.*(gl_FragCoord.xy-0.5*v2Resolution.xy)/v2Resolution.y; + //uv = floor(uv*loduv)/loduv; + d = length(uv); + //uv *= rot(sin(d*2.-time)*.5); + uv.y -= pow(abs(uv.x)*.4,0.1)-.8; + d = length(uv); + float tint = d*.7-time*.2; + //tint += 2.*atan(uv.y,uv.x)/3.14; + float lod = 5.; + tint = ceil(tint*lod)/lod; + float s = step(mod(tint*2., 1.),0.5); + color.rgb = hsv2rgb(vec3(tint, 0.9, color.r)); + + out_color = color; +} \ No newline at end of file diff --git a/2020-03-26/flopine.glsl b/2020-03-26/flopine.glsl new file mode 100644 index 0000000..9544c16 --- /dev/null +++ b/2020-03-26/flopine.glsl @@ -0,0 +1,124 @@ +#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 PI 3.141592 +#define TAU (2.*PI) +#define time fGlobalTime + +#define blipbloop texture(texFFT, 0.01) + +void mo (inout vec2 p, vec2 d) +{ + p = abs(p)-d; + if(p.y>p.x) p = p.yx; + } + + float hash21(vec2 x) + {return fract(sin(dot(x,vec2(12.35,18.5)))*1245.5);} + + +float cyl (vec3 p, float r, float h) +{return max(length(p.xy)-r,abs(p.z)-h);} + +float plane (vec3 p, vec3 n) +{return dot(p,normalize(n));} + +float lily (vec3 p) +{ + float a = atan(p.z,p.x); + p.y += (mod(a, TAU/5.))*0.15; + return cyl(p.xzy, 3.,0.15); + } + + // NO WAS NOT PLANNED + + float flower (vec3 p) + { + p.y += sin(length(p.xz*2.)-time*blipbloop.r)*0.3; + mo(p.xz, vec2(.5)); + mo(p.xy, vec2(.5)); + mo(p.yz, vec2(.3)); + return plane(p, vec3(0.5,0.5,1.)); + } + + float water (vec3 p) + { + p.y += 1.2; + p.y += texture(texNoise, p.xz*0.06+time*0.02).r + texture (texNoise, p.xz*0.05-time*0.01).r; + return abs(p.y)-1.; + } + + float li,wat, flo; +float SDF (vec3 p) +{ + li = lily(p); + wat = water(p); + flo = flower(p); + return min(li,min(flo,wat)); + } + +vec3 getcam (vec3 ro, vec3 tar, vec2 uv) +{ + vec3 f = normalize(tar-ro); + vec3 l = normalize(cross(vec3(0.,1.,0.),f)); + vec3 u = normalize(cross(f,l)); + return normalize(f + l*uv.x + u*uv.y); + } + +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); + + float sither = hash21(uv); + vec3 ro = vec3(0.001,8.,-3.), + p = ro, + tar = vec3(0.), + rd = getcam(ro, tar, uv), + col = vec3(0.); + + float d, shad = 0.; + + for (float i=0.; i<64.; i++) + { + d = SDF(p); + if (d <0.001) + { + shad = i/64.; + break; + } + d *= 0.9+sither*0.05; + p += d*rd; + } + + if (d==wat) + { + col = mix(vec3(0.1,0.2,0.8),vec3(0.7,0.8,0.9),floor((shad)*7.)/7.); + } + if (d==li) + { + col = mix(vec3(0.1,0.5,0.2),vec3(0.7,0.9,0.8),floor((shad)*15)/15); + } + if (d==flo) + { + col = mix(vec3(0.7,0.2,0.8),vec3(0.7,0.7,0.8),floor((shad)*8.)/8.)*0.8; + } + + //col = vec3(water(vec3(uv,0.))); + out_color = vec4(sqrt(col),1.); +} \ No newline at end of file diff --git a/2020-03-26/lamogui.glsl b/2020-03-26/lamogui.glsl new file mode 100644 index 0000000..98e0787 --- /dev/null +++ b/2020-03-26/lamogui.glsl @@ -0,0 +1,83 @@ +#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 + +mat2 rot(float a){ + float c = cos(a); + float s = sin(a); + return mat2(c,-s,s,c); +} + +float cube( vec3 p, vec3 b ) { + vec2 uv = p.xy; + float v = 3.0 * texture(texFFT, fract((uv.x * 0.3))).x; + b.x += v; + vec3 q = abs( p) - b; + return length( max(q, 0.0) ) + min(max(q.x, max(q.y, q.z)), 0.0); + +} + +float qqube( vec3 p ) { + vec3 q = p; + q.y += sin((p.z+fGlobalTime) *0.3 + p.x * 0.2) * 1.5; + + q = mod(q, 5.0) - 2.5; + q.xy = rot( fGlobalTime) * q.xy; + q.yz = rot( fGlobalTime) * q.yz; + + return cube( q, vec3(1.0)); +} + +float map(vec3 p) { + + float d = qqube(p); + + d = max( d,qqube(p*10.0)/10.0 ); +return d; +} + +vec3 grad(vec3 p ){ + vec2 e = vec2(0.01, 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 /= vec2(v2Resolution.y / v2Resolution.x, 1); + + vec3 ro = vec3(0.0, 0.0, -2.0 + 1.3 * texture(texFFTIntegrated, 0.01).x); + vec3 rd = normalize(vec3(uv, 0.8 - length(uv) - texture(texFFT, 0.01).x) ); + + vec3 p = ro; + for ( float i = .0; i < 128.0; ++i) { + float d = map(p); + if ( abs(d) < 0.001) { + break; + } + p += rd * d; + } + + float dc = exp(-0.2 * distance(ro, p) ); + vec3 n = grad(p); + +vec3 col = vec3(uv,0.0 ) * vec3(dc ) + vec3(dc)* (n * 0.5 + 0.5) ; + + out_color = vec4(col, 1.0); +} \ No newline at end of file diff --git a/2020-03-26/nusan.glsl b/2020-03-26/nusan.glsl new file mode 100644 index 0000000..3d62f6d --- /dev/null +++ b/2020-03-26/nusan.glsl @@ -0,0 +1,111 @@ +#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 time=fGlobalTime; + +mat2 rot(float a) { + float ca=cos(a); + float sa=sin(a); + return mat2(ca,sa,-sa,ca); +} + +float box(vec3 p, vec3 s) { + p=abs(p)-s; + return max(p.x, max(p.y,p.z)); +} + +float rnd(float t) { + return fract(sin(t*247.542)*567.665); +} + +float curve(float t, float d) { + t/=d; + return mix(rnd(floor(t)), rnd(floor(t)+1), pow(smoothstep(0,1,fract(t)),10)); +} + +float d2 = 0.0; +float map(vec3 p) { + + for(int i=0; i<5; ++i) { + float t=time*0.1 + i; + p.xz *= rot(curve(t,0.3)*10.0); + p.xy *= rot(curve(t,0.23)*7.0); + p.yz = abs(p.yz) - vec2(0.3,0.8)*(curve(time, 0.2)*0.8+0.2); + } + + float d = box(p, vec3(1,0.3,2.0)); + d2 = length(p.xz) - 0.3; + d=min(d,d2-0.3); + + + return abs(d); +} + +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); + + if(fract(time*0.1)>0.5) uv.x=abs(uv.x); + + vec2 buv=uv; + for(int i=0; i<2; ++i) { + uv *= rot(time*0.1); + uv.x += abs(sin(time + uv.y)*0.1); + uv.y += abs(sin(time + uv.x)*0.3); + float size = 30 + pow(curve(time + i*12, .4+sin(uv.x*0.1+time)*0.1),10.0)*200; + uv=floor(uv*size)/size; + uv=abs(uv); + } + uv-=0.1; + + vec3 s=vec3(0,0,-15); + vec3 r=normalize(vec3(-uv, 1)); + + vec3 col=vec3(0); + vec3 p=s; + float dd=0; + for(int i=0; i<70; ++i) { + float d=map(p) * 0.7; + if(d<0.01) { + d=0.01; + } + float d2 = sin(d+curve(time,0.2))*0.1+d; + float ff=0.02; + r.xz *= rot(sin(dd*0.3*ff)); + r.yz *= rot(sin(dd*0.1*ff)); + p+=r*d2; + dd+=d; + col += vec3(1,0.2,0.6) * 0.05/(abs(d)+1.6); + col += vec3(0.3,0.8,0.7) * 0.004/(abs(d2)+0.2); + } + + float t3 = time*0.1+curve(time, 0.3); + col.xz *= rot(t3 + buv.x*0.7); + col.xy *= rot(t3*1.3 + buv.y*0.6); + col=abs(col); + col *= 0.4 + curve(time, 0.1); + col = smoothstep(0,1,col); + col = pow(col, vec3(0.4545)); + + /* + col *= smoothstep(0.1,0.4,fract(curve(uv.x*10.0 + time*0.1,0.1))*0.5)+0.5; + col *= smoothstep(0.1,0.4,fract(curve(uv.y*10.0 + time*2.3+10.0,0.1))*0.5)+0.5; + */ + out_color = vec4(col, 1); +} \ No newline at end of file diff --git a/2020-03-26/ponk.glsl b/2020-03-26/ponk.glsl new file mode 100644 index 0000000..3b0b8f1 --- /dev/null +++ b/2020-03-26/ponk.glsl @@ -0,0 +1,106 @@ +#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 cookie; +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 sdCube (vec3 p, vec3 r) { + vec3 b = abs(p)-r; + return max(b.x,max(b.y,b.z)); +} + +mat2 rot (float a) { + float c=cos(a),s=sin(a); + return mat2(c,-s,s,c); +} + +#define time fGlobalTime + +float map (vec3 p, inout float mat) { + float scene = 1.0; + const float count = 8.; + float a = 1.0; + float falloff = 2.5; + float speed = 0.1; + float t = time*speed;//floor(time*speed) + pow(fract(time*speed), 0.5); + float w = sin(time - length(p)*.5); + for (float index = count; index > 0.; --index) { + float r = 4. + 2. * w; + p.xz *= rot(t*2.2); + p.yz *= rot(t*4.1); + p.yx *= rot(t*2.3); + p.x = abs(p.x)-r*a; + + //p.x += sin(abs(p.z)); + p.y += abs(sin(p.z*2.))*.2; + scene = min(scene, sdCube(p, vec3(2.+.5*sin(abs(p.z*3.14)),0.01,1))); + a /= falloff; + } + p = abs(p)-0.2; + p.xz *= rot(- time); + p.yz *= rot(- time); + p.yx *= rot(- time*2.); + + float sphs = max(abs(p.y)-2., length(p.xz)-0.02); + mat = step(sphs, scene); + scene = min(scene, sphs); + sphs = length(p)-0.2; + mat += step(sphs, scene); + scene = min(scene, sphs); + return scene * .5; +} + +vec3 getNormal (vec3 p) { + vec2 e = vec2(0.001,0); + float m = 0.; + return normalize(vec3(map(p+e.xyy,m)-map(p-e.xyy,m),map(p+e.yxy,m)-map(p-e.yxy,m),map(p+e.yyx,m)-map(p-e.yyx,m))); +} + +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); + + vec3 eye = vec3(0,0,-12); + vec3 ray = normalize(vec3(uv,1.)); + float total = 0.0; + float shade = 0.0; + float mat = 0.0; + const float count = 100.; + for (float index = count; index > 0.; --index) { + float dist = map(eye+ray*total, mat); + if (dist < 0.001) { + shade = index/count; + break; + } + total += dist; + } + + vec3 color = vec3(0); + vec3 normal = getNormal(eye+ray*total); + if (mat == 0.0) { + color += .7*vec3(0.1,1.,.2) * clamp(dot(normal, -ray), 0., 1.); + color += vec3(0.54,.2,.1) * clamp(dot(normal, vec3(0,-1,0))*.5+.5, 0., 1.); + } else if (mat == 1.0) { + color += vec3(1.0) * clamp(dot(normal, vec3(0,-1,0))*.5+.5, 0., 1.); + } else if (mat == 2.0) { + color += vec3(1.,.1,0.) * clamp(dot(normal, vec3(0,-1,0))*.5+.5, 0., 1.); + } + color *= pow(shade, .2); + + + out_color = vec4(color,1); +} \ No newline at end of file