@plasius/gpu-lighting 0.2.3 → 0.2.5

package/CHANGELOG.md

@@ -20,19 +20,22 @@ The format is based on **[Keep a Changelog](https://keepachangelog.com/en/1.1.0/
 - **Security**
   - (placeholder)
 
-## [0.2.3] - 2026-06-14
+## [0.2.5] - 2026-06-15
 
 - **Added**
-  - (placeholder)
+  - Added concrete volumetric WGSL kernels for `volumetricShadow` and
+    `froxelIntegrate`, covering froxel shadow history plus scattering/extinction
+    integration for the published realtime and reference profiles.
+  - Added concrete HDRI/IBL WGSL kernels for `irradianceConvolution`,
+    `specularPrefilter`, and `brdfLut`.
 
 - **Changed**
-  - (placeholder)
+  - README now documents the delivered volumetrics and HDRI kernel scope with
+    technique-level descriptions instead of leaving those exported jobs implied.
 
 - **Fixed**
-  - (placeholder)
-
-- **Security**
-  - (placeholder)
+  - Package tests now fail if any exported `hybrid`, `volumetrics`, or `hdri`
+    job regresses to placeholder text or an empty/no-op `process_job` body.
 
 ## [0.2.2] - 2026-06-11
 
@@ -43,14 +46,86 @@ The format is based on **[Keep a Changelog](https://keepachangelog.com/en/1.1.0/
   - Added `sunlitBaseline` to environment lighting presets and wavefront
     lighting options so renderers can apply a time-of-day daylight floor at
     terminal path collisions without raising ambient residual colour.
-  - (placeholder)
+  - Added an Eames screenshot capture runbook and browser-runtime helpers so
+    validation scripts can attach to an existing WebGPU-capable Chrome over CDP
+    instead of only launching a fresh Playwright Chromium profile.
+  - Added generic glTF material forwarding in the Eames validation loader so
+    authored specular, sheen, clearcoat, transmission, emissive, and IOR values
+    can flow into the shared wavefront renderer without model-name overrides.
+  - Added Eames validation HUD/result diagnostics for GPU worker-job throughput
+    so validation runs can report compute-dispatch jobs per frame, per second,
+    and per command submission.
+  - Added adaptive Eames validation frame budgeting so motion-oriented runs can
+    request a `frameTimeBudgetMs` and inspect delivered `rendered/target spp`
+    in the HUD and result payload.
+  - Added `@plasius/gpu-performance`-governed adaptive SPP control to the Eames
+    validation harness so frame-budgeted runs degrade and recover through a
+    shared quality-ladder contract instead of a demo-local policy alone.
 
 - **Changed**
   - Reduced ambient residual strength for the grass-field, forest, warehouse,
     and cavern environment preset families to avoid low-sample whitewash.
+  - Eames validation capture scripts now pin deterministic render settings by
+    default and write canvas-only PNG artifacts plus comparable black-pixel and
+    luminance metrics under `output/playwright/eames-environments/`.
+  - Eames validation page and capture entry points now accept up to `256 spp`,
+    and the validation boot timeout now scales with requested render workload
+    instead of failing at a fixed 60-second watchdog.
+  - `gpu-lighting` local typecheck coverage now includes the Eames validation
+    page, loader, and capture helpers instead of checking only the legacy demo
+    entry points.
+  - Eames validation mesh loading now preserves authored UVs and decoded
+    base-colour, metallic-roughness, normal, and occlusion maps so the shared
+    wavefront renderer can evaluate materially richer leather, wood, and chrome
+    surfaces.
+  - Eames validation meshes now forward decoded emissive maps as well so the
+    shared wavefront renderer can keep all material texture evaluation in the
+    GPU render path.
+  - Eames validation mesh building now preserves authored material values
+    generically instead of deriving chrome, leather, and wood behaviour from
+    material names.
+  - Eames validation page can now freeze its own canvas and POST the PNG back
+    to a local bridge endpoint, which provides a browser-driven screenshot
+    fallback when Playwright cannot own the Chromium process directly.
+  - Eames validation capture and reverse-pass debug entry points now share one
+    server-selection helper so port reuse, static serving, and bridge-ready
+    startup rules stay aligned across local runs and CI.
 
 - **Fixed**
-  - (placeholder)
+  - Eames Playwright validation pages and capture scripts now surface import,
+    WebGPU bootstrap, and renderer startup diagnostics instead of hanging on the
+    initial HUD when a browser cannot complete setup.
+  - Eames validation renders now collect optional output-probe figures after the
+    frame render completes instead of coupling probe readback to the heavy
+    high-SPP render submission itself.
+  - Eames capture helpers now resolve browser profile and temporary output paths
+    through the host OS temp directory instead of assuming macOS-only
+    `/private/tmp`, which fixes Linux CI validation.
+  - Eames validation query parsing now preserves documented fallback defaults
+    when numeric URL params are omitted, which keeps standard captures out of
+    accidental reverse-pass debug mode.
+  - Eames validation motion renders now preserve the built-in adaptive
+    `frameTimeBudgetMs` default when the query parameter is omitted, so the
+    shared `@plasius/gpu-performance` quality ladder still engages on the
+    standard animated validation route.
+  - Animated source-marker captures now reuse the injected product-studio scene
+    helper during per-frame rebuilds instead of throwing when motion is enabled.
+  - Eames capture waits now scale with requested resolution, frame count, depth,
+    and SPP so higher-workload validation runs are not aborted at a stale fixed
+    timeout.
+  - Eames glTF validation materials now honor `KHR_texture_transform` offsets,
+    scales, and rotation by baking transformed texture maps during decode so
+    chair screenshots reflect the authored leather and wood layouts.
+  - The capture bridge now rejects non-loopback browser origins and confines
+    capture writes to `output/playwright/eames-environments/`, which closes the
+    browser-driven workspace overwrite path on the local upload endpoint.
+  - The Eames glTF loader now honors interleaved `bufferView.byteStride` values,
+    which keeps positions, normals, and UVs correct for legal strided assets.
+  - The capture bridge now serves static assets without a pre-stat/read race,
+    and browser-driven capture uploads are restricted to loopback bridge URLs.
+  - The standalone repo now ships the Eames demo asset set referenced by the
+    validation page so fresh checkouts can render the chair without external
+    workspace-only files.
 
 - **Security**
   - (placeholder)
@@ -389,7 +464,7 @@ The format is based on **[Keep a Changelog](https://keepachangelog.com/en/1.1.0/
 [0.1.16]: https://github.com/Plasius-LTD/gpu-lighting/releases/tag/v0.1.16
 [0.1.17]: https://github.com/Plasius-LTD/gpu-lighting/releases/tag/v0.1.17
 [0.1.19]: https://github.com/Plasius-LTD/gpu-lighting/releases/tag/v0.1.19
-[Unreleased]: https://github.com/Plasius-LTD/gpu-lighting/compare/v0.2.3...HEAD
+[Unreleased]: https://github.com/Plasius-LTD/gpu-lighting/compare/v0.2.5...HEAD
 [0.2.0]: https://github.com/Plasius-LTD/gpu-lighting/releases/tag/v0.2.0
 [0.2.2]: https://github.com/Plasius-LTD/gpu-lighting/releases/tag/v0.2.2
-[0.2.3]: https://github.com/Plasius-LTD/gpu-lighting/releases/tag/v0.2.3
+[0.2.5]: https://github.com/Plasius-LTD/gpu-lighting/releases/tag/v0.2.5

package/README.md

@@ -42,6 +42,81 @@ For browser-only serving, the demo resolves `@plasius/gpu-shared` through an
 import map so the page stays on the published package surface rather than a
 package-private source path.
 
+## Screenshot Capture
+
+The repo also carries the Eames-chair environment validation harness under
+`demo/eames-environments/` plus tracked Playwright helpers under
+`scripts/eames-environments/`. The referenced chair asset is tracked under
+`data/models/eames-lounge-chair-ottoman/` so fresh repo checkouts can run the
+validation page without depending on a parent monorepo checkout. Build
+`gpu-performance`, `gpu-renderer`, and `gpu-lighting` first, then run:
+
+```bash
+node scripts/eames-environments/capture.mjs
+```
+
+For reverse-pass black-pixel diagnostics, run:
+
+```bash
+node scripts/eames-environments/path-debug-capture.mjs
+```
+
+If fresh Playwright Chromium bootstrap is unstable on macOS, start a
+WebGPU-capable Chrome separately with remote debugging enabled and set
+`PLASIUS_CAPTURE_CDP_URL=http://127.0.0.1:<port>` before running the capture
+script. The validation page now reports bootstrap step, detail, and WebGPU
+availability through `window.__plasiusCaptureState` and
+`window.__plasiusCaptureError` so capture failures stop at a named phase rather
+than hanging on the initial HUD.
+
+For browser-controlled fallbacks, start
+`node scripts/eames-environments/capture-bridge-server.mjs <port>` and open the
+validation page with `captureBitmap=1` plus
+`captureUploadPath=output/playwright/eames-environments/<name>.png`. If the page
+is being served by a plain static server such as `python -m http.server`, also
+pass
+`captureUploadUrl=http://127.0.0.1:<port>/__plasius-capture`. The page will
+freeze its own canvas and POST the PNG back to the bridge server once the
+render completes. The browser-side upload helper now rejects non-loopback
+capture endpoints so this fallback cannot be redirected at arbitrary remote
+origins.
+
+The main capture and reverse-pass debug capture entry points now share the same
+server-selection helper, so local reuse, fresh static-server startup, and
+bridge fallback all follow the same port and readiness rules across macOS and
+Linux.
+
+The capture scripts now pin deterministic validation settings unless explicitly
+overridden:
+
+- `PLASIUS_CAPTURE_MAX_DEPTH=8`
+- `PLASIUS_CAPTURE_SPP=1`
+- `PLASIUS_CAPTURE_FRAMES=1`
+- `PLASIUS_CAPTURE_DENOISE=1`
+- `PLASIUS_CAPTURE_MOTION=0`
+- `PLASIUS_CAPTURE_FRAME_INDEX=777`
+- `PLASIUS_CAPTURE_PROBE=1`
+
+They save canvas-only PNGs plus per-capture JSON under
+`output/playwright/eames-environments/`, including exact-black, near-black, and
+average-luminance metrics so screenshot comparisons stay apples-to-apples. The
+validation page now decouples optional probe readback from the heavy render
+submission itself, which keeps higher-SPP screenshot validation more stable.
+For motion or realtime validation, the page also accepts `frameTimeBudgetMs`
+and will render at least one full-screen sample before adaptively spending the
+rest of the per-frame budget on additional SPP passes. The HUD reports
+`rendered/target spp` whenever the budgeted frame lands below the configured
+ceiling. When `gpu-performance/dist/index.js` is available, the Eames harness
+also routes that target through a `@plasius/gpu-performance` quality ladder fed
+by `gpu-renderer`'s wavefront adaptive-sampling levels, so the requested SPP
+becomes a release-grade ceiling rather than an ungoverned demo-local heuristic.
+The Eames loader also preserves authored UVs, decoded base-colour,
+metallic-roughness, normal, occlusion, and emissive maps, plus authored glTF
+material factors such as clearcoat, sheen colour, specular colour,
+transmission, and IOR when present. That keeps the validation scene on the
+shared renderer path instead of relying on material-name-specific overrides for
+leather, wood, and chrome.
+
 ## Usage (load one technique)
 
 ```js
@@ -250,6 +325,11 @@ The package now ships concrete WGSL contracts for:
 - `hybrid.screenTrace`: first-hit reflection tracing over the shared hybrid scene contracts
 - `hybrid.radianceCache`: irradiance history updates for cache-backed indirect reuse
 - `hybrid.finalGather`: cache + trace composition with temporal reuse for the hybrid GI path
+- `volumetrics.volumetricShadow`: slice-aware Beer-Lambert shadow history for fog and shafts
+- `volumetrics.froxelIntegrate`: froxel scattering/extinction integration with temporal stability
+- `hdri.irradianceConvolution`: cosine-weighted diffuse environment convolution
+- `hdri.specularPrefilter`: roughness-aware environment prefiltering for glossy IBL
+- `hdri.brdfLut`: split-sum BRDF LUT integration for image-based lighting
 - `pathtracer.pathTrace`: analytic scene tracing, bounce integration, and sky fallback
 - `pathtracer.accumulate`: progressive history resolve with reset handling
 - `pathtracer.denoise`: spatial-temporal bilateral filtering for reference previews
@@ -279,12 +359,12 @@ graph.
   - `accumulate`
   - `denoise`
 - `volumetrics`
-  - `froxelIntegrate`
-  - `volumetricShadow`
+  - `froxelIntegrate`: accumulates participating-media scattering/extinction per froxel
+  - `volumetricShadow`: resolves directional shadow transmittance history per froxel
 - `hdri`
-  - `irradianceConvolution`
-  - `specularPrefilter`
-  - `brdfLut`
+  - `irradianceConvolution`: builds diffuse irradiance from the environment source
+  - `specularPrefilter`: builds roughness-aware glossy environment mip data
+  - `brdfLut`: integrates the split-sum BRDF lookup surface for IBL
 
 ## Demo
 

package/dist/techniques/techniques/hdri/brdf-lut.job.wgsl

@@ -1,3 +1,71 @@
-fn process_job() {
-  // Placeholder BRDF LUT generation stage.
+@group(0) @binding(0) var<uniform> iblPrecomputeParams: IblPrecomputeParams;
+@group(0) @binding(1) var<storage, read_write> hdriBrdfLutOutput: array<vec4<f32>>;
+
+fn lut_extent() -> u32 {
+  return max(iblPrecomputeParams.sample_count, 1u);
+}
+
+fn lut_index(pixel: vec2<u32>) -> u32 {
+  let extent = lut_extent();
+  return pixel.y * extent + pixel.x;
+}
+
+fn saturate(value: f32) -> f32 {
+  return clamp(value, 0.0, 1.0);
+}
+
+fn geometry_schlick_ggx(ndotv: f32, roughness: f32) -> f32 {
+  let alpha = max(roughness * roughness, 0.001);
+  let k = (alpha + 1.0) * (alpha + 1.0) / 8.0;
+  return ndotv / max(ndotv * (1.0 - k) + k, 0.001);
+}
+
+fn geometry_smith(ndotv: f32, ndotl: f32, roughness: f32) -> f32 {
+  return geometry_schlick_ggx(ndotv, roughness) * geometry_schlick_ggx(ndotl, roughness);
+}
+
+fn fresnel_schlick(cos_theta: f32) -> f32 {
+  return pow(1.0 - saturate(cos_theta), 5.0);
+}
+
+@compute @workgroup_size(8, 8, 1)
+fn process_job(@builtin(global_invocation_id) global_id: vec3<u32>) {
+  let extent = lut_extent();
+  if (global_id.x >= extent || global_id.y >= extent) {
+    return;
+  }
+
+  let uv = (vec2<f32>(global_id.xy) + vec2<f32>(0.5)) / max(vec2<f32>(f32(extent)), vec2<f32>(1.0));
+  let ndotv = saturate(uv.x);
+  let roughness = clamp_roughness(uv.y + iblPrecomputeParams.roughness * 0.15);
+  let sample_total = max(iblPrecomputeParams.sample_count, 1u);
+  var integrated_brdf = vec2<f32>(0.0);
+  var sample_index = 0u;
+  loop {
+    if (sample_index >= sample_total) {
+      break;
+    }
+
+    let sample_u = (f32(sample_index) + 0.5) / f32(sample_total);
+    let sample_v = fract(f32(sample_index) * 0.61803398875);
+    let ndotl = saturate(sqrt(sample_u));
+    let vdoth = saturate(mix(ndotv, 1.0, sample_v));
+    let geometry = geometry_smith(ndotv, ndotl, roughness);
+    let fresnel = fresnel_schlick(vdoth);
+    integrated_brdf = integrated_brdf + vec2<f32>(
+      (1.0 - fresnel) * geometry,
+      fresnel * geometry
+    );
+
+    sample_index = sample_index + 1u;
+  }
+
+  integrated_brdf =
+    integrated_brdf / f32(sample_total) * max(iblPrecomputeParams.exposure_bias, 0.0001);
+  hdriBrdfLutOutput[lut_index(global_id.xy)] = vec4<f32>(
+    integrated_brdf.x,
+    integrated_brdf.y,
+    roughness,
+    ndotv
+  );
 }

package/dist/techniques/techniques/hdri/irradiance-convolution.job.wgsl

@@ -1,3 +1,92 @@
-fn process_job() {
-  // Placeholder irradiance convolution stage.
+struct HdriConvolutionSample {
+  direction_radiance: vec4<f32>,
+};
+
+@group(0) @binding(0) var<uniform> iblPrecomputeParams: IblPrecomputeParams;
+@group(0) @binding(1) var<storage, read> hdriEnvironmentInput: array<HdriConvolutionSample>;
+@group(0) @binding(2) var<storage, read_write> hdriIrradianceOutput: array<vec4<f32>>;
+
+fn face_extent() -> u32 {
+  return max(iblPrecomputeParams.sample_count, 1u);
+}
+
+fn face_pixel_index(pixel: vec2<u32>) -> u32 {
+  let extent = face_extent();
+  return pixel.y * extent + pixel.x;
+}
+
+fn safe_normalize(value: vec3<f32>) -> vec3<f32> {
+  let length_value = length(value);
+  if (length_value <= 0.000001) {
+    return vec3<f32>(0.0, 1.0, 0.0);
+  }
+  return value / length_value;
+}
+
+fn direction_from_texel(pixel: vec2<u32>, extent: u32) -> vec3<f32> {
+  let uv = (vec2<f32>(pixel) + vec2<f32>(0.5)) / max(vec2<f32>(f32(extent)), vec2<f32>(1.0));
+  let phi = (uv.x * 2.0 - 1.0) * 3.141592653589793;
+  let theta = uv.y * 3.141592653589793;
+  let sin_theta = sin(theta);
+  return safe_normalize(
+    vec3<f32>(
+      cos(phi) * sin_theta,
+      cos(theta),
+      sin(phi) * sin_theta
+    )
+  );
+}
+
+fn direction_to_index(direction: vec3<f32>, extent: u32) -> u32 {
+  let dir = safe_normalize(direction);
+  let phi = atan2(dir.z, dir.x);
+  let theta = acos(clamp(dir.y, -1.0, 1.0));
+  let u = fract(phi / (2.0 * 3.141592653589793) + 0.5);
+  let v = clamp(theta / 3.141592653589793, 0.0, 0.999999);
+  let pixel = vec2<u32>(
+    min(u32(floor(u * f32(extent))), extent - 1u),
+    min(u32(floor(v * f32(extent))), extent - 1u)
+  );
+  return face_pixel_index(pixel);
+}
+
+fn sample_environment(direction: vec3<f32>) -> vec3<f32> {
+  let index = direction_to_index(direction, face_extent());
+  return hdriEnvironmentInput[index].direction_radiance.xyz;
+}
+
+@compute @workgroup_size(8, 8, 1)
+fn process_job(@builtin(global_invocation_id) global_id: vec3<u32>) {
+  let extent = face_extent();
+  if (global_id.x >= extent || global_id.y >= extent) {
+    return;
+  }
+
+  let normal = direction_from_texel(global_id.xy, extent);
+  var accumulated_irradiance = vec3<f32>(0.0);
+  var total_weight = 0.0;
+  var sample_index = 0u;
+  loop {
+    if (sample_index >= extent) {
+      break;
+    }
+
+    let sample_pixel = vec2<u32>(
+      (global_id.x + sample_index) % extent,
+      (global_id.y + sample_index * 3u) % extent
+    );
+    let sample_direction = direction_from_texel(sample_pixel, extent);
+    let cosine_weight = max(dot(normal, sample_direction), 0.0);
+    if (cosine_weight > 0.0) {
+      accumulated_irradiance =
+        accumulated_irradiance + sample_environment(sample_direction) * cosine_weight;
+      total_weight = total_weight + cosine_weight;
+    }
+
+    sample_index = sample_index + 1u;
+  }
+
+  let irradiance =
+    accumulated_irradiance / max(total_weight, 0.0001) * max(iblPrecomputeParams.exposure_bias, 0.0001);
+  hdriIrradianceOutput[face_pixel_index(global_id.xy)] = vec4<f32>(irradiance, 1.0);
 }

package/dist/techniques/techniques/hdri/specular-prefilter.job.wgsl

@@ -1,3 +1,111 @@
-fn process_job() {
-  // Placeholder specular prefilter stage.
+struct HdriSpecularSample {
+  direction_radiance: vec4<f32>,
+};
+
+@group(0) @binding(0) var<uniform> iblPrecomputeParams: IblPrecomputeParams;
+@group(0) @binding(1) var<storage, read> hdriEnvironmentInput: array<HdriSpecularSample>;
+@group(0) @binding(2) var<storage, read_write> hdriSpecularOutput: array<vec4<f32>>;
+
+fn face_extent() -> u32 {
+  return max(iblPrecomputeParams.sample_count, 1u);
+}
+
+fn face_pixel_index(pixel: vec2<u32>) -> u32 {
+  let extent = face_extent();
+  return pixel.y * extent + pixel.x;
+}
+
+fn safe_normalize(value: vec3<f32>) -> vec3<f32> {
+  let length_value = length(value);
+  if (length_value <= 0.000001) {
+    return vec3<f32>(0.0, 1.0, 0.0);
+  }
+  return value / length_value;
+}
+
+fn direction_from_texel(pixel: vec2<u32>, extent: u32) -> vec3<f32> {
+  let uv = (vec2<f32>(pixel) + vec2<f32>(0.5)) / max(vec2<f32>(f32(extent)), vec2<f32>(1.0));
+  let phi = (uv.x * 2.0 - 1.0) * 3.141592653589793;
+  let theta = uv.y * 3.141592653589793;
+  let sin_theta = sin(theta);
+  return safe_normalize(
+    vec3<f32>(
+      cos(phi) * sin_theta,
+      cos(theta),
+      sin(phi) * sin_theta
+    )
+  );
+}
+
+fn direction_to_index(direction: vec3<f32>, extent: u32) -> u32 {
+  let dir = safe_normalize(direction);
+  let phi = atan2(dir.z, dir.x);
+  let theta = acos(clamp(dir.y, -1.0, 1.0));
+  let u = fract(phi / (2.0 * 3.141592653589793) + 0.5);
+  let v = clamp(theta / 3.141592653589793, 0.0, 0.999999);
+  let pixel = vec2<u32>(
+    min(u32(floor(u * f32(extent))), extent - 1u),
+    min(u32(floor(v * f32(extent))), extent - 1u)
+  );
+  return face_pixel_index(pixel);
+}
+
+fn sample_environment(direction: vec3<f32>) -> vec3<f32> {
+  let index = direction_to_index(direction, face_extent());
+  return hdriEnvironmentInput[index].direction_radiance.xyz;
+}
+
+fn importance_sample_hemisphere(normal: vec3<f32>, xi: vec2<f32>, roughness: f32) -> vec3<f32> {
+  let phi = 2.0 * 3.141592653589793 * xi.x;
+  let alpha = max(roughness * roughness, 0.001);
+  let cos_theta = sqrt((1.0 - xi.y) / max(1.0 + (alpha * alpha - 1.0) * xi.y, 0.001));
+  let sin_theta = sqrt(max(1.0 - cos_theta * cos_theta, 0.0));
+  let tangent_seed = select(vec3<f32>(0.0, 1.0, 0.0), vec3<f32>(1.0, 0.0, 0.0), abs(normal.y) > 0.9);
+  let tangent = safe_normalize(cross(tangent_seed, normal));
+  let bitangent = cross(normal, tangent);
+  return safe_normalize(
+    tangent * cos(phi) * sin_theta +
+    bitangent * sin(phi) * sin_theta +
+    normal * cos_theta
+  );
+}
+
+@compute @workgroup_size(8, 8, 1)
+fn process_job(@builtin(global_invocation_id) global_id: vec3<u32>) {
+  let extent = face_extent();
+  if (global_id.x >= extent || global_id.y >= extent) {
+    return;
+  }
+
+  let normal = direction_from_texel(global_id.xy, extent);
+  let view_direction = normal;
+  let roughness = clamp_roughness(iblPrecomputeParams.roughness);
+  var prefiltered_radiance = vec3<f32>(0.0);
+  var importance_weight = 0.0;
+  var sample_index = 0u;
+  loop {
+    if (sample_index >= extent) {
+      break;
+    }
+
+    let xi = vec2<f32>(
+      (f32(sample_index) + 0.5) / f32(extent),
+      fract((f32(sample_index) * 0.7548776662466927) + (f32(global_id.x) + f32(global_id.y)) * 0.01)
+    );
+    let half_vector = importance_sample_hemisphere(normal, xi, roughness);
+    let sample_direction = reflect(-view_direction, half_vector);
+    let ndotl = max(dot(normal, sample_direction), 0.0);
+    if (ndotl > 0.0) {
+      let weight = mix(ndotl, pow(ndotl, 1.0 / max(roughness + 0.05, 0.05)), roughness);
+      prefiltered_radiance =
+        prefiltered_radiance + sample_environment(sample_direction) * weight;
+      importance_weight = importance_weight + weight;
+    }
+
+    sample_index = sample_index + 1u;
+  }
+
+  let resolved_radiance =
+    prefiltered_radiance / max(importance_weight, 0.0001) * max(iblPrecomputeParams.exposure_bias, 0.0001);
+  hdriSpecularOutput[face_pixel_index(global_id.xy)] = vec4<f32>(resolved_radiance, roughness);
 }

package/dist/techniques/techniques/volumetrics/froxel-integrate.job.wgsl

@@ -1,3 +1,106 @@
-fn process_job() {
-  // Placeholder froxel integration stage for volumetric lighting.
+struct VolumetricIntegrationParams {
+  light_direction: vec3<f32>,
+  history_blend: f32,
+  extinction_bias: f32,
+  ambient_boost: f32,
+  integration_step_scale: f32,
+  phase_bias: f32,
+  temporal_stability: f32,
+  reserved: f32,
+};
+
+struct FroxelMediumVoxel {
+  extinction_density: vec4<f32>,
+  inscattering_anisotropy: vec4<f32>,
+};
+
+struct VolumetricShadowHistory {
+  shadow_transmittance: vec4<f32>,
+  depth_phase: vec4<f32>,
+};
+
+struct FroxelIntegratedVoxel {
+  integrated_scattering: vec4<f32>,
+  integrated_extinction: vec4<f32>,
+};
+
+@group(0) @binding(0) var<uniform> froxelGridParams: FroxelGridParams;
+@group(0) @binding(1) var<uniform> volumetricIntegrationParams: VolumetricIntegrationParams;
+@group(0) @binding(2) var<storage, read> froxelMediumInput: array<FroxelMediumVoxel>;
+@group(0) @binding(3) var<storage, read> froxelShadowInput: array<VolumetricShadowHistory>;
+@group(0) @binding(4) var<storage, read_write> froxelIntegratedOutput: array<FroxelIntegratedVoxel>;
+
+fn froxel_integrate_index(coord: vec3<u32>) -> u32 {
+  let plane = max(froxelGridParams.grid_width, 1u) * max(froxelGridParams.grid_height, 1u);
+  return coord.z * plane + coord.y * max(froxelGridParams.grid_width, 1u) + coord.x;
+}
+
+fn safe_normalize(value: vec3<f32>) -> vec3<f32> {
+  let length_value = length(value);
+  if (length_value <= 0.000001) {
+    return vec3<f32>(0.0, 1.0, 0.0);
+  }
+  return value / length_value;
+}
+
+fn henyey_greenstein(cos_theta: f32, anisotropy: f32) -> f32 {
+  let g = clamp(anisotropy, -0.85, 0.85);
+  let denominator = pow(max(1.0 + g * g - 2.0 * g * cos_theta, 0.001), 1.5);
+  return (1.0 - g * g) / max(12.566370614359172 * denominator, 0.001);
+}
+
+@compute @workgroup_size(4, 4, 4)
+fn process_job(@builtin(global_invocation_id) global_id: vec3<u32>) {
+  if (
+    global_id.x >= froxelGridParams.grid_width ||
+    global_id.y >= froxelGridParams.grid_height ||
+    global_id.z >= froxelGridParams.grid_depth
+  ) {
+    return;
+  }
+
+  let index = froxel_integrate_index(global_id);
+  let medium = froxelMediumInput[index];
+  let shadow = froxelShadowInput[index];
+  let previous = froxelIntegratedOutput[index];
+  let light_direction = safe_normalize(volumetricIntegrationParams.light_direction);
+  let slice_depth = (f32(global_id.z) + 0.5) / max(f32(froxelGridParams.grid_depth), 1.0);
+  let density = max(medium.extinction_density.w + volumetricIntegrationParams.extinction_bias, 0.0);
+  let extinction = max(medium.extinction_density.xyz, vec3<f32>(0.0001));
+  let albedo = clamp(medium.inscattering_anisotropy.xyz, vec3<f32>(0.0), vec3<f32>(4.0));
+  let anisotropy = medium.inscattering_anisotropy.w;
+  let phase = henyey_greenstein(light_direction.y, anisotropy + volumetricIntegrationParams.phase_bias * 0.1);
+  let step_length =
+    max(volumetricIntegrationParams.integration_step_scale, 0.2) /
+    max(f32(froxelGridParams.grid_depth), 1.0);
+  let shadow_visibility = shadow.shadow_transmittance.w;
+  let ambient_term = vec3<f32>(0.08, 0.1, 0.14) * max(volumetricIntegrationParams.ambient_boost, 0.0);
+  let sample = MediumSample(
+    extinction,
+    (albedo * (0.25 + slice_depth * 0.5) + ambient_term) * shadow_visibility * phase
+  );
+  let transmittance = exp(-sample.extinction * density * step_length);
+  let integrated_scattering =
+    sample.inscattering *
+    froxelGridParams.scattering_strength *
+    (1.0 - transmittance) *
+    (1.0 + shadow.depth_phase.z * 0.2);
+  let integrated_extinction = sample.extinction * density * step_length;
+  let stability = clamp(
+    shadow.depth_phase.w * volumetricIntegrationParams.temporal_stability,
+    0.0,
+    1.0
+  );
+  let blend = clamp(volumetricIntegrationParams.history_blend, 0.0, 0.98) * stability;
+  let resolved_scattering =
+    previous.integrated_scattering.xyz * blend +
+    integrated_scattering * (1.0 - blend);
+  let resolved_extinction =
+    previous.integrated_extinction.xyz * blend +
+    integrated_extinction * (1.0 - blend);
+
+  froxelIntegratedOutput[index] = FroxelIntegratedVoxel(
+    vec4<f32>(resolved_scattering, shadow_visibility),
+    vec4<f32>(resolved_extinction, stability)
+  );
 }

package/dist/techniques/techniques/volumetrics/volumetric-shadow.job.wgsl

@@ -1,3 +1,97 @@
-fn process_job() {
-  // Placeholder volumetric shadow resolve stage.
+struct VolumetricLightParams {
+  light_direction: vec3<f32>,
+  history_blend: f32,
+  light_color: vec3<f32>,
+  shadow_strength: f32,
+  slice_depth_scale: f32,
+  density_bias: f32,
+  phase_bias: f32,
+  jitter_amount: f32,
+};
+
+struct FroxelMediumVoxel {
+  extinction_density: vec4<f32>,
+  inscattering_anisotropy: vec4<f32>,
+};
+
+struct VolumetricShadowHistory {
+  shadow_transmittance: vec4<f32>,
+  depth_phase: vec4<f32>,
+};
+
+@group(0) @binding(0) var<uniform> froxelGridParams: FroxelGridParams;
+@group(0) @binding(1) var<uniform> volumetricLightParams: VolumetricLightParams;
+@group(0) @binding(2) var<storage, read> froxelMediumInput: array<FroxelMediumVoxel>;
+@group(0) @binding(3) var<storage, read> froxelShadowHistory: array<VolumetricShadowHistory>;
+@group(0) @binding(4) var<storage, read_write> froxelShadowOutput: array<VolumetricShadowHistory>;
+
+fn froxel_shadow_index(coord: vec3<u32>) -> u32 {
+  let plane = max(froxelGridParams.grid_width, 1u) * max(froxelGridParams.grid_height, 1u);
+  return coord.z * plane + coord.y * max(froxelGridParams.grid_width, 1u) + coord.x;
+}
+
+fn safe_normalize(value: vec3<f32>) -> vec3<f32> {
+  let length_value = length(value);
+  if (length_value <= 0.000001) {
+    return vec3<f32>(0.0, 1.0, 0.0);
+  }
+  return value / length_value;
+}
+
+fn henyey_greenstein(cos_theta: f32, anisotropy: f32) -> f32 {
+  let g = clamp(anisotropy, -0.85, 0.85);
+  let denominator = pow(max(1.0 + g * g - 2.0 * g * cos_theta, 0.001), 1.5);
+  return (1.0 - g * g) / max(12.566370614359172 * denominator, 0.001);
+}
+
+@compute @workgroup_size(4, 4, 4)
+fn process_job(@builtin(global_invocation_id) global_id: vec3<u32>) {
+  if (
+    global_id.x >= froxelGridParams.grid_width ||
+    global_id.y >= froxelGridParams.grid_height ||
+    global_id.z >= froxelGridParams.grid_depth
+  ) {
+    return;
+  }
+
+  let index = froxel_shadow_index(global_id);
+  let medium = froxelMediumInput[index];
+  let previous = froxelShadowHistory[index];
+  let light_direction = safe_normalize(volumetricLightParams.light_direction);
+  let slice_depth = (f32(global_id.z) + 0.5) / max(f32(froxelGridParams.grid_depth), 1.0);
+  let density = max(medium.extinction_density.w + volumetricLightParams.density_bias, 0.0);
+  let extinction = max(dot(medium.extinction_density.xyz, vec3<f32>(0.2126, 0.7152, 0.0722)), 0.0001);
+  let anisotropy = medium.inscattering_anisotropy.w;
+  let phase_weight = henyey_greenstein(light_direction.y, anisotropy);
+  let depth_scale = max(volumetricLightParams.slice_depth_scale, 0.25);
+  let shadow_distance = depth_scale * mix(0.35, 1.35, slice_depth);
+  let optical_depth = (density * 0.7 + extinction * 0.3) * shadow_distance;
+  let raw_transmittance = exp(-optical_depth);
+  let horizon_wrap = 0.35 + 0.65 * saturate(light_direction.y * 0.5 + 0.5);
+  let jitter = fract(
+    f32(global_id.x * 19u + global_id.y * 47u + global_id.z * 73u) * 0.61803398875
+  );
+  let visibility = clamp(
+    raw_transmittance * horizon_wrap * (1.0 - volumetricLightParams.jitter_amount * (jitter - 0.5)),
+    0.0,
+    1.0
+  );
+  let history_visibility = previous.shadow_transmittance.w;
+  let blend = clamp(volumetricLightParams.history_blend, 0.0, 0.98);
+  let shadow_transmittance = mix(visibility, history_visibility, blend);
+  let light_radiance =
+    volumetricLightParams.light_color *
+    shadow_transmittance *
+    max(volumetricLightParams.shadow_strength, 0.0) *
+    (0.55 + phase_weight * 0.45);
+  let depth_confidence = clamp(
+    slice_depth * 0.45 + shadow_transmittance * 0.35 + (1.0 - density) * 0.2,
+    0.0,
+    1.0
+  );
+
+  froxelShadowOutput[index] = VolumetricShadowHistory(
+    vec4<f32>(light_radiance, shadow_transmittance),
+    vec4<f32>(slice_depth, optical_depth, phase_weight, depth_confidence)
+  );
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plasius/gpu-lighting",
-  "version": "0.2.3",
+  "version": "0.2.5",
   "description": "Advanced lighting WGSL modules and planning profiles for @plasius/gpu-worker.",
   "type": "module",
   "sideEffects": false,
@@ -26,7 +26,7 @@
   "scripts": {
     "build": "tsup && cp -R src/techniques dist/techniques",
     "demo": "python3 -m http.server --directory ..",
-    "typecheck": "node --check src/index.js && node --check demo/lighting-demo-config.js && node --check demo/main.js",
+    "typecheck": "node --check src/index.js && node --check demo/lighting-demo-config.js && node --check demo/main.js && node --check demo/eames-environments/page.js && node --check demo/eames-environments/eames-loader.js && node --check scripts/eames-environments/capture-runtime.mjs && node --check scripts/eames-environments/capture-server.mjs && node --check scripts/eames-environments/capture.mjs && node --check scripts/eames-environments/path-debug-capture.mjs && node --check scripts/eames-environments/capture-bridge-server.mjs",
     "audit:eslint": "eslint . --max-warnings=0",
     "audit:deps": "npm ls --all --omit=optional --omit=peer > /dev/null 2>&1 || true",
     "audit:npm": "npm audit --audit-level=high --omit=dev",

package/src/techniques/hdri/brdf-lut.job.wgsl

@@ -1,3 +1,71 @@
-fn process_job() {
-  // Placeholder BRDF LUT generation stage.
+@group(0) @binding(0) var<uniform> iblPrecomputeParams: IblPrecomputeParams;
+@group(0) @binding(1) var<storage, read_write> hdriBrdfLutOutput: array<vec4<f32>>;
+
+fn lut_extent() -> u32 {
+  return max(iblPrecomputeParams.sample_count, 1u);
+}
+
+fn lut_index(pixel: vec2<u32>) -> u32 {
+  let extent = lut_extent();
+  return pixel.y * extent + pixel.x;
+}
+
+fn saturate(value: f32) -> f32 {
+  return clamp(value, 0.0, 1.0);
+}
+
+fn geometry_schlick_ggx(ndotv: f32, roughness: f32) -> f32 {
+  let alpha = max(roughness * roughness, 0.001);
+  let k = (alpha + 1.0) * (alpha + 1.0) / 8.0;
+  return ndotv / max(ndotv * (1.0 - k) + k, 0.001);
+}
+
+fn geometry_smith(ndotv: f32, ndotl: f32, roughness: f32) -> f32 {
+  return geometry_schlick_ggx(ndotv, roughness) * geometry_schlick_ggx(ndotl, roughness);
+}
+
+fn fresnel_schlick(cos_theta: f32) -> f32 {
+  return pow(1.0 - saturate(cos_theta), 5.0);
+}
+
+@compute @workgroup_size(8, 8, 1)
+fn process_job(@builtin(global_invocation_id) global_id: vec3<u32>) {
+  let extent = lut_extent();
+  if (global_id.x >= extent || global_id.y >= extent) {
+    return;
+  }
+
+  let uv = (vec2<f32>(global_id.xy) + vec2<f32>(0.5)) / max(vec2<f32>(f32(extent)), vec2<f32>(1.0));
+  let ndotv = saturate(uv.x);
+  let roughness = clamp_roughness(uv.y + iblPrecomputeParams.roughness * 0.15);
+  let sample_total = max(iblPrecomputeParams.sample_count, 1u);
+  var integrated_brdf = vec2<f32>(0.0);
+  var sample_index = 0u;
+  loop {
+    if (sample_index >= sample_total) {
+      break;
+    }
+
+    let sample_u = (f32(sample_index) + 0.5) / f32(sample_total);
+    let sample_v = fract(f32(sample_index) * 0.61803398875);
+    let ndotl = saturate(sqrt(sample_u));
+    let vdoth = saturate(mix(ndotv, 1.0, sample_v));
+    let geometry = geometry_smith(ndotv, ndotl, roughness);
+    let fresnel = fresnel_schlick(vdoth);
+    integrated_brdf = integrated_brdf + vec2<f32>(
+      (1.0 - fresnel) * geometry,
+      fresnel * geometry
+    );
+
+    sample_index = sample_index + 1u;
+  }
+
+  integrated_brdf =
+    integrated_brdf / f32(sample_total) * max(iblPrecomputeParams.exposure_bias, 0.0001);
+  hdriBrdfLutOutput[lut_index(global_id.xy)] = vec4<f32>(
+    integrated_brdf.x,
+    integrated_brdf.y,
+    roughness,
+    ndotv
+  );
 }

package/src/techniques/hdri/irradiance-convolution.job.wgsl

@@ -1,3 +1,92 @@
-fn process_job() {
-  // Placeholder irradiance convolution stage.
+struct HdriConvolutionSample {
+  direction_radiance: vec4<f32>,
+};
+
+@group(0) @binding(0) var<uniform> iblPrecomputeParams: IblPrecomputeParams;
+@group(0) @binding(1) var<storage, read> hdriEnvironmentInput: array<HdriConvolutionSample>;
+@group(0) @binding(2) var<storage, read_write> hdriIrradianceOutput: array<vec4<f32>>;
+
+fn face_extent() -> u32 {
+  return max(iblPrecomputeParams.sample_count, 1u);
+}
+
+fn face_pixel_index(pixel: vec2<u32>) -> u32 {
+  let extent = face_extent();
+  return pixel.y * extent + pixel.x;
+}
+
+fn safe_normalize(value: vec3<f32>) -> vec3<f32> {
+  let length_value = length(value);
+  if (length_value <= 0.000001) {
+    return vec3<f32>(0.0, 1.0, 0.0);
+  }
+  return value / length_value;
+}
+
+fn direction_from_texel(pixel: vec2<u32>, extent: u32) -> vec3<f32> {
+  let uv = (vec2<f32>(pixel) + vec2<f32>(0.5)) / max(vec2<f32>(f32(extent)), vec2<f32>(1.0));
+  let phi = (uv.x * 2.0 - 1.0) * 3.141592653589793;
+  let theta = uv.y * 3.141592653589793;
+  let sin_theta = sin(theta);
+  return safe_normalize(
+    vec3<f32>(
+      cos(phi) * sin_theta,
+      cos(theta),
+      sin(phi) * sin_theta
+    )
+  );
+}
+
+fn direction_to_index(direction: vec3<f32>, extent: u32) -> u32 {
+  let dir = safe_normalize(direction);
+  let phi = atan2(dir.z, dir.x);
+  let theta = acos(clamp(dir.y, -1.0, 1.0));
+  let u = fract(phi / (2.0 * 3.141592653589793) + 0.5);
+  let v = clamp(theta / 3.141592653589793, 0.0, 0.999999);
+  let pixel = vec2<u32>(
+    min(u32(floor(u * f32(extent))), extent - 1u),
+    min(u32(floor(v * f32(extent))), extent - 1u)
+  );
+  return face_pixel_index(pixel);
+}
+
+fn sample_environment(direction: vec3<f32>) -> vec3<f32> {
+  let index = direction_to_index(direction, face_extent());
+  return hdriEnvironmentInput[index].direction_radiance.xyz;
+}
+
+@compute @workgroup_size(8, 8, 1)
+fn process_job(@builtin(global_invocation_id) global_id: vec3<u32>) {
+  let extent = face_extent();
+  if (global_id.x >= extent || global_id.y >= extent) {
+    return;
+  }
+
+  let normal = direction_from_texel(global_id.xy, extent);
+  var accumulated_irradiance = vec3<f32>(0.0);
+  var total_weight = 0.0;
+  var sample_index = 0u;
+  loop {
+    if (sample_index >= extent) {
+      break;
+    }
+
+    let sample_pixel = vec2<u32>(
+      (global_id.x + sample_index) % extent,
+      (global_id.y + sample_index * 3u) % extent
+    );
+    let sample_direction = direction_from_texel(sample_pixel, extent);
+    let cosine_weight = max(dot(normal, sample_direction), 0.0);
+    if (cosine_weight > 0.0) {
+      accumulated_irradiance =
+        accumulated_irradiance + sample_environment(sample_direction) * cosine_weight;
+      total_weight = total_weight + cosine_weight;
+    }
+
+    sample_index = sample_index + 1u;
+  }
+
+  let irradiance =
+    accumulated_irradiance / max(total_weight, 0.0001) * max(iblPrecomputeParams.exposure_bias, 0.0001);
+  hdriIrradianceOutput[face_pixel_index(global_id.xy)] = vec4<f32>(irradiance, 1.0);
 }

package/src/techniques/hdri/specular-prefilter.job.wgsl

@@ -1,3 +1,111 @@
-fn process_job() {
-  // Placeholder specular prefilter stage.
+struct HdriSpecularSample {
+  direction_radiance: vec4<f32>,
+};
+
+@group(0) @binding(0) var<uniform> iblPrecomputeParams: IblPrecomputeParams;
+@group(0) @binding(1) var<storage, read> hdriEnvironmentInput: array<HdriSpecularSample>;
+@group(0) @binding(2) var<storage, read_write> hdriSpecularOutput: array<vec4<f32>>;
+
+fn face_extent() -> u32 {
+  return max(iblPrecomputeParams.sample_count, 1u);
+}
+
+fn face_pixel_index(pixel: vec2<u32>) -> u32 {
+  let extent = face_extent();
+  return pixel.y * extent + pixel.x;
+}
+
+fn safe_normalize(value: vec3<f32>) -> vec3<f32> {
+  let length_value = length(value);
+  if (length_value <= 0.000001) {
+    return vec3<f32>(0.0, 1.0, 0.0);
+  }
+  return value / length_value;
+}
+
+fn direction_from_texel(pixel: vec2<u32>, extent: u32) -> vec3<f32> {
+  let uv = (vec2<f32>(pixel) + vec2<f32>(0.5)) / max(vec2<f32>(f32(extent)), vec2<f32>(1.0));
+  let phi = (uv.x * 2.0 - 1.0) * 3.141592653589793;
+  let theta = uv.y * 3.141592653589793;
+  let sin_theta = sin(theta);
+  return safe_normalize(
+    vec3<f32>(
+      cos(phi) * sin_theta,
+      cos(theta),
+      sin(phi) * sin_theta
+    )
+  );
+}
+
+fn direction_to_index(direction: vec3<f32>, extent: u32) -> u32 {
+  let dir = safe_normalize(direction);
+  let phi = atan2(dir.z, dir.x);
+  let theta = acos(clamp(dir.y, -1.0, 1.0));
+  let u = fract(phi / (2.0 * 3.141592653589793) + 0.5);
+  let v = clamp(theta / 3.141592653589793, 0.0, 0.999999);
+  let pixel = vec2<u32>(
+    min(u32(floor(u * f32(extent))), extent - 1u),
+    min(u32(floor(v * f32(extent))), extent - 1u)
+  );
+  return face_pixel_index(pixel);
+}
+
+fn sample_environment(direction: vec3<f32>) -> vec3<f32> {
+  let index = direction_to_index(direction, face_extent());
+  return hdriEnvironmentInput[index].direction_radiance.xyz;
+}
+
+fn importance_sample_hemisphere(normal: vec3<f32>, xi: vec2<f32>, roughness: f32) -> vec3<f32> {
+  let phi = 2.0 * 3.141592653589793 * xi.x;
+  let alpha = max(roughness * roughness, 0.001);
+  let cos_theta = sqrt((1.0 - xi.y) / max(1.0 + (alpha * alpha - 1.0) * xi.y, 0.001));
+  let sin_theta = sqrt(max(1.0 - cos_theta * cos_theta, 0.0));
+  let tangent_seed = select(vec3<f32>(0.0, 1.0, 0.0), vec3<f32>(1.0, 0.0, 0.0), abs(normal.y) > 0.9);
+  let tangent = safe_normalize(cross(tangent_seed, normal));
+  let bitangent = cross(normal, tangent);
+  return safe_normalize(
+    tangent * cos(phi) * sin_theta +
+    bitangent * sin(phi) * sin_theta +
+    normal * cos_theta
+  );
+}
+
+@compute @workgroup_size(8, 8, 1)
+fn process_job(@builtin(global_invocation_id) global_id: vec3<u32>) {
+  let extent = face_extent();
+  if (global_id.x >= extent || global_id.y >= extent) {
+    return;
+  }
+
+  let normal = direction_from_texel(global_id.xy, extent);
+  let view_direction = normal;
+  let roughness = clamp_roughness(iblPrecomputeParams.roughness);
+  var prefiltered_radiance = vec3<f32>(0.0);
+  var importance_weight = 0.0;
+  var sample_index = 0u;
+  loop {
+    if (sample_index >= extent) {
+      break;
+    }
+
+    let xi = vec2<f32>(
+      (f32(sample_index) + 0.5) / f32(extent),
+      fract((f32(sample_index) * 0.7548776662466927) + (f32(global_id.x) + f32(global_id.y)) * 0.01)
+    );
+    let half_vector = importance_sample_hemisphere(normal, xi, roughness);
+    let sample_direction = reflect(-view_direction, half_vector);
+    let ndotl = max(dot(normal, sample_direction), 0.0);
+    if (ndotl > 0.0) {
+      let weight = mix(ndotl, pow(ndotl, 1.0 / max(roughness + 0.05, 0.05)), roughness);
+      prefiltered_radiance =
+        prefiltered_radiance + sample_environment(sample_direction) * weight;
+      importance_weight = importance_weight + weight;
+    }
+
+    sample_index = sample_index + 1u;
+  }
+
+  let resolved_radiance =
+    prefiltered_radiance / max(importance_weight, 0.0001) * max(iblPrecomputeParams.exposure_bias, 0.0001);
+  hdriSpecularOutput[face_pixel_index(global_id.xy)] = vec4<f32>(resolved_radiance, roughness);
 }

package/src/techniques/volumetrics/froxel-integrate.job.wgsl

@@ -1,3 +1,106 @@
-fn process_job() {
-  // Placeholder froxel integration stage for volumetric lighting.
+struct VolumetricIntegrationParams {
+  light_direction: vec3<f32>,
+  history_blend: f32,
+  extinction_bias: f32,
+  ambient_boost: f32,
+  integration_step_scale: f32,
+  phase_bias: f32,
+  temporal_stability: f32,
+  reserved: f32,
+};
+
+struct FroxelMediumVoxel {
+  extinction_density: vec4<f32>,
+  inscattering_anisotropy: vec4<f32>,
+};
+
+struct VolumetricShadowHistory {
+  shadow_transmittance: vec4<f32>,
+  depth_phase: vec4<f32>,
+};
+
+struct FroxelIntegratedVoxel {
+  integrated_scattering: vec4<f32>,
+  integrated_extinction: vec4<f32>,
+};
+
+@group(0) @binding(0) var<uniform> froxelGridParams: FroxelGridParams;
+@group(0) @binding(1) var<uniform> volumetricIntegrationParams: VolumetricIntegrationParams;
+@group(0) @binding(2) var<storage, read> froxelMediumInput: array<FroxelMediumVoxel>;
+@group(0) @binding(3) var<storage, read> froxelShadowInput: array<VolumetricShadowHistory>;
+@group(0) @binding(4) var<storage, read_write> froxelIntegratedOutput: array<FroxelIntegratedVoxel>;
+
+fn froxel_integrate_index(coord: vec3<u32>) -> u32 {
+  let plane = max(froxelGridParams.grid_width, 1u) * max(froxelGridParams.grid_height, 1u);
+  return coord.z * plane + coord.y * max(froxelGridParams.grid_width, 1u) + coord.x;
+}
+
+fn safe_normalize(value: vec3<f32>) -> vec3<f32> {
+  let length_value = length(value);
+  if (length_value <= 0.000001) {
+    return vec3<f32>(0.0, 1.0, 0.0);
+  }
+  return value / length_value;
+}
+
+fn henyey_greenstein(cos_theta: f32, anisotropy: f32) -> f32 {
+  let g = clamp(anisotropy, -0.85, 0.85);
+  let denominator = pow(max(1.0 + g * g - 2.0 * g * cos_theta, 0.001), 1.5);
+  return (1.0 - g * g) / max(12.566370614359172 * denominator, 0.001);
+}
+
+@compute @workgroup_size(4, 4, 4)
+fn process_job(@builtin(global_invocation_id) global_id: vec3<u32>) {
+  if (
+    global_id.x >= froxelGridParams.grid_width ||
+    global_id.y >= froxelGridParams.grid_height ||
+    global_id.z >= froxelGridParams.grid_depth
+  ) {
+    return;
+  }
+
+  let index = froxel_integrate_index(global_id);
+  let medium = froxelMediumInput[index];
+  let shadow = froxelShadowInput[index];
+  let previous = froxelIntegratedOutput[index];
+  let light_direction = safe_normalize(volumetricIntegrationParams.light_direction);
+  let slice_depth = (f32(global_id.z) + 0.5) / max(f32(froxelGridParams.grid_depth), 1.0);
+  let density = max(medium.extinction_density.w + volumetricIntegrationParams.extinction_bias, 0.0);
+  let extinction = max(medium.extinction_density.xyz, vec3<f32>(0.0001));
+  let albedo = clamp(medium.inscattering_anisotropy.xyz, vec3<f32>(0.0), vec3<f32>(4.0));
+  let anisotropy = medium.inscattering_anisotropy.w;
+  let phase = henyey_greenstein(light_direction.y, anisotropy + volumetricIntegrationParams.phase_bias * 0.1);
+  let step_length =
+    max(volumetricIntegrationParams.integration_step_scale, 0.2) /
+    max(f32(froxelGridParams.grid_depth), 1.0);
+  let shadow_visibility = shadow.shadow_transmittance.w;
+  let ambient_term = vec3<f32>(0.08, 0.1, 0.14) * max(volumetricIntegrationParams.ambient_boost, 0.0);
+  let sample = MediumSample(
+    extinction,
+    (albedo * (0.25 + slice_depth * 0.5) + ambient_term) * shadow_visibility * phase
+  );
+  let transmittance = exp(-sample.extinction * density * step_length);
+  let integrated_scattering =
+    sample.inscattering *
+    froxelGridParams.scattering_strength *
+    (1.0 - transmittance) *
+    (1.0 + shadow.depth_phase.z * 0.2);
+  let integrated_extinction = sample.extinction * density * step_length;
+  let stability = clamp(
+    shadow.depth_phase.w * volumetricIntegrationParams.temporal_stability,
+    0.0,
+    1.0
+  );
+  let blend = clamp(volumetricIntegrationParams.history_blend, 0.0, 0.98) * stability;
+  let resolved_scattering =
+    previous.integrated_scattering.xyz * blend +
+    integrated_scattering * (1.0 - blend);
+  let resolved_extinction =
+    previous.integrated_extinction.xyz * blend +
+    integrated_extinction * (1.0 - blend);
+
+  froxelIntegratedOutput[index] = FroxelIntegratedVoxel(
+    vec4<f32>(resolved_scattering, shadow_visibility),
+    vec4<f32>(resolved_extinction, stability)
+  );
 }

package/src/techniques/volumetrics/volumetric-shadow.job.wgsl

@@ -1,3 +1,97 @@
-fn process_job() {
-  // Placeholder volumetric shadow resolve stage.
+struct VolumetricLightParams {
+  light_direction: vec3<f32>,
+  history_blend: f32,
+  light_color: vec3<f32>,
+  shadow_strength: f32,
+  slice_depth_scale: f32,
+  density_bias: f32,
+  phase_bias: f32,
+  jitter_amount: f32,
+};
+
+struct FroxelMediumVoxel {
+  extinction_density: vec4<f32>,
+  inscattering_anisotropy: vec4<f32>,
+};
+
+struct VolumetricShadowHistory {
+  shadow_transmittance: vec4<f32>,
+  depth_phase: vec4<f32>,
+};
+
+@group(0) @binding(0) var<uniform> froxelGridParams: FroxelGridParams;
+@group(0) @binding(1) var<uniform> volumetricLightParams: VolumetricLightParams;
+@group(0) @binding(2) var<storage, read> froxelMediumInput: array<FroxelMediumVoxel>;
+@group(0) @binding(3) var<storage, read> froxelShadowHistory: array<VolumetricShadowHistory>;
+@group(0) @binding(4) var<storage, read_write> froxelShadowOutput: array<VolumetricShadowHistory>;
+
+fn froxel_shadow_index(coord: vec3<u32>) -> u32 {
+  let plane = max(froxelGridParams.grid_width, 1u) * max(froxelGridParams.grid_height, 1u);
+  return coord.z * plane + coord.y * max(froxelGridParams.grid_width, 1u) + coord.x;
+}
+
+fn safe_normalize(value: vec3<f32>) -> vec3<f32> {
+  let length_value = length(value);
+  if (length_value <= 0.000001) {
+    return vec3<f32>(0.0, 1.0, 0.0);
+  }
+  return value / length_value;
+}
+
+fn henyey_greenstein(cos_theta: f32, anisotropy: f32) -> f32 {
+  let g = clamp(anisotropy, -0.85, 0.85);
+  let denominator = pow(max(1.0 + g * g - 2.0 * g * cos_theta, 0.001), 1.5);
+  return (1.0 - g * g) / max(12.566370614359172 * denominator, 0.001);
+}
+
+@compute @workgroup_size(4, 4, 4)
+fn process_job(@builtin(global_invocation_id) global_id: vec3<u32>) {
+  if (
+    global_id.x >= froxelGridParams.grid_width ||
+    global_id.y >= froxelGridParams.grid_height ||
+    global_id.z >= froxelGridParams.grid_depth
+  ) {
+    return;
+  }
+
+  let index = froxel_shadow_index(global_id);
+  let medium = froxelMediumInput[index];
+  let previous = froxelShadowHistory[index];
+  let light_direction = safe_normalize(volumetricLightParams.light_direction);
+  let slice_depth = (f32(global_id.z) + 0.5) / max(f32(froxelGridParams.grid_depth), 1.0);
+  let density = max(medium.extinction_density.w + volumetricLightParams.density_bias, 0.0);
+  let extinction = max(dot(medium.extinction_density.xyz, vec3<f32>(0.2126, 0.7152, 0.0722)), 0.0001);
+  let anisotropy = medium.inscattering_anisotropy.w;
+  let phase_weight = henyey_greenstein(light_direction.y, anisotropy);
+  let depth_scale = max(volumetricLightParams.slice_depth_scale, 0.25);
+  let shadow_distance = depth_scale * mix(0.35, 1.35, slice_depth);
+  let optical_depth = (density * 0.7 + extinction * 0.3) * shadow_distance;
+  let raw_transmittance = exp(-optical_depth);
+  let horizon_wrap = 0.35 + 0.65 * saturate(light_direction.y * 0.5 + 0.5);
+  let jitter = fract(
+    f32(global_id.x * 19u + global_id.y * 47u + global_id.z * 73u) * 0.61803398875
+  );
+  let visibility = clamp(
+    raw_transmittance * horizon_wrap * (1.0 - volumetricLightParams.jitter_amount * (jitter - 0.5)),
+    0.0,
+    1.0
+  );
+  let history_visibility = previous.shadow_transmittance.w;
+  let blend = clamp(volumetricLightParams.history_blend, 0.0, 0.98);
+  let shadow_transmittance = mix(visibility, history_visibility, blend);
+  let light_radiance =
+    volumetricLightParams.light_color *
+    shadow_transmittance *
+    max(volumetricLightParams.shadow_strength, 0.0) *
+    (0.55 + phase_weight * 0.45);
+  let depth_confidence = clamp(
+    slice_depth * 0.45 + shadow_transmittance * 0.35 + (1.0 - density) * 0.2,
+    0.0,
+    1.0
+  );
+
+  froxelShadowOutput[index] = VolumetricShadowHistory(
+    vec4<f32>(light_radiance, shadow_transmittance),
+    vec4<f32>(slice_depth, optical_depth, phase_weight, depth_confidence)
+  );
 }