@downdraft/engine 0.1.1 → 0.2.0

package/dist/libraries/postfx/src/shaders/post-process/fxaa.wgsl

@@ -0,0 +1,102 @@
+// wgsl-validate: prelude ./fullscreen-vs.wgsl
+// wgsl-validate: prelude ./occluder-chunk.wgsl
+struct U { texelSize: vec2<f32>, _p0: f32, _p1: f32, _p2: f32, _p3: f32, _p4: f32, _p5: f32, _p6: f32, };
+@group(0) @binding(0) var colorTex: texture_2d<f32>;
+@group(0) @binding(1) var dummyTex: texture_2d<f32>;
+@group(0) @binding(2) var samp: sampler;
+@group(0) @binding(3) var<uniform> u: U;
+
+fn FxaaContrast(a: vec4<f32>, b: vec4<f32>) -> f32 {
+  let d = abs(a - b);
+  return max(max(max(d.r, d.g), d.b), d.a);
+}
+
+@fragment
+fn fs_main(input: VertexOutput) -> @location(0) vec4<f32> {
+  if (isOccluded(input.uv)) { discard; }
+  let posM = input.uv;
+  let rcpFrame = u.texelSize;
+
+  let rgbaM = textureSample(colorTex, samp, posM);
+  let rgbaS = textureSample(colorTex, samp, posM + vec2(0.0, rcpFrame.y));
+  let rgbaE = textureSample(colorTex, samp, posM + vec2(rcpFrame.x, 0.0));
+  let rgbaN = textureSample(colorTex, samp, posM + vec2(0.0, -rcpFrame.y));
+  let rgbaW = textureSample(colorTex, samp, posM + vec2(-rcpFrame.x, 0.0));
+
+  let earlyExit = max(max(max(
+    FxaaContrast(rgbaM, rgbaN),
+    FxaaContrast(rgbaM, rgbaS)),
+    FxaaContrast(rgbaM, rgbaE)),
+    FxaaContrast(rgbaM, rgbaW)) < 0.06;
+  if (earlyExit) { return rgbaM; }
+
+  let contrastN = FxaaContrast(rgbaM, rgbaN);
+  let contrastS = FxaaContrast(rgbaM, rgbaS);
+  let contrastE = FxaaContrast(rgbaM, rgbaE);
+  let contrastW = FxaaContrast(rgbaM, rgbaW);
+
+  var relativeVContrast = (contrastN + contrastS) - (contrastE + contrastW);
+  relativeVContrast = relativeVContrast * 5.0;
+
+  var horzSpan = relativeVContrast > 0.0;
+
+  if (abs(relativeVContrast) < 0.1) {
+    let dirToEdgeX = select(-1.0, 1.0, contrastE > contrastW);
+    let dirToEdgeY = select(-1.0, 1.0, contrastS > contrastN);
+
+    let rgbaAlongH = textureSampleLevel(colorTex, samp, posM + vec2(dirToEdgeX, -dirToEdgeY) * rcpFrame, 0.0);
+    let matchAlongH = FxaaContrast(rgbaM, rgbaAlongH);
+
+    let rgbaAlongV = textureSampleLevel(colorTex, samp, posM + vec2(-dirToEdgeX, dirToEdgeY) * rcpFrame, 0.0);
+    let matchAlongV = FxaaContrast(rgbaM, rgbaAlongV);
+
+    relativeVContrast = (matchAlongV - matchAlongH) * 5.0;
+    if (abs(relativeVContrast) < 0.1) {
+      return mix(rgbaM, (rgbaN + rgbaS + rgbaE + rgbaW) * 0.25, 0.4);
+    }
+    horzSpan = relativeVContrast > 0.0;
+  }
+
+  var rgbaN2 = select(rgbaN, rgbaW, horzSpan);
+  var rgbaS2 = select(rgbaS, rgbaE, horzSpan);
+
+  let pairN = FxaaContrast(rgbaM, rgbaN2) > FxaaContrast(rgbaM, rgbaS2);
+  if (!pairN) { rgbaN2 = rgbaS2; }
+
+  let offNPX = select(0.0, rcpFrame.x, horzSpan);
+  let offNPY = select(rcpFrame.y, 0.0, horzSpan);
+
+  var doneN = false;
+  var doneP = false;
+  var nDist = 0.0;
+  var pDist = 0.0;
+  var posN = posM;
+  var posP = posM;
+
+  for (var i = 0u; i < 5u; i++) {
+    let inc = f32(i + 1u);
+    if (!doneN) {
+      nDist = nDist + inc;
+      posN = posM + vec2(offNPX, offNPY) * nDist;
+      let rgbaEndN = textureSampleLevel(colorTex, samp, posN, 0.0);
+      doneN = FxaaContrast(rgbaEndN, rgbaM) > FxaaContrast(rgbaEndN, rgbaN2);
+    }
+    if (!doneP) {
+      pDist = pDist + inc;
+      posP = posM - vec2(offNPX, offNPY) * pDist;
+      let rgbaEndP = textureSampleLevel(colorTex, samp, posP, 0.0);
+      doneP = FxaaContrast(rgbaEndP, rgbaM) > FxaaContrast(rgbaEndP, rgbaN2);
+    }
+    if (doneN || doneP) { break; }
+  }
+
+  if (!doneN && !doneP) { return rgbaM; }
+
+  let span = nDist + pDist;
+  var dist = min(nDist, pDist) / max(span, 0.001);
+  dist = 1.0 - dist;
+  dist = sqrt(dist);
+
+  let result = mix(rgbaM, rgbaN2, dist * 0.5);
+  return result;
+}

