S1C004.glsl

// Libraries

#define tau (3.1415926535*2.)
float rand(vec2 co){
  return fract(sin(dot(co.xy, vec2(12.9898,78.233))) * 43758.5453);
}
float noise0(float t, float s) {
  float r = floor(t);
  float f = fract(t);
  f = smoothstep(0., 1., f);
  float u0 = rand(vec2(r+0.,s)) - 0.5;
  float u1 = rand(vec2(r+1.,s)) - 0.5;
  return mix(u0, u1, f);
}
float noise1(float t, float s) {
  float r = floor(t);
  float f = fract(t);
  f = smoothstep(0., 1., f);
  float v0 = rand(vec2(r+0.,s));
  float v1 = rand(vec2(r+1.,s));
  float v2 = rand(vec2(r+2.,s));
  float u0 = v1 - v0;
  float u1 = v2 - v1;
  return mix(u0, u1, f);
}
float noise2(float t, float s) {
  float r = floor(t);
  float f = fract(t);
  f = smoothstep(0., 1., f);
  float w0 = rand(vec2(r+0.,s));
  float w1 = rand(vec2(r+1.,s));
  float w2 = rand(vec2(r+2.,s));
  float w3 = rand(vec2(r+3.,s));
  float v0 = w1 - w0;
  float v1 = w2 - w1;
  float v2 = w3 - w2;
  float u0 = v1 - v0;
  float u1 = v2 - v1;
  return mix(u0, u1, f);
}
float noiseR0(float t, float p) {
  t += noise0(t, 0.) * p;
  return noise0(t, 1.);
}
float inst0(float f, float t, float m, float o, float p) {
  float rep = 1./f;
  float fac = mod(t,rep);
  float mult = m;
  float offset = t*o;
  return mix(
    noiseR0(fac*mult + offset, p),
    noiseR0((fac+rep)*mult + offset, p),
    smoothstep(0.,1.,1.-fac/rep));
}
float noiseR1(float t, float p) {
  t += noise0(t, 0.) * p;
  return noise1(t, 1.);
}
float inst1(float f, float t, float m, float o, float p) {
  float rep = 1./f;
  float fac = mod(t,rep);
  float mult = m;
  float offset = t*o;
  return mix(
    noiseR1(fac*mult + offset, p),
    noiseR1((fac+rep)*mult + offset, p),
    smoothstep(0.,1.,1.-fac/rep));
}
float noiseR2(float t, float p) {
  t += noise0(t, 0.) * p;
  return noise2(t, 1.);
}
float inst2(float f, float t, float m, float o, float p) {
  float rep = 1./f;
  float fac = mod(t,rep);
  float mult = m;
  float offset = t*o;
  return mix(
    noiseR2(fac*mult + offset, p),
    noiseR2((fac+rep)*mult + offset, p),
    smoothstep(0.,1.,1.-fac/rep));
}
float chirp(float sf, float df, float rate, float t) {
  // integrate sf+df*exp(-rate*t) = sf*t-df*exp(-rate*t)/rate
  float v = sf*t - df*exp(-rate*t)/rate;
  return sin(v*tau) + sin(v*1.5*tau)*0.5;
}
vec2 ov(float f, float t, float m, float e) {
  vec2 v = vec2(0.);
  float ff = f;
  float ee = (1.+e)/2.;
  for(int i=0;i<4;i++) {
    v += sin(ff*t*tau+float(i)+vec2(-0.25,0.25)) * ee;
    ff *= m;
    ee *= e;
  }
  return v;
}
float ev(float s, float e, float t) {
  return (1.-exp(-s*t)) * exp(-e*t);
}
float ev2(float s, float e, float t) {
  return ev(s, e, t) + ev(s*4., e*8., t) * 2.;
}

// Instruments

float a(float f, float t) {
  return inst0(f*4., t/4., 1000., 100., 0.);
}
float b(float t) {
  return chirp(10., 500., 100., t);
}
float b2(float t) {
  return chirp(10., 100., 20., t);
}
float h(float t) {
  return noise2(t*18000., 0.);
}
float c1(float t) {
  return inst2(20., t, 4000., 50., 1.);
}
float c2(float t) {
  return inst2(10., t, 2000., 50., 0.5);
}
vec2 m(float f, float t) {
  return ov(f/1.5, t, 1.3, exp(-t*1.5));
}

// Main

vec2 mainSound(float time){
  vec2 v = vec2(0.);
  float t = time;
  float bpm = 140.;
  float spb = 60./bpm;
  float bt = t/spb;
  
  float u = fract(bt);
  v.x += a(50., t) * (1. - ev(0.5, 2., u)) * 0.2;
  v.y += a(50., t+1.) * (1. - ev(0.5, 2., u)) * 0.2;
  v += b(u*spb) * ev(100., 4., u) * 0.4;
  
  u = fract(bt+0.5);
  v += h(u*spb) * ev(100., 16., u) * 0.08;
  u = fract(bt/8.-0.25);
  v += h(u*spb*8.) * ev(100., 240., u) * 0.15;
  
  vec2 ba = vec2(0.);
  u = fract(bt/4.);
  ba += m(250., u*spb*4.) * ev(100., 2., u) * 0.1;
  u = fract(bt/4.-0.375);
  ba += m(300., u*spb*4.) * ev(100., 1., u) * 0.1;
  float ut = fract(bt/64.)*64. < 62. ? bt : bt+0.5;
  u = fract(ut/16.-15./16.);
  ba += m(333., u*spb*16.) * ev(100., 32., u) * 0.1;
  u = fract(ut/32.-31.5/32.);
  ba += m(300., u*spb*32.) * ev(200., 32., u) * 0.1;
  
  u = fract(bt/4.-0.25);
  v += c1(u*spb*4.) * ev(100., 32., u) * 0.1;
  vec2 cl2 = vec2(c2(u*spb*4.), c2(u*spb*4.+5.));
  v += mat2(0.8,0.5,-0.5,0.8) * cl2 * ev(100., 6., u) * 0.05;
  
  u = fract(bt/4.-0.375);
  v += b(u*spb*4.) * ev(100., 4., u) * 0.5;
  float bf = 2400.;
  v += sin(bf*u*spb*4.) * (ev(100., 64., u) + ev(100., 8., u)*0.1) * 0.2;
  u = fract(bt/4.-0.625);
  float mu = int(floor(bt/4.))%4 == 3 ? 3./2. : 5./4.;
  v += sin(bf*mu*u*spb*4.) * ev(100., 48., u) * 0.3;
  u = fract(bt/4.-0.75);
  v += sin(bf*u*spb*4.) * (ev(100., 64., u) + ev(100., 8., u)*0.1) * 0.1;
  
  v += ba;
  
  return v;
}