@downdraft/engine 0.0.0 → 0.1.0

package/libraries/postfx/src/shaders/post-process/afterimage.wgsl

@@ -0,0 +1,14 @@
+// wgsl-validate: prelude ./fullscreen-vs.wgsl
+// wgsl-validate: prelude ./occluder-chunk.wgsl
+struct U { texelSize: vec2<f32>, damp: 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 prevTex: 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 cur = textureSample(colorTex, samp, input.uv);
+  let prev = textureSample(prevTex, samp, input.uv);
+  return mix(cur, prev, u.damp);
+}

package/libraries/postfx/src/shaders/post-process/ascii.wgsl

@@ -0,0 +1,24 @@
+// wgsl-validate: prelude ./fullscreen-vs.wgsl
+// wgsl-validate: prelude ./occluder-chunk.wgsl
+struct U { texelSize: vec2<f32>, cellSize: f32, useColor: f32, screenW: f32, screenH: f32, _p0: f32, _p1: f32, _p2: f32, };
+@group(0) @binding(0) var colorTex: texture_2d<f32>;
+@group(0) @binding(1) var glyphTex: texture_2d<f32>;
+@group(0) @binding(2) var samp: sampler;
+@group(0) @binding(3) var<uniform> u: U;
+const NUM_GLYPHS = 10.0;
+@fragment
+fn fs_main(input: VertexOutput) -> @location(0) vec4<f32> {
+  if (isOccluded(input.uv)) { discard; }
+  let screen = vec2(u.screenW, u.screenH);
+  let cellPx = u.cellSize;
+  let cellCoord = floor(input.uv * screen / cellPx);
+  let cellCenter = (cellCoord + vec2(0.5)) * cellPx / screen;
+  let color = textureSample(colorTex, samp, cellCenter);
+  let l = lum(color.rgb);
+  let charIdx = clamp(floor(l * (NUM_GLYPHS - 1.0)), 0.0, NUM_GLYPHS - 1.0);
+  let local = fract(input.uv * screen / cellPx);
+  let glyphUV = vec2((charIdx + local.x) / NUM_GLYPHS, local.y);
+  let glyph = textureSample(glyphTex, samp, glyphUV).r;
+  let outColor = mix(vec3(0.0, 1.0, 0.0), color.rgb, u.useColor);
+  return vec4(outColor * glyph, 1.0);
+}

package/libraries/postfx/src/shaders/post-process/blit.wgsl

@@ -0,0 +1,12 @@
+// 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;
+@fragment
+fn fs_main(input: VertexOutput) -> @location(0) vec4<f32> {
+  if (isOccluded(input.uv)) { discard; }
+  return textureSample(colorTex, samp, input.uv);
+}

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

@@ -0,0 +1,21 @@
+// wgsl-validate: prelude ./fullscreen-vs.wgsl
+// wgsl-validate: prelude ./occluder-chunk.wgsl
+struct U { texelSize: vec2<f32>, dirX: f32, dirY: 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 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;
+  var sum = textureSample(colorTex, samp, uv).rgb * 0.227027;
+  sum += textureSample(colorTex, samp, uv + dir * 1.0).rgb * 0.1945946;
+  sum += textureSample(colorTex, samp, uv - dir * 1.0).rgb * 0.1945946;
+  sum += textureSample(colorTex, samp, uv + dir * 2.0).rgb * 0.1216216;
+  sum += textureSample(colorTex, samp, uv - dir * 2.0).rgb * 0.1216216;
+  sum += textureSample(colorTex, samp, uv + dir * 3.0).rgb * 0.0675676;
+  sum += textureSample(colorTex, samp, uv - dir * 3.0).rgb * 0.0675676;
+  return vec4(sum, 1.0);
+}

package/libraries/postfx/src/shaders/post-process/bloom-bright.wgsl

@@ -0,0 +1,15 @@
+// wgsl-validate: prelude ./fullscreen-vs.wgsl
+// wgsl-validate: prelude ./occluder-chunk.wgsl
+struct U { texelSize: vec2<f32>, threshold: 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 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 c = textureSample(colorTex, samp, input.uv);
+  let l = lum(c.rgb);
+  if (l > u.threshold) { return c; }
+  return vec4(0.0);
+}

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

@@ -0,0 +1,14 @@
+// wgsl-validate: prelude ./fullscreen-vs.wgsl
+// wgsl-validate: prelude ./occluder-chunk.wgsl
+struct U { texelSize: vec2<f32>, strength: 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 brightTex: 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 c = textureSample(colorTex, samp, input.uv);
+  let b = textureSample(brightTex, samp, input.uv);
+  return vec4(c.rgb + b.rgb * u.strength, c.a);
+}