package/dist/libraries/postfx/src/shaders/post-process/gaussian-blur.wgsl

@@ -0,0 +1,37 @@
+// wgsl-validate: prelude ./fullscreen-vs.wgsl
+// wgsl-validate: prelude ./occluder-chunk.wgsl
+// Gaussian blur — two-pass separable convolution.
+// 9-tap kernel with normalized weights (sum = 1.0) — fixes B1.
+struct U {
+  texelSize: vec2<f32>,
+  dirX: f32,
+  dirY: f32,
+  radius: f32,
+  _p0: f32,
+  _p1: f32,
+  _p2: f32,
+};
+@group(0) @binding(0) var colorTex: texture_2d<f32>;
+@group(0) @binding(1) var dummyTex: texture_2d<f32>;
+@group(0) @binding(2) var samp: sampler;
+@group(0) @binding(3) var<uniform> u: U;
+
+@fragment
+fn fs_main(input: VertexOutput) -> @location(0) vec4<f32> {
+  if (isOccluded(input.uv)) { discard; }
+  let uv = input.uv;
+  let dir = vec2(u.dirX, u.dirY) * u.texelSize * u.radius;
+
+  // Normalized 9-tap Gaussian: center 0.227027 + 2*(0.1945946+0.1216216+0.054054+0.016216) = 1.0
+  var color = textureSample(colorTex, samp, uv) * 0.227027;
+  color += textureSample(colorTex, samp, uv + dir * 1.0) * 0.1945946;
+  color += textureSample(colorTex, samp, uv - dir * 1.0) * 0.1945946;
+  color += textureSample(colorTex, samp, uv + dir * 2.0) * 0.1216216;
+  color += textureSample(colorTex, samp, uv - dir * 2.0) * 0.1216216;
+  color += textureSample(colorTex, samp, uv + dir * 3.0) * 0.054054;
+  color += textureSample(colorTex, samp, uv - dir * 3.0) * 0.054054;
+  color += textureSample(colorTex, samp, uv + dir * 4.0) * 0.016216;
+  color += textureSample(colorTex, samp, uv - dir * 4.0) * 0.016216;
+
+  return color;
+}

package/dist/libraries/postfx/src/shaders/post-process/glow-blur.wgsl

@@ -0,0 +1,33 @@
+// wgsl-validate: prelude ./fullscreen-vs.wgsl
+// wgsl-validate: prelude ./occluder-chunk.wgsl
+// Glow blur — separable Gaussian blur of the emissive mask.
+struct U {
+  texelSize: vec2<f32>,
+  dirX: f32,
+  dirY: f32,
+  blurRadius: f32,
+  _p0: f32,
+  _p1: f32,
+  _p2: f32,
+};
+@group(0) @binding(0) var glowTex: texture_2d<f32>;
+@group(0) @binding(1) var dummyTex: texture_2d<f32>;
+@group(0) @binding(2) var samp: sampler;
+@group(0) @binding(3) var<uniform> u: U;
+
+@fragment
+fn fs_main(input: VertexOutput) -> @location(0) vec4<f32> {
+  if (isOccluded(input.uv)) { discard; }
+  let uv = input.uv;
+  let weights = array<f32, 5>(0.227027, 0.1945946, 0.1216216, 0.054054, 0.016216);
+  let offsets = array<f32, 5>(0.0, 1.3846154, 3.2307692, 5.176923, 7.1076923);
+  let dir = vec2<f32>(u.dirX, u.dirY) * u.blurRadius * u.texelSize;
+
+  var color = textureSample(glowTex, samp, uv) * weights[0];
+  for (var i = 1u; i < 5u; i = i + 1u) {
+    let offset = dir * offsets[i];
+    color += textureSample(glowTex, samp, uv + offset) * weights[i];
+    color += textureSample(glowTex, samp, uv - offset) * weights[i];
+  }
+  return color;
+}

