@forgeax/engine-shader 0.1.7 → 0.1.20

package/src/shadow_caster.wgsl

@@ -1,4 +1,5 @@
 #pragma variant_axis STORAGE_BUFFER_AVAILABLE
+#pragma variant_axis SKINNING_DISABLED
 
 // @forgeax/engine-shader shadow_caster.wgsl
 // feat-20260520-directional-light-shadow-mapping M1c / w9 (D-9 / AC-09):
@@ -20,15 +21,28 @@
 //   @group(2) binding(0) meshes : array<Mesh>        -- common.wgsl
 //   @group(3) binding(0) instances : array<InstanceData>  -- common.wgsl
 //
-// Vertex layout: matches the 12F procedural layout of every mesh
-// (position vec3, normal vec3, uv vec2, tangent vec4; 48 B stride).
+// SKINNING_DISABLED=true consumes the ordinary 12F mesh layout; the explicit
+// false variant consumes JOINTS_0 / WEIGHTS_0 from the same 18F layout as pbr-skin and
+// projects the animated world-space palette result into the shadow view.
 
 #import forgeax_view::common::{View, Mesh, InstanceData, ShadowCasterCascade, view, shadowCasterCascade, meshes, instances}
 
 struct VsInput {
   @location(0) position : vec3<f32>,
+#if SKINNING_DISABLED == false
+  @location(4) skinIndex : vec4<u32>,
+  @location(5) skinWeight : vec4<f32>,
+#endif
 };
 
+#if SKINNING_DISABLED == false
+#if STORAGE_BUFFER_AVAILABLE == true
+@group(2) @binding(1) var<storage, read> palette : array<mat4x4<f32>>;
+#else
+@group(2) @binding(1) var<uniform> palette : array<mat4x4<f32>, 255>;
+#endif
+#endif
+
 fn _cascadeLightViewProj(layer : u32) -> mat4x4<f32> {
   switch (layer) {
     case 0u: { return view.lightViewProj_A; }
@@ -40,7 +54,18 @@ fn _cascadeLightViewProj(layer : u32) -> mat4x4<f32> {
 
 @vertex
 fn vs_main(in : VsInput, @builtin(instance_index) idx : u32) -> @builtin(position) vec4<f32> {
+#if SKINNING_DISABLED == false
+  let skinMatrix = palette[in.skinIndex.x] * in.skinWeight.x +
+    palette[in.skinIndex.y] * in.skinWeight.y +
+    palette[in.skinIndex.z] * in.skinWeight.z +
+    palette[in.skinIndex.w] * in.skinWeight.w;
+  // Palette entries are jointWorld * inverseBind and therefore already
+  // produce world-space positions. Applying meshes[0].worldFromLocal again
+  // would double-transform a parented skinned entity.
+  let worldPos = skinMatrix * vec4<f32>(in.position, 1.0);
+#else
   let worldPos = meshes[0].worldFromLocal * instances[idx].localFromInstance * vec4<f32>(in.position, 1.0);
+#endif
   // feat-20260625-spot-light-shadow-mapping M2 / w10 (D-1): spot shadow passes
   // set `isSpot = 1u` and write their perspective matrix into
   // `spotLightViewProj`; directional cascade passes keep `isSpot = 0u` and read

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,8 +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, packSceneTemporal}
-#import forgeax_view::fog::{apply_fog}
+#import forgeax_view::common::{View, Mesh, InstanceData, PointLight, SpotLight, view, meshes, instances, pointLightsBuffer, spotLightsBuffer, sampleMaterialTexture}
+#import forgeax_scene_temporal::{packSceneTemporalV1}
 
 // @forgeax/engine-shader - sprite-lit.wgsl
 // (tweak-20260701-sprite-lit-flat-default-drop-ndotl-for-2d).
@@ -221,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);
@@ -245,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),
@@ -265,15 +248,14 @@ 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 {
   @builtin(position) clip : vec4<f32>,
   @location(0) uvAtlas : vec2<f32>,
-  @location(1) @interpolate(linear) currentClip : vec4<f32>,
-  @location(2) @interpolate(linear) previousClip : vec4<f32>,
+  @location(1) @interpolate(perspective) currentClip : vec4<f32>,
+  @location(2) @interpolate(perspective) previousClip : vec4<f32>,
 };
 
 @vertex
@@ -301,7 +283,7 @@ fn fs_temporal(in : TemporalVsOut) -> @location(0) vec4<f32> {
   if (alpha <= 0.0) {
     discard;
   }
-  return packSceneTemporal(in.currentClip, in.previousClip, 1.0);
+  return packSceneTemporalV1(in.currentClip, in.previousClip, view.temporalProjection, 1.0);
 }
 // sprite-lit needs at least one light in the scene to be visible; for unlit
 // sprites use forgeax::sprite (1 string change in MaterialAsset).

package/src/sprite.wgsl

@@ -2,8 +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, packSceneTemporal}
-#import forgeax_view::fog::{apply_fog}
+#import forgeax_view::common::{View, Mesh, InstanceData, view, meshes, instances, sampleMaterialTexture}
+#import forgeax_scene_temporal::{packSceneTemporalV1}
 
 // @forgeax/engine-shader - sprite.wgsl (feat-20260520-2d-sprite-layer-mvp /
 // M-3 / w19). 2D sprite material — third variant of the MaterialAsset
