@forgeax/engine-shader 0.1.19 → 0.1.21

package/src/skybox.wgsl

@@ -23,9 +23,8 @@
 //   @binding(3) rotation      : SkyboxRotation (UBO)
 
 #import forgeax_view::common::FullscreenOutput
-#import forgeax_view::common::{View, FogViewParams, FogRay}
+#import forgeax_view::common::View
 #import forgeax_view::common::fullscreen_triangle
-#import forgeax_view::fog::{apply_fog}
 #import forgeax_pbr::ibl_shared::{inverseRotateEnvironment}
 
 @group(0) @binding(0) var cubemap       : texture_cube<f32>;
@@ -67,9 +66,5 @@ fn skyboxDirection(uv : vec2<f32>) -> vec3<f32> {
 fn skybox_fs(in : FullscreenOutput) -> @location(0) vec4<f32> {
   let dir = skyboxDirection(in.uv);
   let color = textureSample(cubemap, cubemapSampler, dir).rgb;
-  return apply_fog(
-    view.fog,
-    FogRay(view.cameraPos, dir, max(view.temporalProjection.y, 0.0)),
-    vec4<f32>(color, 1.0),
-  );
+  return vec4<f32>(color, 1.0);
 }

package/src/sprite-lit.wgsl

@@ -1,9 +1,12 @@
 #pragma variant_axis STORAGE_BUFFER_AVAILABLE
+#pragma variant_axis CLUSTER_FORWARD_AVAILABLE
 #define_import_path forgeax_material::sprite-lit
 
-#import forgeax_view::common::{View, FogViewParams, FogRay, Mesh, InstanceData, PointLight, SpotLight, view, meshes, instances, pointLightsBuffer, spotLightsBuffer, sampleMaterialTexture}
-#import forgeax_scene_temporal::{packSceneTemporalV1}
-#import forgeax_view::fog::{apply_fog}
+#import forgeax_view::common::{View, Mesh, InstanceData, view, meshes, instances, sampleMaterialTexture}
+#import forgeax_scene_temporal::{packSceneTemporalV1, sceneViewZ}
+#ifdef CLUSTER_FORWARD_AVAILABLE
+#import forgeax_standard::cluster::{evaluateStandardClusterLights}
+#endif
 
 // @forgeax/engine-shader - sprite-lit.wgsl
 // (tweak-20260701-sprite-lit-flat-default-drop-ndotl-for-2d).
@@ -27,7 +30,8 @@
 //   - no shadow receiver / caster
 //   - no Godot-style light_mode blends
 //   - no IBL ambient
-//   - no HDRP cluster-forward path
+//   - Standard clustered punctual lights are enabled by the
+//     CLUSTER_FORWARD_AVAILABLE variant.
 //
 // >>> AI user error self-recovery hint:
 // sprite-lit needs at least one light in scene; for unlit sprites use
@@ -39,8 +43,7 @@
 // pipelineState.defaultSampler + .defaultWhiteTextureView on the host side):
 //
 //   @group(0) @binding(0) view                       uniform
-//   @group(0) @binding(1) pointLightsBuffer          storage / uniform (variant)
-//   @group(0) @binding(2) spotLightsBuffer           storage / uniform (variant)
+//   @group(0) @binding(1..2) Standard Cluster storage (selected variant)
 //   @group(1) @binding(0) material                   uniform (sprite layout
 //                                                             colorTint /
 //                                                             region /
@@ -81,16 +84,17 @@ struct VsIn {
   @location(3) tangent : vec4<f32>,
 };
 
-// VsOut carries the atlas UV plus the per-fragment world-space position.
-// The world position is emitted from the vertex stage (already computed
-// there for `out.clip`), so PointLight / SpotLight attenuation gets an
-// exact per-fragment worldPos through interpolation. This replaces the
-// earlier fragment-side reconstruction path, which collapsed under
-// multi-instance draws and could not handle the 9-slice quad layout.
+// VsOut carries the atlas UV plus the per-fragment world-space position and
+// the Standard cluster coordinates produced by the vertex stage. Fragment
+// `@builtin(position)` is framebuffer-space after rasterization, so it is not
+// a valid source for NDC cluster lookup; keep the perspective divide here and
+// interpolate the result alongside worldPos.
 struct VsOut {
   @builtin(position) clip     : vec4<f32>,
   @location(0)       uv_atlas : vec2<f32>,
   @location(1)       worldPos : vec3<f32>,
+  @location(2)       ndc      : vec3<f32>,
+  @location(3)       viewZ    : f32,
 };
 
 struct SpriteVertex {
@@ -156,6 +160,11 @@ fn vs_main(in : VsIn, @builtin(instance_index) idx : u32, @builtin(vertex_index)
   out.clip = view.worldViewProj * world;
   out.uv_atlas = vertex.uvAtlas;
   out.worldPos = world.xyz;
+  let clipPos = out.clip;
+  out.ndc = clipPos.xyz / clipPos.w;
+  // Keep the cluster depth exactly aligned with the CPU binner for both
+  // perspective and off-axis orthographic projections.
+  out.viewZ = sceneViewZ(clipPos, view.temporalProjection);
   return out;
 }
 
@@ -175,79 +184,36 @@ fn spriteLitDirectional(albedo : vec3<f32>) -> vec3<f32> {
   return albedo * view.lightColor;
 }
 
-// Flat point-light contribution. Applies the KHR-lights-punctual smooth-
-// window range attenuation only. `attenuation` is 0 outside the light's
-// range (`invRangeSquared`) and 1 at the light center; the reciprocal-square
-// term gives the physical falloff. URP cap = 4 point lights per pass.
-fn spriteLitPoint(p : PointLight, worldPos : vec3<f32>, albedo : vec3<f32>) -> vec3<f32> {
-  let toLight = p.position - worldPos;
-  let dSquared = max(dot(toLight, toLight), 1e-4);
-  let factor = 1.0 - (dSquared * p.invRangeSquared) * (dSquared * p.invRangeSquared);
-  let attenuation = max(min(factor, 1.0), 0.0) / dSquared;
-  return albedo * p.colorTimesIntensity * attenuation;
-}
-
-// Flat spot-light contribution. Same range attenuation as spriteLitPoint,
-// modulated by a smoothstep cone factor (host-side degree -> cosine
-// conversion). Spot direction only shapes the cone; it does not project
-// onto a surface normal. URP cap = 4 spot lights per pass.
-fn spriteLitSpot(s : SpotLight, worldPos : vec3<f32>, albedo : vec3<f32>) -> vec3<f32> {
-  let toLight = s.position - worldPos;
-  let dSquared = max(dot(toLight, toLight), 1e-4);
-  let l = toLight / sqrt(dSquared);
-  let factor = 1.0 - (dSquared * s.invRangeSquared) * (dSquared * s.invRangeSquared);
-  let attenuation = max(min(factor, 1.0), 0.0) / dSquared;
-  let cone = smoothstep(s.cosOuter, s.cosInner, dot(l, -s.direction));
-  return albedo * s.colorTimesIntensity * attenuation * cone;
-}
-
 // Shared shading body used by both fs_main (LDR) and fs_main_hdr (HDR).
 // The two entry points differ only in their tail-end clamp + srgb encode
 // step (LDR clamp / HDR pass-through boundary).
-fn spriteLitShadeAccum(albedo : vec3<f32>, worldPos : vec3<f32>) -> vec3<f32> {
+fn spriteLitShadeAccum(
+  albedo : vec3<f32>,
+  worldPos : vec3<f32>,
+  ndc : vec3<f32>,
+  viewZ : f32,
+) -> vec3<f32> {
   // Directional contribution (1 light, View UBO).
   var lit = spriteLitDirectional(albedo);
-  // Point-light contribution (URP cap = 4; PointLightsArray.count).
-  let pointCount = pointLightsBuffer.count;
-  for (var i : u32 = 0u; i < pointCount; i = i + 1u) {
-    let p = pointLightsBuffer.slots[i];
-    lit = lit + spriteLitPoint(p, worldPos, albedo);
-  }
-  // Spot-light contribution (URP cap = 4).
-  let spotCount = spotLightsBuffer.count;
-  for (var i : u32 = 0u; i < spotCount; i = i + 1u) {
-    let s = spotLightsBuffer.slots[i];
-    lit = lit + spriteLitSpot(s, worldPos, albedo);
-  }
+#ifdef CLUSTER_FORWARD_AVAILABLE
+  let viewDir = normalize(view.cameraPos - worldPos);
+  lit = lit + evaluateStandardClusterLights(
+    ndc, viewZ, worldPos, vec3<f32>(0.0, 0.0, 1.0),
+    viewDir, albedo, 0.0, 1.0, vec3<f32>(0.04), true,
+  );
+#endif
   return lit;
 }
 
-fn applySceneFog(viewParams : View, color : vec3<f32>, alpha : f32, worldPos : vec3<f32>) -> vec4<f32> {
-  var origin = viewParams.cameraPos;
-  var direction = normalize(worldPos - origin);
-  var rayDistance = length(worldPos - origin);
-  if (viewParams.temporalProjection.z >= 0.5) {
-    let nearH = viewParams.inverseViewProj * vec4<f32>(0.0, 0.0, 0.0, 1.0);
-    let farH = viewParams.inverseViewProj * vec4<f32>(0.0, 0.0, 1.0, 1.0);
-    let nearPoint = nearH.xyz / nearH.w;
-    let farPoint = farH.xyz / farH.w;
-    direction = normalize(farPoint - nearPoint);
-    origin = worldPos - direction * dot(worldPos - viewParams.cameraPos, direction);
-    rayDistance = max(dot(worldPos - origin, direction), 0.0);
-  }
-  return apply_fog(viewParams.fog, FogRay(origin, direction, rayDistance), vec4<f32>(color, alpha));
-}
-
 @fragment
 fn fs_main(in : VsOut) -> @location(0) vec4<f32> {
   let texel = sampleMaterialTexture(baseColorTexture, baseColorSampler, in.uv_atlas, material.baseColorTextureCoordinatesMetadata.zw);
   let albedo4 = texel * material.colorTint;
-  let lit = spriteLitShadeAccum(albedo4.rgb, in.worldPos);
+  let lit = spriteLitShadeAccum(albedo4.rgb, in.worldPos, in.ndc, in.viewZ);
   // Strict clamp 0..1 before premultiplied alpha multiply keeps the LDR
   // path bounded even when a scene stacks many lights.
   let lit_rgba = clamp(vec4<f32>(lit, albedo4.a), vec4<f32>(0.0), vec4<f32>(1.0));
-  let fogged = applySceneFog(view, lit_rgba.rgb, lit_rgba.a, in.worldPos);
-  let premult = vec4<f32>(fogged.rgb * fogged.a, fogged.a);
+  let premult = vec4<f32>(lit_rgba.rgb * lit_rgba.a, lit_rgba.a);
   // LDR target is bgra8unorm; encode rgb via the sRGB transfer in-shader.
   return vec4<f32>(
     linear_to_srgb(premult.r),
@@ -261,13 +227,12 @@ fn fs_main(in : VsOut) -> @location(0) vec4<f32> {
 fn fs_main_hdr(in : VsOut) -> @location(0) vec4<f32> {
   let texel = sampleMaterialTexture(baseColorTexture, baseColorSampler, in.uv_atlas, material.baseColorTextureCoordinatesMetadata.zw);
   let albedo4 = texel * material.colorTint;
-  let lit = spriteLitShadeAccum(albedo4.rgb, in.worldPos);
+  let lit = spriteLitShadeAccum(albedo4.rgb, in.worldPos, in.ndc, in.viewZ);
   // HDR variant: do NOT clamp the lit output to [0, 1]; let the tonemap
   // pass absorb HDR values > 1. Alpha stays clamped because the premult
   // math requires alpha in [0, 1].
   let alpha = clamp(albedo4.a, 0.0, 1.0);
-  let fogged = applySceneFog(view, lit, alpha, in.worldPos);
-  return vec4<f32>(fogged.rgb * fogged.a, fogged.a);
+  return vec4<f32>(lit * alpha, alpha);
 }
 
 struct TemporalVsOut {

package/src/sprite.wgsl

@@ -2,9 +2,8 @@
 #pragma variant_axis STORAGE_BUFFER_AVAILABLE
 #pragma variant_axis PER_INSTANCE_REGION
 
-#import forgeax_view::common::{View, FogViewParams, FogRay, Mesh, InstanceData, view, meshes, instances, sampleMaterialTexture}
+#import forgeax_view::common::{View, Mesh, InstanceData, view, meshes, instances, sampleMaterialTexture}
 #import forgeax_scene_temporal::{packSceneTemporalV1}
-#import forgeax_view::fog::{apply_fog}
 
 // @forgeax/engine-shader - sprite.wgsl (feat-20260520-2d-sprite-layer-mvp /
 // M-3 / w19). 2D sprite material — third variant of the MaterialAsset
@@ -271,22 +270,6 @@ fn vs_main(in : VsIn, @builtin(instance_index) idx : u32, @builtin(vertex_index)
   return out;
 }
 
-fn applySceneFog(viewParams : View, color : vec3<f32>, alpha : f32, worldPos : vec3<f32>) -> vec4<f32> {
-  var origin = viewParams.cameraPos;
-  var direction = normalize(worldPos - origin);
-  var rayDistance = length(worldPos - origin);
-  if (viewParams.temporalProjection.z >= 0.5) {
-    let nearH = viewParams.inverseViewProj * vec4<f32>(0.0, 0.0, 0.0, 1.0);
-    let farH = viewParams.inverseViewProj * vec4<f32>(0.0, 0.0, 1.0, 1.0);
-    let nearPoint = nearH.xyz / nearH.w;
-    let farPoint = farH.xyz / farH.w;
-    direction = normalize(farPoint - nearPoint);
-    origin = worldPos - direction * dot(worldPos - viewParams.cameraPos, direction);
-    rayDistance = max(dot(worldPos - origin, direction), 0.0);
-  }
-  return apply_fog(viewParams.fog, FogRay(origin, direction, rayDistance), vec4<f32>(color, alpha));
-}
-
 // linear_to_srgb: per-channel IEC 61966-2-1 transfer function used by the
 // LDR fragment entry to encode linear premultiplied RGB into the bgra8unorm
 // swap-chain storage. The bgra8unorm target is not hardware-sRGB-encoded
@@ -304,8 +287,7 @@ fn fs_main(in : VsOut) -> @location(0) vec4<f32> {
   let rgba = clamp(texel * material.colorTint, vec4<f32>(0.0), vec4<f32>(1.0));
   // Premultiplied alpha: rgb pre-multiplied by alpha for srcFactor='one' /
   // dstFactor='one-minus-src-alpha' blend.
-  let fogged = applySceneFog(view, rgba.rgb, rgba.a, in.worldPos);
-  let premult = vec4<f32>(fogged.rgb * fogged.a, fogged.a);
+  let premult = vec4<f32>(rgba.rgb * rgba.a, rgba.a);
   // LDR target is bgra8unorm (blendable per WebGPU spec); hardware does not
   // sRGB-encode bgra8unorm, so apply the transfer function in the shader.
   // Only RGB channels are encoded; alpha is linear throughout the blend.
@@ -324,8 +306,7 @@ fn fs_main_hdr(in : VsOut) -> @location(0) vec4<f32> {
   let texel = sampleMaterialTexture(baseColorTexture, baseColorSampler, in.uv_atlas, material.baseColorTextureCoordinatesMetadata.zw);
   // R6 mitigation: strict clamp 0..1 before premultiplied alpha multiply.
   let rgba = clamp(texel * material.colorTint, vec4<f32>(0.0), vec4<f32>(1.0));
-  let fogged = applySceneFog(view, rgba.rgb, rgba.a, in.worldPos);
-  return vec4<f32>(fogged.rgb * fogged.a, fogged.a);
+  return vec4<f32>(rgba.rgb * rgba.a, rgba.a);
 }
 
 struct TemporalVsOut {

package/src/{hdrp-cluster-forward.wgsl → standard-cluster.wgsl}

@@ -1,13 +1,17 @@
-// hdrp-cluster-forward.wgsl — HDRP cluster-forward punctual light evaluation.
+// standard-cluster.wgsl — Standard clustered punctual light evaluation.
 // feat-20260608-cluster-lighting M4 / w17.
 //
 // The cluster module owns membership and raw payload decoding only. Punctual
 // BRDF, range, cone, PCF, and fail-open behavior live in lighting-punctual.
 
-#define_import_path forgeax_hdrp::cluster_forward
+#define_import_path forgeax_standard::cluster
 
-#import forgeax_pbr::lighting_punctual::{evalPoint, evalSpot, evalSpotShadowed}
+#import forgeax_pbr::lighting_punctual::{evalPoint, evalPointFlat, evalSpot, evalSpotFlat, evalSpotShadowed}
+#import forgeax_pbr::lighting_attenuation::{projectSpotUv}
 #import forgeax_view::common::{view}
+#ifdef PROJECTOR_AVAILABLE
+#import forgeax_view::common::{projectorTexture, projectorSampler}
+#endif
 #ifdef POINT_SHADOW_AVAILABLE
 #import forgeax_pbr::lighting_punctual::{evalPointShadowed}
 #endif
@@ -16,6 +20,11 @@
 
 const KIND_POINT: u32 = 0u;
 const KIND_SPOT: u32 = 1u;
+// LightSlot.kind_and_shadow.y uses one high bit as the accepted projector
+// marker. The remaining bits are the shadow-atlas tile (0..3), with zero as
+// the explicit View-UBO lane for projector-only spots.
+const PROJECTOR_FLAG: i32 = 0x40000000;
+const TILE_MASK: i32 = 0x3fffffff;
 
 // LightSlot is the byte-frozen 64B std430/std140 transport contract.
 // [0..2] position, [3] invRangeSquared
@@ -37,13 +46,9 @@ struct ClusterUniform {
   near_far_log : vec4<f32>,
 };
 
-#if STORAGE_BUFFER_AVAILABLE == true
 @group(2) @binding(3) var<storage, read> light_data      : array<LightSlot, 256>;
 @group(2) @binding(4) var<storage, read> cluster_grid     : array<u32>;
 @group(2) @binding(5) var<storage, read> light_index_list : array<u32>;
-#else
-@group(2) @binding(3) var<uniform> light_data_uniform : array<LightSlot, 128>;
-#endif
 @group(2) @binding(6) var<uniform> cluster_uniform : ClusterUniform;
 
 fn get_ssao_intensity() -> f32 {
@@ -84,6 +89,26 @@ fn ndc_position_to_cluster(
   return vec3(cx, cy, cz);
 }
 
+// Surface SpotLight projector sampling is owned by the same clustered light
+// evaluator as the analytic cone/range contribution. The host marks the
+// selected projector in the LightSlot flag and writes its matrix to the
+// corresponding View lane (lane 0 for projector-only); no second
+// material-local sampling loop or resource owner is allowed.
+fn sampleStandardSpotProjector(
+  lightViewProj : mat4x4<f32>,
+  world_pos    : vec3<f32>,
+) -> vec3<f32> {
+#ifdef PROJECTOR_AVAILABLE
+  let uv = projectSpotUv(lightViewProj, world_pos);
+  if (!(uv.x >= 0.0 && uv.x <= 1.0 && uv.y >= 0.0 && uv.y <= 1.0)) {
+    return vec3<f32>(1.0);
+  }
+  return textureSampleLevel(projectorTexture, projectorSampler, uv, 0.0).rgb;
+#else
+  return vec3<f32>(1.0);
+#endif
+}
+
 // Decode one kind first, then delegate the complete evaluation to the shared
 // punctual owner. Unknown kinds are explicitly zero contribution.
 fn evaluate_cluster_light(
@@ -95,9 +120,16 @@ fn evaluate_cluster_light(
   metallic   : f32,
   alpha_sq   : f32,
   f0         : vec3<f32>,
+  flat_2d    : bool,
 ) -> vec3<f32> {
   let kind = light.kind_and_shadow.x;
   if (kind == KIND_POINT) {
+    if (flat_2d) {
+      return evalPointFlat(
+        light.position.xyz, light.color.xyz, light.position.w,
+        world_pos, base_color,
+      );
+    }
 #ifdef POINT_SHADOW_AVAILABLE
     let layer = bitcast<i32>(light.kind_and_shadow.y);
     if (layer >= 0) {
@@ -117,8 +149,36 @@ fn evaluate_cluster_light(
     );
   }
   if (kind == KIND_SPOT) {
-    let tile = bitcast<i32>(light.kind_and_shadow.y);
-    if (tile >= 0) {
+    if (flat_2d) {
+      return evalSpotFlat(
+        light.position.xyz, light.direction.xyz, light.color.xyz,
+        light.color.w, light.direction.w, light.position.w,
+        world_pos, base_color,
+      );
+    }
+    let encoded_tile = bitcast<i32>(light.kind_and_shadow.y);
+    // The unshadowed sentinel is -1. A signed bitwise test against the
+    // projector flag would misclassify that sentinel because -1 has every bit
+    // set, so admit the flag only from the non-negative encoded domain.
+    if (encoded_tile >= 0 && (encoded_tile & PROJECTOR_FLAG) != 0) {
+      let tile = encoded_tile & TILE_MASK;
+      if (tile < 4) {
+        let projector = sampleStandardSpotProjector(view.spotLightViewProj[tile], world_pos);
+        return evalSpotShadowed(
+          light.position.xyz, light.direction.xyz, light.color.xyz,
+          // LightSlot packs cosInner in color.w and cosOuter in direction.w;
+          // keep the evaluator's named cone order intact at the decode boundary.
+          light.color.w, light.direction.w, light.position.w,
+          world_pos, normal, view_dir, base_color, metallic, alpha_sq, f0,
+          view.spotLightViewProj[tile], tile, 0.005, 0.05,
+          bitcast<f32>(light.kind_and_shadow.w),
+          bitcast<f32>(light.kind_and_shadow.z),
+        ) * projector;
+      }
+      return vec3<f32>(0.0);
+    }
+    if (encoded_tile >= 0 && encoded_tile < 4) {
+      let tile = encoded_tile;
       return evalSpotShadowed(
         light.position.xyz, light.direction.xyz, light.color.xyz,
         // LightSlot packs cosInner in color.w and cosOuter in direction.w;
@@ -126,6 +186,8 @@ fn evaluate_cluster_light(
         light.color.w, light.direction.w, light.position.w,
         world_pos, normal, view_dir, base_color, metallic, alpha_sq, f0,
         view.spotLightViewProj[tile], tile, 0.005, 0.05,
+        bitcast<f32>(light.kind_and_shadow.w),
+        bitcast<f32>(light.kind_and_shadow.z),
       );
     }
     return evalSpot(
@@ -137,7 +199,7 @@ fn evaluate_cluster_light(
   return vec3<f32>(0.0);
 }
 
-fn evaluate_cluster_lights(
+fn evaluateStandardClusterLights(
   ndc        : vec3<f32>,
   view_z     : f32,
   world_pos  : vec3<f32>,
@@ -147,6 +209,7 @@ fn evaluate_cluster_lights(
   metallic   : f32,
   alpha_sq   : f32,
   f0         : vec3<f32>,
+  flat_2d    : bool,
 ) -> vec3<f32> {
   let gx = cluster_uniform.grid.x;
   let gy = cluster_uniform.grid.y;
@@ -156,7 +219,6 @@ fn evaluate_cluster_lights(
   let log_far = cluster_uniform.near_far_log.z;
   var total_radiance = vec3<f32>(0.0);
 
-#if STORAGE_BUFFER_AVAILABLE == true
   let cluster_idx = ndc_position_to_cluster(ndc, view_z, gx, gy, gz, near, far, log_far);
   let cluster_linear = cluster_idx.z * gy * gx + cluster_idx.y * gx + cluster_idx.x;
   let grid_offset = cluster_linear * 2u;
@@ -166,20 +228,9 @@ fn evaluate_cluster_lights(
     let light = light_data[light_index_list[list_offset + i]];
     total_radiance += evaluate_cluster_light(
       light, world_pos, normal, view_dir, base_color, metallic, alpha_sq, f0,
+      flat_2d,
     );
   }
-#else
-  let light_count = min(cluster_uniform.grid.w, 128u);
-  for (var i = 0u; i < 128u; i = i + 1u) {
-    if (i >= light_count) {
-      break;
-    }
-    total_radiance += evaluate_cluster_light(
-      light_data_uniform[i], world_pos, normal, view_dir,
-      base_color, metallic, alpha_sq, f0,
-    );
-  }
-#endif
   return total_radiance;
 }
 

package/src/tonemap.wgsl

@@ -9,7 +9,7 @@
 
 #import forgeax_view::common::FullscreenOutput
 #import forgeax_view::common::fullscreen_triangle
-#import forgeax_view::common::linearToSrgbOetf
+#import forgeax_view::common::{linearToSrgbOetf, ditherUnorm8}
 
 const TONEMAP_LUMINANCE_EPSILON : f32 = 1e-5;
 
@@ -17,7 +17,7 @@ struct TonemapParams {
   exposure   : f32,
   whitePoint : f32,
   mode       : u32,
-  pad1       : f32,
+  ditherEnabled : f32,
 };
 
 @group(1) @binding(0) var hdr  : texture_2d<f32>;
@@ -171,5 +171,10 @@ fn fs_main(in : FullscreenOutput) -> @location(0) vec4<f32> {
   }
   // Every public mode reaches exactly one shared sRGB OETF.
   let encoded = linearToSrgbOetf(mapped);
-  return vec4<f32>(encoded, source.a);
+  let output = select(
+    encoded,
+    ditherUnorm8(encoded, in.position.xy),
+    params.ditherEnabled > 0.5,
+  );
+  return vec4<f32>(output, source.a);
 }

package/src/unlit.wgsl

@@ -1,7 +1,6 @@
 #define_import_path forgeax_material::unlit
-#import forgeax_view::common::{View, FogViewParams, FogRay, Mesh, InstanceData, view, meshes, instances, sampleMaterialTextureLinear}
+#import forgeax_view::common::{View, Mesh, InstanceData, view, meshes, instances, sampleMaterialTextureLinear}
 #import forgeax_scene_temporal::{packSceneTemporalV1}
-#import forgeax_view::fog::{apply_fog}
 
 #pragma variant_axis STORAGE_BUFFER_AVAILABLE
 #pragma variant_axis VERTEX_COLOR_AVAILABLE
@@ -101,22 +100,6 @@ fn materialVertexColor(in : VsOut) -> vec4<f32> {
 #endif
 }
 
-fn applySceneFog(viewParams : View, color : vec3<f32>, alpha : f32, worldPos : vec3<f32>) -> vec4<f32> {
-  var origin = viewParams.cameraPos;
-  var direction = normalize(worldPos - origin);
-  var rayDistance = length(worldPos - origin);
-  if (viewParams.temporalProjection.z >= 0.5) {
-    let nearH = viewParams.inverseViewProj * vec4<f32>(0.0, 0.0, 0.0, 1.0);
-    let farH = viewParams.inverseViewProj * vec4<f32>(0.0, 0.0, 1.0, 1.0);
-    let nearPoint = nearH.xyz / nearH.w;
-    let farPoint = farH.xyz / farH.w;
-    direction = normalize(farPoint - nearPoint);
-    origin = worldPos - direction * dot(worldPos - viewParams.cameraPos, direction);
-    rayDistance = max(dot(worldPos - origin, direction), 0.0);
-  }
-  return apply_fog(viewParams.fog, FogRay(origin, direction, rayDistance), vec4<f32>(color, alpha));
-}
-
 @fragment
 fn fs_main(in : VsOut) -> @location(0) vec4<f32> {
   let texSample = sampleMaterialTextureLinear(baseColorTexture, baseColorSampler, in.uv, material.baseColorTextureCoordinatesMetadata.zw);
@@ -125,12 +108,7 @@ fn fs_main(in : VsOut) -> @location(0) vec4<f32> {
   if (material.alphaCutoff > 0.0 && alpha < material.alphaCutoff) {
     discard;
   }
-  return applySceneFog(
-    view,
-    material.baseColor.rgb * texSample.rgb * vertexColor.rgb,
-    alpha,
-    in.worldPos,
-  );
+  return vec4<f32>(material.baseColor.rgb * texSample.rgb * vertexColor.rgb, alpha);
 }
 
 struct TemporalVsOut {

package/src/volume/volume-composite.wgsl

@@ -0,0 +1,113 @@
+#define_import_path forgeax_view::volume_composite
+// This is a view-UBO projection, not a second matrix source. The fields and
+// padding preserve common::View camera/inverse-projection byte offsets.
+struct VolumeDepthView {
+  _prefix : array<vec4<f32>, 6>,
+  cameraPos : vec4<f32>,
+  _lightViewProjA : mat4x4<f32>,
+  inverseViewProj : mat4x4<f32>,
+};
+
+struct VolumeOutput {
+  @builtin(position) position : vec4<f32>,
+  @location(0) uv : vec2<f32>,
+};
+
+@group(0) @binding(0) var resolved_volume : texture_2d<f32>;
+@group(0) @binding(1) var volume_sampler : sampler;
+@group(0) @binding(2) var scene_depth : texture_depth_2d;
+@group(0) @binding(3) var<uniform> volume_view : VolumeDepthView;
+
+@vertex
+fn volume_vs(@builtin(vertex_index) index : u32) -> VolumeOutput {
+  var positions = array<vec2<f32>, 3>(
+    vec2<f32>(-1.0, -1.0),
+    vec2<f32>(3.0, -1.0),
+    vec2<f32>(-1.0, 3.0),
+  );
+  var output : VolumeOutput;
+  output.position = vec4<f32>(positions[index], 0.0, 1.0);
+  output.uv = vec2<f32>(
+    positions[index].x * 0.5 + 0.5,
+    0.5 - positions[index].y * 0.5,
+  );
+  return output;
+}
+
+fn composite_resolved_volume(sample : vec4<f32>) -> vec4<f32> {
+  let transmittance = clamp(sample.a, 0.0, 1.0);
+  return vec4<f32>(sample.rgb, 1.0 - transmittance);
+}
+
+fn linear_scene_depth(uv : vec2<f32>) -> f32 {
+  let dimensions = max(vec2<f32>(textureDimensions(scene_depth)), vec2<f32>(1.0));
+  let pixel = vec2<i32>(clamp(uv * dimensions, vec2<f32>(0.0), dimensions - vec2<f32>(1.0)));
+  let device_depth = textureLoad(scene_depth, pixel, 0);
+  // WebGPU's framebuffer Y is opposite the view UBO's NDC Y.
+  let clip = vec4<f32>(uv.x * 2.0 - 1.0, 1.0 - uv.y * 2.0, device_depth, 1.0);
+  let world = volume_view.inverseViewProj * clip;
+  let world_position = world.xyz / max(abs(world.w), 1e-5);
+  return distance(world_position, volume_view.cameraPos.xyz);
+}
+
+fn radiance_luma(sample : vec4<f32>) -> f32 {
+  return max(dot(sample.rgb, vec3<f32>(0.2126, 0.7152, 0.0722)), 0.0);
+}
+
+fn radiance_luma_weight(center : vec4<f32>, neighbor : vec4<f32>) -> f32 {
+  let center_luma = radiance_luma(center);
+  let neighbor_luma = radiance_luma(neighbor);
+  let relative_luma = abs(neighbor_luma - center_luma) /
+    max(max(neighbor_luma, center_luma), 1e-4);
+  return exp(-relative_luma * 8.0);
+}
+
+fn edge_aware_resolved_volume(uv : vec2<f32>) -> vec4<f32> {
+  let dimensions = max(vec2<f32>(textureDimensions(resolved_volume)), vec2<f32>(1.0));
+  let texel = 1.0 / dimensions;
+  let center = textureSampleLevel(resolved_volume, volume_sampler, uv, 0.0);
+  let center_depth = linear_scene_depth(uv);
+  var accumulated = center * 4.0;
+  var total_weight = 4.0;
+  let offsets = array<vec2<f32>, 8>(
+    vec2<f32>(texel.x, 0.0),
+    vec2<f32>(-texel.x, 0.0),
+    vec2<f32>(0.0, texel.y),
+    vec2<f32>(0.0, -texel.y),
+    vec2<f32>(texel.x, texel.y),
+    vec2<f32>(-texel.x, texel.y),
+    vec2<f32>(texel.x, -texel.y),
+    vec2<f32>(-texel.x, -texel.y),
+  );
+  let spatial_weights = array<f32, 8>(2.0, 2.0, 2.0, 2.0, 1.0, 1.0, 1.0, 1.0);
+  for (var index = 0u; index < 8u; index += 1u) {
+    let neighbor_uv = clamp(uv + offsets[index], vec2<f32>(0.0), vec2<f32>(1.0));
+    let neighbor = textureSampleLevel(
+      resolved_volume,
+      volume_sampler,
+      neighbor_uv,
+      0.0,
+    );
+    let neighbor_depth = linear_scene_depth(neighbor_uv);
+    // Relative view-depth rejection keeps the silhouette transition local;
+    // a fixed world-unit threshold creates halos at far occluders.
+    let depth_weight = select(0.0, exp(-abs(neighbor_depth - center_depth) * 0.08),
+      abs(neighbor_depth - center_depth) <= max(center_depth * 0.08, 0.25));
+    // Transmittance is the available edge signal: retain hard depth/occluder
+    // boundaries while reconstructing smooth low-frequency scattering.
+    let edge_weight = spatial_weights[index] * depth_weight * exp(-abs(neighbor.a - center.a) * 6.0) *
+      radiance_luma_weight(center, neighbor);
+    accumulated += neighbor * edge_weight;
+    total_weight += edge_weight;
+  }
+  return accumulated / max(total_weight, 1e-5);
+}
+
+@fragment
+fn volume_fs(input : VolumeOutput) -> @location(0) vec4<f32> {
+  // Injection zeroes samples behind the observed scene depth. Sampling the
+  // cumulative far slice therefore applies the full ray integral while the
+  // depth test remains owned by the injection path.
+  let sample = edge_aware_resolved_volume(input.uv);
+  return composite_resolved_volume(sample);
+}