@forgeax/engine-shader 0.1.7 → 0.1.20

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/index.ts

@@ -84,6 +84,9 @@ export const BUILTIN_MATERIAL_MODULES = {
   sprite: 'forgeax_material::sprite',
 } as const;
 
+/** Stable build-time module id for the temporal-v1 accessor owner. */
+export const SCENE_DATA_TEMPORAL_V1_SHADER_MODULE = 'forgeax_scene_temporal' as const;
+
 /**
  * Material modules whose shader source and parameter contract are owned by
  * the Engine. They live in the runtime ShaderRegistry, so a Pack containing

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/material-schemas.ts

@@ -19,12 +19,19 @@ export const DEFAULT_STANDARD_PBR_PARAM_SCHEMA: readonly ParamSchemaEntry[] = [
   { name: 'clearcoatRoughness', type: 'f32', default: 0.5 },
   { name: 'specularTint', type: 'vec3', colorSpace: 'srgb', default: [1, 1, 1] },
   { name: 'normalScale', type: 'f32', default: 1 },
+  { name: 'transmission', type: 'f32', default: 0 },
+  { name: 'ior', type: 'f32', default: 1.5 },
+  { name: 'thickness', type: 'f32', default: 0 },
+  { name: 'attenuationColor', type: 'vec3', colorSpace: 'linear', default: [1, 1, 1] },
+  { name: 'attenuationDistance', type: 'f32' },
   { name: 'baseColorTexture', type: 'texture2d' },
   { name: 'metallicRoughnessTexture', type: 'texture2d' },
   { name: 'normalTexture', type: 'texture2d' },
   { name: 'specularTintTexture', type: 'texture2d' },
   { name: 'emissiveTexture', type: 'texture2d' },
   { name: 'occlusionTexture', type: 'texture2d' },
+  { name: 'transmissionTexture', type: 'texture2d' },
+  { name: 'thicknessTexture', type: 'texture2d' },
 ];
 
 export const DEFAULT_UNLIT_PARAM_SCHEMA: readonly ParamSchemaEntry[] = [

package/src/motion-blur.wgsl

@@ -0,0 +1,77 @@
+#define_import_path forgeax_view::motion_blur
+
+#import forgeax_view::common::FullscreenOutput
+#import forgeax_view::common::fullscreen_triangle
+#import forgeax_scene_temporal::{unpackSceneTemporalV1}
+
+struct MotionBlurParams {
+  shutterAngle : f32,
+  maxRadiusPixels : f32,
+  sampleCount : u32,
+  reset : u32,
+};
+
+@group(1) @binding(0) var currentColor : texture_2d<f32>;
+@group(1) @binding(1) var linearSampler : sampler;
+@group(1) @binding(2) var<uniform> params : MotionBlurParams;
+@group(1) @binding(3) var sceneTemporal : texture_2d<f32>;
+
+fn depthReject(center : f32, sample : f32) -> bool {
+  return abs(center - sample) > max(0.01, center * 0.01);
+}
+
+fn symmetricOffset(index : u32, count : u32, motion : vec2<f32>) -> vec2<f32> {
+  let denominator = max(f32(count), 1.0);
+  let signedIndex = f32(index) - (denominator - 1.0) * 0.5;
+  return motion * (signedIndex / denominator);
+}
+
+@vertex
+fn vs_main(@builtin(vertex_index) vertexIndex : u32) -> FullscreenOutput {
+  return fullscreen_triangle(vertexIndex);
+}
+
+@fragment
+fn fs_main(in : FullscreenOutput) -> @location(0) vec4<f32> {
+  let current = textureSampleLevel(currentColor, linearSampler, in.uv, 0.0);
+  let packed = textureSampleLevel(sceneTemporal, linearSampler, in.uv, 0.0);
+  let temporal = unpackSceneTemporalV1(packed);
+  let dimensions = vec2<f32>(textureDimensions(currentColor));
+  let pixelMotion = temporal.motionUv * dimensions;
+  let shutter = clamp(params.shutterAngle / 360.0, 0.0, 1.0);
+  let radius = min(length(pixelMotion) * shutter, params.maxRadiusPixels);
+  let motion = normalize(select(vec2<f32>(0.0), pixelMotion, radius > 1e-5));
+  let invalidDepth = !temporal.validDepth;
+  let reactive = clamp(temporal.reactive, 0.0, 1.0);
+  let subpixel = radius <= 1e-5;
+  let reset = params.reset != 0u;
+  var output = current;
+  output.a = current.a;
+  if (invalidDepth || subpixel || reset || params.sampleCount < 4u) {
+    return output;
+  }
+
+  var accum = vec3<f32>(0.0);
+  var weight = 0.0;
+  let temporalDimensions = vec2<i32>(textureDimensions(sceneTemporal));
+  for (var index = 0u; index < 16u; index += 1u) {
+    if (index >= params.sampleCount) { break; }
+    let offset = symmetricOffset(index, params.sampleCount, motion * radius) / dimensions;
+    let sampleUv = clamp(in.uv + offset, vec2<f32>(0.0), vec2<f32>(1.0));
+    let samplePixel = clamp(
+      vec2<i32>(sampleUv * dimensions),
+      vec2<i32>(0),
+      temporalDimensions - vec2<i32>(1),
+    );
+    let sampleTemporal = unpackSceneTemporalV1(textureLoad(sceneTemporal, samplePixel, 0));
+    if (sampleTemporal.validDepth && !depthReject(temporal.viewDepth, sampleTemporal.viewDepth)) {
+      accum += textureSampleLevel(currentColor, linearSampler, sampleUv, 0.0).rgb;
+      weight += 1.0;
+    }
+  }
+  let gathered = accum / max(weight, 1.0);
+  let blurWeight = (1.0 - reactive) * select(0.0, 1.0, weight > 0.0);
+  output = vec4<f32>(mix(current.rgb, gathered, blurWeight), current.a);
+  output.a = current.a;
+  return output;
+}

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/pbr-temporal.wgsl

@@ -1,6 +1,7 @@
 #define_import_path forgeax_pbr::temporal
 
-#import forgeax_view::common::{sampleMaterialTexture, packSceneTemporal}
+#import forgeax_view::common::{sampleMaterialTexture}
+#import forgeax_scene_temporal::{packSceneTemporalV1}
 
 fn transformedPbrTemporalUv(
   transform : vec4<f32>,
@@ -29,6 +30,16 @@ fn transformedPbrTemporalUv(
   return vec2<f32>(scaled.x * c - scaled.y * s, scaled.x * s + scaled.y * c) + transform.xy;
 }
 
+fn resolvePbrTemporalReactive(
+  reactive : f32,
+  baseColorAlpha : f32,
+  sampledAlpha : f32,
+) -> f32 {
+  let coverage = clamp(baseColorAlpha * sampledAlpha, 0.0, 1.0);
+  let coverageReactive = 1.0 - coverage;
+  return max(clamp(reactive, 0.0, 1.0), coverageReactive);
+}
+
 fn projectPbrSceneTemporal(
   baseColorAlpha : f32,
   alphaCutoff : f32,
@@ -38,6 +49,7 @@ fn projectPbrSceneTemporal(
   metadata : vec4<f32>,
   currentClip : vec4<f32>,
   previousClip : vec4<f32>,
+  temporalProjection : vec4<f32>,
   reactive : f32,
   uv0 : vec2<f32>,
   uv1 : vec2<f32>,
@@ -69,5 +81,6 @@ fn projectPbrSceneTemporal(
   if (alphaCutoff > 0.0 && baseColorAlpha * baseSample.a <= alphaCutoff) {
     discard;
   }
-  return packSceneTemporal(currentClip, previousClip, reactive);
+  let reactiveCoverage = resolvePbrTemporalReactive(reactive, baseColorAlpha, baseSample.a);
+  return packSceneTemporalV1(currentClip, previousClip, temporalProjection, reactiveCoverage);
 }

package/src/scene-temporal.wgsl

@@ -0,0 +1,54 @@
+#define_import_path forgeax_scene_temporal
+
+// The sole shader interpretation of forgeax::scene-data::temporal-v1.
+// The packed target is rgba16float at render resolution and is sampled only.
+
+const SCENE_DATA_TEMPORAL_V1_CLEAR : vec4<f32> = vec4<f32>(0.0, 0.0, -1.0, 1.0);
+
+struct SceneTemporalV1 {
+  motionUv : vec2<f32>,
+  viewDepth : f32,
+  reactive : f32,
+  validDepth : bool,
+};
+
+fn unpackSceneTemporalV1(packed : vec4<f32>) -> SceneTemporalV1 {
+  let invalidDepth = packed.z < 0.0;
+  let validDepth = !invalidDepth;
+  let viewDepth = select(0.0, exp2(packed.z) - 1.0, validDepth);
+  let motionUv = packed.xy;
+  let reactive = clamp(packed.w, 0.0, 1.0);
+  return SceneTemporalV1(motionUv, viewDepth, reactive, validDepth);
+}
+
+fn sceneTemporalUv(clip : vec4<f32>) -> vec2<f32> {
+  let safeW = select(1e-6, clip.w, abs(clip.w) >= 1e-6);
+  let ndc = clip.xy / safeW;
+  return vec2<f32>(ndc.x * 0.5 + 0.5, 0.5 - ndc.y * 0.5);
+}
+
+fn sceneTemporalViewDepth(clip : vec4<f32>, temporalProjection : vec4<f32>) -> f32 {
+  let perspectiveDepth = max(clip.w, 0.0);
+  let ndcDepth = clip.z / max(abs(clip.w), 1e-6);
+  let orthographicDepth = temporalProjection.x +
+    ndcDepth * (temporalProjection.y - temporalProjection.x);
+  let viewDepth = select(
+    perspectiveDepth,
+    max(orthographicDepth, 0.0),
+    temporalProjection.z >= 0.5,
+  );
+  return log2(1.0 + viewDepth);
+}
+
+fn packSceneTemporalV1(
+  currentClip : vec4<f32>,
+  previousClip : vec4<f32>,
+  temporalProjection : vec4<f32>,
+  reactive : f32,
+) -> vec4<f32> {
+  return vec4<f32>(
+    sceneTemporalUv(currentClip) - sceneTemporalUv(previousClip),
+    sceneTemporalViewDepth(currentClip, temporalProjection),
+    clamp(reactive, 0.0, 1.0),
+  );
+}

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);
-}
+}