@plasius/gpu-lighting 0.1.16 → 0.1.17

package/src/index.js

@@ -131,6 +131,16 @@ export const lightingProfiles = Object.freeze(
 export const lightingProfileNames = Object.freeze(Object.keys(lightingProfiles));
 
 export const defaultLightingProfile = "realtime";
+export const lightingProfileModeOrder = Object.freeze([
+  "realtime",
+  "hybrid",
+  "reference",
+]);
+export const defaultAdaptiveLightingProfilePolicy = Object.freeze({
+  preferredProfile: "reference",
+  minimumFrameRate: 30,
+  sampleWindowSize: 4,
+});
 export const lightingDistanceBands = Object.freeze([
   "near",
   "mid",
@@ -199,6 +209,23 @@ function assertLightingImportance(name, value) {
   return value;
 }
 
+function readPositiveIntegerOption(name, value, fallback) {
+  if (value === undefined) {
+    return fallback;
+  }
+
+  if (
+    typeof value !== "number" ||
+    !Number.isFinite(value) ||
+    value <= 0 ||
+    Math.round(value) !== value
+  ) {
+    throw new Error(`${name} must be a positive integer.`);
+  }
+
+  return value;
+}
+
 function resolveBandParticipation(profileName, band, importance) {
   const referenceProfile = profileName === "reference";
   const premiumImportance =
@@ -276,6 +303,93 @@ export function createLightingBandPlan(options = {}) {
   });
 }
 
+const lightingProfileModeEstimatedCostMs = Object.freeze({
+  realtime: 4.5,
+  hybrid: 7.5,
+  reference: 12.5,
+});
+
+export function createLightingProfileModeLadder(options = {}) {
+  const moduleId =
+    typeof options.id === "string" && options.id.trim().length > 0
+      ? options.id.trim()
+      : "lighting-profile-mode";
+  const preferredProfile = getLightingProfile(
+    options.preferredProfile ?? defaultAdaptiveLightingProfilePolicy.preferredProfile
+  ).name;
+  const initialProfile = getLightingProfile(
+    options.initialProfile ?? preferredProfile
+  ).name;
+  const minimumFrameRate = readPositiveIntegerOption(
+    "minimumFrameRate",
+    options.minimumFrameRate,
+    defaultAdaptiveLightingProfilePolicy.minimumFrameRate
+  );
+  const sampleWindowSize = readPositiveIntegerOption(
+    "sampleWindowSize",
+    options.sampleWindowSize,
+    defaultAdaptiveLightingProfilePolicy.sampleWindowSize
+  );
+  const importance = assertLightingImportance(
+    "importance",
+    options.importance ?? "high"
+  );
+  const moduleImportance = assertLightingImportance(
+    "moduleImportance",
+    options.moduleImportance ?? "critical"
+  );
+
+  const levels = Object.freeze(
+    lightingProfileModeOrder.map((profileName) => {
+      const profile = getLightingProfile(profileName);
+      return Object.freeze({
+        id: profile.name,
+        estimatedCostMs: lightingProfileModeEstimatedCostMs[profile.name],
+        config: Object.freeze({
+          profile: profile.name,
+          description: profile.description,
+          techniques: Object.freeze([...profile.techniques]),
+          lightingBandPlan: createLightingBandPlan({
+            profile: profile.name,
+            importance,
+          }),
+          policy: Object.freeze({
+            preferredProfile,
+            minimumFrameRate,
+            sampleWindowSize,
+          }),
+        }),
+      });
+    })
+  );
+
+  return Object.freeze({
+    id: moduleId,
+    domain: "lighting",
+    authority: "visual",
+    importance: moduleImportance,
+    initialLevel: initialProfile,
+    levels,
+    target: Object.freeze({
+      minimumFrameRate,
+      maximumFrameRate: minimumFrameRate,
+      preferredFrameRates: Object.freeze([minimumFrameRate]),
+    }),
+    adaptation: Object.freeze({
+      sampleWindowSize,
+      minimumSamplesBeforeAdjustment: sampleWindowSize,
+      degradeCooldownFrames: 1,
+      upgradeCooldownFrames: sampleWindowSize,
+      minStableFramesForRecovery: sampleWindowSize,
+    }),
+    policy: Object.freeze({
+      preferredProfile,
+      minimumFrameRate,
+      sampleWindowSize,
+    }),
+  });
+}
+
 function buildWorkerBudgetLevels(jobType, queueClass, presets) {
   return Object.freeze([
     Object.freeze({

package/src/techniques/hybrid/prelude.wgsl

@@ -3,6 +3,14 @@ struct HybridFrameParams {
   max_trace_steps: u32,
   history_weight: f32,
   exposure: f32,
+  image_width: u32,
+  image_height: u32,
+  reflection_reset: u32,
+  sky_mode: u32,
+  sky_intensity: f32,
+  max_reflection_distance: f32,
+  roughness_bias: f32,
+  thickness: f32,
 };
 
 struct HybridHit {
@@ -10,6 +18,115 @@ struct HybridHit {
   hit_distance: f32,
 };
 
+struct HybridReflectionCamera {
+  position: vec3<f32>,
+  _padding0: f32,
+};
+
+struct HybridReflectionSurface {
+  position: vec4<f32>,
+  normal_roughness: vec4<f32>,
+  albedo_metalness: vec4<f32>,
+  emission_occlusion: vec4<f32>,
+};
+
+struct HybridGroundPlane {
+  normal: vec3<f32>,
+  height: f32,
+  material_index: u32,
+  enabled: u32,
+  _padding0: vec2<u32>,
+};
+
+struct HybridReflectionSceneMetadata {
+  sphere_count: u32,
+  material_count: u32,
+  _padding0: vec2<u32>,
+  max_trace_distance: f32,
+};
+
+struct HybridReflectionMaterial {
+  albedo_roughness: vec4<f32>,
+  emission_metalness: vec4<f32>,
+};
+
+struct HybridReflectionSphere {
+  center_radius: vec4<f32>,
+  material_index: u32,
+  flags: u32,
+  _padding0: vec2<u32>,
+};
+
+struct HybridReflectionTrace {
+  hit_mask: u32,
+  distance: f32,
+  position: vec3<f32>,
+  material_index: u32,
+  normal: vec3<f32>,
+  _padding1: u32,
+};
+
+struct HybridReflectionPixel {
+  reflection_confidence: vec4<f32>,
+  hit_normal_distance: vec4<f32>,
+};
+
 fn encode_history_weight(value: f32) -> f32 {
   return clamp(value, 0.0, 1.0);
 }
+
+fn hybrid_saturate(value: f32) -> f32 {
+  return clamp(value, 0.0, 1.0);
+}
+
+fn hybrid_safe_normalize(value: vec3<f32>) -> vec3<f32> {
+  if (dot(value, value) <= 0.000001) {
+    return vec3<f32>(0.0, 1.0, 0.0);
+  }
+
+  return normalize(value);
+}
+
+fn hybrid_fresnel_schlick(cos_theta: f32, f0: vec3<f32>) -> vec3<f32> {
+  let factor = pow(1.0 - hybrid_saturate(cos_theta), 5.0);
+  return f0 + (vec3<f32>(1.0) - f0) * factor;
+}
+
+fn hybrid_hash_u32(value: u32) -> u32 {
+  var x = value + 0x9e3779b9u;
+  x = (x ^ (x >> 16u)) * 0x85ebca6bu;
+  x = (x ^ (x >> 13u)) * 0xc2b2ae35u;
+  return x ^ (x >> 16u);
+}
+
+fn hybrid_random_f32(state: ptr<function, u32>) -> f32 {
+  let next = hybrid_hash_u32((*state) ^ 0x7f4a7c15u);
+  *state = next;
+  return f32(next) * 2.3283064365386963e-10;
+}
+
+fn hybrid_sample_unit_sphere(state: ptr<function, u32>) -> vec3<f32> {
+  let z = hybrid_random_f32(state) * 2.0 - 1.0;
+  let angle = 6.283185307179586 * hybrid_random_f32(state);
+  let radius = sqrt(max(1.0 - z * z, 0.0));
+  return vec3<f32>(radius * cos(angle), radius * sin(angle), z);
+}
+
+fn hybrid_environment(direction: vec3<f32>, intensity: f32, mode: u32) -> vec3<f32> {
+  let up_factor = hybrid_saturate(direction.y * 0.5 + 0.5);
+  let horizon_color = vec3<f32>(0.54, 0.64, 0.77);
+  let zenith_color = select(
+    vec3<f32>(0.04, 0.09, 0.18),
+    vec3<f32>(0.09, 0.07, 0.16),
+    mode == 1u
+  );
+  let sun_direction = hybrid_safe_normalize(vec3<f32>(0.31, 0.92, 0.22));
+  let sun_glow = pow(hybrid_saturate(dot(direction, sun_direction)), 192.0);
+  let sunset_bias = select(vec3<f32>(0.0), vec3<f32>(0.55, 0.24, 0.08) * (1.0 - up_factor), mode == 1u);
+  return (
+    horizon_color * (1.0 - up_factor) +
+    zenith_color * up_factor +
+    sunset_bias +
+    vec3<f32>(5.8, 5.5, 5.0) * sun_glow
+  ) * max(intensity, 0.0001);
+}

package/src/techniques/hybrid/reflection-resolve.job.wgsl

@@ -1,3 +1,236 @@
-fn process_job() {
-  // Placeholder reflection resolve stage for rough/specular response.
+@group(0) @binding(0) var<uniform> hybridFrameParams: HybridFrameParams;
+@group(0) @binding(1) var<uniform> hybridReflectionCamera: HybridReflectionCamera;
+@group(0) @binding(2) var<storage, read> hybridReflectionSurfaces: array<HybridReflectionSurface>;
+@group(0) @binding(3) var<storage, read> hybridReflectionHistory: array<HybridReflectionPixel>;
+@group(0) @binding(4) var<storage, read> hybridReflectionScene: HybridReflectionSceneMetadata;
+@group(0) @binding(5) var<uniform> hybridGroundPlane: HybridGroundPlane;
+@group(0) @binding(6) var<storage, read> hybridReflectionMaterials: array<HybridReflectionMaterial>;
+@group(0) @binding(7) var<storage, read> hybridReflectionSpheres: array<HybridReflectionSphere>;
+@group(0) @binding(8) var<storage, read_write> hybridReflectionOutput: array<HybridReflectionPixel>;
+
+fn reflection_index(pixel: vec2<u32>) -> u32 {
+  return pixel.y * max(hybridFrameParams.image_width, 1u) + pixel.x;
+}
+
+fn unpack_reflection_material(index: u32) -> HybridReflectionMaterial {
+  if (hybridReflectionScene.material_count == 0u) {
+    return HybridReflectionMaterial(
+      vec4<f32>(0.7, 0.72, 0.76, 0.4),
+      vec4<f32>(0.0, 0.0, 0.0, 0.0)
+    );
+  }
+
+  let safe_index = min(index, hybridReflectionScene.material_count - 1u);
+  return hybridReflectionMaterials[safe_index];
+}
+
+fn miss_reflection() -> HybridReflectionTrace {
+  return HybridReflectionTrace(
+    0u,
+    hybridReflectionScene.max_trace_distance,
+    vec3<f32>(0.0),
+    0u,
+    vec3<f32>(0.0, 1.0, 0.0),
+    0u
+  );
+}
+
+fn set_best_reflection(best: ptr<function, HybridReflectionTrace>, candidate: HybridReflectionTrace) {
+  if (candidate.hit_mask == 1u && candidate.distance < (*best).distance) {
+    *best = candidate;
+  }
+}
+
+fn trace_reflection_ground(
+  origin: vec3<f32>,
+  direction: vec3<f32>,
+  best: ptr<function, HybridReflectionTrace>
+) {
+  if (hybridGroundPlane.enabled == 0u) {
+    return;
+  }
+
+  let plane_normal = hybrid_safe_normalize(hybridGroundPlane.normal);
+  let denominator = dot(plane_normal, direction);
+  if (abs(denominator) <= 0.0005) {
+    return;
+  }
+
+  let distance = -(dot(plane_normal, origin) + hybridGroundPlane.height) / denominator;
+  if (distance <= 0.0005 || distance >= (*best).distance || distance >= hybridReflectionScene.max_trace_distance) {
+    return;
+  }
+
+  set_best_reflection(
+    best,
+    HybridReflectionTrace(
+      1u,
+      distance,
+      origin + direction * distance,
+      hybridGroundPlane.material_index,
+      plane_normal,
+      0u
+    )
+  );
+}
+
+fn trace_reflection_spheres(
+  origin: vec3<f32>,
+  direction: vec3<f32>,
+  best: ptr<function, HybridReflectionTrace>
+) {
+  var index = 0u;
+  loop {
+    if (index >= hybridReflectionScene.sphere_count) {
+      break;
+    }
+
+    let sphere = hybridReflectionSpheres[index];
+    let offset = origin - sphere.center_radius.xyz;
+    let a = dot(direction, direction);
+    let half_b = dot(offset, direction);
+    let c = dot(offset, offset) - sphere.center_radius.w * sphere.center_radius.w;
+    let discriminant = half_b * half_b - a * c;
+    if (discriminant >= 0.0) {
+      let root = sqrt(discriminant);
+      var distance = (-half_b - root) / max(a, 0.0005);
+      if (distance <= 0.0005) {
+        distance = (-half_b + root) / max(a, 0.0005);
+      }
+      if (distance > 0.0005 && distance < (*best).distance && distance < hybridReflectionScene.max_trace_distance) {
+        let position = origin + direction * distance;
+        let normal = hybrid_safe_normalize(position - sphere.center_radius.xyz);
+        set_best_reflection(
+          best,
+          HybridReflectionTrace(
+            1u,
+            distance,
+            position,
+            sphere.material_index,
+            normal,
+            0u
+          )
+        );
+      }
+    }
+
+    index = index + 1u;
+  }
+}
+
+fn trace_reflection_scene(origin: vec3<f32>, direction: vec3<f32>) -> HybridReflectionTrace {
+  var best = miss_reflection();
+  trace_reflection_ground(origin, direction, &best);
+  trace_reflection_spheres(origin, direction, &best);
+  return best;
+}
+
+fn evaluate_hit_lighting(trace: HybridReflectionTrace, view_direction: vec3<f32>) -> vec3<f32> {
+  let material = unpack_reflection_material(trace.material_index);
+  let surface_normal = hybrid_safe_normalize(trace.normal);
+  let light_direction = hybrid_safe_normalize(vec3<f32>(0.31, 0.92, 0.22));
+  let ndotl = hybrid_saturate(dot(surface_normal, light_direction));
+  let halfway = hybrid_safe_normalize(light_direction + view_direction);
+  let roughness = clamp(material.albedo_roughness.w, 0.02, 1.0);
+  let metalness = hybrid_saturate(material.emission_metalness.w);
+  let albedo = material.albedo_roughness.xyz;
+  let f0 = vec3<f32>(0.04) * (1.0 - metalness) + albedo * metalness;
+  let fresnel = hybrid_fresnel_schlick(
+    hybrid_saturate(dot(surface_normal, view_direction)),
+    f0
+  );
+  let diffuse = albedo * ndotl * 0.3183098861837907 * (1.0 - metalness);
+  let specular_power = 12.0 + (1.0 - roughness) * 96.0;
+  let specular = fresnel * pow(hybrid_saturate(dot(surface_normal, halfway)), specular_power) * ndotl;
+  let direct_light = vec3<f32>(5.4, 5.0, 4.6) * ndotl;
+  let environment = hybrid_environment(surface_normal, hybridFrameParams.sky_intensity, hybridFrameParams.sky_mode);
+  return material.emission_metalness.xyz + (diffuse + specular) * direct_light + environment * 0.08;
+}
+
+@compute @workgroup_size(8, 8, 1)
+fn process_job(@builtin(global_invocation_id) global_id: vec3<u32>) {
+  if (
+    global_id.x >= hybridFrameParams.image_width ||
+    global_id.y >= hybridFrameParams.image_height
+  ) {
+    return;
+  }
+
+  let index = reflection_index(global_id.xy);
+  let surface = hybridReflectionSurfaces[index];
+  let previous = hybridReflectionHistory[index];
+  let position = surface.position.xyz;
+  let normal = hybrid_safe_normalize(surface.normal_roughness.xyz);
+  let roughness = clamp(surface.normal_roughness.w + hybridFrameParams.roughness_bias, 0.02, 1.0);
+  let albedo = surface.albedo_metalness.xyz;
+  let metalness = hybrid_saturate(surface.albedo_metalness.w);
+  let occlusion = hybrid_saturate(surface.emission_occlusion.w);
+  let view_direction = hybrid_safe_normalize(hybridReflectionCamera.position - position);
+  let f0 = vec3<f32>(0.04) * (1.0 - metalness) + albedo * metalness;
+  let fresnel = hybrid_fresnel_schlick(hybrid_saturate(dot(normal, view_direction)), f0);
+  let grazing_boost = pow(1.0 - hybrid_saturate(dot(normal, view_direction)), 5.0);
+  let reflection_budget = clamp(
+    (metalness * 0.85 + max(fresnel.x, max(fresnel.y, fresnel.z))) *
+      (1.0 - roughness * 0.65) +
+      grazing_boost * 0.2,
+    0.0,
+    1.0
+  );
+  let trace_needed = reflection_budget > 0.02;
+  var random_state = hybrid_hash_u32(
+    hybridFrameParams.frame_index * 747796405u +
+    index * 2891336453u +
+    0x27d4eb2du
+  );
+  let reflection_direction = hybrid_safe_normalize(
+    reflect(-view_direction, normal) +
+      hybrid_sample_unit_sphere(&random_state) * roughness * roughness * 0.35
+  );
+  var trace = miss_reflection();
+  if (trace_needed) {
+    trace = trace_reflection_scene(
+      position + normal * max(hybridFrameParams.thickness, 0.0005),
+      reflection_direction
+    );
+  }
+  let hit_radiance = select(
+    hybrid_environment(reflection_direction, hybridFrameParams.sky_intensity, hybridFrameParams.sky_mode),
+    evaluate_hit_lighting(trace, -reflection_direction),
+    trace.hit_mask == 1u
+  );
+  let roughness_mix = roughness * roughness;
+  let distant_fade = exp(
+    -trace.distance /
+      max(hybridFrameParams.max_reflection_distance * 0.65, 0.0005)
+  );
+  let reflection_color =
+    hit_radiance * reflection_budget * distant_fade * occlusion;
+  let sky_lobe = hybrid_environment(normal, hybridFrameParams.sky_intensity, hybridFrameParams.sky_mode);
+  let shaped_reflection =
+    reflection_color * (1.0 - roughness_mix * 0.35) +
+    sky_lobe * roughness_mix * 0.18 * reflection_budget;
+  let history_weight = select(
+    0.0,
+    encode_history_weight(hybridFrameParams.history_weight),
+    hybridFrameParams.reflection_reset == 0u && previous.reflection_confidence.w > 0.0
+  );
+  let resolved =
+    previous.reflection_confidence.xyz * history_weight +
+    shaped_reflection * (1.0 - history_weight);
+  let confidence = clamp(
+    reflection_budget * (0.45 + distant_fade * 0.55) * (1.0 - roughness * 0.35),
+    0.0,
+    1.0
+  );
+  let resolved_normal = select(normal, hybrid_safe_normalize(trace.normal), trace.hit_mask == 1u);
+  let resolved_distance = select(
+    hybridFrameParams.max_reflection_distance,
+    trace.distance,
+    trace.hit_mask == 1u
+  );
+
+  hybridReflectionOutput[index] = HybridReflectionPixel(
+    vec4<f32>(resolved * hybridFrameParams.exposure, confidence),
+    vec4<f32>(resolved_normal, resolved_distance)
+  );
 }

package/src/techniques/pathtracer/accumulate.job.wgsl

@@ -1,3 +1,65 @@
-fn process_job() {
-  // Placeholder progressive accumulation stage.
+@group(0) @binding(0) var<uniform> pathTracerParams: PathTracerParams;
+@group(0) @binding(1) var<storage, read> pathSampleBuffer: array<PathSamplePixel>;
+@group(0) @binding(2) var<storage, read_write> pathAccumulationBuffer: array<PathAccumulationPixel>;
+
+fn accumulation_index(pixel: vec2<u32>) -> u32 {
+  return pixel.y * max(pathTracerParams.image_width, 1u) + pixel.x;
+}
+
+fn reset_accumulation(sample: PathSamplePixel) -> PathAccumulationPixel {
+  let sample_luminance = luminance(sample.radiance_opacity.xyz);
+  return PathAccumulationPixel(
+    vec4<f32>(sample.radiance_opacity.xyz, max(sample.albedo_sample_count.w, 1.0)),
+    vec4<f32>(sample_luminance, 0.0, 0.0, f32(pathTracerParams.frame_index))
+  );
+}
+
+@compute @workgroup_size(8, 8, 1)
+fn process_job(@builtin(global_invocation_id) global_id: vec3<u32>) {
+  if (
+    global_id.x >= pathTracerParams.image_width ||
+    global_id.y >= pathTracerParams.image_height
+  ) {
+    return;
+  }
+
+  let index = accumulation_index(global_id.xy);
+  let sample = pathSampleBuffer[index];
+  let history = pathAccumulationBuffer[index];
+  let sample_luminance = luminance(sample.radiance_opacity.xyz);
+  let current_samples = max(sample.albedo_sample_count.w, 1.0);
+  let history_samples = max(history.integrated_radiance.w, 0.0);
+  let should_reset =
+    pathTracerParams.accumulation_reset != 0u ||
+    history_samples <= 0.0 ||
+    history.moments.w <= 0.0;
+
+  if (should_reset) {
+    pathAccumulationBuffer[index] = reset_accumulation(sample);
+    return;
+  }
+
+  let combined_samples = min(history_samples + current_samples, 4096.0);
+  let progressive_weight = current_samples / max(combined_samples, 1.0);
+  let minimum_refresh = 1.0 - clamp(pathTracerParams.history_blend, 0.0, 0.98);
+  let blend = clamp(max(progressive_weight, minimum_refresh), 0.02, 1.0);
+  let integrated =
+    history.integrated_radiance.xyz * (1.0 - blend) +
+    sample.radiance_opacity.xyz * blend;
+  let mean_luminance =
+    history.moments.x * (1.0 - blend) +
+    sample_luminance * blend;
+  let variance_sample = sample_luminance - mean_luminance;
+  let variance =
+    max(0.0, history.moments.y * (1.0 - blend) + variance_sample * variance_sample * blend);
+
+  pathAccumulationBuffer[index] = PathAccumulationPixel(
+    vec4<f32>(integrated, combined_samples),
+    vec4<f32>(
+      mean_luminance,
+      variance,
+      1.0 - blend,
+      f32(pathTracerParams.frame_index)
+    )
+  );
 }

package/src/techniques/pathtracer/denoise.job.wgsl

@@ -1,3 +1,126 @@
-fn process_job() {
-  // Placeholder denoise stage for interactive reference previews.
+@group(0) @binding(0) var<uniform> pathTracerParams: PathTracerParams;
+@group(0) @binding(1) var<storage, read> pathAccumulationBuffer: array<PathAccumulationPixel>;
+@group(0) @binding(2) var<storage, read> pathSampleBuffer: array<PathSamplePixel>;
+@group(0) @binding(3) var<storage, read_write> pathDenoiseHistoryBuffer: array<PathDenoisePixel>;
+
+fn denoise_index(pixel: vec2<u32>) -> u32 {
+  return pixel.y * max(pathTracerParams.image_width, 1u) + pixel.x;
+}
+
+fn in_bounds(pixel: vec2<i32>) -> bool {
+  return
+    pixel.x >= 0 &&
+    pixel.y >= 0 &&
+    pixel.x < i32(pathTracerParams.image_width) &&
+    pixel.y < i32(pathTracerParams.image_height);
+}
+
+fn spatial_kernel(offset: vec2<i32>) -> f32 {
+  if (offset.x == 0 && offset.y == 0) {
+    return 4.0;
+  }
+  if (offset.x == 0 || offset.y == 0) {
+    return 2.0;
+  }
+  return 1.0;
+}
+
+fn bilateral_weight(
+  center_sample: PathSamplePixel,
+  center_accumulation: PathAccumulationPixel,
+  neighbor_sample: PathSamplePixel,
+  offset: vec2<i32>
+) -> f32 {
+  let strength = clamp(pathTracerParams.denoise_strength, 0.0, 1.0);
+  let center_normal = safe_normalize(center_sample.normal_roughness.xyz);
+  let neighbor_normal = safe_normalize(neighbor_sample.normal_roughness.xyz);
+  let normal_alignment = pow(
+    saturate(dot(center_normal, neighbor_normal)),
+    6.0 + (1.0 - strength) * 24.0
+  );
+  let depth_delta = abs(center_sample.direction_distance.w - neighbor_sample.direction_distance.w);
+  let depth_scale =
+    max(center_sample.direction_distance.w, 1.0) *
+    (0.01 + strength * 0.04);
+  let depth_weight = exp(-depth_delta * safe_rcp(depth_scale));
+  let albedo_delta = length(
+    center_sample.albedo_sample_count.xyz - neighbor_sample.albedo_sample_count.xyz
+  );
+  let albedo_weight = exp(-albedo_delta * (2.0 + strength * 2.0));
+  let sample_weight = clamp(
+    neighbor_sample.albedo_sample_count.w /
+      max(center_sample.albedo_sample_count.w, 1.0),
+    0.25,
+    1.5
+  );
+  let variance_penalty = 1.0 / (1.0 + center_accumulation.moments.y * 0.5);
+  return spatial_kernel(offset) *
+    max(normal_alignment * depth_weight * albedo_weight * sample_weight * variance_penalty, 0.0001);
+}
+
+@compute @workgroup_size(8, 8, 1)
+fn process_job(@builtin(global_invocation_id) global_id: vec3<u32>) {
+  if (
+    global_id.x >= pathTracerParams.image_width ||
+    global_id.y >= pathTracerParams.image_height
+  ) {
+    return;
+  }
+
+  let pixel = vec2<i32>(i32(global_id.x), i32(global_id.y));
+  let index = denoise_index(global_id.xy);
+  let center_accumulation = pathAccumulationBuffer[index];
+  let center_sample = pathSampleBuffer[index];
+  let center_history = pathDenoiseHistoryBuffer[index];
+  var filtered = vec3<f32>(0.0);
+  var total_weight = 0.0;
+
+  for (var y = -1; y <= 1; y = y + 1) {
+    for (var x = -1; x <= 1; x = x + 1) {
+      let neighbor_pixel = pixel + vec2<i32>(x, y);
+      if (!in_bounds(neighbor_pixel)) {
+        continue;
+      }
+
+      let neighbor_index = denoise_index(vec2<u32>(u32(neighbor_pixel.x), u32(neighbor_pixel.y)));
+      let neighbor_accumulation = pathAccumulationBuffer[neighbor_index];
+      let neighbor_sample = pathSampleBuffer[neighbor_index];
+      let weight = bilateral_weight(
+        center_sample,
+        center_accumulation,
+        neighbor_sample,
+        vec2<i32>(x, y)
+      );
+      filtered = filtered + neighbor_accumulation.integrated_radiance.xyz * weight;
+      total_weight = total_weight + weight;
+    }
+  }
+
+  let filtered_color = filtered / max(total_weight, PATH_TRACER_EPSILON);
+  let sample_confidence = clamp(
+    log2(max(center_accumulation.integrated_radiance.w, 1.0) + 1.0) / 6.0,
+    0.0,
+    1.0
+  );
+  let variance_penalty = 1.0 / (1.0 + center_accumulation.moments.y * 0.75);
+  let confidence = clamp(sample_confidence * variance_penalty, 0.0, 1.0);
+  let use_history =
+    pathTracerParams.accumulation_reset == 0u &&
+    center_history.filtered_radiance.w > 0.0;
+  let temporal_blend = clamp(0.2 + confidence * 0.6, 0.2, 0.9);
+  let resolved_color = select(
+    filtered_color,
+    center_history.filtered_radiance.xyz * (1.0 - temporal_blend) +
+      filtered_color * temporal_blend,
+    use_history
+  );
+
+  pathDenoiseHistoryBuffer[index] = PathDenoisePixel(
+    vec4<f32>(resolved_color, confidence),
+    vec4<f32>(safe_normalize(center_sample.normal_roughness.xyz), center_sample.direction_distance.w),
+    vec4<f32>(
+      center_sample.albedo_sample_count.xyz,
+      center_accumulation.integrated_radiance.w
+    )
+  );
 }