this logo: 245 b

← SUBTRAKT v2

index.html

<!doctype html>
<html lang=en>
<head>
<meta charset=utf-8>
<title>SUBTRAKT</title>
<meta name=viewport content="width=device-width,initial-scale=1">
<style>html,body{margin:0;height:100%;background:#000;overflow:hidden}canvas{display:block;width:100vw;height:100vh;cursor:pointer}</style>
</head>
<body>
<canvas id=c></canvas>
<script>
/* SUBTRAKT - a study in add and subtract.
   Ray-marched signed distance fields built from CSG (union / subtraction / intersection and
   their chamfered, stepped and smooth variants). Every moving parameter is driven by an FFT of
   the soundtrack, which is synthesised in real time. No assets, no dependencies.
   Keys: F fullscreen, 1-6 lock a scene, 0 unlock. Drop an audio file to use your own music. */
(()=>{
'use strict';

/* ---------------- synth (runs inside an AudioWorklet) ---------------- */
function SYN(sr){
const TAU=6.283185307179586,T=1/sr,S16=sr*15/128,LEN=1024,mf=n=>440*2**((n-69)/12),dc=s=>Math.exp(-1/(sr*s));
let rs=22222;const rnd=()=>{rs^=rs<<13;rs^=rs>>>17;rs^=rs<<5;return(rs>>>0)/2147483648-1};
// TPT state variable filter: returns low-pass, leaves band-pass in s[2]
const svf=(s,x,fc,k)=>{const g=Math.tan(Math.PI*Math.min(fc,sr*.45)*T),h=1/(1+g*(g+k)),v3=x-s[1],v1=h*s[0]+g*h*v3,v2=s[1]+g*h*s[0]+g*g*h*v3;s[0]=2*v1-s[0];s[1]=2*v2-s[1];s[2]=v1;return v2};
const saw=(p,d)=>{let v=2*p-1;if(p<d){const t=p/d;v-=t+t-t*t-1}else if(p>1-d){const t=(p-1)/d;v-=t*t+t+t+1}return v};
// D minor: Dm Bb F C, as [bass root, triad]
const CH=[[38,62,65,69],[34,62,65,70],[41,60,65,69],[36,60,64,67]];
const AR=[0,1,2,0,1,2,0,1,2,1,0,2,1,2,0,1],AO=[0,0,0,1,0,1,1,0,1,1,0,0,1,0,1,1];
const ME=[69,0,0,74,0,0,77,0,76,0,74,0,0,0,69,0,70,0,0,74,0,0,77,0,79,0,77,0,0,0,74,0,
          72,0,0,77,0,0,81,0,79,0,77,0,0,0,72,0,76,0,0,79,0,0,84,0,81,0,79,0,76,0,0,0];
// per section: pad cutoff a,b, arp cutoff a,b, bass cutoff a,b, pad level, arp level, lead level
const AU=[[300,2200,350,1800,0,0,1,.6,0],[2200,3000,1800,3200,80,380,.8,.7,0],[4000,4000,3500,3500,300,420,.7,.8,0],
          [4000,5000,3500,5000,420,600,.7,.9,0],[1200,5000,700,4500,0,0,1,.7,.6],[5000,5000,4500,4500,350,500,.7,.8,1],
          [5000,5000,4500,5500,500,650,.7,.9,1],[4000,250,3500,250,400,70,.8,.7,0]];
let pos=0,nx=0,st=-1,
 kt=-1,kp=0,
 bph=0,bf=55,be=0,ba=0,bt=0,bcut=0,
 he=0,hd=.99,hl=0,ce=-1,clv=0,cre=0,crl=0,ris=0,ri=0,
 pl=0,pr=0,pl2=0,pr2=0,pc=.02,pct=.02,plv=0,plt=0,
 aph=0,af=220,ae=0,acut=800,alv=0,ap=.3,
 lph=0,lph2=0,lf=440,lt=440,le=0,llv=0,lvt=0,
 di=0,dlp=0,drp=0;
const bs=new Float64Array(3),cs=new Float64Array(3),rz=new Float64Array(3),as=new Float64Array(3),ls=new Float64Array(3);
const pph=new Float64Array(12).map(()=>rnd()*.5+.5),pfr=new Float64Array(12),pdt=[.9936,.9977,1.0029,1.0069];
const bdc=dc(.07),bad=dc(.2),adc=dc(.11),ldc=dc(.9),crd=dc(.5),hdo=dc(.09),hdc=dc(.018),HV=[.5,.22,.8,.3];
// stereo ping-pong delay (dotted eighth) and a Freeverb-style reverb
const DN=Math.round(S16*3),dL=new Float32Array(DN),dR=new Float32Array(DN);
const mk=(a,o)=>a.map(n=>new Float32Array(Math.round((n+o)*sr/44100)));
const cl=[1116,1188,1277,1356,1422,1491,1557,1617],al=[556,441,341,225];
const cL=mk(cl,0),cR=mk(cl,23),aL=mk(al,0),aR=mk(al,23),ci=new Int32Array(16),ai=new Int32Array(8),cf=new Float64Array(16);
const verb=(x,C,A,o)=>{let y=0;
 for(let j=0;j<8;j++){const b=C[j],q=o*8+j,i=ci[q],v=b[i];cf[q]=v*.8+cf[q]*.2;b[i]=x+cf[q]*.86;ci[q]=i+1==b.length?0:i+1;y+=v}
 for(let j=0;j<4;j++){const b=A[j],q=o*4+j,i=ai[q],v=b[i];b[i]=y+v*.5;ai[q]=i+1==b.length?0:i+1;y=v-y}
 return y};
const X=(a,b,sp)=>a*(b/a)**sp;
const trig=()=>{
 const s=st&15,bar=st>>4,b8=bar&7,sec=bar>>3,sp=(b8*16+s)/128,ch=CH[(bar>>1)&3],A=AU[sec],
  dr=sec==1||sec==2||sec==3||sec==5||sec==6||(sec==7&&bar<60),full=sec==2||sec==3||sec==5||sec==6;
 for(let j=0;j<12;j++)pfr[j]=mf(ch[1+(j>>2)])*pdt[j&3];
 pct=1-Math.exp(-TAU*X(A[0],A[1],sp)*T);acut=X(A[2],A[3],sp);bcut=A[4]?X(A[4],A[5],sp):0;
 plt=A[6]*(sec?1:Math.min(1,sp*4))*(sec==7?Math.min(1,(1-sp)*1.6):1);
 alv=A[7]*(sec?1:Math.min(1,sp*2))*(sec==7?1-sp:1);llv=A[8];
 if(dr&&!(s&3)){kt=0;kp=0}
 if(full&&(s==4||s==12)){ce=0;clv=.5}
 if(sec==4&&bar>=38&&(bar>38||!(s&1))){ce=0;clv=.1+.45*(((bar-38)*16+s)/32)**2}
 if(dr&&(sec>1||sp>.5)){he=HV[s&3]*(full?1:.6);hd=(s&3)==2&&full?hdo:hdc}
 if(bcut&&dr&&(s&3)){bf=mf(ch[0]+((s&3)==3&&(bar&1)?12:0));be=1;bt=1}
 if(alv>0&&(sec||!(s&1))){af=mf(ch[1+AR[s]]+12*AO[s]+(sec>4&&sec<7?12:0));ae=1;ap=-ap}
 if(llv>0&&!(s&1)){const n=ME[b8*8+(s>>1)];if(n){lt=mf(n);le=1}}
 if(!s&&!b8&&sec){cre=1;crl=full?.45:.25}
 ris=sec<2&&b8>5?((b8-6)*16+s)/32:sec==4&&b8>3?((b8-4)*16+s)/64:sec==3&&b8==7?s/16:0;
};
return(L,R)=>{
 for(let i=0;i<L.length;i++){
  if(pos>=nx){nx+=S16;st=(st+1)%LEN;trig()}
  pos++;
  let m=0,l=0,r=0,duck=1,dly=0,rv=0;
  // kick
  if(kt>=0){kp+=(46+160*Math.exp(-kt*24)+500*Math.exp(-kt*160))*T;m+=Math.tanh(Math.sin(TAU*kp)*Math.exp(-kt*6)*2.2)*.75;duck=1-.75*Math.exp(-kt*9);kt+=T;if(kt>.6)kt=-1}
  // bass
  if(bcut){bph+=bf*T;if(bph>=1)bph-=1;be*=bdc;bt*=bad;ba+=(bt-ba)*.02;
   m+=Math.tanh(svf(bs,(saw(bph,bf*T)*.7+Math.sin(TAU*bph)*.6)*ba,bcut*(1+5*be),.5)*1.6)*.42*duck}
  // hats, clap, crash, riser share one noise source
  const n=rnd();hl+=(n-hl)*.4;const hh=n-hl;he*=hd;l+=hh*he*.2;r+=hh*he*.24;
  if(ce>=0){svf(cs,n,1300,.7);const c=cs[2]*(ce<.03?1-(ce%.01)*70:Math.exp(-(ce-.03)*20))*clv*1.6;m+=c;rv+=c*.5;ce+=T;if(ce>.5)ce=-1}
  cre*=crd;{const c=hh*cre*crl;l+=c;r+=c;rv+=c*.5}
  ri+=(ris-ri)*.001;if(ri>.001){svf(rz,n,300*2**(ri*5),.4);const c=rz[2]*ri*ri*.35;m+=c;rv+=c*.3}
  // pad: 3 notes x 4 detuned saws, split left/right
  {let a=0,b=0;for(let j=0;j<12;j++){let p=pph[j]+pfr[j]*T;if(p>=1)p-=1;pph[j]=p;if(j&1)b+=p;else a+=p}
   pc+=(pct-pc)*.0005;plv+=(plt-plv)*.0002;
   pl+=((2*a-6)*.07-pl)*pc;pl2+=(pl-pl2)*pc;pr+=((2*b-6)*.07-pr)*pc;pr2+=(pr-pr2)*pc;
   const g=plv*(.35+.65*duck);l+=pl2*g;r+=pr2*g;rv+=(pl2+pr2)*g*.25}
  // arp pluck
  if(alv>0||ae>1e-4){aph+=af*T;if(aph>=1)aph-=1;ae*=adc;
   const x=svf(as,(saw(aph,af*T)+(aph<.5?.5:-.5))*ae,acut*(1+3*ae),.35)*alv*.22*(.5+.5*duck);
   l+=x*.6*(1-ap);r+=x*.6*(1+ap);dly+=x*.7;rv+=x*.3}
  // lead
  if(llv>0||le>1e-4){lf+=(lt-lf)*.002;lvt+=T;const f=lf*(1+.005*Math.sin(TAU*5.5*lvt))*T;
   lph+=f*1.004;if(lph>=1)lph-=1;lph2+=f*.996;if(lph2>=1)lph2-=1;le*=ldc;
   const x=svf(ls,(saw(lph,f)+saw(lph2,f))*le,1500+3500*le,.6)*llv*.16;m+=x;dly+=x*.8;rv+=x*.5}
  // delay
  {const a=dL[di],b=dR[di];dlp+=(b-dlp)*.4;drp+=(a-drp)*.4;dL[di]=dly+dlp*.5;dR[di]=drp*.5;if(++di==DN)di=0;l+=a*.6;r+=b*.6;rv+=(a+b)*.15}
  // reverb + soft clip
  l+=verb(rv*.03+1e-18,cL,aL,0)*1.2;r+=verb(rv*.03+1e-18,cR,aR,1)*1.2;
  L[i]=Math.tanh((m+l)*.9);R[i]=Math.tanh((m+r)*.9);
 }
 return pos};
}

/* ---------------- shaders ---------------- */
const VS=`#version 300 es
void main(){gl_Position=vec4(vec2(gl_VertexID&1,gl_VertexID>>1)*4.-1.,0,1);}`;

const HEAD=n=>`#version 300 es
precision highp float;precision highp sampler2D;
#define SCENE ${n}
`;

const SCN=`
uniform vec2 uR;uniform float uT,uRow,uV;uniform vec4 uA,uK;uniform sampler2D uS;out vec4 O;
// uA: bass, low-mid, mid, high (FFT bands)   uK: kick env, hat env, integral of bass, integral of energy
#define PI 3.14159265
#define sat(x) clamp(x,0.,1.)
float M,E,RL,DI;vec3 al,em;float rg,f0,rf;
mat2 rot(float a){float c=cos(a),s=sin(a);return mat2(c,-s,s,c);}
float h21(vec2 p){return fract(sin(dot(p,vec2(127.1,311.7)))*43758.5453);}
vec3 pal(float t){return .5+.5*cos(6.2832*(t+vec3(0.,.33,.67)));}
float fft(float x){return textureLod(uS,vec2(x,uRow),0.).r;}                 // spectrum now, x = log frequency
float fth(float x,float a){return textureLod(uS,vec2(x,uRow-a*.98),0.).r;}   // spectrum a*2 seconds ago
float box(vec3 p,vec3 b){vec3 q=abs(p)-b;return length(max(q,0.))+min(max(q.x,max(q.y,q.z)),0.);}
float box2(vec2 p,vec2 b){vec2 q=abs(p)-b;return length(max(q,0.))+min(max(q.x,q.y),0.);}
float tor(vec3 p,vec2 t){return length(vec2(length(p.xz)-t.x,p.y))-t.y;}
// the operators: add, subtract, intersect - smooth, chamfered and stepped
float smin(float a,float b,float k){float h=max(k-abs(a-b),0.)/k;return min(a,b)-h*h*k*.25;}
float smax(float a,float b,float k){return -smin(-a,-b,k);}
float uCh(float a,float b,float r){return min(min(a,b),(a-r+b)*.7071);}
float dCh(float a,float b,float r){return max(max(a,-b),(a+r-b)*.7071);}
float iCh(float a,float b,float r){return max(max(a,b),(a+r+b)*.7071);}
float uSt(float a,float b,float r,float n){float s=r/n,u=b-r;return min(min(a,b),.5*(u+a+abs(mod(u-a+s,2.*s)-s)));}
float dSt(float a,float b,float r,float n){return -uSt(-a,b,r,n);}

#if SCENE==0
// (cube & sphere) - three bores - slices + core
#define STEPS 100
#define TMAX 40.
#define SK .85
#define GS 1e3
#define FOG .002
#define FC vec3(.01,.012,.02)
#define GK 8.
#define GI .25
#define EP vec3(0)
#define EI 6.
#define AMB0 vec3(.01)
#define AMB1 vec3(.05,.06,.09)
#define L normalize(vec3(.5,.8,-.4))
#define LC vec3(2.,1.9,1.8)
vec3 gc(vec3 p){return vec3(1.,.42,.12)*(.4+1.2*uK.x+.5*uA.x);}
vec3 sky(vec3 d){return vec3(.012,.014,.022)+.05*pow(sat(1.-abs(d.y)),6.)*vec3(.3,.4,.8);}
vec3 tw(vec3 p){p.xz*=rot(uT*.23+uK.z*.6);p.xy*=rot(.5+.2*sin(uT*.31));return p;}
float map(vec3 p){
  float fl=p.y+1.9;vec3 q=tw(p);
  float a=iCh(box(q,vec3(1.)),length(q)-1.36,.06);
  float c=min(min(length(q.yz)-.3-.35*uA.x,length(q.xz)-.25-.4*uA.y),length(q.xy)-.2-.45*uA.z);
  float d=dSt(a,c,.14,3.);
  float i=round(q.y*5.);
  d=max(d,.005+.03*fft(.08+.06*(i+6.))-abs(q.y-i*.2));
  float co=length(q)-.32-.22*uK.x;E=co;
  M=1.+.5*step(a+.002,d);float r=d;
  if(co<r){r=co;M=2.;}
  if(fl<r){r=fl;M=0.;}
  return r;
}
void mtl(vec3 p,vec3 n,float m){
  em=vec3(0);rf=0.;
  if(m<.5){float r=length(p.xz),v=fth(.07,sat(r/18.));al=vec3(.02);rg=.25;f0=.06;rf=1.;
    em=vec3(.1,.5,1.)*v*v*smoothstep(.42,.5,abs(fract(r*1.5)-.5))*2.*exp(-r*.1);}
  else if(m<1.25){al=vec3(.85,.86,.9);rg=.35;f0=.05;}
  else if(m<1.75){al=vec3(.6,.33,.12);rg=.3;f0=.6;rf=.4;em=vec3(1.,.3,.05)*(.1+uK.x);}
  else{al=vec3(0);rg=1.;f0=0.;em=gc(p)*4.;}
}
void cam(out vec3 ro,out vec3 ta,out float fv){
  float a=uT*.17+uV*2.4,r=4.6+1.2*sin(uV*1.7);
  ro=vec3(sin(a)*r,.3+1.1*sin(uV*3.1+1.),cos(a)*r);ta=vec3(0.,-.15,0.);fv=1.6;}

#elif SCENE==1
// solid - corridor - niches (stepped) - slots (chamfered) + columns (stepped)
#define STEPS 110
#define TMAX 60.
#define SK .8
#define GS 1e3
#define FOG .0012
#define FC vec3(0.,.005,.015)
#define GK 30.
#define GI .15
#define EI 1.2
#define EK 3.
#define AMB0 vec3(.01)
#define AMB1 vec3(.02)
#define NOSUN
#define HL vec3(.25)
float cz(){return uT*2.5+uK.z*4.;}
vec3 gc(vec3 p){return mix(vec3(1.,.15,.45),vec3(.1,.7,1.),smoothstep(-.5,.5,p.x))*(.6+uA.x);}
vec3 sky(vec3 d){return FC;}
vec3 tw(vec3 p){p.xy*=rot(.2*sin(p.z*.07+uT*.1));return p;}
float map(vec3 p){
  p=tw(p);
  float zc=round(p.z*.5),z=p.z-zc*2.,age=sat((zc*2.-cz())/50.);
  float v=p.x<0.?fth(.07,age):fth(.4,age),ft=fth(.75,age);
  float d=-box2(p.xy,vec2(2.,1.5));
  vec3 q=vec3(abs(p.x)-2.1,p.y+.1,z);
  d=dSt(d,length(q)-.35-.7*v,.15,3.);
  d=dCh(d,box(vec3(p.x,p.y-1.5,z),vec3(1.2,.1+.5*ft,.35)),.08);
  d=max(d,-box2(vec2(p.x,p.y+1.5),vec2(.5,.12)));
  float z2=p.z-1.-2.*round((p.z-1.)*.5);
  d=uSt(d,length(vec2(abs(p.x)-1.45,z2))-.1,.25,4.);
  float orb=length(q)-.1-.25*v,strip=box2(vec2(p.x,p.y+1.6),vec2(.3,.03));
  float e=min(orb,strip);E=orb;M=1.;
  if(e<d){d=e;M=2.;}
  return d;
}
void mtl(vec3 p,vec3 n,float m){
  em=vec3(0);rf=0.;
  if(m<1.5){al=vec3(.18,.2,.25);rg=.5;f0=.04;rf=.5*step(.9,n.y);}
  else{al=vec3(0);rg=1.;f0=0.;em=gc(tw(p))*(1.2+2.*uK.x);}
}
void cam(out vec3 ro,out vec3 ta,out float fv){
  ro=vec3(.5*sin(uT*.31+uV),-.35+.3*sin(uT*.23),cz());
  ta=ro+vec3(.4*sin(uT*.17+uV*2.),.15*sin(uT*.2),2.);fv=1.1;RL=.25*sin(uT*.21+uV);}

#elif SCENE==2
// sum of FFT bars - sphere + smooth sun
#define STEPS 140
#define TMAX 70.
#define SK .9
#define GS 1e3
#define FOG .0005
#define FC vec3(.03,.01,.04)
#define GK 3.
#define GI .2
#define EP sc()
#define EI 10.
#define AMB0 vec3(.01,.005,.02)
#define AMB1 vec3(.04,.03,.08)
#define L normalize(vec3(-.4,.5,.6))
#define LC vec3(.5,.4,.8)
vec3 gc(vec3 p){return vec3(1.,.5,.15)*(.6+2.*uK.x);}
vec3 sky(vec3 d){return mix(vec3(.01,.005,.03),vec3(.12,.03,.1),exp(-abs(d.y)*7.));}
vec3 sc(){return vec3(0.,1.8+.3*sin(uT*.7),0.);}
float fq(vec2 id){return .04+.85*abs(fract(abs(atan(id.x,id.y+1e-4))/PI*2.)-.5)*2.;}
float hg(vec2 id){return .15+3.4*pow(fth(fq(id),sat(length(id)/40.)),1.5);}
float map(vec3 p){
  vec2 id=round(p.xz),q=p.xz-id;
  float d=min(box(vec3(q.x,p.y,q.y),vec3(.38,hg(id),.38))-.02,min(.5-abs(q.x),.5-abs(q.y))+.1);
  d=min(max(d,p.y-3.7),p.y);
  float a=d;d=dCh(d,length(p-vec3(0.,2.5,0.))-5.5-1.2*uA.x,.12);
  M=1.+.5*step(a+.01,d);
  vec3 c=p-sc();float su=length(c)-.8-.35*uK.x;
  for(int i=0;i<3;i++){float f=float(i)*2.094+uT*.8+uK.z;
    su=smin(su,length(c-1.7*vec3(cos(f),.4*sin(f*1.3+uT),sin(f)))-.28-.2*uA[i+1],.6);}
  E=su;if(su<d){d=su;M=2.;}
  return d;
}
void mtl(vec3 p,vec3 n,float m){
  em=vec3(0);rf=0.;al=vec3(.04);rg=.3;f0=.05;
  if(m<1.25){vec2 id=round(p.xz);float h=hg(id);vec3 c=pal(.62+fq(id)*.45);
    em=c*(smoothstep(h-.14,h-.02,p.y)*2.+.2*step(.5,fract(p.y*3.)))*h*h*.09*step(.01,p.y);}
  else if(m<1.75){al=vec3(.02);em=vec3(1.,.3,.08)*(.25+1.5*uK.x)*(.3+smoothstep(.38,.5,abs(fract(p.y*4.)-.5)));}
  else{al=vec3(0);rg=1.;f0=0.;em=gc(p)*3.;}
}
void cam(out vec3 ro,out vec3 ta,out float fv){
  float a=uT*.1+uV*1.9,r=11.+3.*sin(uV*2.3);
  ro=vec3(sin(a)*r,5.5+1.3*sin(uV*1.3),cos(a)*r);ta=vec3(0.,1.,0.);fv=1.5;}

#elif SCENE==3
// smooth union of blobs - smooth union of anti-blobs
#define STEPS 90
#define TMAX 25.
#define SK .8
#define GS .04
#define FOG 0.
#define FC vec3(0)
#define GK 300.
#define GI .1
#define EI 0.
#define EK 1.
#define AMB0 vec3(.02,.03,.04)
#define AMB1 vec3(.1,.12,.16)
#define L normalize(vec3(.6,.7,-.3))
#define LC vec3(2.2,2.,1.8)
vec3 gc(vec3 p){return vec3(.3,.7,1.)*(.4+uA.z);}
vec3 sky(vec3 d){return vec3(.012,.03,.045)*(1.2+d.y)+vec3(.5,.2,.6)*.25*pow(sat(dot(d,L)),3.)+vec3(.1,.4,.5)*.2*pow(sat(-d.x),4.);}
float map(vec3 p){
  float d=1e9,t=uT*.3+uK.w*.6;
  for(int i=0;i<6;i++){float f=float(i);
    d=smin(d,length(p-1.25*sin(vec3(1.3,1.7,1.1)*(t+f*1.9)+f*vec3(2.1,.7,4.2)))-.5-.45*fft(.06+f*.14),.7);}
  vec3 q=p;q.xy*=rot(t*.7);q.yz*=rot(t*.5);
  d=smin(d,tor(q,vec2(2.1,.1+.1*uA.y)),.4);
  float a=d,e=1e9;
  for(int i=0;i<3;i++){float f=float(i);
    float s=length(p-1.5*sin(vec3(1.9,1.4,2.3)*(t*1.4+f*2.4)+f))-.6-.5*uA[i];
    d=smax(d,-s,.2);e=min(e,abs(s));}
  E=e;M=1.+sat((d-a)*6.);
  return d;
}
void mtl(vec3 p,vec3 n,float m){
  float k=sat(m-1.);rf=0.;rg=.25;f0=.08;
  al=mix(pal(.55+.22*n.y+.08*sin(p.x*2.+uT))*.6,vec3(.04),k);
  em=vec3(1.,.25,.05)*k*k*(1.+2.5*uK.x);
}
void cam(out vec3 ro,out vec3 ta,out float fv){
  float a=uT*.21+uV*2.1;
  ro=vec3(sin(a)*6.5,1.5*sin(uV*1.7+uT*.1),cos(a)*6.5);ta=vec3(0);fv=1.7;RL=.2*sin(uV);}

#elif SCENE==4
// nested shells & gyroid - rotating half-spaces + core
#define STEPS 120
#define TMAX 30.
#define SK .6
#define GS 1e3
#define FOG 0.
#define FC vec3(0)
#define GK 2.5
#define GI .35
#define EP vec3(0)
#define EI 8.
#define AMB0 vec3(.02)
#define AMB1 vec3(.05,.06,.1)
#define L normalize(vec3(-.5,.7,-.5))
#define LC vec3(1.2,1.3,1.6)
vec3 gc(vec3 p){return vec3(.4,.6,1.)*(.6+2.*uK.x)+vec3(1.,.3,.5)*uA.y;}
vec3 sky(vec3 d){return vec3(.015,.02,.05)+vec3(.1,.05,.2)*pow(sat(.5+.5*d.y),3.);}
float gy(vec3 p){return dot(sin(p),cos(p.zxy));}
float map(vec3 p){
  p.xz*=rot(uT*.12);
  float s=length(p),k=min(floor(s/.8),3.);
  float sh=abs(s-(k+.5)*.8)-.045-.05*uA[int(k)];
  vec3 q=p;q.xy*=rot(uT*.25*(k-1.5)+k*1.3+uK.w*.5);q.yz*=rot(uT*.17*(2.-k)+k*2.1);
  float d=iCh(sh,q.y-.15*s,.03),f=6.-k;
  d=max(d,(abs(gy(q*f))-.45-.6*uA.y)/(f*1.8));
  float co=s-.16-.14*uK.x;E=co;M=1.+k*.1;
  if(co<d){d=co;M=2.;}
  return d;
}
void mtl(vec3 p,vec3 n,float m){
  em=vec3(0);rf=0.;
  if(m<1.5){float g=step(.05,fract((m-1.)*5.));al=mix(vec3(.9,.86,.8),vec3(1.,.65,.25),g);rg=.3;f0=mix(.05,.5,g);}
  else{al=vec3(0);rg=1.;f0=0.;em=gc(p)*4.;}
}
void cam(out vec3 ro,out vec3 ta,out float fv){
  float a=uT*.15+uV*2.6;
  ro=vec3(sin(a)*7.5,2.5*sin(uV*1.9+.5),cos(a)*7.5);ta=vec3(0);fv=1.9;}

#else
// cube - cross - cross - cross - cross (Menger: nothing but subtraction), each level sized by one FFT band
#define STEPS 110
#define TMAX 30.
#define SK .75
#define GS 1e3
#define FOG .012
#define FC vec3(.03,.01,0.)
#define GK 40.
#define GI .6
#define EI 1.5
#define EK 6.
#define AMB0 vec3(.01)
#define AMB1 vec3(.02)
#define NOSUN
#define HL vec3(.35,.32,.28)
vec3 gc(vec3 p){return vec3(1.,.6,.2)*(.5+2.*uK.x);}
vec3 sky(vec3 d){return FC;}
vec3 tw(vec3 p){p.xy*=rot(p.z*.04+.3*sin(uT*.1));return p;}
float map(vec3 p){
  p=tw(p);
  float d=-1e9,s=1.;M=1.;
  for(int i=0;i<4;i++){
    vec3 a=mod(p*s,2.)-1.;s*=3.;
    vec3 r=abs(1.-3.*abs(a));
    float c=(min(max(r.x,r.y),min(max(r.y,r.z),max(r.z,r.x)))-1.+.3*uA[i])/s;
    if(c>d){d=c;M=1.+float(i)*.25;}
  }
  float o=length(mod(p+vec3(0.,1.,1.),2.)-1.)-.07-.06*uK.x;   // orbs in the side tunnels
  E=o;if(o<d){d=o;M=3.;}
  return d;
}
void mtl(vec3 p,vec3 n,float m){
  em=vec3(0);rf=0.;al=vec3(.2,.19,.18);rg=.5;f0=.04;
  if(m>2.5){al=vec3(0);em=gc(p)*5.;}
  else if(m>1.3){int i=int((m-1.)*4.+.5);em=mix(vec3(1.,.45,.1),vec3(.1,.6,1.),float(i-2))*(.02+.6*uA[i]*uA[i])*float(i-1)*.5;}
}
void cam(out vec3 ro,out vec3 ta,out float fv){
  ro=vec3(.08*sin(uT*.5),.08*cos(uT*.4),uT*1.2+uK.z*2.);
  ta=ro+vec3(.5*sin(uT*.2+uV*1.3),.4*sin(uT*.15+uV),1.);fv=.9;RL=uT*.1+uV;}
#endif

vec3 nrm(vec3 p,float t){vec2 e=vec2(1,-1)*(.0005+.0004*t);
  return normalize(e.xyy*map(p+e.xyy)+e.yyx*map(p+e.yyx)+e.yxy*map(p+e.yxy)+e.xxx*map(p+e.xxx));}
float shd(vec3 p,vec3 l){float r=1.,t=.03;
  for(int i=0;i<28;i++){float d=map(p+l*t);r=min(r,10.*d/t);t+=clamp(d,.02,.4);if(r<.01||t>12.)break;}
  return sat(r);}
float ao(vec3 p,vec3 n){float a=0.,s=1.;
  for(int i=1;i<=5;i++){float h=.03+.11*float(i);a+=(h-map(p+n*h))*s;s*=.75;}
  return sat(1.-1.2*a);}
float march(vec3 ro,vec3 rd,out vec3 g){
  float t=.02+.05*DI;g=vec3(0);
  for(int i=0;i<STEPS;i++){
    vec3 p=ro+rd*t;float d=map(p);
    g+=gc(p)*GI*min(d,.25)/(1.+E*E*GK);
    if(d<.0006*t+.0003||t>TMAX)break;
    t+=min(d*SK,E*.8+GS);
  }
  return t;
}
vec3 shade(vec3 p,vec3 rd,float m,float t,out vec3 n){
  map(p);float e=E;
  n=nrm(p,t);mtl(p,n,m);
  float o=ao(p,n),nv=sat(dot(n,-rd)),fr=f0+(1.-f0)*pow(1.-nv,5.),ex=2./(rg*rg*rg*rg+.001);
  vec3 c=al*mix(AMB0,AMB1,.5+.5*n.y)*o+em+sky(reflect(rd,n))*fr*o*.5;
#ifndef NOSUN
  float nl=sat(dot(n,L));
  if(nl>0.)c+=LC*nl*shd(p+n*.01,L)*(al+fr*(ex+2.)*.125*pow(sat(dot(n,normalize(L-rd))),ex));
#else
  c+=al*HL*nv/(1.+t*t*.05);
#endif
#ifdef EP
  vec3 lv=EP-p;float l2=dot(lv,lv);lv*=inversesqrt(l2);
  c+=gc(p)*EI/(1.+l2)*sat(dot(n,lv))*o*(al+fr*(ex+2.)*.125*pow(sat(dot(n,normalize(lv-rd))),ex));
#else
  c+=al*gc(p)*EI/(1.+e*e*EK)*o;
#endif
  return c;
}
void main(){
  vec2 uv=(gl_FragCoord.xy*2.-uR)/uR.y;
  vec3 ro,ta;float fv;RL=0.;cam(ro,ta,fv);
  vec3 f=normalize(ta-ro),r=normalize(cross(vec3(sin(RL),cos(RL),0.),f)),u=cross(f,r);
  vec3 rd=normalize(f*fv+r*uv.x+u*uv.y);
  DI=h21(gl_FragCoord.xy+fract(uT)*91.);
  vec3 g;float t=march(ro,rd,g),m=M;
  vec3 col;
  if(t<TMAX){
    vec3 p=ro+rd*t,n;col=shade(p,rd,m,t,n);
    float w=rf*mix(.06,1.,pow(1.-sat(dot(n,-rd)),3.));
    if(w>.01){
      vec3 r2=reflect(rd,n),g2,q=p+n*.02,c2;float t2=march(q,r2,g2),m2=M;
      if(t2<TMAX){vec3 n2;c2=shade(q+r2*t2,r2,m2,t2,n2);c2=mix(c2,FC,1.-exp(-FOG*t2*t2));}else c2=sky(r2);
      col+=w*(c2+g2);
    }
    col=mix(col,FC,1.-exp(-FOG*t*t));
  }else col=sky(rd);
  O=vec4(max(col+g,0.),1.);
}`;

const PRE=`#version 300 es
precision highp float;uniform sampler2D uC;uniform vec2 uR,uI;uniform float uTh;out vec4 O;
`;
// dual-filter bloom: 5-tap downsample (soft threshold on the first pass), 8-tap tent upsample
const DOWN=PRE+`void main(){vec2 v=gl_FragCoord.xy/uR;
vec3 s=texture(uC,v).rgb*4.+texture(uC,v+uI).rgb+texture(uC,v-uI).rgb+texture(uC,v+uI*vec2(1,-1)).rgb+texture(uC,v+uI*vec2(-1,1)).rgb;s*=.125;
if(uTh>0.){s=min(s,vec3(24.));s*=smoothstep(.5,1.8,max(s.r,max(s.g,s.b)));}
O=vec4(s,1);}`;
const UP=PRE+`void main(){vec2 v=gl_FragCoord.xy/uR;vec3 e=vec3(uI,0.);
vec3 s=texture(uC,v+e.xz).rgb+texture(uC,v-e.xz).rgb+texture(uC,v+e.zy).rgb+texture(uC,v-e.zy).rgb
+2.*(texture(uC,v+uI*.5).rgb+texture(uC,v-uI*.5).rgb+texture(uC,v+uI*vec2(.5,-.5)).rgb+texture(uC,v+uI*vec2(-.5,.5)).rgb);
O=vec4(s/12.,1);}`;
const COMP=`#version 300 es
precision highp float;uniform sampler2D uC,uB,uX,uS;uniform vec2 uR;uniform float uT,uF,uXa,uRow,uFl;out vec4 O;
vec3 aces(vec3 x){return clamp((x*(2.51*x+.03))/(x*(2.43*x+.59)+.14),0.,1.);}
void main(){
  vec2 v=gl_FragCoord.xy/uR,c=v-.5;float r2=dot(c,c);
  vec2 o=c*r2*(.012+.03*uFl);
  vec3 col=vec3(texture(uC,v-o).r,texture(uC,v).g,texture(uC,v+o).b);
  col+=texture(uB,v).rgb*.16;
  col*=1.-1.1*r2;
  col+=uFl*.3;
  col=pow(aces(col*1.15),vec3(.4545));
  float sp=texture(uS,vec2(abs(c.x)*2.,uRow)).r;
  col+=.35*step(v.y,.003+.035*sp)*vec3(.6,.8,1.);
  col=mix(col,vec3(1),texture(uX,vec2(v.x,1.-v.y)).a*uXa);
  col+=(fract(sin(dot(gl_FragCoord.xy+uT*61.,vec2(12.9898,78.233)))*43758.5453)-.5)*.035;
  O=vec4(col*uF,1);
}`;

/* ---------------- GL setup ---------------- */
const C=document.getElementById('c'),gl=C.getContext('webgl2',{antialias:false,alpha:false,powerPreference:'high-performance'});
if(!gl){document.body.innerHTML='<p style="color:#fff;font:16px sans-serif;padding:2em">This demo needs WebGL2.</p>';return}
const HF=gl.getExtension('EXT_color_buffer_float')||gl.getExtension('EXT_color_buffer_half_float');
gl.getExtension('KHR_parallel_shader_compile');
const TQ=gl.getExtension('EXT_disjoint_timer_query_webgl2'),tq=TQ&&gl.createQuery();let qp=0,gms=8;
const IF=HF?gl.RGBA16F:gl.RGBA8,TY=HF?gl.HALF_FLOAT:gl.UNSIGNED_BYTE;
gl.bindVertexArray(gl.createVertexArray());
const tex=(unit,wrapT)=>{const t=gl.createTexture();gl.activeTexture(gl.TEXTURE0+unit);gl.bindTexture(gl.TEXTURE_2D,t);
 gl.texParameteri(gl.TEXTURE_2D,gl.TEXTURE_MIN_FILTER,gl.LINEAR);gl.texParameteri(gl.TEXTURE_2D,gl.TEXTURE_MAG_FILTER,gl.LINEAR);
 gl.texParameteri(gl.TEXTURE_2D,gl.TEXTURE_WRAP_S,gl.CLAMP_TO_EDGE);gl.texParameteri(gl.TEXTURE_2D,gl.TEXTURE_WRAP_T,wrapT||gl.CLAMP_TO_EDGE);return t};
const target=(w,h)=>{const t=tex(1);gl.texImage2D(gl.TEXTURE_2D,0,IF,w,h,0,gl.RGBA,TY,null);
 const f=gl.createFramebuffer();gl.bindFramebuffer(gl.FRAMEBUFFER,f);gl.framebufferTexture2D(gl.FRAMEBUFFER,gl.COLOR_ATTACHMENT0,gl.TEXTURE_2D,t,0);return{t,f,w,h}};
const prog=fs=>{const p=gl.createProgram(),sh=[];
 for(const[ty,src]of[[gl.VERTEX_SHADER,VS],[gl.FRAGMENT_SHADER,fs]]){const s=gl.createShader(ty);gl.shaderSource(s,src);gl.compileShader(s);gl.attachShader(p,s);sh.push(s)}
 gl.linkProgram(p);return{p,sh,u:null}};
const errs=[];
const use=o=>{
 if(!o.u){o.u={};
  if(!gl.getProgramParameter(o.p,gl.LINK_STATUS)){const e=gl.getProgramInfoLog(o.p)+'\n'+gl.getShaderInfoLog(o.sh[1]);errs.push(e);console.error('shader',e)}
  for(let i=0,n=gl.getProgramParameter(o.p,gl.ACTIVE_UNIFORMS);i<n;i++){const a=gl.getActiveUniform(o.p,i);o.u[a.name]=gl.getUniformLocation(o.p,a.name)}}
 gl.useProgram(o.p);return o.u};
// scene 0 first, so it is on screen immediately; the rest compile in the background
const NS=6,PS=[];for(let i=0;i<NS;i++)PS.push(prog(HEAD(i)+SCN));
const PD=prog(DOWN),PU=prog(UP),PC=prog(COMP);

// spectrogram texture: 256 log-frequency bins x 128 rows of history (ring buffer)
const NB=256,HR=128,cur=new Float32Array(NB),row8=new Uint8Array(NB);
const TS=tex(0,gl.REPEAT);gl.pixelStorei(gl.UNPACK_ALIGNMENT,1);
gl.texImage2D(gl.TEXTURE_2D,0,gl.R8,NB,HR,0,gl.RED,gl.UNSIGNED_BYTE,new Uint8Array(NB*HR));
// text overlay
const TX=tex(3),XC=document.createElement('canvas'),X=XC.getContext('2d');
let W=0,H=0,sc=1,scMax=1,S=null,B=[],txt=['','',''],txtDirty=1;
const free=o=>{if(o){gl.deleteTexture(o.t);gl.deleteFramebuffer(o.f)}};
const alloc=()=>{free(S);B.forEach(free);B=[];
 let w=Math.max(2,W*sc|0),h=Math.max(2,H*sc|0);S=target(w,h);
 for(let i=0;i<6;i++){w=Math.max(1,w>>1);h=Math.max(1,h>>1);B.push(target(w,h))}};
const resize=()=>{const d=Math.min(devicePixelRatio||1,2);W=C.width=Math.max(2,innerWidth*d|0);H=C.height=Math.max(2,innerHeight*d|0);
 scMax=sc=Math.min(1,Math.sqrt(1.4e6/(W*H)));alloc();txtDirty=1};
addEventListener('resize',resize);resize();
const drawText=()=>{txtDirty=0;
 const w=XC.width=Math.min(W,1600),h=XC.height=Math.max(1,Math.round(w*H/W));X.clearRect(0,0,w,h);X.fillStyle='#fff';X.textBaseline='middle';
 const sans='"Helvetica Neue",Helvetica,Arial,sans-serif',mono='ui-monospace,Menlo,Consolas,monospace';
 if(txt[0]){X.textAlign='center';X.font=`200 ${h*.15}px ${sans}`;try{X.letterSpacing=h*.045+'px'}catch(e){}X.fillText(txt[0],w/2+h*.022,h*.47)}
 try{X.letterSpacing=h*.008+'px'}catch(e){}
 if(txt[1]){X.textAlign='center';X.font=`400 ${h*.026}px ${mono}`;X.fillText(txt[1],w/2,h*.61)}
 if(txt[2]){X.textAlign='left';X.font=`400 ${h*.024}px ${mono}`;X.fillText(txt[2],h*.06,h*.9)}
 gl.activeTexture(gl.TEXTURE3);gl.bindTexture(gl.TEXTURE_2D,TX);gl.texImage2D(gl.TEXTURE_2D,0,gl.RGBA,gl.RGBA,gl.UNSIGNED_BYTE,XC)};

/* ---------------- audio + FFT ---------------- */
let ctx=null,an=null,node=null,t0=null,ext=null,extT=0,fb=null,lo=null,hi=null,mode='';
const start=async()=>{
 if(ctx){ctx.resume();return}
 ctx=new(window.AudioContext||window.webkitAudioContext)({latencyHint:'playback'});ctx.resume();
 an=ctx.createAnalyser();an.fftSize=2048;an.smoothingTimeConstant=.35;an.minDecibels=-85;an.maxDecibels=-18;an.connect(ctx.destination);
 fb=new Uint8Array(1024);
 const hz=ctx.sampleRate/2048;lo=new Float32Array(NB);hi=new Float32Array(NB);
 for(let i=0;i<NB;i++){lo[i]=35*2**(i/NB*8.8)/hz;hi[i]=35*2**((i+1)/NB*8.8)/hz}
 try{ // data: URL, because Blob URL worklets fail to load from file:// in Chrome
  await ctx.audioWorklet.addModule('data:text/javascript;charset=utf-8,'+encodeURIComponent(SYN+';registerProcessor("s",class extends AudioWorkletProcessor{constructor(){super();this.f=SYN(sampleRate);this.n=0}process(i,o){const p=this.f(o[0][0],o[0][1]);if(!(this.n++&31))this.port.postMessage([p,currentTime]);return true}})'));
  node=new AudioWorkletNode(ctx,'s',{numberOfInputs:0,outputChannelCount:[2]});
  node.port.onmessage=e=>{t0=e.data[1]-(e.data[0]-128)/ctx.sampleRate};mode='worklet';
 }catch(e){ // no worklet: same synth on the main thread
  const f=SYN(ctx.sampleRate);node=ctx.createScriptProcessor(2048,0,2);
  node.onaudioprocess=e=>{const b=e.outputBuffer,p=f(b.getChannelData(0),b.getChannelData(1));t0=e.playbackTime-(p-2048)/ctx.sampleRate};mode='scriptprocessor: '+e;
 }
 if(!ext)node.connect(an);
};
// your own music: drop a file, the FFT does the rest
const play=async file=>{
 await start();
 const buf=await ctx.decodeAudioData(await file.arrayBuffer());
 if(ext)ext.stop();else node.disconnect();
 ext=ctx.createBufferSource();ext.buffer=buf;ext.loop=true;ext.connect(an);ext.start();extT=ctx.currentTime;
};
addEventListener('dragover',e=>e.preventDefault());
addEventListener('drop',e=>{e.preventDefault();const f=e.dataTransfer.files[0];if(f)play(f).catch(e=>console.error(e))});
addEventListener('pointerdown',start);
let lock=-1;
addEventListener('keydown',e=>{
 if(e.key=='f'||e.key=='F'){try{(document.fullscreenElement?document.exitFullscreen():document.documentElement.requestFullscreen()).catch(()=>{})}catch(e){}}
 else if(e.key>='0'&&e.key<='6')lock=+e.key-1;
 start()});

const band=[0,0,0,0],peak=[.2,.2,.2,.2],A=[0,0,0,0],K=[0,0,0,0],RG=[0,52,116,186,256];
let pb=0,ph=0,row=0,racc=0;
const analyse=dt=>{
 if(an&&ctx.state=='running'){
  an.getByteFrequencyData(fb);
  for(let i=0;i<NB;i++){
   const a=lo[i],b=hi[i];let v=0,k=a|0;
   if(b-a<1)v=fb[k]+(fb[k+1]-fb[k])*(a-k);else for(;k<b;k++)v=Math.max(v,fb[k]);
   {const x=i/NB;v=Math.max(0,v/255-.3+.14*x)/.7*(.8+1.2*x)}v=Math.min(1,v*v*1.3);
   cur[i]+=(v-cur[i])*(v>cur[i]?.7:1-Math.exp(-dt*9));
  }
 }else for(let i=0;i<NB;i++)cur[i]*=.9;
 for(let j=0;j<4;j++){
  let s=0;for(let i=RG[j];i<RG[j+1];i++)s+=cur[i];s/=RG[j+1]-RG[j];
  band[j]=s;peak[j]=Math.max(peak[j]*Math.exp(-dt*.05),s,.12);
  A[j]+=(Math.min(1,s/peak[j])-A[j])*.5;
 }
 const d=Math.exp(-dt*5);
 K[0]=Math.max(K[0]*d,Math.min(1,Math.max(0,band[0]-pb)*7));pb=band[0];
 K[1]=Math.max(K[1]*d,Math.min(1,Math.max(0,band[3]-ph)*9));ph=band[3];
 K[2]+=dt*A[0];K[3]+=dt*(A[0]+A[1]+A[2]+A[3])*.25;
 racc+=dt;
 if(racc>=1/61){racc=Math.min(racc-1/60,.02);row=(row+1)%HR;
  for(let i=0;i<NB;i++)row8[i]=cur[i]*255;
  gl.activeTexture(gl.TEXTURE0);gl.bindTexture(gl.TEXTURE_2D,TS);gl.texSubImage2D(gl.TEXTURE_2D,0,0,row,NB,1,gl.RED,gl.UNSIGNED_BYTE,row8)}
};

/* ---------------- timeline ---------------- */
const CAP=['(cube ∩ sphere) − Σ cylinders − slices ∪ core','solid − corridor − Σ niches ∪ columns','Σ fft bars − sphere ∪ sun',
 '⋃ blobs − ⋃ anti-blobs','shells ∩ gyroid − half-spaces','cube − ⊞ − ⊞ − ⊞ − ⊞'];
const BAR=1.875,SONG=120;
let shot=-2,shotT=0,scene=0,vari=0,flash=0,fade=0,lt=0,ft=1/60,hold=0,frames=0;
const frame=now=>{
 requestAnimationFrame(frame);frames++;
 const t=now/1e3,dt=Math.min(.1,Math.max(.001,t-lt));lt=t;
 analyse(dt);
 // which shot are we in?
 let sh=-1,big='SUBTRAKT',sub='click to start',cap='';
 if(ext){const k=(ctx.currentTime-extT)/15|0;sh=1e3+k;scene=k%NS;vari=k*1.7;big=sub='';cap=CAP[scene]}
 else if(t0!=null&&ctx.state=='running'){
  const mt=Math.max(0,ctx.currentTime-t0-(ctx.outputLatency||0))%SONG,bar=mt/BAR,sec=bar/8|0;
  sh=sec==6?60+((bar-48)/2|0):sec*2+((bar&7)>>2);
  scene=sec==6?[1,3,2,5][(bar-48)/2&3]:[0,1,2,3,4,5,0,0][sec];vari=sh*1.3+sec;
  big=sec==0||sec==7?'SUBTRAKT':'';sub=sec==0?'a study in add and subtract':sec==7?'all geometry is arithmetic · all motion is fourier':'';
  cap=sec==7?'':CAP[scene];
  if(sec==0&&(bar&7)>3)big=sub='';
 }
 if(lock>=0&&sh>=0){scene=lock;cap=CAP[scene];big=sub=''}
 if(sh!=shot){if(shot>-2&&sh>=0)flash=1;shot=sh;shotT=0}
 if(txt[0]!=big||txt[1]!=sub||txt[2]!=cap){txt=[big,sub,cap];txtDirty=1}
 if(txtDirty)drawText();
 shotT+=dt;flash*=Math.exp(-dt*5);fade=Math.min(1,fade+dt*1.5);
 const xa=sh<0?.75+.25*Math.sin(t*3):Math.min(1,shotT*2)*Math.min(1,Math.max(0,(7.2-shotT)));

 // adaptive resolution: GPU time of the scene pass where the timer extension exists, frame time otherwise
 ft+=(dt-ft)*.05;
 if(TQ){if(qp&&gl.getQueryParameter(tq,gl.QUERY_RESULT_AVAILABLE)){if(!gl.getParameter(TQ.GPU_DISJOINT_EXT))gms+=(gl.getQueryParameter(tq,gl.QUERY_RESULT)/1e6-gms)*.2;qp=0}}
 else if(dt<.05)gms+=(dt*600-gms)*.05;
 hold-=dt;
 if(hold<0&&t>2){hold=.5;if(gms>11&&sc>.3){sc*=.88;alloc();gms=8}else if(gms<6&&sc<scMax){sc=Math.min(scMax,sc*1.08);alloc();hold=2}}

 // scene into the HDR target
 let u=use(PS[scene]);
 gl.disable(gl.BLEND);
 gl.bindFramebuffer(gl.FRAMEBUFFER,S.f);gl.viewport(0,0,S.w,S.h);
 gl.uniform2f(u.uR,S.w,S.h);gl.uniform1f(u.uT,t);gl.uniform1f(u.uRow,(row+.5)/HR);gl.uniform1f(u.uV,vari);
 gl.uniform4fv(u.uA,A);gl.uniform4fv(u.uK,K);gl.uniform1i(u.uS,0);
 const q=TQ&&!qp;if(q)gl.beginQuery(TQ.TIME_ELAPSED_EXT,tq);
 gl.drawArrays(gl.TRIANGLES,0,3);
 if(q){gl.endQuery(TQ.TIME_ELAPSED_EXT);qp=1}
 // bloom down
 gl.activeTexture(gl.TEXTURE1);
 u=use(PD);gl.uniform1i(u.uC,1);
 let src=S;
 for(let i=0;i<B.length;i++){const d=B[i];gl.bindFramebuffer(gl.FRAMEBUFFER,d.f);gl.viewport(0,0,d.w,d.h);gl.bindTexture(gl.TEXTURE_2D,src.t);
  gl.uniform2f(u.uR,d.w,d.h);gl.uniform2f(u.uI,1/src.w,1/src.h);gl.uniform1f(u.uTh,i?0:1);gl.drawArrays(gl.TRIANGLES,0,3);src=d}
 // bloom up (additive)
 u=use(PU);gl.uniform1i(u.uC,1);gl.enable(gl.BLEND);gl.blendFunc(gl.ONE,gl.ONE);
 for(let i=B.length-1;i>0;i--){const d=B[i-1];src=B[i];gl.bindFramebuffer(gl.FRAMEBUFFER,d.f);gl.viewport(0,0,d.w,d.h);gl.bindTexture(gl.TEXTURE_2D,src.t);
  gl.uniform2f(u.uR,d.w,d.h);gl.uniform2f(u.uI,1/src.w,1/src.h);gl.drawArrays(gl.TRIANGLES,0,3)}
 gl.disable(gl.BLEND);
 // composite
 u=use(PC);gl.bindFramebuffer(gl.FRAMEBUFFER,null);gl.viewport(0,0,W,H);
 gl.bindTexture(gl.TEXTURE_2D,S.t);gl.activeTexture(gl.TEXTURE2);gl.bindTexture(gl.TEXTURE_2D,B[0].t);
 gl.uniform1i(u.uC,1);gl.uniform1i(u.uB,2);gl.uniform1i(u.uX,3);gl.uniform1i(u.uS,0);
 gl.uniform2f(u.uR,W,H);gl.uniform1f(u.uT,t%100);gl.uniform1f(u.uF,fade);gl.uniform1f(u.uXa,xa);gl.uniform1f(u.uRow,(row+.5)/HR);gl.uniform1f(u.uFl,flash);
 gl.drawArrays(gl.TRIANGLES,0,3);
};
requestAnimationFrame(frame);
// if this page was opened by a press (a host's start screen) audio may already be allowed: try now, else wait for a click
start().catch(()=>{});
// inspection hook
window.SUBTRAKT={SYN,errs,get state(){return{scene,sc,ft,gms,tq:!!TQ,mt:ctx&&t0!=null?(ctx.currentTime-t0)%120:-1,frames,mode,A:[...A],K:[...K],band:[...band],t0,W,H,ctx:ctx&&ctx.state}},set lock(v){lock=v}};
})();
</script>
</body>
</html>