@chromatic-coherence/generative-engine 1.0.0

package/dist/post.js

@@ -0,0 +1,213 @@
+// generative-engine — post.ts: GL program helpers + the HDR post chain.
+// The chain: scene renders into an offscreen HDR target (RGBA16F when
+// EXT_color_buffer_float is available, RGBA8 otherwise) with a real depth
+// texture; then bright-pass -> half-res separable gaussian (ping-pong) for
+// bloom, depth-based half-res SSAO + blur, one composite pass (bloom add,
+// ACES filmic, grade, vignette), and an optional FXAA pass last.
+import { FST_VS, BRIGHT_FS, BLUR_FS, SSAO_FS, AOBLUR_FS, COMPOSITE_FS, FXAA_FS, } from "./shaders.js";
+export function makeProg(gl, vs, fs) {
+    const sh = (type, src) => {
+        const s = gl.createShader(type);
+        gl.shaderSource(s, src);
+        gl.compileShader(s);
+        if (!gl.getShaderParameter(s, gl.COMPILE_STATUS))
+            throw new Error("generative-engine shader: " + gl.getShaderInfoLog(s));
+        return s;
+    };
+    const p = gl.createProgram();
+    gl.attachShader(p, sh(gl.VERTEX_SHADER, vs));
+    gl.attachShader(p, sh(gl.FRAGMENT_SHADER, fs));
+    gl.linkProgram(p);
+    if (!gl.getProgramParameter(p, gl.LINK_STATUS))
+        throw new Error("generative-engine link: " + gl.getProgramInfoLog(p));
+    return p;
+}
+/** A program plus a uniform-location cache — getUniformLocation once, ever. */
+export class PInfo {
+    constructor(gl, vs, fs) {
+        this.gl = gl;
+        this.locs = new Map();
+        this.prog = makeProg(gl, vs, fs);
+    }
+    u(name) {
+        let l = this.locs.get(name);
+        if (l === undefined) {
+            l = this.gl.getUniformLocation(this.prog, name);
+            this.locs.set(name, l);
+        }
+        return l;
+    }
+    use() { this.gl.useProgram(this.prog); }
+}
+export class PostChain {
+    constructor(gl) {
+        this.scene = null;
+        this.sceneDepth = null;
+        this.bloomA = null;
+        this.bloomB = null;
+        this.aoA = null;
+        this.aoB = null;
+        this.ldr = null;
+        this.W = 0;
+        this.H = 0;
+        this.gl = gl;
+        this.hdr = !!gl.getExtension("EXT_color_buffer_float");
+        this.pBright = new PInfo(gl, FST_VS, BRIGHT_FS);
+        this.pBlur = new PInfo(gl, FST_VS, BLUR_FS);
+        this.pSsao = new PInfo(gl, FST_VS, SSAO_FS);
+        this.pAoBlur = new PInfo(gl, FST_VS, AOBLUR_FS);
+        this.pComposite = new PInfo(gl, FST_VS, COMPOSITE_FS);
+        this.pFxaa = new PInfo(gl, FST_VS, FXAA_FS);
+    }
+    makeTarget(w, h, hdrFmt, filter) {
+        const gl = this.gl;
+        const tex = gl.createTexture();
+        gl.bindTexture(gl.TEXTURE_2D, tex);
+        if (hdrFmt)
+            gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA16F, w, h, 0, gl.RGBA, gl.HALF_FLOAT, null);
+        else
+            gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA8, w, h, 0, gl.RGBA, gl.UNSIGNED_BYTE, null);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, filter);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, filter);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+        const fbo = gl.createFramebuffer();
+        gl.bindFramebuffer(gl.FRAMEBUFFER, fbo);
+        gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, tex, 0);
+        return { fbo, tex, w, h };
+    }
+    drop(t) {
+        if (!t)
+            return;
+        this.gl.deleteFramebuffer(t.fbo);
+        this.gl.deleteTexture(t.tex);
+    }
+    /** (Re)allocate every target at the given DEVICE-pixel size. */
+    resize(w, h) {
+        if (w === this.W && h === this.H)
+            return;
+        const gl = this.gl;
+        this.W = w;
+        this.H = h;
+        this.drop(this.scene);
+        this.drop(this.bloomA);
+        this.drop(this.bloomB);
+        this.drop(this.aoA);
+        this.drop(this.aoB);
+        this.drop(this.ldr);
+        if (this.sceneDepth)
+            gl.deleteTexture(this.sceneDepth);
+        this.scene = this.makeTarget(w, h, this.hdr, gl.LINEAR);
+        // real depth texture on the scene FBO — SSAO reads it directly
+        this.sceneDepth = gl.createTexture();
+        gl.bindTexture(gl.TEXTURE_2D, this.sceneDepth);
+        gl.texImage2D(gl.TEXTURE_2D, 0, gl.DEPTH_COMPONENT24, w, h, 0, gl.DEPTH_COMPONENT, gl.UNSIGNED_INT, null);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+        gl.bindFramebuffer(gl.FRAMEBUFFER, this.scene.fbo);
+        gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.DEPTH_ATTACHMENT, gl.TEXTURE_2D, this.sceneDepth, 0);
+        const hw = Math.max(1, w >> 1), hh = Math.max(1, h >> 1);
+        this.bloomA = this.makeTarget(hw, hh, this.hdr, gl.LINEAR);
+        this.bloomB = this.makeTarget(hw, hh, this.hdr, gl.LINEAR);
+        this.aoA = this.makeTarget(hw, hh, false, gl.LINEAR);
+        this.aoB = this.makeTarget(hw, hh, false, gl.LINEAR);
+        this.ldr = this.makeTarget(w, h, false, gl.LINEAR);
+        gl.bindFramebuffer(gl.FRAMEBUFFER, null);
+    }
+    /** Bind the scene target — the world's render pass draws into this. */
+    begin() {
+        const gl = this.gl;
+        gl.bindFramebuffer(gl.FRAMEBUFFER, this.scene.fbo);
+        gl.viewport(0, 0, this.W, this.H);
+    }
+    fst(p, to) {
+        const gl = this.gl;
+        gl.bindFramebuffer(gl.FRAMEBUFFER, to ? to.fbo : null);
+        gl.viewport(0, 0, to ? to.w : this.W, to ? to.h : this.H);
+        p.use();
+        gl.drawArrays(gl.TRIANGLES, 0, 3);
+    }
+    bindTex(unit, tex) {
+        const gl = this.gl;
+        gl.activeTexture(gl.TEXTURE0 + unit);
+        gl.bindTexture(gl.TEXTURE_2D, tex);
+    }
+    /** Run the chain: bloom + ssao + composite (+ fxaa) to the canvas. */
+    end(o) {
+        const gl = this.gl;
+        gl.disable(gl.DEPTH_TEST);
+        gl.disable(gl.BLEND);
+        gl.depthMask(true);
+        if (o.bloomOn) {
+            this.pBright.use();
+            this.bindTex(0, this.scene.tex);
+            gl.uniform1i(this.pBright.u("uTex"), 0);
+            gl.uniform1f(this.pBright.u("uThresh"), o.bloomThreshold);
+            gl.uniform1f(this.pBright.u("uKnee"), o.bloomKnee);
+            this.fst(this.pBright, this.bloomA);
+            for (let i = 0; i < 2; i++) { // two separable blur rounds: wide, soft
+                this.pBlur.use();
+                this.bindTex(0, this.bloomA.tex);
+                gl.uniform1i(this.pBlur.u("uTex"), 0);
+                gl.uniform2f(this.pBlur.u("uDir"), (1 + i) / this.bloomA.w, 0);
+                this.fst(this.pBlur, this.bloomB);
+                this.bindTex(0, this.bloomB.tex);
+                gl.uniform2f(this.pBlur.u("uDir"), 0, (1 + i) / this.bloomA.h);
+                this.fst(this.pBlur, this.bloomA);
+            }
+        }
+        if (o.ssaoOn) {
+            this.pSsao.use();
+            this.bindTex(0, this.sceneDepth);
+            gl.uniform1i(this.pSsao.u("uDepth"), 0);
+            gl.uniform1f(this.pSsao.u("uNear"), o.near);
+            gl.uniform1f(this.pSsao.u("uFar"), o.far);
+            gl.uniform1f(this.pSsao.u("uRadius"), o.ssaoRadius);
+            gl.uniform2f(this.pSsao.u("uRes"), this.aoA.w, this.aoA.h);
+            this.fst(this.pSsao, this.aoA);
+            this.pAoBlur.use();
+            this.bindTex(0, this.aoA.tex);
+            gl.uniform1i(this.pAoBlur.u("uTex"), 0);
+            gl.uniform2f(this.pAoBlur.u("uPx"), 1 / this.aoA.w, 1 / this.aoA.h);
+            this.fst(this.pAoBlur, this.aoB);
+        }
+        this.pComposite.use();
+        this.bindTex(0, this.scene.tex);
+        this.bindTex(1, o.bloomOn ? this.bloomA.tex : null);
+        this.bindTex(2, o.ssaoOn ? this.aoB.tex : null);
+        gl.uniform1i(this.pComposite.u("uScene"), 0);
+        gl.uniform1i(this.pComposite.u("uBloom"), 1);
+        gl.uniform1i(this.pComposite.u("uAO"), 2);
+        gl.uniform1f(this.pComposite.u("uBloomStr"), o.bloomOn ? o.bloomStrength : 0);
+        gl.uniform1f(this.pComposite.u("uAOStr"), o.ssaoOn ? o.ssaoStrength : 0);
+        gl.uniform1f(this.pComposite.u("uFilm"), o.filmic ? 1 : 0);
+        gl.uniform1f(this.pComposite.u("uGrade"), o.grade ? 1 : 0);
+        gl.uniform1f(this.pComposite.u("uVig"), o.vignette);
+        gl.uniform1f(this.pComposite.u("uInk"), o.ink ? 1 : 0);
+        this.fst(this.pComposite, o.fxaa ? this.ldr : null);
+        if (o.fxaa) {
+            this.pFxaa.use();
+            this.bindTex(0, this.ldr.tex);
+            gl.uniform1i(this.pFxaa.u("uTex"), 0);
+            gl.uniform2f(this.pFxaa.u("uPx"), 1 / this.W, 1 / this.H);
+            this.fst(this.pFxaa, null);
+        }
+        // leave texture unit 0 active and the default framebuffer bound
+        gl.activeTexture(gl.TEXTURE0);
+        gl.enable(gl.DEPTH_TEST);
+    }
+    dispose() {
+        this.drop(this.scene);
+        this.drop(this.bloomA);
+        this.drop(this.bloomB);
+        this.drop(this.aoA);
+        this.drop(this.aoB);
+        this.drop(this.ldr);
+        if (this.sceneDepth)
+            this.gl.deleteTexture(this.sceneDepth);
+        this.scene = this.bloomA = this.bloomB = this.aoA = this.aoB = this.ldr = null;
+        this.sceneDepth = null;
+    }
+}

