@downdraft/engine 0.1.1 → 0.2.0

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

@@ -0,0 +1,47 @@
+// wgsl-validate: prelude ./fullscreen-vs.wgsl
+// wgsl-validate: prelude ./occluder-chunk.wgsl
+// Pixelation — blocky low-res look via nearest-neighbor UV quantization
+// + depth edge detection. Samples color and depth at quantized UVs to
+// emulate rendering at reduced resolution without a separate low-res target.
+struct U {
+  texelSize: vec2<f32>,
+  pixelSize: f32,
+  depthEdgeStrength: f32,
+  screenW: f32,
+  screenH: f32,
+  _p0: 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 screen = vec2(u.screenW, u.screenH);
+  let px = u.pixelSize;
+  let cellCoord = floor(input.uv * screen / px);
+  let cellCenter = (cellCoord + vec2(0.5)) * px / screen;
+
+  let texel = textureSample(colorTex, samp, cellCenter);
+  let depth = textureSample(depthTex, samp, cellCenter);
+
+  let texelStep = px / screen;
+  let depthR = textureSample(depthTex, samp, cellCenter + vec2(texelStep.x, 0.0));
+  let depthL = textureSample(depthTex, samp, cellCenter - vec2(texelStep.x, 0.0));
+  let depthU = textureSample(depthTex, samp, cellCenter + vec2(0.0, texelStep.y));
+  let depthD = textureSample(depthTex, samp, cellCenter - vec2(0.0, texelStep.y));
+
+  var diff = 0.0;
+  diff += clamp(depthR - depth, 0.0, 1.0);
+  diff += clamp(depthL - depth, 0.0, 1.0);
+  diff += clamp(depthU - depth, 0.0, 1.0);
+  diff += clamp(depthD - depth, 0.0, 1.0);
+
+  let dei = floor(smoothstep(0.01, 0.02, diff) * 2.0) / 2.0;
+  let strength = select(1.0, 1.0 - dei * u.depthEdgeStrength, dei > 0.0);
+
+  return vec4(texel.rgb * strength, texel.a);
+}

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

@@ -0,0 +1,32 @@
+// wgsl-validate: prelude ./fullscreen-vs.wgsl
+// wgsl-validate: prelude ./occluder-chunk.wgsl
+// Sharpen — unsharp mask (center + (center - blurred) * sharpness).
+struct U {
+  texelSize: vec2<f32>,
+  sharpness: 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 uv = input.uv;
+  let texel = u.texelSize;
+  let center = textureSample(colorTex, samp, uv).rgb;
+  let up    = textureSample(colorTex, samp, uv + vec2<f32>(0.0, -1.0) * texel).rgb;
+  let down  = textureSample(colorTex, samp, uv + vec2<f32>(0.0,  1.0) * texel).rgb;
+  let left  = textureSample(colorTex, samp, uv + vec2<f32>(-1.0, 0.0) * texel).rgb;
+  let right = textureSample(colorTex, samp, uv + vec2<f32>( 1.0, 0.0) * texel).rgb;
+  let blurred = (up + down + left + right) * 0.25;
+  let result = center + (center - blurred) * u.sharpness;
+  return vec4<f32>(result, 1.0);
+}

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

@@ -0,0 +1,26 @@
+// 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; }
+  let uv = input.uv; let t = u.texelSize;
+  let tl = lum(textureSample(colorTex, samp, uv + vec2(-t.x, -t.y)).rgb);
+  let tm = lum(textureSample(colorTex, samp, uv + vec2(0.0, -t.y)).rgb);
+  let tr = lum(textureSample(colorTex, samp, uv + vec2( t.x, -t.y)).rgb);
+  let ml = lum(textureSample(colorTex, samp, uv + vec2(-t.x, 0.0)).rgb);
+  let mr = lum(textureSample(colorTex, samp, uv + vec2( t.x, 0.0)).rgb);
+  let bl = lum(textureSample(colorTex, samp, uv + vec2(-t.x,  t.y)).rgb);
+  let bm = lum(textureSample(colorTex, samp, uv + vec2(0.0,  t.y)).rgb);
+  let br = lum(textureSample(colorTex, samp, uv + vec2( t.x,  t.y)).rgb);
+  let gx = -tl + tr - 2.0 * ml + 2.0 * mr - bl + br;
+  let gy = -tl - 2.0 * tm - tr + bl + 2.0 * bm + br;
+  let g = sqrt(gx * gx + gy * gy);
+  let edge = clamp(g, 0.0, 1.0);
+  let c = textureSample(colorTex, samp, uv);
+  return vec4(c.rgb * (1.0 - edge) + vec3(edge) * 0.5, c.a);
+}

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