package/dist/libraries/postfx/src/shaders/post-process/glow-composite.wgsl

@@ -0,0 +1,25 @@
+// wgsl-validate: prelude ./fullscreen-vs.wgsl
+// wgsl-validate: prelude ./occluder-chunk.wgsl
+// Glow composite — add blurred glow to color.
+struct U {
+  intensity: f32,
+  _p0: f32,
+  _p1: f32,
+  _p2: f32,
+  _p3: f32,
+  _p4: f32,
+  _p5: f32,
+  _p6: f32,
+};
+@group(0) @binding(0) var colorTex: texture_2d<f32>;
+@group(0) @binding(1) var glowBlurTex: texture_2d<f32>;
+@group(0) @binding(2) var samp: sampler;
+@group(0) @binding(3) var<uniform> u: U;
+
+@fragment
+fn fs_main(input: VertexOutput) -> @location(0) vec4<f32> {
+  if (isOccluded(input.uv)) { discard; }
+  let color = textureSample(colorTex, samp, input.uv).rgb;
+  let glow = textureSample(glowBlurTex, samp, input.uv).rgb;
+  return vec4<f32>(color + glow * u.intensity, 1.0);
+}

package/dist/libraries/postfx/src/shaders/post-process/grain.wgsl

@@ -0,0 +1,37 @@
+// wgsl-validate: prelude ./fullscreen-vs.wgsl
+// wgsl-validate: prelude ./occluder-chunk.wgsl
+// Grain — film grain with optional luminance awareness.
+struct U {
+  texelSize: vec2<f32>,
+  intensity: f32,
+  size: f32,
+  luminanceAware: f32,
+  time: f32,
+  _p0: f32,
+  _p1: f32,
+  _p2: f32,
+};
+@group(0) @binding(0) var colorTex: texture_2d<f32>;
+@group(0) @binding(1) var dummyTex: texture_2d<f32>;
+@group(0) @binding(2) var samp: sampler;
+@group(0) @binding(3) var<uniform> u: U;
+
+fn hash21(p: vec2<f32>) -> f32 {
+  let p2 = fract(p * vec2<f32>(443.897, 441.423));
+  let p3 = dot(p2, p2 + 19.19);
+  return fract(p3);
+}
+
+@fragment
+fn fs_main(input: VertexOutput) -> @location(0) vec4<f32> {
+  if (isOccluded(input.uv)) { discard; }
+  let color = textureSample(colorTex, samp, input.uv).rgb;
+  let grainUV = input.uv * u.size + u.time;
+  let grain = hash21(grainUV) - 0.5;
+  var amount = u.intensity;
+  if (u.luminanceAware > 0.5) {
+    let luma = dot(color, vec3<f32>(0.299, 0.587, 0.114));
+    amount *= 1.0 - luma * 0.5;
+  }
+  return vec4<f32>(color + grain * amount, 1.0);
+}

package/dist/libraries/postfx/src/shaders/post-process/halftone.wgsl