package/dist/shaders.d.ts

@@ -0,0 +1,17 @@
+export declare const FACE_VS = "#version 300 es\nin vec3 aPos; in vec3 aNorm; in vec4 aCol; in float aBlood; in float aGrp;\nin vec3 aPos2; in vec3 aNorm2;\nuniform mat4 uVP; uniform mat4 uSVP;\nuniform mat4 uGM[8]; uniform mat3 uNM[8]; uniform float uMW[8]; uniform float uGA[8];\nout vec3 vPos; out vec3 vNorm; out vec4 vCol; out float vZ; out vec4 vSh;\nout float vGA; out float vBlood;\nvoid main(){\n  int g = int(aGrp + 0.5);\n  float w = uMW[g];\n  vec3 p = mix(aPos, aPos2, w), n = mix(aNorm, aNorm2, w);\n  vec4 wp = uGM[g] * vec4(p, 1.0);\n  vPos = wp.xyz; vNorm = uNM[g] * n; vCol = aCol; vGA = uGA[g]; vBlood = aBlood;\n  vec4 cp = uVP * wp; vZ = cp.w; vSh = uSVP * wp; gl_Position = cp;\n}";
+export declare const FACE_FS = "#version 300 es\nprecision highp float;\nin vec3 vPos; in vec3 vNorm; in vec4 vCol; in float vZ; in vec4 vSh;\nin float vGA; in float vBlood;\nuniform vec3 uLdir; uniform float uAmb; uniform float uDif; uniform float uSigned;\nuniform vec3 uLp[8]; uniform float uLi[8]; uniform float uLf[8]; uniform int uLn;\nuniform vec3 uCam; uniform float uFogK; uniform float uSpec; uniform vec3 uBg;\nuniform vec3 uSkyC; uniform vec3 uGroundC; uniform float uPulse;\nuniform float uShadowOn; uniform float uShadowSoft; uniform float uShadowBias;\nuniform lowp sampler2DShadow uShadow; uniform float uShadowPx;\nout vec4 fragColor;\nfloat h3(vec3 p){ return fract(sin(dot(p, vec3(12.9898, 78.233, 37.719))) * 43758.5453); }\nfloat vnoise(vec3 p){ vec3 i = floor(p), f = fract(p); f = f * f * (3.0 - 2.0 * f);\n  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),\n             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); }\nfloat shadowFactor(){\n  vec3 pr = vSh.xyz / vSh.w * 0.5 + 0.5;\n  if (pr.x < 0.0 || pr.x > 1.0 || pr.y < 0.0 || pr.y > 1.0 || pr.z > 1.0) return 1.0;\n  float ref = pr.z - uShadowBias;\n  // 3x3 taps over a hardware-compared (LINEAR sampler2DShadow => free 2x2 PCF each) map\n  float s = 0.0;\n  for (int sy = -1; sy <= 1; sy++)\n    for (int sx = -1; sx <= 1; sx++)\n      s += texture(uShadow, vec3(pr.xy + vec2(float(sx), float(sy)) * uShadowPx * uShadowSoft, ref));\n  s /= 9.0;\n  return 0.35 + 0.65 * s;\n}\nvoid main(){\n  vec3 n = normalize(vNorm);\n  vec3 V = normalize(uCam - vPos);\n  float skin = clamp(vBlood * 5.0, 0.0, 1.0);\n  { // procedural micro-relief: perturb the shading normal by a fine noise gradient\n    float bs = 5.5, e = 0.12, n0 = vnoise(vPos * bs);\n    vec3 g = vec3(vnoise(vPos * bs + vec3(e, 0.0, 0.0)) - n0,\n                  vnoise(vPos * bs + vec3(0.0, e, 0.0)) - n0,\n                  vnoise(vPos * bs + vec3(0.0, 0.0, e)) - n0) / e;\n    n = normalize(n - g * (0.10 + 0.30 * skin));\n  }\n  float d = dot(n, normalize(uLdir));\n  float shade = uAmb + uDif * mix(abs(d), max(d, 0.0), uSigned);\n  float spec = 0.0;\n  float sh = uShadowOn > 0.5 ? shadowFactor() : 1.0;\n  for (int i = 0; i < 8; i++) { if (i >= uLn) break;\n    vec3 v = uLp[i] - vPos; float d2 = dot(v, v); vec3 L = v * inversesqrt(d2 + 1e-4);\n    float lam = dot(n, L); lam = mix(abs(lam), max(lam, 0.0), uSigned);\n    float fall = 1.0 / (1.0 + d2 / (uLf[i] * uLf[i]));\n    float k = (i == 0) ? sh : 1.0;\n    shade += uLi[i] * lam * fall * k;\n    // GGX microfacet + Fresnel \u2014 roughness from the face's gloss (colour alpha slot)\n    vec3 H = normalize(L + V);\n    float nh = max(dot(n, H), 0.0);\n    float rough = clamp(1.0 - vCol.a, 0.08, 1.0), a2 = rough * rough; a2 = a2 * a2;\n    float dnm = nh * nh * (a2 - 1.0) + 1.0;\n    float ggx = a2 / (3.14159 * dnm * dnm);\n    float fres = 0.04 + 0.96 * pow(1.0 - max(dot(H, V), 0.0), 5.0);\n    spec += uLi[i] * min(ggx, 6.0) * fres * fall * k * 0.16;\n  }\n  // coloured hemispheric ambient: cool from above, warm from below\n  vec3 tint = mix(uGroundC, uSkyC, n.y * 0.5 + 0.5);\n  vec3 lit = vCol.rgb * (uAmb * tint + vec3(shade - uAmb));\n  // the perfusion term: blood near the surface changes how it meets the light\n  float b = clamp(vBlood + uPulse * vBlood * 6.0, 0.0, 1.0);\n  lit *= mix(vec3(1.0), vec3(1.07, 0.95, 0.94), b);\n  lit += vec3(0.62, 0.06, 0.08) * (b * 0.20 * (1.0 - abs(d)));\n  // pore noise, only where there is blood (skin, not cloth)\n  float pore = vnoise(vPos * 2.4) * 0.6 + vnoise(vPos * 6.0) * 0.4;\n  lit *= 1.0 + (pore - 0.5) * 0.09 * skin;\n  // subsurface rim: grazing light bleeds through thin tissue, warm\n  float fres = pow(1.0 - clamp(dot(n, V), 0.0, 1.0), 3.0);\n  lit += vec3(0.55, 0.09, 0.10) * fres * skin * (0.28 + 0.5 * b);\n  float fog = clamp(uFogK / vZ, 0.08, 1.0);\n  vec3 outC = lit + vec3(1.0) * spec * uSpec * vCol.a;\n  // fog and fades resolve toward the REAL background colour (the engine owns its ground)\n  fragColor = vec4(mix(uBg, outC, fog * vGA), 1.0);\n}";
+export declare const DEPTH_VS = "#version 300 es\nin vec3 aPos; in float aGrp; in vec3 aPos2;\nuniform mat4 uVP;\nuniform mat4 uGM[8]; uniform mat3 uNM[8]; uniform float uMW[8]; uniform float uGA[8];\nvoid main(){\n  int g = int(aGrp + 0.5);\n  vec3 p = mix(aPos, aPos2, uMW[g]);\n  gl_Position = uVP * (uGM[g] * vec4(p, 1.0));\n}";
+export declare const DEPTH_FS = "#version 300 es\nprecision mediump float;\nvoid main(){}";
+export declare const LINE_VS = "#version 300 es\nin vec3 aPos; in vec4 aCol; in float aGrp;\nuniform mat4 uVP;\nuniform mat4 uGM[8]; uniform mat3 uNM[8]; uniform float uMW[8]; uniform float uGA[8];\nout vec4 vCol; out float vZ; out float vGA;\nvoid main(){\n  int g = int(aGrp + 0.5);\n  vCol = aCol; vGA = uGA[g];\n  vec4 p = uVP * (uGM[g] * vec4(aPos, 1.0)); vZ = p.w; gl_Position = p;\n}";
+export declare const LINE_FS = "#version 300 es\nprecision mediump float;\nin vec4 vCol; in float vZ; in float vGA;\nuniform float uFogK; uniform float uInk;\nout vec4 fragColor;\nvoid main(){\n  float fog = clamp(uFogK / vZ, 0.08, 1.0);\n  if (uInk > 0.5) fragColor = vec4(vCol.rgb, min(1.0, vCol.a * 1.6) * fog * vGA);\n  else fragColor = vec4(vCol.rgb * fog, vCol.a * fog * vGA);\n}";
+export declare const PT_VS = "#version 300 es\nin vec3 aPos; in float aSize; in vec4 aCol; in float aGrp;\nuniform mat4 uVP; uniform float uFocal;\nuniform mat4 uGM[8]; uniform mat3 uNM[8]; uniform float uMW[8]; uniform float uGA[8];\nout vec4 vCol; out float vZ; out float vGA;\nvoid main(){\n  int g = int(aGrp + 0.5);\n  vCol = aCol; vGA = uGA[g];\n  vec4 p = uVP * (uGM[g] * vec4(aPos, 1.0)); vZ = p.w;\n  gl_PointSize = clamp(aSize * uFocal / p.w, 1.0, 256.0); gl_Position = p;\n}";
+export declare const PT_FS = "#version 300 es\nprecision mediump float;\nin vec4 vCol; in float vZ; in float vGA;\nuniform float uFogK; uniform float uInk;\nout vec4 fragColor;\nvoid main(){\n  float r = length(gl_PointCoord - 0.5) * 2.0;\n  float a = exp(-3.2 * r * r) * (1.0 - smoothstep(0.85, 1.0, r));\n  float fog = clamp(uFogK / vZ, 0.08, 1.0);\n  if (uInk > 0.5) fragColor = vec4(vCol.rgb, min(1.0, vCol.a * 1.6) * a * fog * vGA);\n  else fragColor = vec4(vCol.rgb, 1.0) * (vCol.a * a * fog * vGA);\n}";
+export declare const RIBBON_VS = "#version 300 es\nin vec3 aPos; in vec3 aPrev; in vec3 aNext; in float aSide; in float aWidth;\nin vec4 aCol; in float aGrp;\nuniform mat4 uVP; uniform vec2 uRes;\nuniform mat4 uGM[8]; uniform mat3 uNM[8]; uniform float uMW[8]; uniform float uGA[8];\nout vec4 vCol; out float vZ; out float vGA; out float vSide;\nvoid main(){\n  int g = int(aGrp + 0.5);\n  mat4 M = uGM[g];\n  vec4 cp = uVP * (M * vec4(aPos, 1.0));\n  vec4 cq = uVP * (M * vec4(aPrev, 1.0));\n  vec4 cr = uVP * (M * vec4(aNext, 1.0));\n  vec2 sp = cp.xy / max(cp.w, 1e-4) * uRes;\n  vec2 sq = cq.xy / max(cq.w, 1e-4) * uRes;\n  vec2 sr = cr.xy / max(cr.w, 1e-4) * uRes;\n  vec2 dir = sr - sq;\n  float dl = length(dir);\n  dir = dl > 1e-3 ? dir / dl : vec2(1.0, 0.0);\n  vec2 perp = vec2(-dir.y, dir.x);\n  vec2 off = perp * aWidth * 0.5 * aSide;\n  cp.xy += off / uRes * cp.w * 2.0;\n  vCol = aCol; vZ = cp.w; vGA = uGA[g]; vSide = aSide;\n  gl_Position = cp;\n}";
+export declare const RIBBON_FS = "#version 300 es\nprecision mediump float;\nin vec4 vCol; in float vZ; in float vGA; in float vSide;\nuniform float uFogK; uniform float uInk;\nout vec4 fragColor;\nvoid main(){\n  float edge = 1.0 - smoothstep(0.55, 1.0, abs(vSide));\n  float fog = clamp(uFogK / vZ, 0.08, 1.0);\n  float a = vCol.a * edge * fog * vGA;\n  if (uInk > 0.5) fragColor = vec4(vCol.rgb, min(1.0, a * 1.6));\n  else fragColor = vec4(vCol.rgb * a, a);\n}";
+export declare const FST_VS = "#version 300 es\nout vec2 vUv;\nvoid main(){\n  vec2 p = vec2(float((gl_VertexID << 1) & 2), float(gl_VertexID & 2));\n  vUv = p; gl_Position = vec4(p * 2.0 - 1.0, 0.0, 1.0);\n}";
+export declare const BRIGHT_FS = "#version 300 es\nprecision mediump float;\nin vec2 vUv; uniform sampler2D uTex; uniform float uThresh; uniform float uKnee;\nout vec4 fragColor;\nvoid main(){\n  vec3 c = texture(uTex, vUv).rgb;\n  float luma = max(c.r, max(c.g, c.b));\n  float w = smoothstep(uThresh, uThresh + uKnee, luma);\n  fragColor = vec4(c * w, 1.0);\n}";
+export declare const BLUR_FS = "#version 300 es\nprecision mediump float;\nin vec2 vUv; uniform sampler2D uTex; uniform vec2 uDir;\nout vec4 fragColor;\nvoid main(){\n  vec3 s = texture(uTex, vUv).rgb * 0.227027;\n  vec2 o1 = uDir * 1.3846153846, o2 = uDir * 3.2307692308;\n  s += (texture(uTex, vUv + o1).rgb + texture(uTex, vUv - o1).rgb) * 0.3162162162;\n  s += (texture(uTex, vUv + o2).rgb + texture(uTex, vUv - o2).rgb) * 0.0702702703;\n  fragColor = vec4(s, 1.0);\n}";
+export declare const SSAO_FS = "#version 300 es\nprecision highp float;\nin vec2 vUv; uniform sampler2D uDepth;\nuniform float uNear; uniform float uFar; uniform float uRadius; uniform vec2 uRes;\nout vec4 fragColor;\nfloat viewZ(vec2 uv){\n  float d = texture(uDepth, uv).r * 2.0 - 1.0;\n  return 2.0 * uNear * uFar / (uFar + uNear - d * (uFar - uNear));\n}\nfloat hash(vec2 p){ return fract(sin(dot(p, vec2(12.9898, 78.233))) * 43758.5453); }\nvoid main(){\n  float z0 = viewZ(vUv);\n  // screen-space sample radius shrinks with distance (a world-ish radius)\n  float rad = uRadius / z0;\n  float ang = hash(vUv * uRes) * 6.2831853;\n  float occ = 0.0;\n  for (int i = 0; i < 12; i++) {\n    float fi = float(i);\n    float a = ang + fi * 2.3999632;           // golden-angle spiral\n    float r = rad * (0.25 + 0.75 * fract(fi * 0.618034));\n    vec2 uv = vUv + vec2(cos(a), sin(a)) * r;\n    float dz = z0 - viewZ(uv);                // positive => sample nearer camera => occluder\n    occ += smoothstep(z0 * 0.002, z0 * 0.02, dz) * smoothstep(z0 * 0.35, 0.0, dz);\n  }\n  float ao = 1.0 - occ / 12.0;\n  fragColor = vec4(vec3(ao), 1.0);\n}";
+export declare const AOBLUR_FS = "#version 300 es\nprecision mediump float;\nin vec2 vUv; uniform sampler2D uTex; uniform vec2 uPx;\nout vec4 fragColor;\nvoid main(){\n  float s = 0.0;\n  for (int y = -1; y <= 2; y++)\n    for (int x = -1; x <= 2; x++)\n      s += texture(uTex, vUv + vec2(float(x) - 0.5, float(y) - 0.5) * uPx).r;\n  fragColor = vec4(vec3(s / 16.0), 1.0);\n}";
+export declare const COMPOSITE_FS = "#version 300 es\nprecision mediump float;\nin vec2 vUv;\nuniform sampler2D uScene; uniform sampler2D uBloom; uniform sampler2D uAO;\nuniform float uBloomStr; uniform float uAOStr;\nuniform float uFilm; uniform float uGrade; uniform float uVig; uniform float uInk;\nout vec4 fragColor;\nvoid main(){\n  vec3 c = texture(uScene, vUv).rgb;\n  c *= mix(1.0, texture(uAO, vUv).r, uAOStr);\n  c += texture(uBloom, vUv).rgb * uBloomStr;\n  if (uFilm > 0.5) { // ACES-ish filmic: highlights roll off instead of clipping\n    c = (c * (2.51 * c + 0.03)) / (c * (2.43 * c + 0.59) + 0.14);\n  }\n  c = clamp(c, 0.0, 1.0);\n  if (uGrade > 0.5) { // violet-cool shadows, warm highlights\n    float luma = dot(c, vec3(0.299, 0.587, 0.114));\n    c *= mix(vec3(0.85, 0.83, 1.07), vec3(1.07, 0.99, 0.92), smoothstep(0.12, 0.72, luma));\n    c = clamp(c, 0.0, 1.0);\n  }\n  if (uVig > 0.0) { // cinematic vignette, in the composite now (off the overlay)\n    vec2 q = vUv - vec2(0.5, 0.54);\n    float r = smoothstep(0.35, 0.9, length(q * vec2(1.15, 1.0)));\n    vec3 dk = uInk > 0.5 ? vec3(0.20, 0.19, 0.30) : vec3(0.024, 0.016, 0.055);\n    c = mix(c, dk, uVig * r * (uInk > 0.5 ? 0.3 : 1.0));\n  }\n  fragColor = vec4(c, 1.0);\n}";
+export declare const FXAA_FS = "#version 300 es\nprecision mediump float;\nin vec2 vUv; uniform sampler2D uTex; uniform vec2 uPx;\nout vec4 fragColor;\nfloat luma(vec3 c){ return dot(c, vec3(0.299, 0.587, 0.114)); }\nvoid main(){\n  vec3 cM = texture(uTex, vUv).rgb;\n  float lM = luma(cM);\n  float lN = luma(texture(uTex, vUv + vec2(0.0, -uPx.y)).rgb);\n  float lS = luma(texture(uTex, vUv + vec2(0.0, uPx.y)).rgb);\n  float lW = luma(texture(uTex, vUv + vec2(-uPx.x, 0.0)).rgb);\n  float lE = luma(texture(uTex, vUv + vec2(uPx.x, 0.0)).rgb);\n  float lMin = min(lM, min(min(lN, lS), min(lW, lE)));\n  float lMax = max(lM, max(max(lN, lS), max(lW, lE)));\n  float range = lMax - lMin;\n  if (range < max(0.0312, lMax * 0.125)) { fragColor = vec4(cM, 1.0); return; }\n  vec2 dir = normalize(vec2((lE + lS) - (lW + lN), (lN + lE) - (lS + lW)) + 1e-6);\n  vec3 a = texture(uTex, vUv + dir * uPx * 0.5).rgb;\n  vec3 b = texture(uTex, vUv - dir * uPx * 0.5).rgb;\n  fragColor = vec4(mix(cM, (a + b) * 0.5, 0.75), 1.0);\n}";

package/dist/shaders.js

@@ -0,0 +1,307 @@
+// generative-engine — shaders.ts: every GLSL ES 3.00 source, scene + post, as plain strings.
+// The scene shaders carry dark-math-3d's whole light model forward (Lambert + point
+// lights, GGX + Fresnel, procedural micro-relief, the perfusion term, pore noise,
+// subsurface rim) and add: group transforms, morph targets, hardware-PCF shadow
+// 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 = `
+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_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));
+}`;
+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_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_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_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 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 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 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 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);
+}`;
+// 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);
+}`;