@@ -0,0 +1,36 @@
+// wgsl-validate: prelude ./fullscreen-vs.wgsl
+// wgsl-validate: prelude ./occluder-chunk.wgsl
+// Split-tone — separate highlight and shadow tinting with balance control.
+// Applies different color tints to shadows and highlights, blended by luminance.
+struct U {
+  shadowR: f32, shadowG: f32, shadowB: f32,   // shadow tint color
+  highlightR: f32, highlightG: f32, highlightB: f32,  // highlight tint color
+  balance: f32,     // -1.0 = more shadows, 1.0 = more highlights, 0 = even
+  _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;
+
+@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;
+
+  let luma = dot(color, vec3<f32>(0.299, 0.587, 0.114));
+  // Weight: 0 at shadows, 1 at highlights, shifted by balance
+  let weight = smoothstep(0.0, 1.0, luma + u.balance * 0.5);
+
+  let shadowTint = vec3<f32>(u.shadowR, u.shadowG, u.shadowB);
+  let highlightTint = vec3<f32>(u.highlightR, u.highlightG, u.highlightB);
+
+  // Blend: shadows get shadow tint, highlights get highlight tint
+  let tint = mix(shadowTint, highlightTint, weight);
+  // Additive tint with luminance preservation
+  color = color * (vec3<f32>(1.0) + tint * 0.5);
+
+  return vec4<f32>(color, 1.0);
+}

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

@@ -0,0 +1,38 @@
+// wgsl-validate: prelude ./fullscreen-vs.wgsl
+// wgsl-validate: prelude ./occluder-chunk.wgsl
+// SSAO blur — depth-aware bilateral blur.
+struct U {
+  texelSize: vec2<f32>,
+  _p0: f32,
+  _p1: f32,
+  _p2: f32,
+  _p3: f32,
+  _p4: f32,
+  _p5: f32,
+};
+@group(0) @binding(0) var ssaoTex: 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 centerDepth = textureSample(depthTex, samp, uv);
+  var sum = 0.0;
+  var weightSum = 0.0;
+
+  for (var y = -2; y <= 2; y = y + 1) {
+    for (var x = -2; x <= 2; x = x + 1) {
+      let offset = vec2<f32>(f32(x), f32(y)) * u.texelSize;
+      let sampleDepth = textureSample(depthTex, samp, uv + offset);
+      let weight = select(0.0, 1.0, abs(sampleDepth - centerDepth) < 0.1);
+      sum += textureSample(ssaoTex, samp, uv + offset).r * weight;
+      weightSum += weight;
+    }
+  }
+
+  let result = sum / max(weightSum, 1.0);
+  return vec4<f32>(result, result, result, 1.0);
+}

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

@@ -0,0 +1,25 @@
+// wgsl-validate: prelude ./fullscreen-vs.wgsl
+// wgsl-validate: prelude ./occluder-chunk.wgsl
+// SSAO composite — multiply color by AO factor.
+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 aoTex: 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);
+  let ao = textureSample(aoTex, samp, input.uv).r;
+  return vec4<f32>(color.rgb * ao, color.a);
+}

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