@@ -0,0 +1,80 @@
+// wgsl-validate: prelude ./fullscreen-vs.wgsl
+// wgsl-validate: prelude ./occluder-chunk.wgsl
+// Halftone — dot/hex cell pattern for stylized print look.
+// Renders a halftone screen: cells of variable-size dots, with dot size
+// proportional to luminance. Supports rotation and monochrome/color modes.
+struct U {
+  texelSize: vec2<f32>,
+  cellSize: f32,     // cell size in pixels (e.g. 8)
+  dotScale: f32,     // dot size multiplier (0–2)
+  angle: f32,        // screen rotation in radians
+  monochrome: f32,   // 1.0 = grayscale dots, 0.0 = CMYK-style color dots
+  _p0: f32,
+  _p1: f32,
+};
+@group(0) @binding(0) var colorTex: texture_2d<f32>;
+@group(0) @binding(1) var dummyTex: texture_2d<f32>;
+@group(0) @binding(2) var samp: sampler;
+@group(0) @binding(3) var<uniform> u: U;
+
+// Rotated cell coordinate
+fn cellCoord(uv: vec2<f32>, cellSize: f32, angle: f32) -> vec2<f32> {
+  let centered = uv - vec2<f32>(0.5);
+  let rot = mat2x2<f32>(cos(angle), -sin(angle), sin(angle), cos(angle));
+  let rotated = rot * centered + vec2<f32>(0.5);
+  return fract(rotated * vec2<f32>(1.0 / cellSize) * u.texelSize * 1000.0);
+}
+
+@fragment
+fn fs_main(input: VertexOutput) -> @location(0) vec4<f32> {
+  if (isOccluded(input.uv)) { discard; }
+  let uv = input.uv;
+  let color = textureSample(colorTex, samp, uv).rgb;
+  let dims = vec2<f32>(1.0 / u.texelSize.x, 1.0 / u.texelSize.y);
+  let pixelPos = uv * dims;
+
+  // Rotated grid coordinate
+  let cosA = cos(u.angle);
+  let sinA = sin(u.angle);
+  let rot = mat2x2<f32>(cosA, -sinA, sinA, cosA);
+  let centered = pixelPos - dims * 0.5;
+  let rotated = rot * centered + dims * 0.5;
+
+  let cell = floor(rotated / u.cellSize);
+  let cellCenter = (cell + vec2<f32>(0.5)) * u.cellSize;
+  let cellUV = (rotated - cell * u.cellSize) / u.cellSize;
+
+  // Sample color at cell center for stable dot color
+  let samplePos = (cellCenter / dims);
+  let cellColor = textureSample(colorTex, samp, clamp(samplePos, vec2<f32>(0.0), vec2<f32>(1.0))).rgb;
+
+  if (u.monochrome > 0.5) {
+    let luma = dot(cellColor, vec3<f32>(0.299, 0.587, 0.114));
+    let dotRadius = luma * u.dotScale * 0.5;
+    let distFromCenter = length(cellUV - 0.5);
+    let dot = 1.0 - smoothstep(dotRadius - 0.05, dotRadius + 0.05, distFromCenter);
+    return vec4<f32>(vec3<f32>(luma * dot), 1.0);
+  } else {
+    // CMYK-style: separate dot per channel with angle offset
+    var result = vec3<f32>(0.0);
+    let channelAngles = array<f32, 3>(0.0, 1.0471976, 2.0943951);  // 0, 60, 120 deg
+    for (var i = 0u; i < 3u; i = i + 1u) {
+      let chAngle = u.angle + channelAngles[i];
+      let chCos = cos(chAngle);
+      let chSin = sin(chAngle);
+      let chRot = mat2x2<f32>(chCos, -chSin, chSin, chCos);
+      let chCentered = pixelPos - dims * 0.5;
+      let chRotated = chRot * chCentered + dims * 0.5;
+      let chCell = floor(chRotated / u.cellSize);
+      let chCellCenter = (chCell + vec2<f32>(0.5)) * u.cellSize;
+      let chCellUV = (chRotated - chCell * u.cellSize) / u.cellSize;
+      let chSamplePos = clamp(chCellCenter / dims, vec2<f32>(0.0), vec2<f32>(1.0));
+      let chColor = textureSample(colorTex, samp, chSamplePos)[i];
+      let dotRadius = chColor * u.dotScale * 0.5;
+      let distFromCenter = length(chCellUV - 0.5);
+      let dot = 1.0 - smoothstep(dotRadius - 0.05, dotRadius + 0.05, distFromCenter);
+      result[i] = chColor * dot;
+    }
+    return vec4<f32>(result, 1.0);
+  }
+}

package/dist/libraries/postfx/src/shaders/post-process/highlight-blur.wgsl