package/libraries/postfx/src/shaders/post-process/bloom-downsample.wgsl

@@ -0,0 +1,60 @@
+// wgsl-validate: prelude ./fullscreen-vs.wgsl
+// wgsl-validate: prelude ./occluder-chunk.wgsl
+// Bloom downsample — high-quality 13-tap downsample with optional bright-pass.
+// When u.brightPass > 0.5, applies soft-threshold bright extraction (first level).
+// Otherwise, performs a plain downsample for subsequent MIP levels.
+struct U {
+  texelSize: vec2<f32>,   // 1/srcW, 1/srcH (source resolution)
+  brightPass: f32,        // 1.0 = extract bright, 0.0 = plain downsample
+  threshold: f32,
+  softThreshold: 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 softThreshold(color: vec3<f32>) -> vec3<f32> {
+  let luma = dot(color, vec3<f32>(0.299, 0.587, 0.114));
+  let knee = u.threshold * u.softThreshold + 0.00001;
+  let softFactor = clamp(luma - u.threshold + knee, 0.0, 2.0 * knee);
+  let contribution = softFactor * softFactor / (4.0 * knee + 0.00001) + u.threshold - knee;
+  let scale = max(contribution / max(luma, 0.00001), 0.0);
+  return color * scale;
+}
+
+@fragment
+fn fs_main(input: VertexOutput) -> @location(0) vec4<f32> {
+  if (isOccluded(input.uv)) { discard; }
+  let uv = input.uv;
+  let ts = u.texelSize;
+
+  // 13-tap downsample filter (from UE4 "Next Generation Post Processing" approach).
+  // Samples a 3x3 + cross pattern for anti-aliased downsample.
+  let a = textureSample(colorTex, samp, uv + vec2<f32>(-1.0, -1.0) * ts).rgb;
+  let b = textureSample(colorTex, samp, uv + vec2<f32>( 0.0, -1.0) * ts).rgb;
+  let c = textureSample(colorTex, samp, uv + vec2<f32>( 1.0, -1.0) * ts).rgb;
+  let d = textureSample(colorTex, samp, uv + vec2<f32>(-0.5, -0.5) * ts).rgb;
+  let e = textureSample(colorTex, samp, uv + vec2<f32>( 0.5, -0.5) * ts).rgb;
+  let f = textureSample(colorTex, samp, uv + vec2<f32>(-1.0,  0.0) * ts).rgb;
+  let g = textureSample(colorTex, samp, uv).rgb;
+  let h = textureSample(colorTex, samp, uv + vec2<f32>( 1.0,  0.0) * ts).rgb;
+  let i = textureSample(colorTex, samp, uv + vec2<f32>(-0.5,  0.5) * ts).rgb;
+  let j = textureSample(colorTex, samp, uv + vec2<f32>( 0.5,  0.5) * ts).rgb;
+  let k = textureSample(colorTex, samp, uv + vec2<f32>(-1.0,  1.0) * ts).rgb;
+  let l = textureSample(colorTex, samp, uv + vec2<f32>( 0.0,  1.0) * ts).rgb;
+  let m = textureSample(colorTex, samp, uv + vec2<f32>( 1.0,  1.0) * ts).rgb;
+
+  // Weighted group downsample (2 groups of 6+1 for balanced anti-aliasing)
+  let group1 = (a + c + f + h + k + m) * 0.2;
+  let group2 = (b + d + e + g + i + j + l) * 0.18;
+  var color = group1 + group2 + g * 0.15;
+
+  if (u.brightPass > 0.5) {
+    color = softThreshold(color);
+  }
+  return vec4<f32>(color, 1.0);
+}

package/libraries/postfx/src/shaders/post-process/bloom-soft.wgsl

@@ -0,0 +1,46 @@
+// wgsl-validate: prelude ./fullscreen-vs.wgsl
+// wgsl-validate: prelude ./occluder-chunk.wgsl
+// Bloom (soft threshold) — bright pass with soft knee + separable blur.
+// When u.dirX > 1.0, performs the bright-pass extraction step.
+// Otherwise, performs a directional blur pass.
+struct U {
+  texelSize: vec2<f32>,
+  dirX: f32,
+  dirY: f32,
+  threshold: f32,
+  softThreshold: 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<f32>(u.dirX, u.dirY);
+
+  if (u.dirX > 1.0) {
+    let c = textureSample(colorTex, samp, uv).rgb;
+    let luma = dot(c, vec3<f32>(0.299, 0.587, 0.114));
+    let knee = u.threshold * u.softThreshold + 0.00001;
+    let softFactor = clamp(luma - u.threshold + knee, 0.0, 2.0 * knee);
+    let contribution = softFactor * softFactor / (4.0 * knee + 0.00001) + u.threshold - knee;
+    let scale = max(contribution / max(luma, 0.00001), 0.0);
+    return vec4<f32>(c * scale, 1.0);
+  }
+
+  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);
+  var color = textureSample(colorTex, samp, uv).rgb * weights[0];
+  for (var i = 1u; i < 5u; i = i + 1u) {
+    let offset = dir * offsets[i] * u.texelSize;
+    color += textureSample(colorTex, samp, uv + offset).rgb * weights[i];
+    color += textureSample(colorTex, samp, uv - offset).rgb * weights[i];
+  }
+  return vec4<f32>(color, 1.0);
+}