@@ -0,0 +1,147 @@
+// wgsl-validate: prelude ./fullscreen-vs.wgsl
+// wgsl-validate: prelude ./occluder-chunk.wgsl
+// SSAO — Ground-Truth Ambient Occlusion (GTAO).
+// Slice-based horizon scanning with cosine-weighted falloff.
+// Replaces the basic hemisphere approach with a more accurate GTAO that
+// computes per-slice horizons by ray-marching in the view-space slice plane.
+struct U {
+  invProjection: mat4x4<f32>,
+  view: mat4x4<f32>,
+  projection: mat4x4<f32>,
+  directions: f32,   // number of slice directions (default 4)
+  radius: f32,
+  bias: f32,
+  noiseScale: vec2<f32>,
+  screenSize: vec2<f32>,
+  power: f32,        // AO contrast power (default 1.5)
+  thickness: f32,    // depth thickness for horizon test (default 0.1)
+  slices: f32,       // samples per slice direction (default 8)
+  _p0: f32,
+  _p1: f32,
+};
+@group(0) @binding(0) var depthTex: texture_depth_2d;
+@group(0) @binding(1) var normalTex: texture_2d<f32>;
+@group(0) @binding(2) var noiseTex: texture_2d<f32>;
+@group(0) @binding(3) var samp: sampler;
+@group(0) @binding(4) var<uniform> u: U;
+
+fn reconstructViewPos(uv: vec2<f32>, depth: f32) -> vec3<f32> {
+  let ndc = vec3<f32>(uv * 2.0 - 1.0, depth);
+  let clip = vec4<f32>(ndc, 1.0);
+  let viewPos = u.invProjection * clip;
+  return viewPos.xyz / viewPos.w;
+}
+
+fn projectToScreen(viewPos: vec3<f32>) -> vec3<f32> {
+  let clip = u.projection * vec4<f32>(viewPos, 1.0);
+  let ndc = clip.xyz / clip.w;
+  return vec3<f32>(ndc.xy * 0.5 + 0.5, ndc.z);
+}
+
+// Falloff function: 1 near, 0 at radius
+fn falloff(dist: f32) -> f32 {
+  return max(0.0, 1.0 - dist / u.radius);
+}
+
+@fragment
+fn fs_main(input: VertexOutput) -> @location(0) vec4<f32> {
+  if (isOccluded(input.uv)) { discard; }
+  let uv = input.uv;
+  // All textureSample calls in uniform control flow
+  let depth = textureSample(depthTex, samp, uv);
+  let worldNormal = textureSample(normalTex, samp, uv).xyz * 2.0 - 1.0;
+  let noiseVal = textureSample(noiseTex, samp, uv * u.noiseScale).xy;
+
+  if (depth >= 1.0) { return vec4<f32>(1.0, 1.0, 1.0, 1.0); }
+
+  let viewPos = reconstructViewPos(uv, depth);
+  let N = normalize((u.view * vec4<f32>(worldNormal, 0.0)).xyz);
+  let V = normalize(-viewPos);
+
+  let rotAngle = noiseVal.x * 6.2831853;
+  let numDirs = u32(clamp(u.directions, 1.0, 8.0));
+  let numSamples = u32(clamp(u.slices, 2.0, 16.0));
+  let dims = textureDimensions(depthTex);
+
+  var occlusion = 0.0;
+
+  for (var d = 0u; d < 8u; d = d + 1u) {
+    if (d >= numDirs) { break; }
+    // Slice direction in screen space, rotated by noise
+    let sliceAngle = rotAngle + f32(d) * 6.2831853 / f32(numDirs);
+    let sliceDir = vec2<f32>(cos(sliceAngle), sin(sliceAngle));
+
+    // Project slice direction to view space
+    // The slice plane contains V and the slice direction projected to view space
+    let sliceNormalVS = normalize(vec3<f32>(sliceDir, 0.0));
+
+    // Horizon search in both directions along the slice
+    var horizon1 = -1.0;  // max angle in +dir
+    var horizon2 = 1.0;   // min angle in -dir
+
+    for (var s = 1u; s < 16u; s = s + 1u) {
+      if (s >= numSamples) { break; }
+      let t = f32(s) / f32(numSamples);
+      let radius = t * u.radius;
+
+      // +direction sample
+      let samplePos1 = viewPos + vec3<f32>(sliceDir, 0.0) * radius;
+      let screen1 = projectToScreen(samplePos1);
+      if (screen1.x >= 0.0 && screen1.x <= 1.0 && screen1.y >= 0.0 && screen1.y <= 1.0) {
+        let icoords1 = vec2<u32>(clamp(
+          vec2<i32>(i32(screen1.x * f32(dims.x)), i32(screen1.y * f32(dims.y))),
+          vec2<i32>(0, 0), vec2<i32>(i32(dims.x) - 1, i32(dims.y) - 1),
+        ));
+        let sampleDepth1 = textureLoad(depthTex, icoords1, 0);
+        let sampleViewPos1 = reconstructViewPos(screen1.xy, sampleDepth1);
+        let depthDiff1 = samplePos1.z - sampleViewPos1.z;
+        if (depthDiff1 > u.bias && depthDiff1 < u.thickness * radius) {
+          let omega = atan2(sampleViewPos1.z - viewPos.z, length(sampleViewPos1.xy - viewPos.xy));
+          horizon1 = max(horizon1, omega);
+        }
+      }
+
+      // -direction sample
+      let samplePos2 = viewPos - vec3<f32>(sliceDir, 0.0) * radius;
+      let screen2 = projectToScreen(samplePos2);
+      if (screen2.x >= 0.0 && screen2.x <= 1.0 && screen2.y >= 0.0 && screen2.y <= 1.0) {
+        let icoords2 = vec2<u32>(clamp(
+          vec2<i32>(i32(screen2.x * f32(dims.x)), i32(screen2.y * f32(dims.y))),
+          vec2<i32>(0, 0), vec2<i32>(i32(dims.x) - 1, i32(dims.y) - 1),
+        ));
+        let sampleDepth2 = textureLoad(depthTex, icoords2, 0);
+        let sampleViewPos2 = reconstructViewPos(screen2.xy, sampleDepth2);
+        let depthDiff2 = samplePos2.z - sampleViewPos2.z;
+        if (depthDiff2 > u.bias && depthDiff2 < u.thickness * radius) {
+          let omega = atan2(sampleViewPos2.z - viewPos.z, length(sampleViewPos2.xy - viewPos.xy));
+          horizon2 = min(horizon2, omega);
+        }
+      }
+    }
+
+    // Compute the angle between the normal and the slice plane
+    // Project normal onto the slice plane
+    let sliceNormal3D = normalize(vec3<f32>(sliceDir, 0.0));
+    let Nproj = normalize(N - dot(N, sliceNormal3D) * sliceNormal3D);
+    let Nangle = atan2(Nproj.z, length(Nproj.xy));
+
+    // Clamp horizons to the normal hemisphere
+    let h1 = max(horizon1, Nangle);
+    let h2 = min(horizon2, Nangle);
+
+    // AO contribution from this slice: integral of cos(theta - Nangle) from h2 to h1
+    let ao1 = cos(2.0 * h1 - Nangle) - cos(2.0 * Nangle - Nangle);
+    let ao2 = cos(2.0 * Nangle - Nangle) - cos(2.0 * h2 - Nangle);
+    let sliceAO = clamp((ao1 + ao2) * 0.5, 0.0, 1.0);
+
+    // Weight by the slice's alignment with the normal
+    let sliceWeight = abs(dot(Nproj, N));
+    occlusion += sliceAO * sliceWeight;
+  }
+
+  occlusion = occlusion / f32(numDirs);
+  // Apply power for contrast control
+  let ao = 1.0 - pow(clamp(occlusion, 0.0, 1.0), u.power);
+  let result = clamp(ao, 0.0, 1.0);
+  return vec4<f32>(result, result, result, 1.0);
+}

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