@@ -0,0 +1,33 @@
+// wgsl-validate: prelude ./fullscreen-vs.wgsl
+// wgsl-validate: prelude ./occluder-chunk.wgsl
+// Highlight blur — separable Gaussian blur of the mask.
+struct U {
+  texelSize: vec2<f32>,
+  dirX: f32,
+  dirY: f32,
+  blurRadius: f32,
+  _p0: f32,
+  _p1: f32,
+  _p2: f32,
+};
+@group(0) @binding(0) var maskTex: texture_2d<f32>;
+@group(0) @binding(1) var dummyTex: texture_2d<f32>;
+@group(0) @binding(2) var samp: sampler;
+@group(0) @binding(3) var<uniform> u: U;
+
+@fragment
+fn fs_main(input: VertexOutput) -> @location(0) vec4<f32> {
+  if (isOccluded(input.uv)) { discard; }
+  let uv = input.uv;
+  let weights = array<f32, 5>(0.227027, 0.1945946, 0.1216216, 0.054054, 0.016216);
+  let offsets = array<f32, 5>(0.0, 1.3846154, 3.2307692, 5.176923, 7.1076923);
+  let dir = vec2<f32>(u.dirX, u.dirY) * u.blurRadius * u.texelSize;
+
+  var color = textureSample(maskTex, samp, uv) * weights[0];
+  for (var i = 1u; i < 5u; i = i + 1u) {
+    let offset = dir * offsets[i];
+    color += textureSample(maskTex, samp, uv + offset) * weights[i];
+    color += textureSample(maskTex, samp, uv - offset) * weights[i];
+  }
+  return color;
+}

package/dist/libraries/postfx/src/shaders/post-process/highlight-composite.wgsl

@@ -0,0 +1,32 @@
+// wgsl-validate: prelude ./fullscreen-vs.wgsl
+// wgsl-validate: prelude ./occluder-chunk.wgsl
+// Highlight composite — add outer glow + inner fill to color.
+struct U {
+  intensity: f32,
+  innerOpacity: f32,
+  _p0: f32,
+  _p1: f32,
+  _p2: f32,
+  _p3: f32,
+  _p4: f32,
+  _p5: f32,
+};
+@group(0) @binding(0) var colorTex: texture_2d<f32>;
+@group(0) @binding(1) var blurTex: texture_2d<f32>;
+@group(0) @binding(2) var maskTex: texture_2d<f32>;
+@group(0) @binding(3) var samp: sampler;
+@group(0) @binding(4) var<uniform> u: U;
+
+@fragment
+fn fs_main(input: VertexOutput) -> @location(0) vec4<f32> {
+  if (isOccluded(input.uv)) { discard; }
+  let uv = input.uv;
+  let color = textureSample(colorTex, samp, uv).rgb;
+  let blurred = textureSample(blurTex, samp, uv).rgb;
+  let mask = textureSample(maskTex, samp, uv).rgb;
+
+  let outerGlow = blurred * u.intensity;
+  let inner = mask * u.innerOpacity;
+
+  return vec4<f32>(color + outerGlow + inner, 1.0);
+}

package/dist/libraries/postfx/src/shaders/post-process/lens-distortion.wgsl

@@ -0,0 +1,43 @@
+// wgsl-validate: prelude ./fullscreen-vs.wgsl
+// wgsl-validate: prelude ./occluder-chunk.wgsl
+// Lens distortion — barrel/pincushion distortion with optional chromatic split.
+// Applies radial distortion: positive = barrel (fisheye), negative = pincushion.
+struct U {
+  texelSize: vec2<f32>,
+  intensity: f32,    // -1.0 (pincushion) to 1.0 (barrel)
+  scale: f32,        // zoom to compensate for distortion (1.0 = no zoom)
+  chromaSplit: f32,  // chromatic aberration on distortion (0–1)
+  _p0: f32,
+  _p1: f32,
+  _p2: f32,
+};
+@group(0) @binding(0) var colorTex: texture_2d<f32>;
+@group(0) @binding(1) var dummyTex: texture_2d<f32>;
+@group(0) @binding(2) var samp: sampler;
+@group(0) @binding(3) var<uniform> u: U;
+
+@fragment
+fn fs_main(input: VertexOutput) -> @location(0) vec4<f32> {
+  if (isOccluded(input.uv)) { discard; }
+  let uv = input.uv;
+  let center = vec2<f32>(0.5, 0.5);
+  let dir = uv - center;
+  let r2 = dot(dir, dir);
+  // Barrel/pincushion: r' = r * (1 + k * r^2)
+  let distortion = 1.0 + u.intensity * r2;
+  var distortedUV = center + dir * distortion * u.scale;
+
+  // Clamp to valid range
+  distortedUV = clamp(distortedUV, vec2<f32>(0.0, 0.0), vec2<f32>(1.0, 1.0));
+
+  if (u.chromaSplit > 0.001) {
+    let splitDir = normalize(dir + vec2<f32>(0.0001, 0.0001)) * u.chromaSplit * 0.01;
+    let r = textureSample(colorTex, samp, distortedUV + splitDir).r;
+    let g = textureSample(colorTex, samp, distortedUV).g;
+    let b = textureSample(colorTex, samp, distortedUV - splitDir).b;
+    return vec4<f32>(r, g, b, 1.0);
+  }
+
+  let color = textureSample(colorTex, samp, distortedUV).rgb;
+  return vec4<f32>(color, 1.0);
+}