package/libraries/postfx/src/shaders/post-process/bloom-upsample.wgsl

@@ -0,0 +1,51 @@
+// wgsl-validate: prelude ./fullscreen-vs.wgsl
+// wgsl-validate: prelude ./occluder-chunk.wgsl
+// Bloom upsample — 9-tap bilinear-weighted upsample with additive blend + tint.
+// Reads a lower-resolution MIP and adds it to the higher-res target with weight.
+// Used in the upsample cascade: ⅛ → ¼ → ½ → full.
+struct U {
+  texelSize: vec2<f32>,   // 1/srcW, 1/srcH (source = lower-res MIP)
+  weight: f32,            // blend weight for this MIP level
+  _p0: f32,
+  tintR: f32,
+  tintG: f32,
+  tintB: f32,
+  _p1: f32,
+  _p2: f32,
+};
+@group(0) @binding(0) var colorTex: texture_2d<f32>;  // lower-res MIP
+@group(0) @binding(1) var baseTex: texture_2d<f32>;   // higher-res target (for additive read)
+@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 ts = u.texelSize;
+
+  // 9-tap tent filter for smooth upsample
+  let weights = array<f32, 9>(
+    0.0625, 0.125, 0.0625,
+    0.125,  0.25,  0.125,
+    0.0625, 0.125, 0.0625,
+  );
+  let offsets = array<vec2<f32>, 9>(
+    vec2<f32>(-1.0, -1.0), vec2<f32>( 0.0, -1.0), vec2<f32>( 1.0, -1.0),
+    vec2<f32>(-1.0,  0.0), vec2<f32>( 0.0,  0.0), vec2<f32>( 1.0,  0.0),
+    vec2<f32>(-1.0,  1.0), vec2<f32>( 0.0,  1.0), vec2<f32>( 1.0,  1.0),
+  );
+
+  var upsampled = vec3<f32>(0.0);
+  for (var i = 0u; i < 9u; i = i + 1u) {
+    upsampled += textureSample(colorTex, samp, uv + offsets[i] * ts).rgb * weights[i];
+  }
+
+  // Apply tint + weight
+  let tint = vec3<f32>(u.tintR, u.tintG, u.tintB);
+  let bloom = upsampled * tint * u.weight;
+
+  // Additive blend with base (higher-res MIP or original scene)
+  let base = textureSample(baseTex, samp, uv).rgb;
+  return vec4<f32>(base + bloom, 1.0);
+}

package/libraries/postfx/src/shaders/post-process/channel-mixer.wgsl

@@ -0,0 +1,36 @@
+// wgsl-validate: prelude ./fullscreen-vs.wgsl
+// wgsl-validate: prelude ./occluder-chunk.wgsl
+// Channel mixer — per-channel R/G/B output weights + monochrome toggle.
+// Allows remapping color channels: output.R = wRR*R + wRG*G + wRB*B, etc.
+struct U {
+  wRR: f32, wRG: f32, wRB: f32,  // red output weights
+  wGR: f32, wGG: f32, wGB: f32,  // green output weights
+  wBR: f32, wBG: f32, wBB: f32,  // blue output weights
+  monochrome: f32,  // 1.0 = output as grayscale
+  _p0: f32,
+  _p1: f32,
+  _p2: f32,
+  _p3: 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 c = textureSample(colorTex, samp, uv).rgb;
+
+  var outR = u.wRR * c.r + u.wRG * c.g + u.wRB * c.b;
+  var outG = u.wGR * c.r + u.wGG * c.g + u.wGB * c.b;
+  var outB = u.wBR * c.r + u.wBG * c.g + u.wBB * c.b;
+
+  if (u.monochrome > 0.5) {
+    let luma = outR * 0.299 + outG * 0.587 + outB * 0.114;
+    outR = luma; outG = luma; outB = luma;
+  }
+
+  return vec4<f32>(vec3<f32>(outR, outG, outB), 1.0);
+}

