Added La fabrique à cookie 02

2022-11-09/Readme.md

@@ -0,0 +1,15 @@
+# Performances
+
+On November 9, 2022 on [La fabrique à cookie 02](https://fb.me/e/5gBR5qyVB).
+
+## Shaders
+
+1. z0rg
+2. lsdlive
+3. SAM
+
+
+## Software
+- [Atom](https://github.com/atom/atom)
+- [Veda](https://github.com/fand/veda)
+- [Bonzomatic](https://github.com/TheNuSan/Bonzomatic/)

2022-11-09/shader_SAM.glsl

@@ -0,0 +1,170 @@
+#version 410 core
+
+uniform float fGlobalTime; // in seconds
+uniform vec2 v2Resolution; // viewport resolution (in pixels)
+uniform float fFrameTime; // duration of the last frame, in seconds
+
+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 texPreviousFrame; // screenshot of the previous frame
+uniform sampler2D texChecker;
+uniform sampler2D texNoise;
+uniform sampler2D texTex1;
+uniform sampler2D texTex2;
+uniform sampler2D texTex3;
+uniform sampler2D texTex4;
+
+in vec2 out_texcoord;
+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 );
+}
+
+float circle(vec2 p, float r)
+{
+  return length(p) - r;
+}
+
+vec2 pix = vec2(100, 120);
+
+float merge(float t1, float t2, float r)
+{
+    vec2 v = min(vec2(t1 - r, t2 - r), vec2(0));
+    return max(min(t1, t2), r) - length(v);  
+}
+
+float outline(float t, float w)
+{
+  return abs(t) - w;
+}
+
+vec3 merge(vec3 base, vec3 col, float t)
+{
+  return mix(base, col, t > 0);
+}
+
+float pla(vec2 uv) {
+  return sin(uv.x * 17 + uv.y * -6 + 18 * fGlobalTime)
+       + sin(uv.y * 3 + 10 * fGlobalTime)
+       + sin(uv.y * 7 + 5 * fGlobalTime)
+       + sin(uv.x * uv.x * 0.1) + sin(uv.y * uv.y * 16)
+         + uv.x * 3 + uv.y * 2
+       + sin(dot(uv,uv)+fGlobalTime)*30
+         + fGlobalTime * (0.15 + 0.012 * uv.x + 0.01 * uv.y);
+}
+
+float bayer2(vec2 uv) {
+  int x = int(uv.x * pix.x + pix.x) % 2;
+  int y = (int(uv.y * pix.y + pix.y)) % 2;
+  return float(x) + float(y)/2;
+}
+
+float bayer(vec2 uv) {
+  return bayer2(uv) + 0.25 * bayer2(uv*2);
+}
+
+vec3 ramp(float t) {
+   return 0.5 * vec3(sin(t/2), sin(t/3+1), sin(t/4+3)) + vec3(0.5);  
+}
+
+vec3 cl(vec3 c, vec2 uv) {
+   return c - (fract(c * 5) + bayer(uv))/5;  
+}
+
+vec3 red = vec3(1.0, 0.0, 0.0);
+
+mat2 r2d(float a){float c=cos(a),s=sin(a);return mat2(c, s, -s, c);}
+
+
+float re(float p,float d){return mod(p-d*.5, d) -d*.5;}
+void mo(inout vec2 p, vec2 d){
+  p=abs(p)-d;
+  if(p.y>p.x)p=p.yx;}
+
+float sc(vec3 p, float d){
+  p=abs(p);
+  p=max(p, p.yzx);
+  return min(p.x, min(p.y, p.z))-d;
+}
+
+void amod(inout vec2 p, float m){
+  float a = re(atan(p.x,p.y), m);
+  p=vec2(cos(a),sin(a))*p;
+}
+float pi = 3.141592;
+float de(vec3 p){
+  //p.y+=.7;
+  //p.xz*=r2d(fGlobalTime);
+  p.xy*=r2d(fGlobalTime*.3);
+
+  
+  vec3 q =p;
+  amod(p.xy, pi/3);
+  
+  //mo(p.xz, vec2(1));
+  mo(p.xy, vec2(.5));
+  mo(p.xy, vec2(14));
+  
+  amod(p.xy, pi/5);
+  p.x=abs(p.x)-.5;
+  p.z=re(p.z, 6.);
+  
+  
+  q.xy*=r2d(q.z*.2);
+  float d = sc(p, .3);
+  
+  q.x = abs(q.x) - 1.;
+  return min(d, length(q.xy)-.3);
+  return length(p)-1;
+}
+
+
+
+  
+void main(void)
+{
+  // I have no idea what I'm doing
+	vec2 uv = out_texcoord;
+	uv -= 0.5;
+	uv /= vec2(v2Resolution.y / v2Resolution.x, 1);
+  
+  float shade = pla(uv);
+  vec3 bg = ramp(shade + 1.0 * bayer(uv));
+  
+  uv -= fract(uv * pix) / pix;
+  vec3 col = bg;
+ 
+  for (int i = 0; i < 5; ++i) {
+    float t = 1000.0;
+    float a = 0;
+    for (int j = 0; j < 5; ++j) {
+      vec4 s0 = texture2D(texNoise, vec2(i,j)/10);
+      vec4 s1 = texture2D(texNoise, vec2(i,j)/5);
+      vec2 c0 = vec2(sin(fGlobalTime * 0.5 + 2*i+5*j), cos(fGlobalTime * 0.5 + 3*i+j*2)) * vec2(2, 1.0);
+      vec2 c = c0+ vec2(sin(fGlobalTime * 5 + j-i), cos(fGlobalTime * 5 + i+j)) * vec2(0.3);
+      float t2 = circle(uv + (0.2+ 0.2*sin(fGlobalTime + 5.0*s0.x+i+j)) * c, (1.0+sin(12*i+s1.y+3*fGlobalTime+15*s1.z))*0.1);
+      t = merge(t, t2, 0.1);
+    }
+    col = merge(col, cl(ramp(fGlobalTime*5+4.3*i+t*20), uv), -t);
+    t = outline(t,0.005);
+    col = merge(col, vec3(0.0), -t);
+  }
+  
+    float t1 = circle(uv + vec2(sin(fGlobalTime), cos(fGlobalTime)) / 3, 0.2 * (2 + sin(fGlobalTime)));
+  float t2 = circle(uv + vec2(sin(2 * fGlobalTime + 3), cos(3 * fGlobalTime + 3)) / 3, 0.2);
+  //float t2 = circle(uv + vec2(0.2), 0.2);
+  float t = merge(t1, t2, 0.1);
+  t = outline(t, 0.005);
+  col = merge(col, vec3(0), -t);
+    
+//  float t = outline(circle(uv, 0.2), 0.01);
+  //col = merge(col, red, circle(uv + vec2(0.1), 0.2));
+  //out_color.rgb = col;
+  //mix(col, red, t > 0);
+  out_color.rgb = col;
+  //out_color.a = 1.0;
+}

2022-11-09/shader_lsdlive.glsl

@@ -0,0 +1,187 @@
+#version 410 core
+
+uniform float fGlobalTime; // in seconds
+uniform vec2 v2Resolution; // viewport resolution (in pixels)
+uniform float fFrameTime; // duration of the last frame, in seconds
+
+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 texPreviousFrame; // screenshot of the previous frame
+uniform sampler2D texChecker;
+uniform sampler2D texNoise;
+uniform sampler2D texTex1;
+uniform sampler2D texTex2;
+uniform sampler2D texTex3;
+uniform sampler2D texTex4;
+
+in vec2 out_texcoord;
+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 );
+}
+
+float circle(vec2 p, float r)
+{
+  return length(p) - r;
+}
+
+vec2 pix = vec2(100, 120);
+
+float merge(float t1, float t2, float r)
+{
+    vec2 v = min(vec2(t1 - r, t2 - r), vec2(0));
+    return max(min(t1, t2), r) - length(v);  
+}
+
+float outline(float t, float w)
+{
+  return abs(t) - w;
+}
+
+vec3 merge(vec3 base, vec3 col, float t)
+{
+  return mix(base, col, t > 0);
+}
+
+float pla(vec2 uv) {
+  return sin(uv.x * 17 + uv.y * -6 + 18 * fGlobalTime)
+       + sin(uv.y * 3 + 10 * fGlobalTime)
+       + sin(uv.y * 7 + 5 * fGlobalTime)
+       + sin(uv.x * uv.x * 0.1) + sin(uv.y * uv.y * 16)
+         + uv.x * 3 + uv.y * 2
+       + sin(dot(uv,uv)+fGlobalTime)*30
+         + fGlobalTime * (0.15 + 0.012 * uv.x + 0.01 * uv.y);
+}
+
+float bayer2(vec2 uv) {
+  int x = int(uv.x * pix.x + pix.x) % 2;
+  int y = (int(uv.y * pix.y + pix.y)) % 2;
+  return float(x) + float(y)/2;
+}
+
+float bayer(vec2 uv) {
+  return bayer2(uv) + 0.25 * bayer2(uv*2);
+}
+
+vec3 ramp(float t) {
+   return 0.5 * vec3(sin(t/2), sin(t/3+1), sin(t/4+3)) + vec3(0.5);  
+}
+
+vec3 cl(vec3 c, vec2 uv) {
+   return c - (fract(c * 5) + bayer(uv))/5;  
+}
+
+vec3 red = vec3(1.0, 0.0, 0.0);
+
+mat2 r2d(float a){float c=cos(a),s=sin(a);return mat2(c, s, -s, c);}
+
+
+float re(float p,float d){return mod(p-d*.5, d) -d*.5;}
+void mo(inout vec2 p, vec2 d){
+  p=abs(p)-d;
+  if(p.y>p.x)p=p.yx;}
+
+float sc(vec3 p, float d){
+  p=abs(p);
+  p=max(p, p.yzx);
+  return min(p.x, min(p.y, p.z))-d;
+}
+
+void amod(inout vec2 p, float m){
+  float a = re(atan(p.x,p.y), m);
+  p=vec2(cos(a),sin(a))*p;
+}
+float pi = 3.141592;
+float de(vec3 p){
+  //p.y+=.7;
+  //p.xz*=r2d(fGlobalTime);
+  p.xy*=r2d(fGlobalTime*.3);
+
+  
+  vec3 q =p;
+  amod(p.xy, pi/3);
+  
+  //mo(p.xz, vec2(1));
+  mo(p.xy, vec2(.5));
+  mo(p.xy, vec2(14));
+  
+  amod(p.xy, pi/5);
+  p.x=abs(p.x)-.5;
+  p.z=re(p.z, 6.);
+  
+  
+  q.xy*=r2d(q.z*.2);
+  float d = sc(p, .3);
+  
+  q.x = abs(q.x) - 1.;
+  return min(d, length(q.xy)-.3);
+  return length(p)-1;
+}
+
+void main(void){
+vec2 uv = out_texcoord;
+	uv -= 0.5;
+	uv /= vec2(v2Resolution.y / v2Resolution.x, 1);
+
+  vec3 ro=vec3(0,  0,-3+fGlobalTime*7), rd=normalize(vec3(uv, 1)), p;
+  float t=0.,i=0;
+  for(;i<1.;i+=0.01){
+  p=ro+rd*t;
+    float d=de(p);
+    if(d<.01)break;
+    t+=d;
+    }
+
+  out_color.rgb = vec3(1-i);
+  out_color.a = 1.0;
+  }
+
+
+  /*
+void main2(void)
+{
+  // I have no idea what I'm doing
+	vec2 uv = out_texcoord;
+	uv -= 0.5;
+	uv /= vec2(v2Resolution.y / v2Resolution.x, 1);
+  
+  float shade = pla(uv);
+  vec3 bg = ramp(shade + 1.0 * bayer(uv));
+  
+  uv -= fract(uv * pix) / pix;
+  vec3 col = bg;
+ 
+  for (int i = 0; i < 5; ++i) {
+    float t = 1000.0;
+    float a = 0;
+    for (int j = 0; j < 5; ++j) {
+      vec4 s0 = texture2D(texNoise, vec2(i,j)/10);
+      vec4 s1 = texture2D(texNoise, vec2(i,j)/5);
+      vec2 c0 = vec2(sin(fGlobalTime * 0.5 + 2*i+5*j), cos(fGlobalTime * 0.5 + 3*i+j*2)) * vec2(2, 1.0);
+      vec2 c = c0+ vec2(sin(fGlobalTime * 5 + j-i), cos(fGlobalTime * 5 + i+j)) * vec3(0.3);
+      float t2 = circle(uv + (0.2+ 0.2*sin(fGlobalTime + 5.0*s0.x+i+j)) * c, (1.0+sin(12*i+s1.y+3*fGlobalTime+15*s1.z))*0.1);
+      t = merge(t, t2, 0.1);
+    }
+    col = merge(col, cl(ramp(fGlobalTime*5+4.3*i+t*20), uv), -t);2@
+    t = outline(t,0.005);
+    col = merge(col, vec3(0.0), -t);
+  }
+  /*
+    float t1 = circle(uv + vec2(sin(fGlobalTime), cos(fGlobalTime)) / 3, 0.2 * (2 + sin(fGlobalTime)));
+  float t2 = circle(uv + vec2(sin(2 * fGlobalTime + 3), cos(3 * fGlobalTime + 3)) / 3, 0.2);
+  //float t2 = circle(uv + vec2(0.2), 0.2);
+  float t = merge(t1, t2, 0.1);
+  t = outline(t, 0.005);
+  col = merge(col, vec3(0), -t);
+    */
+//  float t = outline(circle(uv, 0.2), 0.01);
+  //col = merge(col, red, circle(uv + vec2(0.1), 0.2));
+  //out_color.rgb = col;
+  //mix(col, red, t > 0);
+  /*out_color.rgb = col;
+  out_color.a = 1.0;
+}*/