package/dist/libraries/postfx/src/shaders/post-process/lens-flare.wgsl

@@ -0,0 +1,68 @@
+// wgsl-validate: prelude ./fullscreen-vs.wgsl
+// wgsl-validate: prelude ./occluder-chunk.wgsl
+// Lens flare — ghost chain + halo + anamorphic streak + bright spot.
+struct U {
+  lightScreenPos: vec2<f32>,
+  intensity: f32,
+  threshold: f32,
+  ghostCount: f32,
+  ghostSpacing: f32,
+  haloWidth: f32,
+  starSamples: f32,
+  _p0: f32,
+  tint: vec3<f32>,
+  _p1: f32,
+};
+@group(0) @binding(0) var colorTex: texture_2d<f32>;
+@group(0) @binding(1) var depthTex: texture_depth_2d;
+@group(0) @binding(2) var samp: sampler;
+@group(0) @binding(3) var<uniform> u: U;
+
+@fragment
+fn fs_main(input: VertexOutput) -> @location(0) vec4<f32> {
+  if (isOccluded(input.uv)) { discard; }
+  let uv = input.uv;
+  let center = vec2<f32>(0.5, 0.5);
+  let lightPos = u.lightScreenPos;
+  let dir = lightPos - center;
+  let dist = length(dir);
+  let ndir = dir / max(dist, 0.0001);
+
+  let color = textureSample(colorTex, samp, uv).rgb;
+  var flare = vec3<f32>(0.0);
+
+  let ghostCount = u32(u.ghostCount);
+  for (var i = 0u; i < 16u; i = i + 1u) {
+    if (i >= ghostCount) { break; }
+    let t = (f32(i) + 1.0) * u.ghostSpacing;
+    let ghostPos = lightPos - ndir * dist * t;
+    let ghostDist = length(uv - ghostPos);
+    let falloff = 1.0 / (1.0 + ghostDist * ghostDist * 200.0);
+    let scale = 1.0 - f32(i) / f32(ghostCount);
+    let ghostColor = textureSampleLevel(colorTex, samp, ghostPos, 0.0).rgb;
+    flare += ghostColor * falloff * scale * u.intensity * u.tint;
+  }
+
+  let haloAxis = lightPos - center;
+  let haloDist = length(uv - center - haloAxis * 0.5);
+  let haloRadius = length(haloAxis) * 0.5;
+  let haloRing = abs(haloDist - haloRadius);
+  let haloFalloff = 1.0 / (1.0 + haloRing * haloRing * 100.0 / u.haloWidth);
+  flare += u.tint * haloFalloff * u.intensity * 0.5;
+
+  let toLight = lightPos - uv;
+  let horizDist = abs(toLight.x);
+  let vertDist = abs(toLight.y);
+  let streakFalloff = 1.0 / (1.0 + horizDist * horizDist * 50.0) * (1.0 / (1.0 + vertDist * vertDist * 500.0));
+  flare += u.tint * streakFalloff * u.intensity * 0.3;
+
+  let lightDist = length(uv - lightPos);
+  let lightFalloff = 1.0 / (1.0 + lightDist * lightDist * 300.0);
+  let lightColor = textureSampleLevel(colorTex, samp, lightPos, 0.0).rgb;
+  let luma = dot(lightColor, vec3<f32>(0.299, 0.587, 0.114));
+  if (luma > u.threshold) {
+    flare += lightColor * lightFalloff * u.intensity;
+  }
+
+  return vec4<f32>(color + flare, 1.0);
+}

package/dist/libraries/postfx/src/shaders/post-process/lut.wgsl