@@ -0,0 +1,155 @@
+// wgsl-validate: prelude ./fullscreen-vs.wgsl
+// wgsl-validate: prelude ./occluder-chunk.wgsl
+// SSR — screen-space reflections with DDA ray marching + binary refinement.
+// Upgraded from linear march to pixel-perfect DDA stepping with sub-pixel
+// binary search refinement for accurate hit detection. Includes thickness
+// testing, edge fade, and distance fade.
+struct U {
+  invProjection: mat4x4<f32>,
+  view: mat4x4<f32>,
+  projection: mat4x4<f32>,
+  maxSteps: f32,
+  thickness: f32,
+  maxDistance: f32,
+  fadeStart: f32,
+  fadeEnd: f32,
+  binarySteps: f32,  // number of binary refinement steps (default 10)
+  stride: f32,       // ray march stride multiplier (default 1.0)
+  _p0: f32,
+  _p1: f32,
+  _p2: f32,
+  _p3: 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 reconstructViewPos(uv: vec2<f32>, depth: f32) -> vec3<f32> {
+  let ndc = vec3<f32>(uv * 2.0 - 1.0, depth);
+  let clip = vec4<f32>(ndc, 1.0);
+  let viewPos = u.invProjection * clip;
+  return viewPos.xyz / viewPos.w;
+}
+
+fn projectToScreen(viewPos: vec3<f32>) -> vec3<f32> {
+  let clip = u.projection * vec4<f32>(viewPos, 1.0);
+  let ndc = clip.xyz / clip.w;
+  return vec3<f32>(ndc.xy * 0.5 + 0.5, ndc.z);
+}
+
+@fragment
+fn fs_main(input: VertexOutput) -> @location(0) vec4<f32> {
+  if (isOccluded(input.uv)) { discard; }
+  let uv = input.uv;
+  // All textureSample calls in uniform control flow
+  let depth = textureSample(depthTex, samp, uv);
+  let baseColor = textureSample(colorTex, samp, uv);
+  let worldNormal = textureSample(normalTex, samp, uv).xyz * 2.0 - 1.0;
+
+  if (depth >= 1.0) { return baseColor; }
+
+  let viewPos = reconstructViewPos(uv, depth);
+  let N = normalize((u.view * vec4<f32>(worldNormal, 0.0)).xyz);
+  let V = normalize(-viewPos);
+  let reflectDir = reflect(-V, N);
+
+  // Skip reflections pointing toward the camera
+  if (reflectDir.z >= 0.0) { return baseColor; }
+
+  // Project start and end points to screen space
+  let startPos = viewPos;
+  let endPos = viewPos + reflectDir * u.maxDistance;
+  let startScreen = projectToScreen(startPos);
+  let endScreen = projectToScreen(endPos);
+
+  // DDA setup: march from startScreen to endScreen in pixel space
+  let dims = textureDimensions(depthTex);
+  let colorDims = textureDimensions(colorTex);
+  let pixelStart = vec2<f32>(startScreen.x * f32(dims.x), startScreen.y * f32(dims.y));
+  let pixelEnd = vec2<f32>(endScreen.x * f32(dims.x), endScreen.y * f32(dims.y));
+  let pixelDir = pixelEnd - pixelStart;
+  let pixelLen = length(pixelDir);
+  let pixelStep = normalize(pixelDir) * u.stride;
+
+  let maxSteps = u32(clamp(u.maxSteps, 1.0, 128.0));
+  let binarySteps = u32(clamp(u.binarySteps, 1.0, 16.0));
+
+  var hitColor = vec3<f32>(0.0);
+  var hitAlpha = 0.0;
+  var hit = false;
+
+  // ── DDA ray march ──
+  var currentPixel = pixelStart;
+  var currentViewPos = startPos;
+
+  for (var i = 0u; i < 128u; i = i + 1u) {
+    if (i >= maxSteps) { break; }
+    currentPixel = currentPixel + pixelStep;
+    let sampleUV = currentPixel / vec2<f32>(f32(dims.x), f32(dims.y));
+
+    // Out of bounds — stop
+    if (sampleUV.x < 0.0 || sampleUV.x > 1.0 || sampleUV.y < 0.0 || sampleUV.y > 1.0) { break; }
+
+    // Interpolate view-space position along the ray
+    let t = f32(i + 1u) / f32(maxSteps);
+    currentViewPos = mix(startPos, endPos, t);
+
+    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 sampleDepth = textureLoad(depthTex, icoords, 0);
+    let sampleViewPos = reconstructViewPos(sampleUV, sampleDepth);
+
+    let depthDiff = currentViewPos.z - sampleViewPos.z;
+    // Hit: ray is behind the surface within thickness threshold
+    if (depthDiff > 0.0 && depthDiff < u.thickness) {
+      hit = true;
+      // ── Binary refinement for sub-pixel accuracy ──
+      var refineStart = currentPixel - pixelStep;
+      var refineEnd = currentPixel;
+      for (var b = 0u; b < 16u; b = b + 1u) {
+        if (b >= binarySteps) { break; }
+        let midPixel = (refineStart + refineEnd) * 0.5;
+        let midUV = midPixel / vec2<f32>(f32(dims.x), f32(dims.y));
+        let midCoords = vec2<u32>(clamp(
+          vec2<i32>(i32(midUV.x * f32(dims.x)), i32(midUV.y * f32(dims.y))),
+          vec2<i32>(0, 0), vec2<i32>(i32(dims.x) - 1, i32(dims.y) - 1),
+        ));
+        let midDepth = textureLoad(depthTex, midCoords, 0);
+        let midViewPos = reconstructViewPos(midUV, midDepth);
+
+        let bt = length(midPixel - pixelStart) / pixelLen;
+        let rayZ = mix(startPos.z, endPos.z, bt);
+        let midDiff = rayZ - midViewPos.z;
+        if (midDiff > 0.0 && midDiff < u.thickness) {
+          refineEnd = midPixel;
+        } else {
+          refineStart = midPixel;
+        }
+      }
+
+      // Sample color at the refined hit position
+      let hitUV = refineEnd / vec2<f32>(f32(dims.x), f32(dims.y));
+      let hitCoords = vec2<u32>(clamp(
+        vec2<i32>(i32(hitUV.x * f32(colorDims.x)), i32(hitUV.y * f32(colorDims.y))),
+        vec2<i32>(0, 0), vec2<i32>(i32(colorDims.x) - 1, i32(colorDims.y) - 1),
+      ));
+      hitColor = textureLoad(colorTex, hitCoords, 0).rgb;
+
+      // Distance fade
+      let dist = length(currentViewPos - viewPos);
+      let fade = 1.0 - smoothstep(u.fadeStart, u.fadeEnd, dist);
+      // Edge fade (screen border)
+      let edgeFade = smoothstep(0.0, 0.1, hitUV.x) * smoothstep(0.0, 0.1, 1.0 - hitUV.x) *
+                     smoothstep(0.0, 0.1, hitUV.y) * smoothstep(0.0, 0.1, 1.0 - hitUV.y);
+      hitAlpha = fade * edgeFade;
+      break;
+    }
+  }
+
+  if (!hit) { return baseColor; }
+  return vec4<f32>(mix(baseColor.rgb, hitColor, hitAlpha), baseColor.a);
+}

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

@@ -0,0 +1,98 @@
+// wgsl-validate: prelude ./fullscreen-vs.wgsl
+// wgsl-validate: prelude ./occluder-chunk.wgsl
+// TAA — Temporal Anti-Aliasing with YCoCg neighborhood clamp + jitter + variance.
+// Upgraded with:
+// - Jitter-aware reprojection (sub-pixel jitter offset for better convergence)
+// - Optional variance-based clamping (reduces ghosting vs pure min/max clamp)
+// - Velocity-based history reprojection (unchanged from original)
+struct U {
+  texelSize: vec2<f32>,
+  blendFactor: f32,
+  varianceClamp: f32,  // 1.0 = enable variance clamping, 0.0 = min/max only
+  jitterX: f32,        // sub-pixel jitter offset X (in texels)
+  jitterY: f32,        // sub-pixel jitter offset Y (in texels)
+  _p0: f32,
+  _p1: f32,
+  _p2: f32,
+};
+@group(0) @binding(0) var colorTex: texture_2d<f32>;
+@group(0) @binding(1) var velocityTex: texture_2d<f32>;
+@group(0) @binding(2) var historyTex: texture_2d<f32>;
+@group(0) @binding(3) var samp: sampler;
+@group(0) @binding(4) var<uniform> u: U;
+
+fn rgbToYCoCg(rgb: vec3<f32>) -> vec3<f32> {
+  let co = rgb.r - rgb.b;
+  let tmp = rgb.b + co * 0.5;
+  let cg = rgb.g - tmp;
+  let y = tmp + cg * 0.5;
+  return vec3<f32>(y, co, cg);
+}
+fn yCoCgToRGB(ycocg: vec3<f32>) -> vec3<f32> {
+  let tmp = ycocg.x - ycocg.z * 0.5;
+  let g = ycocg.z + tmp;
+  let b = tmp - ycocg.y * 0.5;
+  let r = ycocg.y + b;
+  return vec3<f32>(r, g, b);
+}
+
+@fragment
+fn fs_main(input: VertexOutput) -> @location(0) vec4<f32> {
+  if (isOccluded(input.uv)) { discard; }
+  let uv = input.uv;
+  let jitter = vec2<f32>(u.jitterX, u.jitterY) * u.texelSize;
+  // Current color — sample at jittered position (the scene was rendered with jitter)
+  let current = textureSample(colorTex, samp, uv).rgb;
+  let velocity = textureSample(velocityTex, samp, uv).rg;
+  // Reproject: history UV accounts for velocity + jitter offset
+  let historyUV = uv - velocity - jitter;
+  let history = textureSample(historyTex, samp, historyUV).rgb;
+
+  // 3x3 neighborhood for clamping
+  let ts = u.texelSize;
+  let tl = textureSample(colorTex, samp, uv + vec2<f32>(-1.0, -1.0) * ts).rgb;
+  let tr = textureSample(colorTex, samp, uv + vec2<f32>( 1.0, -1.0) * ts).rgb;
+  let bl = textureSample(colorTex, samp, uv + vec2<f32>(-1.0,  1.0) * ts).rgb;
+  let br = textureSample(colorTex, samp, uv + vec2<f32>( 1.0,  1.0) * ts).rgb;
+  let l = textureSample(colorTex, samp, uv + vec2<f32>(-1.0,  0.0) * ts).rgb;
+  let r2 = textureSample(colorTex, samp, uv + vec2<f32>( 1.0,  0.0) * ts).rgb;
+  let t = textureSample(colorTex, samp, uv + vec2<f32>( 0.0, -1.0) * ts).rgb;
+  let b2 = textureSample(colorTex, samp, uv + vec2<f32>( 0.0,  1.0) * ts).rgb;
+
+  let ycocgCenter = rgbToYCoCg(current);
+  var minC = ycocgCenter;
+  var maxC = ycocgCenter;
+  var avgC = ycocgCenter;
+  let neighbors = array<vec3<f32>, 8>(tl, tr, bl, br, l, r2, t, b2);
+  for (var i = 0u; i < 8u; i = i + 1u) {
+    let ycocg = rgbToYCoCg(neighbors[i]);
+    minC = min(minC, ycocg);
+    maxC = max(maxC, ycocg);
+    avgC += ycocg;
+  }
+  avgC = avgC / 9.0;
+
+  var clampedHistory: vec3<f32>;
+  if (u.varianceClamp > 0.5) {
+    // Variance-based clamping: tighten the clamp box using standard deviation
+    var variance = vec3<f32>(0.0);
+    for (var i = 0u; i < 8u; i = i + 1u) {
+      let d = rgbToYCoCg(neighbors[i]) - avgC;
+      variance += d * d;
+    }
+    variance = variance / 8.0;
+    let stdDev = sqrt(variance);
+    let tightMin = avgC - stdDev * 1.5;
+    let tightMax = avgC + stdDev * 1.5;
+    // Use the tighter of min/max and variance-based bounds
+    let clampMin = max(minC, tightMin);
+    let clampMax = min(maxC, tightMax);
+    clampedHistory = yCoCgToRGB(clamp(rgbToYCoCg(history), clampMin, clampMax));
+  } else {
+    // Standard min/max neighborhood clamp
+    clampedHistory = yCoCgToRGB(clamp(rgbToYCoCg(history), minC, maxC));
+  }
+
+  let result = mix(clampedHistory, current, u.blendFactor);
+  return vec4<f32>(result, 1.0);
+}

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

@@ -0,0 +1,40 @@
+// wgsl-validate: prelude ./fullscreen-vs.wgsl
+// wgsl-validate: prelude ./occluder-chunk.wgsl
+// ACES tonemap — HDR→LDR bridge with exposure/gamma/contrast/saturation/vignette.
+struct U {
+  exposure: f32,
+  bloomIntensity: f32,
+  gamma: f32,
+  contrast: f32,
+  saturation: f32,
+  vignette: f32,
+  _p0: f32,
+  _p1: f32,
+};
+@group(0) @binding(0) var colorTex: texture_2d<f32>;
+@group(0) @binding(1) var bloomTex: texture_2d<f32>;
+@group(0) @binding(2) var samp: sampler;
+@group(0) @binding(3) var<uniform> u: U;
+
+fn acesTonemap(color: vec3<f32>) -> vec3<f32> {
+  let a = 2.51; let b = 0.03; let c = 2.43; let d = 0.59; let e = 0.14;
+  return clamp((color * (a * color + b)) / (color * (c * color + d) + e), vec3<f32>(0.0), vec3<f32>(1.0));
+}
+
+@fragment
+fn fs_main(input: VertexOutput) -> @location(0) vec4<f32> {
+  if (isOccluded(input.uv)) { discard; }
+  var color = textureSample(colorTex, samp, input.uv).rgb;
+  let bloom = textureSample(bloomTex, samp, input.uv).rgb;
+  color += bloom * u.bloomIntensity;
+  color *= u.exposure;
+  color = acesTonemap(color);
+  color = (color - 0.5) * u.contrast + 0.5;
+  let luma = dot(color, vec3<f32>(0.299, 0.587, 0.114));
+  color = mix(vec3<f32>(luma), color, u.saturation);
+  let center = input.uv - 0.5;
+  let dist = dot(center, center);
+  color *= 1.0 - dist * u.vignette;
+  color = pow(color, vec3<f32>(1.0 / u.gamma));
+  return vec4<f32>(color, 1.0);
+}