@chromatic-coherence/generative-engine 1.1.0 → 1.3.0

package/dist/shaders.js

@@ -5,303 +5,391 @@
 // maps, and HDR output for the post chain. No clamping in the scene pass — light
 // is allowed to exceed 1.0 and the composite tone-maps it.
 // ── shared vertex preamble: 8 groups, each with a mat4, normal mat3, morph weight, alpha ──
-const GROUPS = `
+const GROUPS = `
 uniform mat4 uGM[8]; uniform mat3 uNM[8]; uniform float uMW[8]; uniform float uGA[8];`;
-export const FACE_VS = `#version 300 es
-in vec3 aPos; in vec3 aNorm; in vec4 aCol; in float aBlood; in float aGrp;
-in vec3 aPos2; in vec3 aNorm2;
-uniform mat4 uVP; uniform mat4 uSVP;${GROUPS}
-out vec3 vPos; out vec3 vNorm; out vec4 vCol; out float vZ; out vec4 vSh;
-out float vGA; out float vBlood;
-void main(){
-  int g = int(aGrp + 0.5);
-  float w = uMW[g];
-  vec3 p = mix(aPos, aPos2, w), n = mix(aNorm, aNorm2, w);
-  vec4 wp = uGM[g] * vec4(p, 1.0);
-  vPos = wp.xyz; vNorm = uNM[g] * n; vCol = aCol; vGA = uGA[g]; vBlood = aBlood;
-  vec4 cp = uVP * wp; vZ = cp.w; vSh = uSVP * wp; gl_Position = cp;
+export const FACE_VS = `#version 300 es
+in vec3 aPos; in vec3 aNorm; in vec4 aCol; in float aBlood; in float aGrp;
+in vec3 aPos2; in vec3 aNorm2;
+uniform mat4 uVP; uniform mat4 uSVP;${GROUPS}
+out vec3 vPos; out vec3 vNorm; out vec4 vCol; out float vZ; out vec4 vSh;
+out float vGA; out float vBlood;
+void main(){
+  int g = int(aGrp + 0.5);
+  float w = uMW[g];
+  vec3 p = mix(aPos, aPos2, w), n = mix(aNorm, aNorm2, w);
+  vec4 wp = uGM[g] * vec4(p, 1.0);
+  vPos = wp.xyz; vNorm = uNM[g] * n; vCol = aCol; vGA = uGA[g]; vBlood = aBlood;
+  vec4 cp = uVP * wp; vZ = cp.w; vSh = uSVP * wp; gl_Position = cp;
 }`;
-export const FACE_FS = `#version 300 es
-precision highp float;
-in vec3 vPos; in vec3 vNorm; in vec4 vCol; in float vZ; in vec4 vSh;
-in float vGA; in float vBlood;
-uniform vec3 uLdir; uniform float uAmb; uniform float uDif; uniform float uSigned;
-uniform vec3 uLp[8]; uniform float uLi[8]; uniform float uLf[8]; uniform int uLn;
-uniform vec3 uCam; uniform float uFogK; uniform float uSpec; uniform vec3 uBg;
-uniform vec3 uSkyC; uniform vec3 uGroundC; uniform float uPulse;
-uniform float uShadowOn; uniform float uShadowSoft; uniform float uShadowBias;
-uniform lowp sampler2DShadow uShadow; uniform float uShadowPx;
-out vec4 fragColor;
-float h3(vec3 p){ return fract(sin(dot(p, vec3(12.9898, 78.233, 37.719))) * 43758.5453); }
-float vnoise(vec3 p){ vec3 i = floor(p), f = fract(p); f = f * f * (3.0 - 2.0 * f);
-  return mix(mix(mix(h3(i), h3(i + vec3(1,0,0)), f.x), mix(h3(i + vec3(0,1,0)), h3(i + vec3(1,1,0)), f.x), f.y),
-             mix(mix(h3(i + vec3(0,0,1)), h3(i + vec3(1,0,1)), f.x), mix(h3(i + vec3(0,1,1)), h3(i + vec3(1,1,1)), f.x), f.y), f.z); }
-float shadowFactor(){
-  vec3 pr = vSh.xyz / vSh.w * 0.5 + 0.5;
-  if (pr.x < 0.0 || pr.x > 1.0 || pr.y < 0.0 || pr.y > 1.0 || pr.z > 1.0) return 1.0;
-  float ref = pr.z - uShadowBias;
-  // 3x3 taps over a hardware-compared (LINEAR sampler2DShadow => free 2x2 PCF each) map
-  float s = 0.0;
-  for (int sy = -1; sy <= 1; sy++)
-    for (int sx = -1; sx <= 1; sx++)
-      s += texture(uShadow, vec3(pr.xy + vec2(float(sx), float(sy)) * uShadowPx * uShadowSoft, ref));
-  s /= 9.0;
-  return 0.35 + 0.65 * s;
-}
-void main(){
-  vec3 n = normalize(vNorm);
-  vec3 V = normalize(uCam - vPos);
-  float skin = clamp(vBlood * 5.0, 0.0, 1.0);
-  { // procedural micro-relief: perturb the shading normal by a fine noise gradient
-    float bs = 5.5, e = 0.12, n0 = vnoise(vPos * bs);
-    vec3 g = vec3(vnoise(vPos * bs + vec3(e, 0.0, 0.0)) - n0,
-                  vnoise(vPos * bs + vec3(0.0, e, 0.0)) - n0,
-                  vnoise(vPos * bs + vec3(0.0, 0.0, e)) - n0) / e;
-    n = normalize(n - g * (0.10 + 0.30 * skin));
-  }
-  float d = dot(n, normalize(uLdir));
-  float shade = uAmb + uDif * mix(abs(d), max(d, 0.0), uSigned);
-  float spec = 0.0;
-  float sh = uShadowOn > 0.5 ? shadowFactor() : 1.0;
-  for (int i = 0; i < 8; i++) { if (i >= uLn) break;
-    vec3 v = uLp[i] - vPos; float d2 = dot(v, v); vec3 L = v * inversesqrt(d2 + 1e-4);
-    float lam = dot(n, L); lam = mix(abs(lam), max(lam, 0.0), uSigned);
-    float fall = 1.0 / (1.0 + d2 / (uLf[i] * uLf[i]));
-    float k = (i == 0) ? sh : 1.0;
-    shade += uLi[i] * lam * fall * k;
-    // GGX microfacet + Fresnel — roughness from the face's gloss (colour alpha slot)
-    vec3 H = normalize(L + V);
-    float nh = max(dot(n, H), 0.0);
-    float rough = clamp(1.0 - vCol.a, 0.08, 1.0), a2 = rough * rough; a2 = a2 * a2;
-    float dnm = nh * nh * (a2 - 1.0) + 1.0;
-    float ggx = a2 / (3.14159 * dnm * dnm);
-    float fres = 0.04 + 0.96 * pow(1.0 - max(dot(H, V), 0.0), 5.0);
-    spec += uLi[i] * min(ggx, 6.0) * fres * fall * k * 0.16;
-  }
-  // coloured hemispheric ambient: cool from above, warm from below
-  vec3 tint = mix(uGroundC, uSkyC, n.y * 0.5 + 0.5);
-  vec3 lit = vCol.rgb * (uAmb * tint + vec3(shade - uAmb));
-  // the perfusion term: blood near the surface changes how it meets the light
-  float b = clamp(vBlood + uPulse * vBlood * 6.0, 0.0, 1.0);
-  lit *= mix(vec3(1.0), vec3(1.07, 0.95, 0.94), b);
-  lit += vec3(0.62, 0.06, 0.08) * (b * 0.20 * (1.0 - abs(d)));
-  // pore noise, only where there is blood (skin, not cloth)
-  float pore = vnoise(vPos * 2.4) * 0.6 + vnoise(vPos * 6.0) * 0.4;
-  lit *= 1.0 + (pore - 0.5) * 0.09 * skin;
-  // subsurface rim: grazing light bleeds through thin tissue, warm
-  float fres = pow(1.0 - clamp(dot(n, V), 0.0, 1.0), 3.0);
-  lit += vec3(0.55, 0.09, 0.10) * fres * skin * (0.28 + 0.5 * b);
-  float fog = clamp(uFogK / vZ, 0.08, 1.0);
-  vec3 outC = lit + vec3(1.0) * spec * uSpec * vCol.a;
-  // fog and fades resolve toward the REAL background colour (the engine owns its ground)
-  fragColor = vec4(mix(uBg, outC, fog * vGA), 1.0);
+export const FACE_FS = `#version 300 es
+precision highp float;
+in vec3 vPos; in vec3 vNorm; in vec4 vCol; in float vZ; in vec4 vSh;
+in float vGA; in float vBlood;
+uniform vec3 uLdir; uniform float uAmb; uniform float uDif; uniform float uSigned;
+uniform vec3 uLp[8]; uniform float uLi[8]; uniform float uLf[8]; uniform int uLn;
+uniform vec3 uCam; uniform float uFogK; uniform float uSpec; uniform vec3 uBg;
+uniform vec3 uSkyC; uniform vec3 uGroundC; uniform float uPulse;
+uniform float uShadowOn; uniform float uShadowSoft; uniform float uShadowBias;
+uniform lowp sampler2DShadow uShadow; uniform float uShadowPx;
+out vec4 fragColor;
+float h3(vec3 p){ return fract(sin(dot(p, vec3(12.9898, 78.233, 37.719))) * 43758.5453); }
+float vnoise(vec3 p){ vec3 i = floor(p), f = fract(p); f = f * f * (3.0 - 2.0 * f);
+  return mix(mix(mix(h3(i), h3(i + vec3(1,0,0)), f.x), mix(h3(i + vec3(0,1,0)), h3(i + vec3(1,1,0)), f.x), f.y),
+             mix(mix(h3(i + vec3(0,0,1)), h3(i + vec3(1,0,1)), f.x), mix(h3(i + vec3(0,1,1)), h3(i + vec3(1,1,1)), f.x), f.y), f.z); }
+float shadowFactor(){
+  vec3 pr = vSh.xyz / vSh.w * 0.5 + 0.5;
+  if (pr.x < 0.0 || pr.x > 1.0 || pr.y < 0.0 || pr.y > 1.0 || pr.z > 1.0) return 1.0;
+  float ref = pr.z - uShadowBias;
+  // 3x3 taps over a hardware-compared (LINEAR sampler2DShadow => free 2x2 PCF each) map
+  float s = 0.0;
+  for (int sy = -1; sy <= 1; sy++)
+    for (int sx = -1; sx <= 1; sx++)
+      s += texture(uShadow, vec3(pr.xy + vec2(float(sx), float(sy)) * uShadowPx * uShadowSoft, ref));
+  s /= 9.0;
+  return 0.35 + 0.65 * s;
+}
+void main(){
+  vec3 n = normalize(vNorm);
+  vec3 V = normalize(uCam - vPos);
+  float skin = clamp(vBlood * 5.0, 0.0, 1.0);
+  { // procedural micro-relief: perturb the shading normal by a fine noise gradient
+    float bs = 5.5, e = 0.12, n0 = vnoise(vPos * bs);
+    vec3 g = vec3(vnoise(vPos * bs + vec3(e, 0.0, 0.0)) - n0,
+                  vnoise(vPos * bs + vec3(0.0, e, 0.0)) - n0,
+                  vnoise(vPos * bs + vec3(0.0, 0.0, e)) - n0) / e;
+    n = normalize(n - g * (0.10 + 0.30 * skin));
+  }
+  float d = dot(n, normalize(uLdir));
+  float shade = uAmb + uDif * mix(abs(d), max(d, 0.0), uSigned);
+  float spec = 0.0;
+  float sh = uShadowOn > 0.5 ? shadowFactor() : 1.0;
+  for (int i = 0; i < 8; i++) { if (i >= uLn) break;
+    vec3 v = uLp[i] - vPos; float d2 = dot(v, v); vec3 L = v * inversesqrt(d2 + 1e-4);
+    float lam = dot(n, L); lam = mix(abs(lam), max(lam, 0.0), uSigned);
+    float fall = 1.0 / (1.0 + d2 / (uLf[i] * uLf[i]));
+    float k = (i == 0) ? sh : 1.0;
+    shade += uLi[i] * lam * fall * k;
+    // GGX microfacet + Fresnel — roughness from the face's gloss (colour alpha slot)
+    vec3 H = normalize(L + V);
+    float nh = max(dot(n, H), 0.0);
+    float rough = clamp(1.0 - vCol.a, 0.08, 1.0), a2 = rough * rough; a2 = a2 * a2;
+    float dnm = nh * nh * (a2 - 1.0) + 1.0;
+    float ggx = a2 / (3.14159 * dnm * dnm);
+    float fres = 0.04 + 0.96 * pow(1.0 - max(dot(H, V), 0.0), 5.0);
+    spec += uLi[i] * min(ggx, 6.0) * fres * fall * k * 0.16;
+  }
+  // coloured hemispheric ambient: cool from above, warm from below
+  vec3 tint = mix(uGroundC, uSkyC, n.y * 0.5 + 0.5);
+  vec3 lit = vCol.rgb * (uAmb * tint + vec3(shade - uAmb));
+  // the perfusion term: blood near the surface changes how it meets the light
+  float b = clamp(vBlood + uPulse * vBlood * 6.0, 0.0, 1.0);
+  lit *= mix(vec3(1.0), vec3(1.07, 0.95, 0.94), b);
+  lit += vec3(0.62, 0.06, 0.08) * (b * 0.20 * (1.0 - abs(d)));
+  // pore noise, only where there is blood (skin, not cloth)
+  float pore = vnoise(vPos * 2.4) * 0.6 + vnoise(vPos * 6.0) * 0.4;
+  lit *= 1.0 + (pore - 0.5) * 0.09 * skin;
+  // subsurface rim: grazing light bleeds through thin tissue, warm
+  float fres = pow(1.0 - clamp(dot(n, V), 0.0, 1.0), 3.0);
+  lit += vec3(0.55, 0.09, 0.10) * fres * skin * (0.28 + 0.5 * b);
+  float fog = clamp(uFogK / vZ, 0.08, 1.0);
+  vec3 outC = lit + vec3(1.0) * spec * uSpec * vCol.a;
+  // fog and fades resolve toward the REAL background colour (the engine owns its ground)
+  fragColor = vec4(mix(uBg, outC, fog * vGA), 1.0);
 }`;
 // depth-only pass (shadow map) — same morph + group transforms, no colour output
-export const DEPTH_VS = `#version 300 es
-in vec3 aPos; in float aGrp; in vec3 aPos2;
-uniform mat4 uVP;${GROUPS}
-void main(){
-  int g = int(aGrp + 0.5);
-  vec3 p = mix(aPos, aPos2, uMW[g]);
-  gl_Position = uVP * (uGM[g] * vec4(p, 1.0));
+// instanced face VS (W8): the per-instance model matrix arrives as 4 vec4 attributes
+// (divisor 1) and composes INSIDE the group transform — instances ride their group's
+// fade / morph / transform like any other geometry. Normals use mat3(instance); with
+// rotation + uniform scale that is exact (the normalize() in the FS absorbs scale).
+export const FACE_INST_VS = `#version 300 es
+in vec3 aPos; in vec3 aNorm; in vec4 aCol; in float aBlood; in float aGrp;
+in vec3 aPos2; in vec3 aNorm2;
+in vec4 aI0; in vec4 aI1; in vec4 aI2; in vec4 aI3; in vec4 aIP;
+uniform mat4 uVP; uniform mat4 uSVP; uniform float uT; uniform vec3 uWindDir;${GROUPS}
+out vec3 vPos; out vec3 vNorm; out vec4 vCol; out float vZ; out vec4 vSh;
+out float vGA; out float vBlood;
+void main(){
+  int g = int(aGrp + 0.5);
+  float w = uMW[g];
+  mat4 inst = mat4(aI0, aI1, aI2, aI3);
+  vec3 p = mix(aPos, aPos2, w), n = mix(aNorm, aNorm2, w);
+  // W9 GPU WIND: per-instance (phase, freq, amp); displacement grows with height,
+  // plus a second harmonic so the sway breathes instead of ticking
+  float sw = sin(uT * aIP.y + aIP.x) + 0.5 * sin(uT * aIP.y * 2.3 + aIP.x * 1.7);
+  p += uWindDir * (sw * aIP.z * max(p.y, 0.0));
+  vec4 wp = uGM[g] * (inst * vec4(p, 1.0));
+  vPos = wp.xyz; vNorm = uNM[g] * (mat3(inst) * n); vCol = aCol; vGA = uGA[g]; vBlood = aBlood;
+  vec4 cp = uVP * wp; vZ = cp.w; vSh = uSVP * wp; gl_Position = cp;
 }`;
-export const DEPTH_FS = `#version 300 es
-precision mediump float;
+export const DEPTH_INST_VS = `#version 300 es
+in vec3 aPos; in float aGrp; in vec3 aPos2;
+in vec4 aI0; in vec4 aI1; in vec4 aI2; in vec4 aI3; in vec4 aIP;
+uniform mat4 uVP; uniform float uT; uniform vec3 uWindDir;${GROUPS}
+void main(){
+  int g = int(aGrp + 0.5);
+  vec3 p = mix(aPos, aPos2, uMW[g]);
+  float sw = sin(uT * aIP.y + aIP.x) + 0.5 * sin(uT * aIP.y * 2.3 + aIP.x * 1.7);
+  p += uWindDir * (sw * aIP.z * max(p.y, 0.0));
+  gl_Position = uVP * (uGM[g] * (mat4(aI0, aI1, aI2, aI3) * vec4(p, 1.0)));
+}`;
+export const DEPTH_VS = `#version 300 es
+in vec3 aPos; in float aGrp; in vec3 aPos2;
+uniform mat4 uVP;${GROUPS}
+void main(){
+  int g = int(aGrp + 0.5);
+  vec3 p = mix(aPos, aPos2, uMW[g]);
+  gl_Position = uVP * (uGM[g] * vec4(p, 1.0));
+}`;
+export const DEPTH_FS = `#version 300 es
+precision mediump float;
 void main(){}`;
-export const LINE_VS = `#version 300 es
-in vec3 aPos; in vec4 aCol; in float aGrp;
-uniform mat4 uVP;${GROUPS}
-out vec4 vCol; out float vZ; out float vGA;
-void main(){
-  int g = int(aGrp + 0.5);
-  vCol = aCol; vGA = uGA[g];
-  vec4 p = uVP * (uGM[g] * vec4(aPos, 1.0)); vZ = p.w; gl_Position = p;
+export const LINE_VS = `#version 300 es
+in vec3 aPos; in vec4 aCol; in float aGrp;
+uniform mat4 uVP;${GROUPS}
+out vec4 vCol; out float vZ; out float vGA;
+void main(){
+  int g = int(aGrp + 0.5);
+  vCol = aCol; vGA = uGA[g];
+  vec4 p = uVP * (uGM[g] * vec4(aPos, 1.0)); vZ = p.w; gl_Position = p;
 }`;
-export const LINE_FS = `#version 300 es
-precision mediump float;
-in vec4 vCol; in float vZ; in float vGA;
-uniform float uFogK; uniform float uInk;
-out vec4 fragColor;
-void main(){
-  float fog = clamp(uFogK / vZ, 0.08, 1.0);
-  if (uInk > 0.5) fragColor = vec4(vCol.rgb, min(1.0, vCol.a * 1.6) * fog * vGA);
-  else fragColor = vec4(vCol.rgb * fog, vCol.a * fog * vGA);
+export const LINE_FS = `#version 300 es
+precision mediump float;
+in vec4 vCol; in float vZ; in float vGA;
+uniform float uFogK; uniform float uInk;
+out vec4 fragColor;
+void main(){
+  float fog = clamp(uFogK / vZ, 0.08, 1.0);
+  if (uInk > 0.5) fragColor = vec4(vCol.rgb, min(1.0, vCol.a * 1.6) * fog * vGA);
+  else fragColor = vec4(vCol.rgb * fog, vCol.a * fog * vGA);
 }`;
-export const PT_VS = `#version 300 es
-in vec3 aPos; in float aSize; in vec4 aCol; in float aGrp;
-uniform mat4 uVP; uniform float uFocal;${GROUPS}
-out vec4 vCol; out float vZ; out float vGA;
-void main(){
-  int g = int(aGrp + 0.5);
-  vCol = aCol; vGA = uGA[g];
-  vec4 p = uVP * (uGM[g] * vec4(aPos, 1.0)); vZ = p.w;
-  gl_PointSize = clamp(aSize * uFocal / p.w, 1.0, 256.0); gl_Position = p;
+export const PT_VS = `#version 300 es
+in vec3 aPos; in float aSize; in vec4 aCol; in float aGrp;
+uniform mat4 uVP; uniform float uFocal;${GROUPS}
+out vec4 vCol; out float vZ; out float vGA;
+void main(){
+  int g = int(aGrp + 0.5);
+  vCol = aCol; vGA = uGA[g];
+  vec4 p = uVP * (uGM[g] * vec4(aPos, 1.0)); vZ = p.w;
+  gl_PointSize = clamp(aSize * uFocal / p.w, 1.0, 256.0); gl_Position = p;
 }`;
-export const PT_FS = `#version 300 es
-precision mediump float;
-in vec4 vCol; in float vZ; in float vGA;
-uniform float uFogK; uniform float uInk;
-out vec4 fragColor;
-void main(){
-  float r = length(gl_PointCoord - 0.5) * 2.0;
-  float a = exp(-3.2 * r * r) * (1.0 - smoothstep(0.85, 1.0, r));
-  float fog = clamp(uFogK / vZ, 0.08, 1.0);
-  if (uInk > 0.5) fragColor = vec4(vCol.rgb, min(1.0, vCol.a * 1.6) * a * fog * vGA);
-  else fragColor = vec4(vCol.rgb, 1.0) * (vCol.a * a * fog * vGA);
+export const PT_FS = `#version 300 es
+precision mediump float;
+in vec4 vCol; in float vZ; in float vGA;
+uniform float uFogK; uniform float uInk;
+out vec4 fragColor;
+void main(){
+  float r = length(gl_PointCoord - 0.5) * 2.0;
+  float a = exp(-3.2 * r * r) * (1.0 - smoothstep(0.85, 1.0, r));
+  float fog = clamp(uFogK / vZ, 0.08, 1.0);
+  if (uInk > 0.5) fragColor = vec4(vCol.rgb, min(1.0, vCol.a * 1.6) * a * fog * vGA);
+  else fragColor = vec4(vCol.rgb, 1.0) * (vCol.a * a * fog * vGA);
 }`;
 // ── ribbons: screen-space-expanded strokes with real pixel width ──
 // Each vertex carries its neighbours; the direction is the central difference in
 // screen space, so joins round themselves. aSide is -1/+1; the fragment feathers
 // the edge for free antialiasing.
-export const RIBBON_VS = `#version 300 es
-in vec3 aPos; in vec3 aPrev; in vec3 aNext; in float aSide; in float aWidth;
-in vec4 aCol; in float aGrp;
-uniform mat4 uVP; uniform vec2 uRes;${GROUPS}
-out vec4 vCol; out float vZ; out float vGA; out float vSide;
-void main(){
-  int g = int(aGrp + 0.5);
-  mat4 M = uGM[g];
-  vec4 cp = uVP * (M * vec4(aPos, 1.0));
-  vec4 cq = uVP * (M * vec4(aPrev, 1.0));
-  vec4 cr = uVP * (M * vec4(aNext, 1.0));
-  vec2 sp = cp.xy / max(cp.w, 1e-4) * uRes;
-  vec2 sq = cq.xy / max(cq.w, 1e-4) * uRes;
-  vec2 sr = cr.xy / max(cr.w, 1e-4) * uRes;
-  vec2 dir = sr - sq;
-  float dl = length(dir);
-  dir = dl > 1e-3 ? dir / dl : vec2(1.0, 0.0);
-  vec2 perp = vec2(-dir.y, dir.x);
-  vec2 off = perp * aWidth * 0.5 * aSide;
-  cp.xy += off / uRes * cp.w * 2.0;
-  vCol = aCol; vZ = cp.w; vGA = uGA[g]; vSide = aSide;
-  gl_Position = cp;
+export const RIBBON_VS = `#version 300 es
+in vec3 aPos; in vec3 aPrev; in vec3 aNext; in float aSide; in float aWidth;
+in vec4 aCol; in float aGrp;
+uniform mat4 uVP; uniform vec2 uRes;${GROUPS}
+out vec4 vCol; out float vZ; out float vGA; out float vSide;
+void main(){
+  int g = int(aGrp + 0.5);
+  mat4 M = uGM[g];
+  vec4 cp = uVP * (M * vec4(aPos, 1.0));
+  vec4 cq = uVP * (M * vec4(aPrev, 1.0));
+  vec4 cr = uVP * (M * vec4(aNext, 1.0));
+  vec2 sp = cp.xy / max(cp.w, 1e-4) * uRes;
+  vec2 sq = cq.xy / max(cq.w, 1e-4) * uRes;
+  vec2 sr = cr.xy / max(cr.w, 1e-4) * uRes;
+  vec2 dir = sr - sq;
+  float dl = length(dir);
+  dir = dl > 1e-3 ? dir / dl : vec2(1.0, 0.0);
+  vec2 perp = vec2(-dir.y, dir.x);
+  vec2 off = perp * aWidth * 0.5 * aSide;
+  cp.xy += off / uRes * cp.w * 2.0;
+  vCol = aCol; vZ = cp.w; vGA = uGA[g]; vSide = aSide;
+  gl_Position = cp;
 }`;
-export const RIBBON_FS = `#version 300 es
-precision mediump float;
-in vec4 vCol; in float vZ; in float vGA; in float vSide;
-uniform float uFogK; uniform float uInk;
-out vec4 fragColor;
-void main(){
-  float edge = 1.0 - smoothstep(0.55, 1.0, abs(vSide));
-  float fog = clamp(uFogK / vZ, 0.08, 1.0);
-  float a = vCol.a * edge * fog * vGA;
-  if (uInk > 0.5) fragColor = vec4(vCol.rgb, min(1.0, a * 1.6));
-  else fragColor = vec4(vCol.rgb * a, a);
+export const RIBBON_FS = `#version 300 es
+precision mediump float;
+in vec4 vCol; in float vZ; in float vGA; in float vSide;
+uniform float uFogK; uniform float uInk;
+out vec4 fragColor;
+void main(){
+  float edge = 1.0 - smoothstep(0.55, 1.0, abs(vSide));
+  float fog = clamp(uFogK / vZ, 0.08, 1.0);
+  float a = vCol.a * edge * fog * vGA;
+  if (uInk > 0.5) fragColor = vec4(vCol.rgb, min(1.0, a * 1.6));
+  else fragColor = vec4(vCol.rgb * a, a);
 }`;
 // ── post chain ──
 // fullscreen triangle, attribute-less (gl_VertexID)
-export const FST_VS = `#version 300 es
-out vec2 vUv;
-void main(){
-  vec2 p = vec2(float((gl_VertexID << 1) & 2), float(gl_VertexID & 2));
-  vUv = p; gl_Position = vec4(p * 2.0 - 1.0, 0.0, 1.0);
+export const FST_VS = `#version 300 es
+out vec2 vUv;
+void main(){
+  vec2 p = vec2(float((gl_VertexID << 1) & 2), float(gl_VertexID & 2));
+  vUv = p; gl_Position = vec4(p * 2.0 - 1.0, 0.0, 1.0);
+}`;
+export const BRIGHT_FS = `#version 300 es
+precision mediump float;
+in vec2 vUv; uniform sampler2D uTex; uniform float uThresh; uniform float uKnee;
+out vec4 fragColor;
+void main(){
+  vec3 c = texture(uTex, vUv).rgb;
+  float luma = max(c.r, max(c.g, c.b));
+  float w = smoothstep(uThresh, uThresh + uKnee, luma);
+  fragColor = vec4(c * w, 1.0);
+}`;
+export const BLUR_FS = `#version 300 es
+precision mediump float;
+in vec2 vUv; uniform sampler2D uTex; uniform vec2 uDir;
+out vec4 fragColor;
+void main(){
+  vec3 s = texture(uTex, vUv).rgb * 0.227027;
+  vec2 o1 = uDir * 1.3846153846, o2 = uDir * 3.2307692308;
+  s += (texture(uTex, vUv + o1).rgb + texture(uTex, vUv - o1).rgb) * 0.3162162162;
+  s += (texture(uTex, vUv + o2).rgb + texture(uTex, vUv - o2).rgb) * 0.0702702703;
+  fragColor = vec4(s, 1.0);
 }`;
-export const BRIGHT_FS = `#version 300 es
-precision mediump float;
-in vec2 vUv; uniform sampler2D uTex; uniform float uThresh; uniform float uKnee;
-out vec4 fragColor;
-void main(){
-  vec3 c = texture(uTex, vUv).rgb;
-  float luma = max(c.r, max(c.g, c.b));
-  float w = smoothstep(uThresh, uThresh + uKnee, luma);
-  fragColor = vec4(c * w, 1.0);
+export const SSAO_FS = `#version 300 es
+precision highp float;
+in vec2 vUv; uniform sampler2D uDepth;
+uniform float uNear; uniform float uFar; uniform float uRadius; uniform vec2 uRes;
+out vec4 fragColor;
+float viewZ(vec2 uv){
+  float d = texture(uDepth, uv).r * 2.0 - 1.0;
+  return 2.0 * uNear * uFar / (uFar + uNear - d * (uFar - uNear));
+}
+float hash(vec2 p){ return fract(sin(dot(p, vec2(12.9898, 78.233))) * 43758.5453); }
+void main(){
+  float z0 = viewZ(vUv);
+  // screen-space sample radius shrinks with distance (a world-ish radius)
+  float rad = uRadius / z0;
+  float ang = hash(vUv * uRes) * 6.2831853;
+  float occ = 0.0;
+  for (int i = 0; i < 12; i++) {
+    float fi = float(i);
+    float a = ang + fi * 2.3999632;           // golden-angle spiral
+    float r = rad * (0.25 + 0.75 * fract(fi * 0.618034));
+    vec2 uv = vUv + vec2(cos(a), sin(a)) * r;
+    float dz = z0 - viewZ(uv);                // positive => sample nearer camera => occluder
+    occ += smoothstep(z0 * 0.002, z0 * 0.02, dz) * smoothstep(z0 * 0.35, 0.0, dz);
+  }
+  float ao = 1.0 - occ / 12.0;
+  fragColor = vec4(vec3(ao), 1.0);
 }`;
-export const BLUR_FS = `#version 300 es
-precision mediump float;
-in vec2 vUv; uniform sampler2D uTex; uniform vec2 uDir;
-out vec4 fragColor;
-void main(){
-  vec3 s = texture(uTex, vUv).rgb * 0.227027;
-  vec2 o1 = uDir * 1.3846153846, o2 = uDir * 3.2307692308;
-  s += (texture(uTex, vUv + o1).rgb + texture(uTex, vUv - o1).rgb) * 0.3162162162;
-  s += (texture(uTex, vUv + o2).rgb + texture(uTex, vUv - o2).rgb) * 0.0702702703;
-  fragColor = vec4(s, 1.0);
+export const AOBLUR_FS = `#version 300 es
+precision mediump float;
+in vec2 vUv; uniform sampler2D uTex; uniform vec2 uPx;
+out vec4 fragColor;
+void main(){
+  float s = 0.0;
+  for (int y = -1; y <= 2; y++)
+    for (int x = -1; x <= 2; x++)
+      s += texture(uTex, vUv + vec2(float(x) - 0.5, float(y) - 0.5) * uPx).r;
+  fragColor = vec4(vec3(s / 16.0), 1.0);
 }`;
-export const SSAO_FS = `#version 300 es
-precision highp float;
-in vec2 vUv; uniform sampler2D uDepth;
-uniform float uNear; uniform float uFar; uniform float uRadius; uniform vec2 uRes;
-out vec4 fragColor;
-float viewZ(vec2 uv){
-  float d = texture(uDepth, uv).r * 2.0 - 1.0;
-  return 2.0 * uNear * uFar / (uFar + uNear - d * (uFar - uNear));
-}
-float hash(vec2 p){ return fract(sin(dot(p, vec2(12.9898, 78.233))) * 43758.5453); }
-void main(){
-  float z0 = viewZ(vUv);
-  // screen-space sample radius shrinks with distance (a world-ish radius)
-  float rad = uRadius / z0;
-  float ang = hash(vUv * uRes) * 6.2831853;
-  float occ = 0.0;
-  for (int i = 0; i < 12; i++) {
-    float fi = float(i);
-    float a = ang + fi * 2.3999632;           // golden-angle spiral
-    float r = rad * (0.25 + 0.75 * fract(fi * 0.618034));
-    vec2 uv = vUv + vec2(cos(a), sin(a)) * r;
-    float dz = z0 - viewZ(uv);                // positive => sample nearer camera => occluder
-    occ += smoothstep(z0 * 0.002, z0 * 0.02, dz) * smoothstep(z0 * 0.35, 0.0, dz);
-  }
-  float ao = 1.0 - occ / 12.0;
-  fragColor = vec4(vec3(ao), 1.0);
+export const COMPOSITE_FS = `#version 300 es
+precision mediump float;
+in vec2 vUv;
+uniform sampler2D uScene; uniform sampler2D uBloom; uniform sampler2D uAO;
+uniform float uBloomStr; uniform float uAOStr;
+uniform float uFilm; uniform float uGrade; uniform float uVig; uniform float uInk;
+out vec4 fragColor;
+void main(){
+  vec3 c = texture(uScene, vUv).rgb;
+  c *= mix(1.0, texture(uAO, vUv).r, uAOStr);
+  c += texture(uBloom, vUv).rgb * uBloomStr;
+  if (uFilm > 0.5) { // ACES-ish filmic: highlights roll off instead of clipping
+    c = (c * (2.51 * c + 0.03)) / (c * (2.43 * c + 0.59) + 0.14);
+  }
+  c = clamp(c, 0.0, 1.0);
+  if (uGrade > 0.5) { // violet-cool shadows, warm highlights
+    float luma = dot(c, vec3(0.299, 0.587, 0.114));
+    c *= mix(vec3(0.85, 0.83, 1.07), vec3(1.07, 0.99, 0.92), smoothstep(0.12, 0.72, luma));
+    c = clamp(c, 0.0, 1.0);
+  }
+  if (uVig > 0.0) { // cinematic vignette, in the composite now (off the overlay)
+    vec2 q = vUv - vec2(0.5, 0.54);
+    float r = smoothstep(0.35, 0.9, length(q * vec2(1.15, 1.0)));
+    vec3 dk = uInk > 0.5 ? vec3(0.20, 0.19, 0.30) : vec3(0.024, 0.016, 0.055);
+    c = mix(c, dk, uVig * r * (uInk > 0.5 ? 0.3 : 1.0));
+  }
+  fragColor = vec4(c, 1.0);
 }`;
-export const AOBLUR_FS = `#version 300 es
-precision mediump float;
-in vec2 vUv; uniform sampler2D uTex; uniform vec2 uPx;
-out vec4 fragColor;
-void main(){
-  float s = 0.0;
-  for (int y = -1; y <= 2; y++)
-    for (int x = -1; x <= 2; x++)
-      s += texture(uTex, vUv + vec2(float(x) - 0.5, float(y) - 0.5) * uPx).r;
-  fragColor = vec4(vec3(s / 16.0), 1.0);
+// depth of field — CoC from linearized depth, 12-tap poisson disc gather on the LDR
+export const DOF_FS = `#version 300 es
+precision highp float;
+in vec2 vUv; uniform sampler2D uTex; uniform sampler2D uDepth;
+uniform float uNear; uniform float uFar; uniform float uFocus; uniform float uRange;
+uniform float uMaxBlur; uniform vec2 uPx;
+out vec4 fragColor;
+float lin(float d){ return uNear * uFar / (uFar - d * (uFar - uNear)); }
+const vec2 DISC[12] = vec2[](
+  vec2(-0.326, -0.406), vec2(-0.840, -0.074), vec2(-0.696, 0.457), vec2(-0.203, 0.621),
+  vec2(0.962, -0.195), vec2(0.473, -0.480), vec2(0.519, 0.767), vec2(0.185, -0.893),
+  vec2(0.507, 0.064), vec2(0.896, 0.412), vec2(-0.322, -0.933), vec2(-0.792, -0.598));
+void main(){
+  float z = lin(texture(uDepth, vUv).r);
+  float coc = clamp(abs(z - uFocus) / max(1.0, uRange), 0.0, 1.0) * uMaxBlur;
+  vec3 acc = texture(uTex, vUv).rgb;
+  float wsum = 1.0;
+  for (int i = 0; i < 12; i++) {
+    vec2 off = DISC[i] * coc * uPx;
+    // a sharp (in-focus) neighbour must not bleed into a blurred one: weight each tap
+    // by ITS OWN CoC so foreground focus stays crisp against a soft background
+    float zt = lin(texture(uDepth, vUv + off).r);
+    float ct = clamp(abs(zt - uFocus) / max(1.0, uRange), 0.0, 1.0);
+    float w = 0.25 + 0.75 * ct;
+    acc += texture(uTex, vUv + off).rgb * w;
+    wsum += w;
+  }
+  fragColor = vec4(acc / wsum, 1.0);
 }`;
-export const COMPOSITE_FS = `#version 300 es
-precision mediump float;
-in vec2 vUv;
-uniform sampler2D uScene; uniform sampler2D uBloom; uniform sampler2D uAO;
-uniform float uBloomStr; uniform float uAOStr;
-uniform float uFilm; uniform float uGrade; uniform float uVig; uniform float uInk;
-out vec4 fragColor;
-void main(){
-  vec3 c = texture(uScene, vUv).rgb;
-  c *= mix(1.0, texture(uAO, vUv).r, uAOStr);
-  c += texture(uBloom, vUv).rgb * uBloomStr;
-  if (uFilm > 0.5) { // ACES-ish filmic: highlights roll off instead of clipping
-    c = (c * (2.51 * c + 0.03)) / (c * (2.43 * c + 0.59) + 0.14);
-  }
-  c = clamp(c, 0.0, 1.0);
-  if (uGrade > 0.5) { // violet-cool shadows, warm highlights
-    float luma = dot(c, vec3(0.299, 0.587, 0.114));
-    c *= mix(vec3(0.85, 0.83, 1.07), vec3(1.07, 0.99, 0.92), smoothstep(0.12, 0.72, luma));
-    c = clamp(c, 0.0, 1.0);
-  }
-  if (uVig > 0.0) { // cinematic vignette, in the composite now (off the overlay)
-    vec2 q = vUv - vec2(0.5, 0.54);
-    float r = smoothstep(0.35, 0.9, length(q * vec2(1.15, 1.0)));
-    vec3 dk = uInk > 0.5 ? vec3(0.20, 0.19, 0.30) : vec3(0.024, 0.016, 0.055);
-    c = mix(c, dk, uVig * r * (uInk > 0.5 ? 0.3 : 1.0));
-  }
-  fragColor = vec4(c, 1.0);
+// camera motion blur — reconstruct world position from depth, reproject into the
+// previous frame's clip space, sample along the screen-space velocity
+export const MOBLUR_FS = `#version 300 es
+precision highp float;
+in vec2 vUv; uniform sampler2D uTex; uniform sampler2D uDepth;
+uniform mat4 uInvVP; uniform mat4 uPrevVP; uniform float uStrength;
+out vec4 fragColor;
+void main(){
+  float d = texture(uDepth, vUv).r;
+  vec4 ndc = vec4(vUv * 2.0 - 1.0, d * 2.0 - 1.0, 1.0);
+  vec4 wp = uInvVP * ndc; wp /= wp.w;
+  vec4 pc = uPrevVP * wp;
+  vec2 prevUv = (pc.xy / pc.w) * 0.5 + 0.5;
+  vec2 vel = (vUv - prevUv) * uStrength;
+  float vlen = length(vel);
+  if (vlen < 1e-5 || pc.w <= 0.0) { fragColor = vec4(texture(uTex, vUv).rgb, 1.0); return; }
+  vel = vlen > 0.04 ? vel * (0.04 / vlen) : vel;  // clamp the streak to 4% of the screen
+  vec3 acc = vec3(0.0);
+  for (int i = 0; i < 8; i++) {
+    float t = (float(i) / 7.0) - 0.5;
+    acc += texture(uTex, clamp(vUv + vel * t, vec2(0.001), vec2(0.999))).rgb;
+  }
+  fragColor = vec4(acc / 8.0, 1.0);
 }`;
 // compact FXAA (luma-based, 5-tap edge blend) — runs last, on the LDR composite
-export const FXAA_FS = `#version 300 es
-precision mediump float;
-in vec2 vUv; uniform sampler2D uTex; uniform vec2 uPx;
-out vec4 fragColor;
-float luma(vec3 c){ return dot(c, vec3(0.299, 0.587, 0.114)); }
-void main(){
-  vec3 cM = texture(uTex, vUv).rgb;
-  float lM = luma(cM);
-  float lN = luma(texture(uTex, vUv + vec2(0.0, -uPx.y)).rgb);
-  float lS = luma(texture(uTex, vUv + vec2(0.0, uPx.y)).rgb);
-  float lW = luma(texture(uTex, vUv + vec2(-uPx.x, 0.0)).rgb);
-  float lE = luma(texture(uTex, vUv + vec2(uPx.x, 0.0)).rgb);
-  float lMin = min(lM, min(min(lN, lS), min(lW, lE)));
-  float lMax = max(lM, max(max(lN, lS), max(lW, lE)));
-  float range = lMax - lMin;
-  if (range < max(0.0312, lMax * 0.125)) { fragColor = vec4(cM, 1.0); return; }
-  vec2 dir = normalize(vec2((lE + lS) - (lW + lN), (lN + lE) - (lS + lW)) + 1e-6);
-  vec3 a = texture(uTex, vUv + dir * uPx * 0.5).rgb;
-  vec3 b = texture(uTex, vUv - dir * uPx * 0.5).rgb;
-  fragColor = vec4(mix(cM, (a + b) * 0.5, 0.75), 1.0);
+export const FXAA_FS = `#version 300 es
+precision mediump float;
+in vec2 vUv; uniform sampler2D uTex; uniform vec2 uPx;
+out vec4 fragColor;
+float luma(vec3 c){ return dot(c, vec3(0.299, 0.587, 0.114)); }
+void main(){
+  vec3 cM = texture(uTex, vUv).rgb;
+  float lM = luma(cM);
+  float lN = luma(texture(uTex, vUv + vec2(0.0, -uPx.y)).rgb);
+  float lS = luma(texture(uTex, vUv + vec2(0.0, uPx.y)).rgb);
+  float lW = luma(texture(uTex, vUv + vec2(-uPx.x, 0.0)).rgb);
+  float lE = luma(texture(uTex, vUv + vec2(uPx.x, 0.0)).rgb);
+  float lMin = min(lM, min(min(lN, lS), min(lW, lE)));
+  float lMax = max(lM, max(max(lN, lS), max(lW, lE)));
+  float range = lMax - lMin;
+  if (range < max(0.0312, lMax * 0.125)) { fragColor = vec4(cM, 1.0); return; }
+  vec2 dir = normalize(vec2((lE + lS) - (lW + lN), (lN + lE) - (lS + lW)) + 1e-6);
+  vec3 a = texture(uTex, vUv + dir * uPx * 0.5).rgb;
+  vec3 b = texture(uTex, vUv - dir * uPx * 0.5).rgb;
+  fragColor = vec4(mix(cM, (a + b) * 0.5, 0.75), 1.0);
 }`;