@@ -0,0 +1,30 @@
+// wgsl-validate: prelude ./fullscreen-vs.wgsl
+// wgsl-validate: prelude ./occluder-chunk.wgsl
+// LUT — 3D LUT color grading. Samples a 3D lookup table to apply color grading.
+// Replaces the standalone frame-graph LUT3DPass with an in-chain effect.
+// Uses a dedicated bind group layout with texture_3d (not the shared ccLayout).
+struct U {
+  enabled: f32,
+  lutSize: f32,
+  _p0: f32,
+  _p1: f32,
+};
+@group(0) @binding(0) var colorTex: texture_2d<f32>;
+@group(0) @binding(1) var lutTex: texture_3d<f32>;
+@group(0) @binding(2) var samp: sampler;
+@group(0) @binding(3) var<uniform> u: U;
+
+@fragment
+fn fs_main(input: VertexOutput) -> @location(0) vec4<f32> {
+  if (isOccluded(input.uv)) { discard; }
+  let uv = input.uv;
+  var color = textureSample(colorTex, samp, uv).rgb;
+
+  if (u.enabled > 0.5) {
+    let lutSize = u.lutSize;
+    // Map [0,1] color to LUT 3D coordinates with proper boundary handling
+    let lutCoord = color * ((lutSize - 1.0) / lutSize) + 0.5 / lutSize;
+    color = textureSample(lutTex, samp, lutCoord).rgb;
+  }
+  return vec4<f32>(color, 1.0);
+}

package/dist/libraries/postfx/src/shaders/post-process/motion-blur.wgsl

@@ -0,0 +1,55 @@
+// wgsl-validate: prelude ./fullscreen-vs.wgsl
+// wgsl-validate: prelude ./occluder-chunk.wgsl
+// Motion blur — velocity-based, with depth-aware weighting.
+struct U {
+  texelSize: vec2<f32>,
+  intensity: f32,
+  maxSamples: f32,
+  _p0: f32,
+  _p1: f32,
+  _p2: f32,
+  _p3: f32,
+  _p4: f32,
+};
+@group(0) @binding(0) var colorTex: texture_2d<f32>;
+@group(0) @binding(1) var velocityTex: texture_2d<f32>;
+@group(0) @binding(2) var depthTex: texture_depth_2d;
+@group(0) @binding(3) var samp: sampler;
+@group(0) @binding(4) var<uniform> u: U;
+
+@fragment
+fn fs_main(input: VertexOutput) -> @location(0) vec4<f32> {
+  if (isOccluded(input.uv)) { discard; }
+  let uv = input.uv;
+  // All textureSample calls must be in uniform control flow (before any branching).
+  let velocity = textureSample(velocityTex, samp, uv).xy;
+  let baseColor = textureSample(colorTex, samp, uv);
+  let depth = textureSample(depthTex, samp, uv);
+  let speed = length(velocity);
+
+  if (speed < 0.001) { return baseColor; }
+
+  let maxSamples = u32(u.maxSamples);
+  let maxSamplesF = u.maxSamples;
+  let clampedVelocity = velocity * u.intensity;
+  let dims = textureDimensions(depthTex);
+  let colorDims = textureDimensions(colorTex);
+
+  var color = vec3<f32>(0.0);
+  var totalWeight = 0.0;
+
+  for (var i = 0u; i < 32u; i = i + 1u) {
+    if (i >= maxSamples) { break; }
+    let t = (f32(i) + 0.5) / maxSamplesF - 0.5;
+    let sampleUV = uv + clampedVelocity * t;
+    // Use textureLoad (works in non-uniform control flow) instead of textureSample.
+    let dcoords = vec2<u32>(clamp(vec2<i32>(i32(sampleUV.x * f32(dims.x)), i32(sampleUV.y * f32(dims.y))), vec2<i32>(0, 0), vec2<i32>(i32(dims.x) - 1, i32(dims.y) - 1)));
+    let sampleDepth = textureLoad(depthTex, dcoords, 0);
+    let weight = select(0.1, 1.0, abs(sampleDepth - depth) < 0.1);
+    let ccoords = vec2<u32>(clamp(vec2<i32>(i32(sampleUV.x * f32(colorDims.x)), i32(sampleUV.y * f32(colorDims.y))), vec2<i32>(0, 0), vec2<i32>(i32(colorDims.x) - 1, i32(colorDims.y) - 1)));
+    color += textureLoad(colorTex, ccoords, 0).rgb * weight;
+    totalWeight += weight;
+  }
+
+  return vec4<f32>(color / max(totalWeight, 1.0), 1.0);
+}

