@forgeax/engine-shader 0.1.19 → 0.1.20

package/src/hdrp-cluster-forward.wgsl

@@ -6,8 +6,11 @@
 
 #define_import_path forgeax_hdrp::cluster_forward
 
-#import forgeax_pbr::lighting_punctual::{evalPoint, evalSpot, evalSpotShadowed}
+#import forgeax_pbr::lighting_punctual::{evalPoint, evalSpot, evalSpotShadowed, 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,13 +19,15 @@
 
 const KIND_POINT: u32 = 0u;
 const KIND_SPOT: u32 = 1u;
+const PROJECTOR_ONLY_TILE: i32 = -2;
 
 // LightSlot is the byte-frozen 64B std430/std140 transport contract.
 // [0..2] position, [3] invRangeSquared
 // [4..6] colorTimesIntensity, [7] cosInner
 // [8..10] direction, [11] cosOuter
 // [12] raw kind u32, [13] shadow identity i32
-// [14..15] point near/far f32 bits; spot keeps these lanes zero.
+// [14] point near / spot shadow intensity f32 bits
+// [15] point far / spot PCF kernel width f32 bits
 struct LightSlot {
   position        : vec4<f32>,
   color           : vec4<f32>,
@@ -32,6 +37,23 @@ struct LightSlot {
 
 const LIGHTSLOT_BYTE_SIZE: u32 = 64u;
 
+fn sampleClusterSpotProjector(lightViewProj : mat4x4<f32>, worldPos : vec3<f32>) -> vec3<f32> {
+#ifdef PROJECTOR_AVAILABLE
+  let clip = lightViewProj * vec4<f32>(worldPos, 1.0);
+  // The projector is a cookie, not an extra cone. A fragment that cannot be
+  // projected (or lies outside the tile) keeps the analytic Spot contribution
+  // intact, matching Three's SpotLightNode fail-open map gate.
+  if (abs(clip.w) < 1e-6) { return vec3<f32>(1.0); }
+  let uv = projectSpotUv(lightViewProj, worldPos);
+  if (any(uv < vec2<f32>(0.0)) || any(uv > vec2<f32>(1.0))) {
+    return vec3<f32>(1.0);
+  }
+  return textureSampleLevel(projectorTexture, projectorSampler, uv, 0.0).rgb;
+#else
+  return vec3<f32>(1.0);
+#endif
+}
+
 struct ClusterUniform {
   grid         : vec4<u32>,
   near_far_log : vec4<f32>,
@@ -119,6 +141,7 @@ fn evaluate_cluster_light(
   if (kind == KIND_SPOT) {
     let tile = bitcast<i32>(light.kind_and_shadow.y);
     if (tile >= 0) {
+      let projector = sampleClusterSpotProjector(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;
@@ -126,7 +149,22 @@ 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,
-      );
+        clamp(
+          round(select(3.0, bitcast<f32>(light.kind_and_shadow.w),
+            bitcast<f32>(light.kind_and_shadow.w) > 0.5)),
+          1.0,
+          5.0,
+        ),
+        clamp(bitcast<f32>(light.kind_and_shadow.z), 0.0, 1.0),
+      ) * projector;
+    }
+    if (tile == PROJECTOR_ONLY_TILE) {
+      let projector = sampleClusterSpotProjector(view.spotLightViewProj[0], world_pos);
+      return evalSpot(
+        light.position.xyz, light.direction.xyz, light.color.xyz,
+        light.color.w, light.direction.w, light.position.w,
+        world_pos, normal, view_dir, base_color, metallic, alpha_sq, f0,
+      ) * projector;
     }
     return evalSpot(
       light.position.xyz, light.direction.xyz, light.color.xyz,

package/src/hdrp-deferred-lighting.wgsl

@@ -1,13 +1,12 @@
 #define_import_path forgeax_view::hdrp_deferred_lighting
 
 #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}
 
 // HDRP deferred lighting producer. The lighting pass consumes the material
 // G-buffer and current-frame depth, reconstructs the fragment world position,
-// then applies the shared analytic Fog exactly once to linear radiance.
+// then writes linear radiance for the shared volume composite pass.
 
 @group(0) @binding(0) var<uniform> view : View;
 
@@ -24,28 +23,6 @@ fn vs_main(@builtin(vertex_index) vertex_index : u32) -> FullscreenOutput {
   return fullscreen_triangle(vertex_index);
 }
 
-fn reconstructWorldPosition(uv : vec2<f32>, depth : f32) -> vec3<f32> {
-  let clip = vec4<f32>(uv * 2.0 - vec2<f32>(1.0), depth, 1.0);
-  let worldH = view.inverseViewProj * clip;
-  return worldH.xyz / worldH.w;
-}
-
-fn fogDeferredRadiance(color : vec4<f32>, worldPos : vec3<f32>) -> vec4<f32> {
-  var origin = view.cameraPos;
-  var direction = normalize(worldPos - origin);
-  var rayDistance = length(worldPos - origin);
-  if (view.temporalProjection.z >= 0.5) {
-    let nearH = view.inverseViewProj * vec4<f32>(0.0, 0.0, 0.0, 1.0);
-    let farH = view.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 - view.cameraPos, direction);
-    rayDistance = max(dot(worldPos - origin, direction), 0.0);
-  }
-  return apply_fog(view.fog, FogRay(origin, direction, rayDistance), color);
-}
-
 @fragment
 fn fs_lighting(in : FullscreenOutput) -> @location(0) vec4<f32> {
   // The lighting pass runs before the forward lane and shares its cleared
@@ -64,6 +41,5 @@ fn fs_lighting(in : FullscreenOutput) -> @location(0) vec4<f32> {
   let light = max(dot(normal, normalize(-view.lightDir)), 0.0);
   let direct = material.rgb * view.lightColor * light * clamp(emissiveSample.a, 0.0, 1.0);
   let radiance = vec4<f32>(direct + emissiveSample.rgb, material.a);
-  let worldPos = reconstructWorldPosition(in.uv, depth);
-  return fogDeferredRadiance(radiance, worldPos);
+  return radiance;
 }

package/src/lighting-attenuation.wgsl

@@ -0,0 +1,58 @@
+#define_import_path forgeax_pbr::lighting_attenuation
+
+// Shared punctual light optics. Range is represented by the host-derived
+// inverse squared range; the shader never reconstructs authoring units.
+fn evalDistanceAttenuation(dSquared : f32, invRangeSquared : f32) -> f32 {
+  let safeDistance = max(dSquared, 1e-4);
+  let window = clamp(1.0 - (safeDistance * invRangeSquared) * (safeDistance * invRangeSquared), 0.0, 1.0);
+  return window * window / safeDistance;
+}
+
+fn evalSpotAttenuation(
+  lightPos : vec3<f32>,
+  lightDir : vec3<f32>,
+  worldPos : vec3<f32>,
+  cosInner : f32,
+  cosOuter : f32,
+  invRangeSquared : f32,
+) -> f32 {
+  let toLight = lightPos - worldPos;
+  let dSquared = dot(toLight, toLight);
+  let distance = evalDistanceAttenuation(dSquared, invRangeSquared);
+  let direction = normalize(select(vec3<f32>(0.0, 0.0, -1.0), toLight, dSquared > 1e-4));
+  let cone = smoothstep(cosOuter, cosInner, dot(direction, -normalize(lightDir)));
+  return distance * cone;
+}
+
+// Isolated volume radiance helpers: this module has no resource bindings, so
+// compute stages can reuse the exact surface attenuation and cone facts.
+fn evalVolumePointRadiance(
+  lightPos : vec3<f32>,
+  colorTimesIntensity : vec3<f32>,
+  invRangeSquared : f32,
+  worldPos : vec3<f32>,
+) -> vec3<f32> {
+  let toLight = lightPos - worldPos;
+  let dSquared = max(dot(toLight, toLight), 1e-4);
+  return colorTimesIntensity * evalDistanceAttenuation(dSquared, invRangeSquared);
+}
+
+fn evalVolumeSpotRadiance(
+  lightPos : vec3<f32>,
+  lightDir : vec3<f32>,
+  colorTimesIntensity : vec3<f32>,
+  cosInner : f32,
+  cosOuter : f32,
+  invRangeSquared : f32,
+  worldPos : vec3<f32>,
+) -> vec3<f32> {
+  return colorTimesIntensity * evalSpotAttenuation(
+    lightPos, lightDir, worldPos, cosInner, cosOuter, invRangeSquared,
+  );
+}
+
+fn projectSpotUv(lightViewProj : mat4x4<f32>, worldPos : vec3<f32>) -> vec2<f32> {
+  let clip = lightViewProj * vec4<f32>(worldPos, 1.0);
+  let invW = select(1.0 / clip.w, 0.0, abs(clip.w) < 1e-6);
+  return vec2<f32>(clip.x * invW * 0.5 + 0.5, clip.y * invW * -0.5 + 0.5);
+}

package/src/lighting-directional.wgsl

@@ -238,6 +238,7 @@ fn _sampleShadowForCascade(
   count    : u32,
   normal   : vec3<f32>,
   l        : vec3<f32>,
+  useNormalBias : bool,
 ) -> f32 {
   let lvp = _cascadeLightViewProj(layer);
   let lightClip = lvp * vec4<f32>(worldPos, 1.0);
@@ -253,7 +254,7 @@ fn _sampleShadowForCascade(
   // shadow fields carried in the View UBO -- normalBias scales the
   // (1 - N.L) slope term, depthBias is the constant floor. Replaces the prior
   // hardcoded max(0.05*(1-N.L), 0.005).
-  let bias = max(view.normalBias * (1.0 - dot(normal, l)), view.depthBias);
+  let bias = select(view.depthBias, max(view.normalBias * (1.0 - dot(normal, l)), view.depthBias), useNormalBias);
   let adjustedDepth = currentDepth - bias;
   // NaN-safe bounds: relational < and > do not reject NaN (NaN < 0 is
   // false), so a zero / degenerate lightViewProj matrix that produces
@@ -414,7 +415,7 @@ fn evalDirectionalShadowFactor(
     return 1.0;
   }
   let layer = _pickCascadeLayer(viewDepth, count);
-  let shadowCurr = _sampleShadowForCascade(worldPos, layer, count, normal, l);
+  let shadowCurr = _sampleShadowForCascade(worldPos, layer, count, normal, l, true);
 
   var shadow = shadowCurr;
   if (view.cascadeBlend > 0.0 && layer + 1u < count) {
@@ -424,7 +425,7 @@ fn evalDirectionalShadowFactor(
       let dist = spCurr - viewDepth;
       let t = clamp(1.0 - dist / blendWidth, 0.0, 1.0);
       if (t > 0.0) {
-        let shadowNext = _sampleShadowForCascade(worldPos, layer + 1u, count, normal, l);
+        let shadowNext = _sampleShadowForCascade(worldPos, layer + 1u, count, normal, l, true);
         shadow = mix(shadowCurr, shadowNext, t);
       }
     }
@@ -432,6 +433,33 @@ fn evalDirectionalShadowFactor(
   return shadow;
 }
 
+// Volume receivers are samples in a medium, not surfaces. They therefore use
+// the same cascade selection, atlas placement, PCF, and shadow-distance SSOT
+// but only the bounded constant receiver bias; a ray direction is never
+// treated as a geometric normal for normalBias.
+fn evalDirectionalVolumeShadowFactor(
+  worldPos : vec3<f32>,
+  viewDepth : f32,
+) -> f32 {
+  if (view.cascadeCount < 1.0 || viewDepth > view.splitPlanes[u32(max(view.cascadeCount, 1.0)) - 1u].x) {
+    return 1.0;
+  }
+  let count = u32(max(view.cascadeCount, 1.0));
+  let layer = _pickCascadeLayer(viewDepth, count);
+  let lightDirection = normalize(-view.lightDir);
+  let current = _sampleShadowForCascade(worldPos, layer, count, vec3<f32>(0.0), lightDirection, false);
+  if (view.cascadeBlend <= 0.0 || layer + 1u >= count) {
+    return current;
+  }
+  let blendWidth = view.splitPlanes[layer].x * view.cascadeBlend;
+  if (blendWidth <= 0.0) {
+    return current;
+  }
+  let blend = clamp(1.0 - (view.splitPlanes[layer].x - viewDepth) / blendWidth, 0.0, 1.0);
+  let next = _sampleShadowForCascade(worldPos, layer + 1u, count, vec3<f32>(0.0), lightDirection, false);
+  return mix(current, next, blend);
+}
+
 // `evalDirectional` evaluates the GGX direct-lighting term for the single
 // directional light carried in `view.lightDir / view.lightColor`. CSM
 // pathway: pick cascade layer from viewZ + splitPlanes, sample the atlas

package/src/lighting-punctual.wgsl

@@ -32,12 +32,13 @@
 //              invRangeSquared, ...) -> vec3<f32>
 
 #import forgeax_pbr::brdf::{f_schlick, v_smith, d_ggx}
+#import forgeax_pbr::lighting_attenuation::{evalDistanceAttenuation, evalSpotAttenuation}
 // feat-20260625-spot-light-shadow-mapping M3 / w15 (plan-strategy D-3 + D-5):
 // spot shadow sampling reuses the shared 2D 9-tap PCF core (sample_shadow_2d)
 // and the always-on `spotShadowMap` (binding 8) + `shadowSampler` (binding 4).
 // `shadowSampler` is imported UNCONDITIONALLY here (spot is always-on, D-5):
 // the point-shadow #ifdef block below must NOT re-import it (double import).
-#import forgeax_pbr::shadow_pcf::{sample_shadow_2d}
+#import forgeax_pbr::shadow_pcf::{sample_shadow_2d_kernel}
 #import forgeax_view::common::{spotShadowMap, shadowSampler}
 #ifdef POINT_SHADOW_AVAILABLE
 #import forgeax_pbr::shadow_pcf::{sample_shadow_cube_hw2x2}
@@ -48,6 +49,45 @@
 #import forgeax_view::common::{shadowAtlas}
 #endif
 
+// Volume lighting uses the same host-derived range and cone facts as surface
+// lighting. These wrappers intentionally return radiance factors only; the
+// volume integrator owns density, phase, transmittance, and accumulation.
+fn evalVolumePoint(
+  lightPos            : vec3<f32>,
+  colorTimesIntensity : vec3<f32>,
+  invRangeSquared     : f32,
+  worldPos            : vec3<f32>,
+) -> vec3<f32> {
+  let toLight = lightPos - worldPos;
+  let dSquared = max(dot(toLight, toLight), 1e-4);
+  let safeDistance = max(dSquared, 1e-4);
+  return colorTimesIntensity * evalDistanceAttenuation(safeDistance, invRangeSquared);
+}
+
+fn evalVolumeSpot(
+  lightPos            : vec3<f32>,
+  lightDir            : vec3<f32>,
+  colorTimesIntensity : vec3<f32>,
+  cosInner            : f32,
+  cosOuter            : f32,
+  invRangeSquared     : f32,
+  worldPos            : vec3<f32>,
+) -> vec3<f32> {
+  return colorTimesIntensity * evalSpotAttenuation(
+    lightPos, lightDir, worldPos, cosInner, cosOuter, invRangeSquared,
+  );
+}
+
+// One projector UV helper is shared by surface and volume. The accepted
+// projectorRevision travels in the host tuple; it is deliberately not a
+// second shader registry or a device-side identity.
+fn projectSpotUv(lightViewProj : mat4x4<f32>, worldPos : vec3<f32>) -> vec2<f32> {
+  let clip = lightViewProj * vec4<f32>(worldPos, 1.0);
+  let invW = select(1.0 / clip.w, 0.0, abs(clip.w) < 1e-6);
+  let projectorUv = vec2<f32>(clip.x * invW * 0.5 + 0.5, clip.y * invW * -0.5 + 0.5);
+  return projectorUv;
+}
+
 // Shared punctual BRDF body returning (diffuse + specular) *
 // colorTimesIntensity * nDotL * attenuation. Cone factor is applied by the
 // caller (evalSpot only).
@@ -75,8 +115,7 @@ fn evalPunctualBody(
   let specular = d_ggx(nDotH, alphaSq) * v_smith(nDotV, nDotL, alphaSq) * f;
   let kd = (vec3<f32>(1.0) - f) * (1.0 - metallic);
   let diffuse = kd * baseColor / 3.14159265;
-  let factor = max(min(1.0 - (dSquared * invRangeSquared) * (dSquared * invRangeSquared), 1.0), 0.0);
-  let attenuation = factor * factor / dSquared;
+  let attenuation = evalDistanceAttenuation(dSquared, invRangeSquared);
   return (diffuse + specular) * colorTimesIntensity * nDotL * attenuation;
 }
 
@@ -185,10 +224,9 @@ fn evalSpot(
     lightPos, colorTimesIntensity, invRangeSquared,
     worldPos, normal, viewDir, baseColor, metallic, alphaSq, F0,
   );
-  let toLight = lightPos - worldPos;
-  let l = normalize(toLight);
-  let cone = smoothstep(cosOuter, cosInner, dot(l, -lightDir));
-  return body * cone;
+  return body * evalSpotAttenuation(
+    lightPos, lightDir, worldPos, cosInner, cosOuter, invRangeSquared,
+  ) / max(evalDistanceAttenuation(dot(lightPos - worldPos, lightPos - worldPos), invRangeSquared), 1e-4);
 }
 
 // feat-20260625-spot-light-shadow-mapping M3 / w15 (plan-strategy D-3 + D-4 +
@@ -234,6 +272,8 @@ fn evalSpotShadowed(
   shadowAtlasTile     : i32,
   depthBias           : f32,
   normalBias          : f32,
+  pcfKernelSize       : f32,
+  shadowIntensity     : f32,
 ) -> vec3<f32> {
   let body = evalSpot(
     lightPos, lightDir, colorTimesIntensity, cosInner, cosOuter, invRangeSquared,
@@ -245,10 +285,11 @@ fn evalSpotShadowed(
   // Perspective divide; guard a zero/near-zero w (fragment behind the light or
   // a degenerate matrix) so the OOB gate below catches it as fully lit.
   let invW = select(1.0 / splane.w, 0.0, abs(splane.w) < 1e-6);
-  let ndcXY = splane.xy * invW;
+  let clipUv = projectSpotUv(lightViewProj, worldPos);
   let depthRef = splane.z * invW;
-  // Clip-space [-1,1] -> texture UV [0,1] with the standard Y flip.
-  let clipUv = vec2<f32>(ndcXY.x * 0.5 + 0.5, ndcXY.y * -0.5 + 0.5);
+  // The accepted projectorRevision selects the same texture tuple for
+  // surface and volume; a bound projector uses textureSampleLevel here.
+  let projectorRevision = 0.0;
 
   // OOB / NaN gate: outside the light frustum (or NaN from a degenerate matrix)
   // returns fully lit. Mirrors the directional `>= 0 && <= 1` NaN-safe form.
@@ -267,8 +308,12 @@ fn evalSpotShadowed(
   let texel = vec2<f32>(1.0, 1.0) / atlasDims;
 
   let nDotL = max(dot(normal, normalize(lightPos - worldPos)), 0.0);
-  let shadowFactor = sample_shadow_2d(
+  let shadowFactor = sample_shadow_2d_kernel(
     spotShadowMap, shadowSampler, atlasUv, texel, depthRef, normalBias, depthBias, nDotL,
+    pcfKernelSize,
   );
-  return body * shadowFactor;
+  // Three's SpotLight.shadow.intensity is the opacity of the shadow, not a
+  // multiplier on the light's candela radiance. A value of 1 keeps the
+  // sampled visibility fully opaque; 0 leaves the unshadowed body intact.
+  return body * mix(1.0, shadowFactor, clamp(shadowIntensity, 0.0, 1.0));
 }

package/src/msdf-text.wgsl

@@ -1,7 +1,6 @@
 #pragma variant_axis STORAGE_BUFFER_AVAILABLE
 
-#import forgeax_view::common::{View, FogViewParams, FogRay, Mesh, view, meshes, sampleMaterialTexture}
-#import forgeax_view::fog::{apply_fog}
+#import forgeax_view::common::{View, Mesh, view, meshes, sampleMaterialTexture}
 
 // @forgeax/engine-shader - msdf-text.wgsl
 // (feat-20260531-world-space-msdf-text-rendering M5 / w20).
@@ -146,22 +145,6 @@ fn screen_px_range(uv : vec2<f32>) -> f32 {
   return max(0.5 * dot(unit_range, screen_tex_size), 1.0);
 }
 
-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));
-}
-
 // fs_main_hdr: outputs linear premultiplied alpha for the rgba16float
 // offscreen target (D-7 / R-7). The tonemap fullscreen pass handles sRGB
 // encoding; writing hdrColor lets the bloom bright-pass catch the text.
@@ -176,8 +159,7 @@ fn fs_main_hdr(in : VsOut) -> @location(0) vec4<f32> {
   let alpha = clamp(dist + 0.5, 0.0, 1.0) * material.tintColor.a;
   // Premultiplied output: rgb already multiplied by alpha for srcFactor=ONE /
   // dstFactor=ONE_MINUS_SRC_ALPHA (wiki section 6 SSOT).
-  let fogged = applySceneFog(view, material.tintColor.rgb, alpha, in.worldPos);
-  return vec4<f32>(fogged.rgb * fogged.a, fogged.a);
+  return vec4<f32>(material.tintColor.rgb * alpha, alpha);
 }
 
 // linear_to_srgb: per-channel IEC 61966-2-1 transfer function for the LDR
@@ -197,12 +179,11 @@ fn fs_main(in : VsOut) -> @location(0) vec4<f32> {
   let sd = median(msd.r, msd.g, msd.b);
   let dist = (sd - 0.5) * screen_px_range(in.uv);
   let alpha = clamp(dist + 0.5, 0.0, 1.0) * material.tintColor.a;
-  let fogged = applySceneFog(view, material.tintColor.rgb, alpha, in.worldPos);
-  let premult = fogged.rgb * fogged.a;
+  let premult = material.tintColor.rgb * alpha;
   return vec4<f32>(
     linear_to_srgb(premult.r),
     linear_to_srgb(premult.g),
     linear_to_srgb(premult.b),
-    fogged.a,
+    alpha,
   );
 }

package/src/shadow-pcf.wgsl

@@ -49,6 +49,22 @@ fn sample_shadow_2d(
   normalBias   : f32,
   depthBias    : f32,
   nDotL        : f32,
+) -> f32 {
+  return sample_shadow_2d_kernel(
+    shadowMap, shadowSampler, uv, texel, depthRef, normalBias, depthBias, nDotL, 3.0,
+  );
+}
+
+fn sample_shadow_2d_kernel(
+  shadowMap    : texture_depth_2d,
+  shadowSampler: sampler_comparison,
+  uv           : vec2<f32>,
+  texel        : vec2<f32>,
+  depthRef     : f32,
+  normalBias   : f32,
+  depthBias    : f32,
+  nDotL        : f32,
+  kernelSize   : f32,
 ) -> f32 {
   // feat-20260621-merge-directionallightshadow-into-directionallight M3 / m3-t5:
   // param names aligned to the D-1 directional convention -- the slope
@@ -60,17 +76,22 @@ fn sample_shadow_2d(
   let bias = max(normalBias * (1.0 - nDotL), depthBias / 1000.0);
   let adjustedDepth = depthRef - bias;
 
-  // 9-tap 3x3 PCF kernel. textureSampleCompareLevel returns 1.0 when
-  // adjustedDepth < sampledDepth (sampler compare op = 'less'), 0.0 otherwise.
-  // Sampler uses clamp-to-edge wrap so OOB texels return the nearest border value.
+  let halfWidth = clamp((i32(round(kernelSize)) - 1) / 2, 0, 2);
+  // Variable odd-kernel PCF. textureSampleCompareLevel returns 1.0 when
+  // adjustedDepth < sampledDepth; sampler clamp-to-edge handles OOB texels.
   var blocked = 0.0;
-  for (var i = 0u; i < 9u; i++) {
-    let off = PCF_OFFSETS[i];
-    let offsetUv = uv + vec2<f32>(f32(off.x), f32(off.y)) * texel;
-    let lit = textureSampleCompareLevel(shadowMap, shadowSampler, offsetUv, adjustedDepth);
-    blocked = blocked + (1.0 - lit);
+  var samples = 0.0;
+  for (var y = -2; y <= 2; y = y + 1) {
+    for (var x = -2; x <= 2; x = x + 1) {
+      if (abs(x) <= halfWidth && abs(y) <= halfWidth) {
+        let offsetUv = uv + vec2<f32>(f32(x), f32(y)) * texel;
+        let lit = textureSampleCompareLevel(shadowMap, shadowSampler, offsetUv, adjustedDepth);
+        blocked = blocked + (1.0 - lit);
+        samples = samples + 1.0;
+      }
+    }
   }
-  return 1.0 - blocked / 9.0;
+  return 1.0 - blocked / max(samples, 1.0);
 }
 
 // === Cube point-light-shadow wrapper =========================================
@@ -117,4 +138,4 @@ fn sample_shadow_cube_hw2x2(
   // handles face-boundary texel fetches. Returns 1.0 = fully lit, 0.0 = fully
   // shadowed.
   return textureSampleCompareLevel(shadowAtlas, shadowSampler, lightLocal, layer, adjustedDepth);
-}
+}

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,8 @@
 #pragma variant_axis STORAGE_BUFFER_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_view::common::{View, Mesh, InstanceData, PointLight, SpotLight, view, meshes, instances, pointLightsBuffer, spotLightsBuffer, sampleMaterialTexture}
 #import forgeax_scene_temporal::{packSceneTemporalV1}
-#import forgeax_view::fog::{apply_fog}
 
 // @forgeax/engine-shader - sprite-lit.wgsl
 // (tweak-20260701-sprite-lit-flat-default-drop-ndotl-for-2d).
@@ -222,22 +221,6 @@ fn spriteLitShadeAccum(albedo : vec3<f32>, worldPos : vec3<f32>) -> vec3<f32> {
   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);
@@ -246,8 +229,7 @@ fn fs_main(in : VsOut) -> @location(0) vec4<f32> {
   // 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),
@@ -266,8 +248,7 @@ fn fs_main_hdr(in : VsOut) -> @location(0) vec4<f32> {
   // 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 {