@@ -270,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
@@ -303,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.
@@ -323,15 +306,14 @@ 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 {
   @builtin(position) clip : vec4<f32>,
   @location(0) uvAtlas : vec2<f32>,
-  @location(1) @interpolate(linear) currentClip : vec4<f32>,
-  @location(2) @interpolate(linear) previousClip : vec4<f32>,
+  @location(1) @interpolate(perspective) currentClip : vec4<f32>,
+  @location(2) @interpolate(perspective) previousClip : vec4<f32>,
 };
 
 @vertex
@@ -359,7 +341,7 @@ fn fs_temporal(in : TemporalVsOut) -> @location(0) vec4<f32> {
   if (alpha <= 0.0) {
     discard;
   }
-  return packSceneTemporal(in.currentClip, in.previousClip, 1.0);
+  return packSceneTemporalV1(in.currentClip, in.previousClip, view.temporalProjection, 1.0);
 }
 // sprite is unlit; do NOT read the directional-light fields of the View
 // UBO -- same SSOT hard rule as the header comment above; R5 mitigation.

package/src/taa-resolve.wgsl

@@ -1,7 +1,28 @@
 #define_import_path forgeax_view::taa_resolve
 
-#import forgeax_view::common::fullscreen_triangle
-#import forgeax_view::common::FullscreenOutput
+// Keep the fragment input shape explicit for compilers that tree-shake imported
+// type declarations before resolving the vertex entry point.
+struct FullscreenOutput {
+  @builtin(position) position : vec4<f32>,
+  @location(0) uv : vec2<f32>,
+};
+
+fn fullscreen_triangle(vertex_index : u32) -> FullscreenOutput {
+  var x : f32 = -1.0;
+  var y : f32 = -1.0;
+  if (vertex_index == 1u) {
+    x = 3.0;
+  }
+  if (vertex_index == 2u) {
+    y = 3.0;
+  }
+  let u : f32 = (x + 1.0) * 0.5;
+  let v : f32 = 1.0 - (y + 1.0) * 0.5;
+  var out : FullscreenOutput;
+  out.position = vec4<f32>(x, y, 0.0, 1.0);
+  out.uv = vec2<f32>(u, v);
+  return out;
+}
 
 struct TaaResolveParams {
   currentJitterUv : vec2<f32>,
@@ -14,12 +35,15 @@ struct TaaResolveOutput {
   @location(1) temporal : vec4<f32>,
 };
 
-@group(0) @binding(0) var currentColor : texture_2d<f32>;
-@group(0) @binding(1) var currentTemporal : texture_2d<f32>;
-@group(0) @binding(2) var historyColor : texture_2d<f32>;
-@group(0) @binding(3) var historyTemporal : texture_2d<f32>;
-@group(0) @binding(4) var historySampler : sampler;
-@group(0) @binding(5) var<uniform> params : TaaResolveParams;
+@group(1) @binding(0) var currentColor : texture_2d<f32>;
+@group(1) @binding(1) var currentSampler : sampler;
+@group(1) @binding(2) var historyColor : texture_2d<f32>;
+@group(1) @binding(3) var historySampler : sampler;
+@group(1) @binding(4) var historyTemporal : texture_2d<f32>;
+@group(1) @binding(5) var temporalSampler : sampler;
+@group(1) @binding(6) var currentTemporal : texture_2d<f32>;
+@group(1) @binding(7) var currentTemporalSampler : sampler;
+@group(1) @binding(8) var<uniform> params : TaaResolveParams;
 
 fn rgbToYCoCg(rgb : vec3<f32>) -> vec3<f32> {
   return vec3<f32>(
@@ -37,93 +61,64 @@ fn luminance(rgb : vec3<f32>) -> f32 {
   return dot(rgb, vec3<f32>(0.2126, 0.7152, 0.0722));
 }
 
-fn jitterCorrectedCurrent(uv : vec2<f32>) -> vec4<f32> {
-  // The resolve and history live in the unjittered output domain. The main
-  // scene raster is the only jittered consumer, so re-center its color here;
-  // packed motion is already unjittered currentUv - previousUv.
-  return textureSampleLevel(currentColor, historySampler, uv + params.currentJitterUv, 0.0);
+fn closestCurrentTemporal(pixel : vec2<i32>, dimensions : vec2<i32>) -> vec4<f32> {
+  let clamped = clamp(pixel, vec2<i32>(0), dimensions - vec2<i32>(1));
+  return textureLoad(currentTemporal, clamped, 0);
 }
 
-fn closestCurrentTemporal(pixel : vec2<i32>, dimensions : vec2<i32>) -> vec4<f32> {
-  var closest = vec4<f32>(0.0, 0.0, -1.0, 1.0);
-  var closestDepth = 1e20;
-  for (var y = -1; y <= 1; y += 1) {
-    for (var x = -1; x <= 1; x += 1) {
-      let samplePixel = clamp(pixel + vec2<i32>(x, y), vec2<i32>(0), dimensions - vec2<i32>(1));
-      let candidate = textureLoad(currentTemporal, samplePixel, 0);
-      if candidate.z >= 0.0 && candidate.z < closestDepth {
-        closest = candidate;
-        closestDepth = candidate.z;
-      }
-    }
-  }
-  return closest;
+fn neighborhoodSquareMean(uv : vec2<f32>, texel : vec2<f32>) -> vec3<f32> {
+  let north = textureSampleLevel(currentColor, currentSampler, uv + vec2<f32>(0.0, texel.y), 0.0).rgb;
+  let south = textureSampleLevel(currentColor, currentSampler, uv - vec2<f32>(0.0, texel.y), 0.0).rgb;
+  let east = textureSampleLevel(currentColor, currentSampler, uv + vec2<f32>(texel.x, 0.0), 0.0).rgb;
+  let west = textureSampleLevel(currentColor, currentSampler, uv - vec2<f32>(texel.x, 0.0), 0.0).rgb;
+  return (north + south + east + west) * 0.25;
 }
 
 @vertex
-fn vs_taa_resolve(@builtin(vertex_index) vertexIndex : u32) -> FullscreenOutput {
+fn vs_main(@builtin(vertex_index) vertexIndex : u32) -> FullscreenOutput {
   return fullscreen_triangle(vertexIndex);
 }
 
-@fragment
 fn fs_taa_resolve(in : FullscreenOutput) -> TaaResolveOutput {
-  let dimensions = vec2<i32>(textureDimensions(currentColor));
-  let pixel = clamp(vec2<i32>(in.position.xy), vec2<i32>(0), dimensions - vec2<i32>(1));
-  let current = jitterCorrectedCurrent(in.uv);
+  let dimensions = vec2<i32>(textureDimensions(currentColor, 0));
+  let texel = 1.0 / vec2<f32>(dimensions);
+  let current = textureSampleLevel(currentColor, currentSampler, in.uv + params.currentJitterUv, 0.0);
+  let pixel = vec2<i32>(in.uv * vec2<f32>(dimensions));
   let temporal = closestCurrentTemporal(pixel, dimensions);
-
-  var output : TaaResolveOutput;
-  output.temporal = temporal;
-  output.color = current;
-
   let historyUv = in.uv - temporal.xy;
-  let historyInBounds = all(historyUv >= vec2<f32>(0.0)) && all(historyUv < vec2<f32>(1.0));
-  if params.historyValid == 0u || !historyInBounds || temporal.z < 0.0 {
-    return output;
-  }
-
-  let previousTemporal = textureSampleLevel(historyTemporal, historySampler, historyUv, 0.0);
+  let historyInBounds = all(historyUv >= vec2<f32>(0.0)) && all(historyUv <= vec2<f32>(1.0));
+  let history = textureSampleLevel(historyColor, historySampler, historyUv, 0.0);
+  let previousTemporal = textureSampleLevel(historyTemporal, temporalSampler, historyUv, 0.0);
   let depthDelta = abs(previousTemporal.z - temporal.z);
-  let depthThreshold = max(0.01, temporal.z * 0.01);
-  if previousTemporal.z < 0.0 || depthDelta > depthThreshold {
-    return output;
-  }
-
-  var neighborhoodMin = vec3<f32>(1e20);
-  var neighborhoodMax = vec3<f32>(-1e20);
-  var neighborhoodMean = vec3<f32>(0.0);
-  var neighborhoodSquareMean = vec3<f32>(0.0);
-  for (var y = -1; y <= 1; y += 1) {
-    for (var x = -1; x <= 1; x += 1) {
-      let sampleUv = in.uv + vec2<f32>(f32(x), f32(y)) / vec2<f32>(dimensions);
-      let sampleValue = rgbToYCoCg(jitterCorrectedCurrent(sampleUv).rgb);
-      neighborhoodMin = min(neighborhoodMin, sampleValue);
-      neighborhoodMax = max(neighborhoodMax, sampleValue);
-      neighborhoodMean += sampleValue;
-      neighborhoodSquareMean += sampleValue * sampleValue;
-    }
-  }
-  neighborhoodMean /= 9.0;
-  neighborhoodSquareMean /= 9.0;
-  let sigma = sqrt(max(neighborhoodSquareMean - neighborhoodMean * neighborhoodMean, vec3<f32>(0.0)));
-  let clipMin = max(neighborhoodMin, neighborhoodMean - sigma * 1.25);
-  let clipMax = min(neighborhoodMax, neighborhoodMean + sigma * 1.25);
-
-  let sampledHistory = textureSampleLevel(historyColor, historySampler, historyUv, 0.0);
-  let clippedHistoryRgb = yCoCgToRgb(clamp(rgbToYCoCg(sampledHistory.rgb), clipMin, clipMax));
-  let velocityFactor = 1.0 - clamp(length(temporal.xy) * 64.0, 0.0, 1.0);
+  let depthThreshold = 0.0025 + temporal.z * 0.01;
+  let rejected =
+    params.historyValid == 0u ||
+    !historyInBounds ||
+    temporal.z < 0.0 ||
+    previousTemporal.z < 0.0 ||
+    depthDelta > depthThreshold;
+  let neighborhood = neighborhoodSquareMean(in.uv, texel);
+  let neighborhoodDelta = abs(luminance(current.rgb) - luminance(neighborhood));
+  let clipPadding = vec3<f32>(0.5);
+  let clipMin = rgbToYCoCg(min(current.rgb, neighborhood - vec3<f32>(neighborhoodDelta) - clipPadding));
+  let clipMax = rgbToYCoCg(max(current.rgb, neighborhood + vec3<f32>(neighborhoodDelta) + clipPadding));
+  let clippedHistoryRgb = yCoCgToRgb(clamp(rgbToYCoCg(history.rgb), clipMin, clipMax));
   let reactiveFactor = 1.0 - clamp(temporal.w, 0.0, 1.0);
+  let velocityFactor = 1.0 - clamp(length(temporal.xy) * 64.0, 0.0, 1.0);
   let depthFactor = 1.0 - clamp(depthDelta / depthThreshold, 0.0, 1.0);
-  let currentLuma = luminance(current.rgb);
-  let historyLuma = luminance(clippedHistoryRgb);
-  let lumaDelta = abs(historyLuma - currentLuma);
-  let unbiasedLumaDelta = clamp(lumaDelta / max(max(currentLuma, historyLuma), 0.2), 0.0, 1.0);
+  let unbiasedLumaDelta = clamp(abs(luminance(current.rgb) - luminance(history.rgb)), 0.0, 1.0);
   let lumaFactor = (1.0 - unbiasedLumaDelta) * (1.0 - unbiasedLumaDelta);
   let fixedPresetWeight = mix(0.88, 0.97, lumaFactor);
-  let startupWeight = f32(params.temporalFrameIndex) / f32(params.temporalFrameIndex + 1u);
-  let progressiveWeight = select(fixedPresetWeight, min(startupWeight, fixedPresetWeight), params.temporalFrameIndex < 8u);
-  let rejectionFactor = min(reactiveFactor, min(velocityFactor, depthFactor));
-  let historyWeight = progressiveWeight * rejectionFactor;
-  output.color = vec4<f32>(mix(current.rgb, clippedHistoryRgb, historyWeight), current.a);
-  return output;
+  let progressiveWeight = select(fixedPresetWeight, 0.0, params.temporalFrameIndex < 8u);
+  let historyWeight = progressiveWeight * reactiveFactor * velocityFactor * depthFactor;
+  let resolved = select(mix(current.rgb, clippedHistoryRgb, historyWeight), current.rgb, rejected);
+  return TaaResolveOutput(
+    vec4<f32>(resolved, current.a),
+    temporal,
+  );
+}
+
+@fragment
+fn fs_main(in : FullscreenOutput) -> TaaResolveOutput {
+  return fs_taa_resolve(in);
 }

package/src/tonemap.wgsl

@@ -1,6 +1,6 @@
 #define_import_path forgeax_view::tonemap
 
-// @forgeax/engine-shader - Three r184 tone mapping output module.
+// @forgeax/engine-shader - Three r184 Output Transform module.
 //
 // The public modes and formulas are the Three.js r184 oracle. The numeric
 // values are the binding contract mirrored by TONEMAP_SHADER_MODE in tonemap.ts.
@@ -153,8 +153,7 @@ fn tonemapNeutral(color : vec3<f32>) -> vec3<f32> {
 
 @fragment
 fn fs_main(in : FullscreenOutput) -> @location(0) vec4<f32> {
-  // linearHdrColorDomain: hdr is sampled before the only HDR-to-LDR stage.
-  // linearLdrColorDomain: the output pass emits the display-target domain.
+  // Output Transform consumes linear HDR and emits display-encoded color.
   let source = textureSample(hdr, samp, in.uv);
   let sample : vec3<f32> = source.rgb;
   let exposed : vec3<f32> = sample * params.exposure;
@@ -167,11 +166,10 @@ fn fs_main(in : FullscreenOutput) -> @location(0) vec4<f32> {
     case 5u: { mapped = tonemapAgx(exposed); }
     case 6u: { mapped = tonemapNeutral(exposed); }
     case 7u: { mapped = tonemapReinhard(exposed); }
-    // Mode 0 is the linear-LDR output pass used when tone mapping is disabled.
-    // It targets the raw canvas format and mirrors Three r184's output OETF.
-    default: { mapped = linearToSrgbOetf(exposed); }
+    // Mode 0 skips the tone curve but still performs the output conversion.
+    default: { mapped = sample; }
   }
-  // The mode-0 output pass is display-encoded; other modes retain their
-  // existing tonemap output contract.
-  return vec4<f32>(mapped, source.a);
+  // Every public mode reaches exactly one shared sRGB OETF.
+  let encoded = linearToSrgbOetf(mapped);
+  return vec4<f32>(encoded, source.a);
 }

package/src/unlit.wgsl

@@ -1,6 +1,6 @@
 #define_import_path forgeax_material::unlit
-#import forgeax_view::common::{View, FogViewParams, FogRay, Mesh, InstanceData, view, meshes, instances, sampleMaterialTextureLinear, packSceneTemporal}
-#import forgeax_view::fog::{apply_fog}
+#import forgeax_view::common::{View, Mesh, InstanceData, view, meshes, instances, sampleMaterialTextureLinear}
+#import forgeax_scene_temporal::{packSceneTemporalV1}
 
 #pragma variant_axis STORAGE_BUFFER_AVAILABLE
 #pragma variant_axis VERTEX_COLOR_AVAILABLE
@@ -100,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);
@@ -124,19 +108,14 @@ 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 {
   @builtin(position) clip : vec4<f32>,
   @location(0) uv : vec2<f32>,
-  @location(1) @interpolate(linear) currentClip : vec4<f32>,
-  @location(2) @interpolate(linear) previousClip : vec4<f32>,
+  @location(1) @interpolate(perspective) currentClip : vec4<f32>,
+  @location(2) @interpolate(perspective) previousClip : vec4<f32>,
 #ifdef VERTEX_COLOR_AVAILABLE
   @location(14) color : vec4<f32>,
 #endif
@@ -178,9 +157,9 @@ fn fs_temporal(in : TemporalVsOut) -> @location(0) vec4<f32> {
   if (material.alphaCutoff > 0.0 && alpha < material.alphaCutoff) {
     discard;
   }
-  var reactive = 1.0;
+  var reactive = 0.0;
 #if STORAGE_BUFFER_AVAILABLE == true
   reactive = meshes[0].temporal.x;
 #endif
-  return packSceneTemporal(in.currentClip, in.previousClip, reactive);
+  return packSceneTemporalV1(in.currentClip, in.previousClip, view.temporalProjection, reactive);
 }

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