package/dist/libraries/postfx/src/shaders/post-process/occluder-chunk.wgsl

@@ -0,0 +1,28 @@
+// Occluder chunk — prepended to all postfx fragment shaders by makePipeline().
+// Provides the OccluderUniform struct, a group(1) binding, and an isOccluded()
+// test. Each shader's fs_main calls `if (isOccluded(input.uv)) { discard; }`
+// at the top to skip work under opaque UI panels (the pixi-ui overlay composites
+// on top of the game canvas, so the game's output under an opaque panel is
+// never seen by the user).
+//
+// Rects are in UV space (0-1, top-left origin matching fullscreen-vs.wgsl).
+// Up to 8 rects supported; count=0 disables occlusion (isOccluded always false).
+struct OccluderUniform {
+  count: f32,
+  _p0: f32,
+  _p1: f32,
+  _p2: f32,
+  rects: array<vec4<f32>, 8>,  // x, y, w, h in UV space (0-1)
+};
+@group(1) @binding(0) var<uniform> occluders: OccluderUniform;
+
+fn isOccluded(uv: vec2<f32>) -> bool {
+  for (var i = 0u; i < 8u; i = i + 1u) {
+    if (f32(i) >= occluders.count) { break; }
+    let r = occluders.rects[i];
+    if (uv.x >= r.x && uv.x <= r.x + r.z && uv.y >= r.y && uv.y <= r.y + r.w) {
+      return true;
+    }
+  }
+  return false;
+}

package/dist/libraries/postfx/src/shaders/post-process/outline.wgsl

@@ -0,0 +1,51 @@
+// wgsl-validate: prelude ./fullscreen-vs.wgsl
+// wgsl-validate: prelude ./occluder-chunk.wgsl
+// Outline — detect mask boundary and draw edge ring outside the mask.
+struct U {
+  texelSize: vec2<f32>,
+  outlineWidth: f32,
+  opacity: f32,
+  _p0: f32,
+  outlineColor: vec3<f32>,
+  _p1: f32,
+  _p2: f32,
+};
+@group(0) @binding(0) var colorTex: texture_2d<f32>;
+@group(0) @binding(1) var maskTex: texture_2d<f32>;
+@group(0) @binding(2) var samp: sampler;
+@group(0) @binding(3) var<uniform> u: U;
+
+@fragment
+fn fs_main(input: VertexOutput) -> @location(0) vec4<f32> {
+  if (isOccluded(input.uv)) { discard; }
+  let uv = input.uv;
+  let texel = u.texelSize;
+  let w = u.outlineWidth;
+  let color = textureSample(colorTex, samp, uv).rgb;
+
+  let center = textureSample(maskTex, samp, uv).r;
+
+  // DEBUG: visualize mask — red where selected, normal color where not
+  if (center > 0.5) {
+    return vec4<f32>(1.0, 0.0, 0.0, 1.0);
+  }
+
+  let offsets = array<vec2<f32>, 8>(
+    vec2<f32>(-1.0, -1.0), vec2<f32>( 1.0, -1.0),
+    vec2<f32>(-1.0,  1.0), vec2<f32>( 1.0,  1.0),
+    vec2<f32>(-1.0,  0.0), vec2<f32>( 1.0,  0.0),
+    vec2<f32>( 0.0, -1.0), vec2<f32>( 0.0,  1.0),
+  );
+
+  let dims = textureDimensions(maskTex);
+  var edge = 0.0;
+  for (var i = 0u; i < 8u; i = i + 1u) {
+    let sampleUV = uv + offsets[i] * texel * w;
+    let icoords = vec2<u32>(clamp(vec2<i32>(i32(sampleUV.x * f32(dims.x)), i32(sampleUV.y * f32(dims.y))), vec2<i32>(0, 0), vec2<i32>(i32(dims.x) - 1, i32(dims.y) - 1)));
+    let s = textureLoad(maskTex, icoords, 0).r;
+    edge = max(edge, abs(center - s));
+  }
+
+  let outline = clamp(edge * (1.0 - center) * u.opacity, 0.0, 1.0);
+  return vec4<f32>(mix(color, u.outlineColor, outline), 1.0);
+}