package/libraries/postfx/src/shaders/post-process/chromatic-aberration.wgsl

@@ -0,0 +1,37 @@
+// wgsl-validate: prelude ./fullscreen-vs.wgsl
+// wgsl-validate: prelude ./occluder-chunk.wgsl
+// Chromatic aberration — radial RGB channel shift with falloff from center.
+// Simulates lens chromatic aberration by offsetting R and B channels radially.
+struct U {
+  texelSize: vec2<f32>,
+  intensity: f32,      // overall strength (0–1)
+  start: f32,          // radial falloff start (0–1, normalized distance from center)
+  end: f32,            // radial falloff end (0–1)
+  centerX: f32,        // lens center offset X (0–1, 0.5 = center)
+  centerY: f32,        // lens center offset Y (0–1, 0.5 = center)
+  _p0: 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>(u.centerX, u.centerY);
+  let dir = uv - center;
+  let dist = length(dir);
+  // Radial falloff: no aberration near center, full at edges
+  let falloff = smoothstep(u.start, u.end, dist);
+  let strength = u.intensity * falloff;
+  let offset = normalize(dir) * strength;
+
+  // Sample R and B at offset positions, G at center
+  let r = textureSample(colorTex, samp, uv + offset).r;
+  let g = textureSample(colorTex, samp, uv).g;
+  let b = textureSample(colorTex, samp, uv - offset).b;
+
+  return vec4<f32>(r, g, b, 1.0);
+}

package/libraries/postfx/src/shaders/post-process/dithering.wgsl

@@ -0,0 +1,64 @@
+// wgsl-validate: prelude ./fullscreen-vs.wgsl
+// wgsl-validate: prelude ./occluder-chunk.wgsl
+// Dithering — ordered (Bayer) + blue-noise modes to reduce color banding.
+// Applies a dithering pattern before quantization to break up smooth gradients.
+struct U {
+  texelSize: vec2<f32>,
+  mode: f32,         // 0 = off, 1 = Bayer 4x4, 2 = blue-noise
+  strength: f32,     // dithering intensity (0–1)
+  levels: f32,       // color quantization levels (0 = no quantization, e.g. 32)
+  _p0: f32,
+  _p1: f32,
+  _p2: f32,
+};
+@group(0) @binding(0) var colorTex: texture_2d<f32>;
+@group(0) @binding(1) var noiseTex: texture_2d<f32>;
+@group(0) @binding(2) var samp: sampler;
+@group(0) @binding(3) var<uniform> u: U;
+
+// 4x4 Bayer matrix (threshold values 0–15, normalized to 0–1)
+fn bayer4(x: u32, y: u32) -> f32 {
+  let m = array<u32, 16>(
+     0u,  8u,  2u, 10u,
+    12u,  4u, 14u,  6u,
+     3u, 11u,  1u,  9u,
+    15u,  7u, 13u,  5u,
+  );
+  return f32(m[(y % 4u) * 4u + (x % 4u)]) / 16.0;
+}
+
+@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.mode < 0.5) {
+    return vec4<f32>(color, 1.0);
+  }
+
+  let dims = vec2<f32>(1.0 / u.texelSize.x, 1.0 / u.texelSize.y);
+  let pixelPos = vec2<u32>(u32(i32(uv.x * dims.x)), u32(i32(uv.y * dims.y)));
+
+  var dither: f32;
+  if (u.mode < 1.5) {
+    // Bayer 4x4
+    dither = bayer4(pixelPos.x, pixelPos.y) - 0.5;
+  } else {
+    // Blue noise
+    let noiseUV = uv * dims / 128.0;  // tile noise texture
+    dither = textureSample(noiseTex, samp, noiseUV).r - 0.5;
+  }
+
+  // Apply dithering: add noise before quantization
+  let dithered = color + dither * u.strength * (1.0 / max(u.levels, 1.0));
+
+  if (u.levels > 0.5) {
+    // Quantize to N levels per channel
+    let q = u.levels;
+    let quantized = floor(dithered * q + 0.5) / q;
+    return vec4<f32>(clamp(quantized, vec3<f32>(0.0), vec3<f32>(1.0)), 1.0);
+  }
+
+  return vec4<f32>(clamp(dithered, vec3<f32>(0.0), vec3<f32>(1.0)), 1.0);
+}