2022-11-09/shader_z0rg.glsl

@@ -0,0 +1,242 @@
+/*{ "camera": true }*/
+uniform sampler2D camera;
+uniform sampler2D backbuffer;
+#ifndef TOOLS_INCLUDE
+#define TOOLS_INCLUDE
+
+precision highp float;
+
+uniform float time;
+uniform vec2 resolution;
+uniform sampler2D spectrum;
+uniform sampler2D midi;
+
+uniform sampler2D greyNoise;
+
+float mtime; // modulated time
+
+#define FFTI(a) time
+
+#define sat(a) clamp(a, 0., 1.)
+#define FFT(a) texture2D(spectrum, vec2(a, 0.)).x
+
+#define EPS vec2(0.01, 0.)
+#define AKAI_KNOB(a) (texture2D(midi, vec2(176. / 256., (0.+min(max(float(a), 0.), 7.)) / 128.)).x)
+
+#define MIDI_KNOB(a) (texture2D(midi, vec2(176. / 256., (16.+min(max(float(a), 0.), 7.)) / 128.)).x)
+#define MIDI_FADER(a) (texture2D(midi, vec2(176. / 256., (0.+min(max(float(a), 0.), 7.)) / 128.)).x)
+
+#define MIDI_BTN_S(a) sat(texture2D(midi, vec2(176. /  256., (32.+min(max(float(a), 0.), 7.)) / 128.)).x*10.)
+#define MIDI_BTN_M(a) sat(texture2D(midi, vec2(176. / 256., (48.+min(max(float(a), 0.), 7.)) / 128.)).x*10.)
+#define MIDI_BTN_R(a) sat(texture2D(midi, vec2(176. / 256., (64.+min(max(float(a), 0.), 7.)) / 128.)).x*10.)
+
+#define FFTlow (FFT(0.1) * MIDI_KNOB(0))
+#define FFTmid (FFT(0.5) * MIDI_KNOB(1))
+#define FFThigh (FFT(0.7) * MIDI_KNOB(2))
+#define PI 3.14159265
+#define TAU (PI*2.0)
+float hash11(float seed)
+{
+    return fract(sin(seed*123.456)*123.456);
+}
+
+float _cube(vec3 p, vec3 s)
+{
+  vec3 l = abs(p)-s;
+  return max(l.x, max(l.y, l.z));
+}
+float _cucube(vec3 p, vec3 s, vec3 th)
+{
+    vec3 l = abs(p)-s;
+    float cube = max(max(l.x, l.y), l.z);
+    l = abs(l)-th;
+    float x = max(l.y, l.z);
+    float y = max(l.x, l.z);
+    float z = max(l.x, l.y);
+
+    return max(min(min(x, y), z), cube);
+}
+float _seed;
+
+float rand()
+{
+    _seed++;
+    return hash11(_seed);
+}
+
+mat2 r2d(float a) { float c = cos(a), s = sin(a); return mat2(c, -s, s, c); }
+
+vec3 getCam(vec3 rd, vec2 uv)
+{
+    vec3 r = normalize(cross(rd, vec3(0.,1.,0.)));
+    vec3 u = normalize(cross(rd, r));
+    return normalize(rd+(r*uv.x+u*uv.y)*3.);
+}
+
+float lenny(vec2 v)
+{
+    return abs(v.x)+abs(v.y);
+}
+float _sqr(vec2 p, vec2 s)
+{
+    vec2 l = abs(p)-s;
+    return max(l.x, l.y);
+}
+float _cir(vec2 uv, float sz)
+{
+  return length(uv)-sz;
+}
+
+float _loz(vec2 uv,float sz)
+{
+  return lenny(uv)-sz;
+}
+vec2 _min(vec2 a, vec2 b)
+{
+    if (a.x < b.x)
+        return a;
+    return b;
+}
+vec2 _max(vec2 a, vec2 b)
+{
+  if (a.x > b.x)
+      return a;
+  return b;
+}
+
+// To replace missing behavior in veda
+vec4 textureRepeat(sampler2D sampler, vec2 uv)
+{
+  return texture2D(sampler, mod(uv, vec2(1.)));
+}
+
+#endif // !TOOLS_INCLUDE
+
+
+
+vec2 map(vec3 p)
+{
+    vec2 acc = vec2(10000., -1.);
+
+
+    float gnd = -p.y+2.;
+    acc = _min(acc, vec2(gnd, 2.));
+//    acc = _min(acc, vec2(length(p+vec3(0.,0.,-4.))-1., 0.));
+
+    float ceili = p.y+2.;
+    acc = _min(acc, vec2(ceili, 1.));
+
+vec2 rep = vec2(7.);
+p.z+=time;
+p.xz = mod(p.xz+rep*.5,rep)-rep*.5;
+
+float cyl = length(p.xz)-.5;
+acc = _min(acc, vec2(cyl, 3.));
+    return acc;
+}
+
+
+vec3 accCol;
+vec3 trace(vec3 ro, vec3 rd)
+{
+    accCol = vec3(0.);
+    vec3 p = ro;
+    for (int i = 0; i < 128; ++i)
+    {
+        vec2 res = map(p);
+        if (res.x < 0.01)
+            return vec3(res.x, distance(p, ro), res.y);
+        p+= rd*res.x;
+    }
+    return vec3(-1.);
+}
+
+vec3 getNorm(vec3 p, float d)
+{
+  vec2 e = vec2(0.01, 0.);
+  return  normalize(vec3(d) - vec3(map(p-e.xyy).x, map(p-e.yxy).x, map(p-e.yyx).x));
+}
+vec3 getMat(vec3 p, vec3 n, vec3 rd, vec3 res)
+{
+  vec3 col = n*.5+.5;
+  if (res.z == 1.)
+  {
+    col = vec3(.1);
+    vec2 uvp = p.xz+vec2(0.,time*2.);
+    vec2 rep = vec2(1.5);
+    vec2 id = floor((uvp+rep*.5)/rep);
+    uvp = mod(uvp+rep*.5,rep)-rep*.5;
+    float dott = length(uvp)-.3;
+    vec3 rgb = mix(vec3(1.,0.,0.), vec3(1.), sat(sin(length(id)-time)));
+    float sampl = textureRepeat(greyNoise, id*.1).x;
+    rgb *= pow(sampl,5.);
+    rgb *= mod(sampl+time, 1.)
+;    col = mix(vec3(0.), rgb*10., 1.-sat(dott*400.));
+  }
+  if (res.z == 2.)
+  {
+    col = vec3(0.);
+    vec2 uvp2 = p.xz+vec2(0.,-2.*time);
+    vec2 grid = sin(uvp2*5.)+.99;
+    col = vec3(.1,.2,.9)*(1.-sat(min(grid.x,grid.y)*100.));
+  }
+  if (res.z == 3.)
+    col = vec3(0.);
+  return col;
+}
+vec3 rdr(vec2 uv)
+{
+  uv *= r2d(sin(time*.5)*.25);
+  float d = 5.;
+  float t = time*.13*0.+.5;
+    vec3 ro = vec3(sin(t)*d, 0., cos(t)*d);
+    vec3 ta = vec3(0.,0.,0.);
+    vec3 rd = normalize(ta-ro);
+    rd = getCam(rd, uv);
+    vec3 col = vec3(0.);
+
+    vec3 res = trace(ro, rd);
+    float depth = 100.;
+    if (res.y > 0.)
+    {
+      depth = res.y;
+        vec3 p = ro + rd*res.y;
+        vec3 n = getNorm(p, res.x);
+        col = getMat(p, n, rd, res);
+        vec3 refl = normalize(reflect(rd, n)+(vec3(rand(), rand(), rand())-.5)*.02);
+        vec3 resrefl = trace(p+n*.005, refl);
+        if (resrefl.y > 0.)
+        {
+          vec3 prefl = p+refl*resrefl.y;
+          vec3 nrefl = getNorm(prefl, resrefl.x);
+          col += getMat(prefl, nrefl, refl, resrefl);
+        }
+    }
+    col = mix(col, vec3(.1,.2,.4)*3., 1.-exp(-depth*0.01));
+    return col;
+}
+void main() {
+    vec2 uv = (gl_FragCoord.xy-.5*resolution.xy) / resolution.xx;
+    vec2 ouv = gl_FragCoord.xy/resolution.xy;
+    float pix = .02;
+    vec2 uv2 = floor(uv/pix)*pix;
+    _seed = time+textureRepeat(greyNoise, uv).x;
+   vec3 col = rdr(uv);
+   for (float i = 0.; i < 8.; ++i)
+   {
+     vec2 off = +(vec2(rand(), rand())-.5)*.02;
+     col += rdr(uv+off)/(8.*length(off)/0.01);
+   }
+   //col = texture2D(camera, uv*10.).xyz;
+//vec3 col = vec3(0.,0.,.5
+col = mix(col, rdr(uv2), sat(length(uv)*2.));
+col *= 1.-sat(lenny(uv));
+float shape = abs(uv.x)-.2;
+col = mix(col, col.xxx, sat(shape*400.));
+
+vec2 uva = vec2(atan(uv.y, uv.x)*.5, length(uv)*.2-time);
+col += pow(textureRepeat(greyNoise, uva*.5).x, 2.)*vec3(.2,.4,.9)*.5;
+
+col = mix(col, texture2D(backbuffer, ouv).xyz, .8);
+    gl_FragColor = vec4(col, 1.0);
+}