package/libraries/postfx/src/shaders/post-process/dof.wgsl

@@ -0,0 +1,131 @@
+// wgsl-validate: prelude ./fullscreen-vs.wgsl
+// wgsl-validate: prelude ./occluder-chunk.wgsl
+// DOF — depth-of-field with circle-of-confusion + bokeh-shaped disk sampling.
+// Computes CoC from depth, then gathers a rotated disk kernel with shape
+// support (circle / hexagon / octagon) and near/far field separation.
+struct U {
+  texelSize: vec2<f32>,
+  focusDist: f32,
+  focusRange: f32,
+  maxBlur: f32,
+  bokehShape: f32,   // 0 = circle, 1 = hexagon, 2 = octagon
+  sampleCount: f32,  // kernel sample count (max 48)
+  nearOnly: f32,     // 1.0 = blur only near field, 0.0 = blur both
+  farOnly: f32,      // 1.0 = blur only far field, 0.0 = blur both
+  bladeRotation: 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 depthTex: texture_depth_2d;
+@group(0) @binding(2) var samp: sampler;
+@group(0) @binding(3) var<uniform> u: U;
+
+// Golden-angle spiral disk sampling — well-distributed kernel points.
+// Returns offset direction (unit) for sample index i of N.
+fn diskSample(i: u32, n: f32) -> vec2<f32> {
+  let goldenAngle = 2.39996323;
+  let r = sqrt((f32(i) + 0.5) / n);
+  let theta = f32(i) * goldenAngle + u.bladeRotation;
+  return vec2<f32>(cos(theta), sin(theta)) * r;
+}
+
+// Shape mask: modifies sample weight based on bokeh shape.
+fn shapeMask(dir: vec2<f32>) -> f32 {
+  if (u.bokehShape < 0.5) {
+    // Circle — no modification
+    return 1.0;
+  } else if (u.bokehShape < 1.5) {
+    // Hexagon — clip to hexagonal aperture
+    let a = atan2(dir.y, dir.x);
+    let hex = abs(cos(a)) * 0.5 + abs(cos(a + 1.0471976)) * 0.5 + abs(cos(a - 1.0471976)) * 0.5;
+    return smoothstep(0.45, 0.5, hex);
+  } else {
+    // Octagon — clip to octagonal aperture
+    let a = atan2(dir.y, dir.x);
+    let oct = abs(cos(a)) * 0.5 + abs(cos(a + 0.7853982)) * 0.5 + abs(cos(a - 0.7853982)) * 0.5;
+    return smoothstep(0.42, 0.5, oct);
+  }
+}
+
+fn computeCoC(depth: f32) -> f32 {
+  // CoC: 0 at focus distance, grows linearly outside focus range, clamped to maxBlur.
+  let diff = depth - u.focusDist;
+  let coc = clamp(abs(diff) / u.focusRange, 0.0, 1.0) * u.maxBlur;
+  // Sign: positive = far field, negative = near field
+  return select(-coc, coc, diff > 0.0);
+}
+
+@fragment
+fn fs_main(input: VertexOutput) -> @location(0) vec4<f32> {
+  if (isOccluded(input.uv)) { discard; }
+  let uv = input.uv;
+  let depth = textureSample(depthTex, samp, uv);
+  let sharp = textureSample(colorTex, samp, uv);
+  let centerCoC = computeCoC(depth);
+
+  // If CoC is negligible, return the sharp pixel directly
+  if (abs(centerCoC) < 0.01) {
+    return vec4<f32>(sharp.rgb, 1.0);
+  }
+
+  let n = u32(clamp(u.sampleCount, 4.0, 48.0));
+  let nF = f32(n);
+  let cocAbs = abs(centerCoC);
+  let isNear = centerCoC < 0.0;
+
+  // Field filtering
+  if (u.nearOnly > 0.5 && !isNear) {
+    return vec4<f32>(sharp.rgb, 1.0);
+  }
+  if (u.farOnly > 0.5 && isNear) {
+    return vec4<f32>(sharp.rgb, 1.0);
+  }
+
+  var color = vec3<f32>(0.0);
+  var totalWeight = 0.0;
+  let dims = textureDimensions(colorTex);
+
+  for (var i = 0u; i < 48u; i = i + 1u) {
+    if (i >= n) { break; }
+    let dir = diskSample(i, nF);
+    let sampleOff = dir * cocAbs * u.texelSize;
+    let sampleUV = uv + sampleOff;
+
+    // Bounds check + textureLoad for non-uniform flow
+    let coords = 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 sampleColor = textureLoad(colorTex, coords, 0).rgb;
+
+    // Sample CoC — use the larger of center and sample CoC for near field
+    // (near field objects should bleed over far field)
+    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 sampleCoC = computeCoC(sampleDepth);
+    let effectiveCoC = select(abs(sampleCoC), max(cocAbs, abs(sampleCoC)), isNear);
+
+    // Weight by shape mask + CoC influence
+    let shapeW = shapeMask(dir);
+    let cocW = smoothstep(0.0, 1.0, effectiveCoC / u.maxBlur);
+    let weight = shapeW * cocW;
+    color += sampleColor * weight;
+    totalWeight += weight;
+  }
+
+  let blurred = color / max(totalWeight, 0.0001);
+  // Blend sharp → blurred based on CoC magnitude
+  let blend = clamp(cocAbs / u.maxBlur, 0.0, 1.0);
+  let result = mix(sharp.rgb, blurred, blend);
+  return vec4<f32>(result, 1.0);
+}

package/libraries/postfx/src/shaders/post-process/edges.wgsl

@@ -0,0 +1,45 @@
+// wgsl-validate: prelude ./fullscreen-vs.wgsl
+// wgsl-validate: prelude ./occluder-chunk.wgsl
+// Edges — normal + depth edge detection, composited via alpha blend.
+struct U {
+  texelSize: vec2<f32>,
+  threshold: f32,
+  opacity: f32,
+  _p0: f32,
+  edgeColor: vec3<f32>,
+  _p1: f32,
+  _p2: f32,
+};
+@group(0) @binding(0) var colorTex: texture_2d<f32>;
+@group(0) @binding(1) var normalTex: 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;
+
+fn decodeNormal(rgb: vec3<f32>) -> vec3<f32> {
+  return normalize(rgb * 2.0 - 1.0);
+}
+
+@fragment
+fn fs_main(input: VertexOutput) -> @location(0) vec4<f32> {
+  if (isOccluded(input.uv)) { discard; }
+  let uv = input.uv;
+  let texel = u.texelSize;
+  let color = textureSample(colorTex, samp, uv).rgb;
+
+  let nCenter = decodeNormal(textureSample(normalTex, samp, uv).rgb);
+  let nRight  = decodeNormal(textureSample(normalTex, samp, uv + vec2<f32>( 1.0, 0.0) * texel).rgb);
+  let nUp     = decodeNormal(textureSample(normalTex, samp, uv + vec2<f32>( 0.0, 1.0) * texel).rgb);
+
+  let dCenter = textureSample(depthTex, samp, uv);
+  let dRight  = textureSample(depthTex, samp, uv + vec2<f32>( 1.0, 0.0) * texel);
+  let dUp     = textureSample(depthTex, samp, uv + vec2<f32>( 0.0, 1.0) * texel);
+
+  let normalEdge = max(1.0 - dot(nCenter, nRight), 1.0 - dot(nCenter, nUp));
+  let depthEdge = max(abs(dCenter - dRight), abs(dCenter - dUp));
+
+  let edge = clamp(max(normalEdge, depthEdge * 100.0) / u.threshold, 0.0, 1.0);
+  let edgeColor = u.edgeColor * edge * u.opacity;
+  let alpha = edge * u.opacity;
+  return vec4<f32>(mix(color, edgeColor, alpha), 1.0);
+}

package/libraries/postfx/src/shaders/post-process/fullscreen-vs.wgsl

@@ -0,0 +1,15 @@
+struct VertexOutput {
+  @builtin(position) clipPos: vec4<f32>,
+  @location(0) uv: vec2<f32>,
+};
+@vertex
+fn vs_main(@builtin(vertex_index) vi: u32) -> VertexOutput {
+  var p = array<vec2<f32>, 3>(
+    vec2(-1.0, -1.0), vec2(3.0, -1.0), vec2(-1.0, 3.0),
+  );
+  var o: VertexOutput;
+  o.clipPos = vec4(p[vi], 0.0, 1.0);
+  o.uv = vec2(p[vi].x * 0.5 + 0.5, 0.5 - p[vi].y * 0.5);
+  return o;
+}
+fn lum(c: vec3<f32>) -> f32 { return dot(c, vec3(0.299, 0.587, 0.114)); }