@forgeax/engine-shader 0.1.6 → 0.1.19

package/src/points-lines.wgsl

@@ -0,0 +1,103 @@
+#define_import_path forgeax_material::points_lines
+
+// Portable triangle expansion for square/circle points and independent butt
+// line-list segments. All dimensions are physical pixels; no native wide
+// primitive state is required by any raster lane.
+
+struct PointsLinesView {
+  worldViewProj : mat4x4<f32>,
+  model : mat4x4<f32>,
+  physicalViewport : vec2<f32>,
+  style : vec4<f32>,
+};
+
+@group(0) @binding(10) var<uniform> pointsLinesView : PointsLinesView;
+
+struct PointsLinesMaterial {
+  baseColor : vec4<f32>,
+  alphaCutoff : f32,
+  _materialPadding : vec3<f32>,
+  baseColorTextureCoordinatesTransform : vec4<f32>,
+  baseColorTextureCoordinatesMetadata : vec4<f32>,
+};
+
+@group(1) @binding(0) var<uniform> material : PointsLinesMaterial;
+@group(1) @binding(1) var baseColorSampler : sampler;
+@group(1) @binding(2) var baseColorTexture : texture_2d<f32>;
+
+struct PointsLinesVertex {
+  @location(0) position : vec3<f32>,
+  @location(1) otherPosition : vec3<f32>,
+  @location(2) corner : vec2<f32>,
+};
+
+struct PointsLinesFragment {
+  @builtin(position) position : vec4<f32>,
+  @location(0) @interpolate(flat) shape : f32,
+  @location(1) @interpolate(linear) sampleCenter : vec2<f32>,
+};
+
+fn clipPixelDelta(clip : vec4<f32>, pixels : vec2<f32>) -> vec2<f32> {
+  let viewport = max(pointsLinesView.physicalViewport, vec2<f32>(1.0, 1.0));
+  let ndcPerPixel = vec2<f32>(2.0 / viewport.x, -2.0 / viewport.y);
+  return pixels * ndcPerPixel * clip.w;
+}
+
+fn expandPoint(position : vec3<f32>, corner : vec2<f32>, sizePx : f32) -> vec4<f32> {
+  let clip = pointsLinesView.worldViewProj * pointsLinesView.model * vec4<f32>(position, 1.0);
+  let offset = clipPixelDelta(clip, corner * (sizePx * 0.5));
+  return vec4<f32>(clip.xy + offset, clip.z, clip.w);
+}
+
+fn expandLine(
+  start : vec3<f32>,
+  end : vec3<f32>,
+  corner : vec2<f32>,
+  widthPx : f32,
+) -> vec4<f32> {
+  let startClip = pointsLinesView.worldViewProj * pointsLinesView.model * vec4<f32>(start, 1.0);
+  let endClip = pointsLinesView.worldViewProj * pointsLinesView.model * vec4<f32>(end, 1.0);
+  let startNdc = startClip.xy / max(startClip.w, 0.000001);
+  let endNdc = endClip.xy / max(endClip.w, 0.000001);
+  let tangent = endNdc - startNdc;
+  let safeTangent = select(vec2<f32>(1.0, 0.0), tangent, dot(tangent, tangent) > 0.0000001);
+  let axis = normalize(safeTangent);
+  let normal = vec2<f32>(-axis.y, axis.x);
+  let endpoint = select(startClip, endClip, corner.x > 0.0);
+  let offset = clipPixelDelta(endpoint, normal * corner.y * (widthPx * 0.5));
+  // butt line-list: each segment owns exactly its two endpoint positions.
+  return vec4<f32>(endpoint.xy + offset, endpoint.z, endpoint.w);
+}
+
+fn circleCoverage(sampleCenter : vec2<f32>) -> bool {
+  return dot(sampleCenter, sampleCenter) <= 1.0;
+}
+
+@vertex
+fn vs_main(input : PointsLinesVertex) -> PointsLinesFragment {
+  let isLine = pointsLinesView.style.y > 0.5;
+  let isCircle = pointsLinesView.style.z > 0.5 && !isLine;
+  var output : PointsLinesFragment;
+  output.position = select(
+    expandPoint(input.position, input.corner, pointsLinesView.style.x),
+    expandLine(input.position, input.otherPosition, input.corner, pointsLinesView.style.x),
+    isLine,
+  );
+  output.shape = select(0.0, 1.0, isCircle);
+  output.sampleCenter = select(input.corner, vec2<f32>(0.0, 0.0), isLine);
+  return output;
+}
+
+@fragment
+fn fs_main(input : PointsLinesFragment) -> @location(0) vec4<f32> {
+  if input.shape > 0.5 && !circleCoverage(input.sampleCenter) {
+    discard;
+  }
+  let uv = material.baseColorTextureCoordinatesMetadata.xy;
+  let textureColor = textureSample(baseColorTexture, baseColorSampler, uv);
+  let color = material.baseColor * textureColor;
+  if material.alphaCutoff > 0.0 && color.a < material.alphaCutoff {
+    discard;
+  }
+  return color;
+}

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_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/sprite-lit.wgsl

@@ -1,7 +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::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}
 
 // @forgeax/engine-shader - sprite-lit.wgsl
@@ -272,8 +273,8 @@ fn fs_main_hdr(in : VsOut) -> @location(0) vec4<f32> {
 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 +302,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,7 +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::common::{View, FogViewParams, FogRay, 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 /
@@ -330,8 +331,8 @@ fn fs_main_hdr(in : VsOut) -> @location(0) vec4<f32> {
 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 +360,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,5 +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::common::{View, FogViewParams, FogRay, Mesh, InstanceData, view, meshes, instances, sampleMaterialTextureLinear}
+#import forgeax_scene_temporal::{packSceneTemporalV1}
 #import forgeax_view::fog::{apply_fog}
 
 #pragma variant_axis STORAGE_BUFFER_AVAILABLE
@@ -135,8 +136,8 @@ fn fs_main(in : VsOut) -> @location(0) vec4<f32> {
 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 +179,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/dist/__tests__/atmosphere-background.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=atmosphere-background.test.d.ts.map

package/dist/__tests__/atmosphere-background.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"atmosphere-background.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/atmosphere-background.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/atmosphere-cubemap-orientation.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=atmosphere-cubemap-orientation.test.d.ts.map

package/dist/__tests__/atmosphere-cubemap-orientation.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"atmosphere-cubemap-orientation.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/atmosphere-cubemap-orientation.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/atmosphere-preetham-numeric.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=atmosphere-preetham-numeric.test.d.ts.map

package/dist/__tests__/atmosphere-preetham-numeric.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"atmosphere-preetham-numeric.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/atmosphere-preetham-numeric.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/atmosphere-preetham-red.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=atmosphere-preetham-red.test.d.ts.map

package/dist/__tests__/atmosphere-preetham-red.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"atmosphere-preetham-red.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/atmosphere-preetham-red.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/atmosphere-preetham.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=atmosphere-preetham.test.d.ts.map

package/dist/__tests__/atmosphere-preetham.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"atmosphere-preetham.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/atmosphere-preetham.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/atmosphere-three-r184-reference.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=atmosphere-three-r184-reference.test.d.ts.map

package/dist/__tests__/atmosphere-three-r184-reference.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"atmosphere-three-r184-reference.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/atmosphere-three-r184-reference.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/bloom-fxaa-tonemap.unit.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=bloom-fxaa-tonemap.unit.test.d.ts.map

package/dist/__tests__/bloom-fxaa-tonemap.unit.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"bloom-fxaa-tonemap.unit.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/bloom-fxaa-tonemap.unit.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/builtin-texture-sampling-contract.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=builtin-texture-sampling-contract.test.d.ts.map

package/dist/__tests__/builtin-texture-sampling-contract.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"builtin-texture-sampling-contract.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/builtin-texture-sampling-contract.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/default-standard-pbr-alpha.unit.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=default-standard-pbr-alpha.unit.test.d.ts.map

package/dist/__tests__/default-standard-pbr-alpha.unit.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"default-standard-pbr-alpha.unit.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/default-standard-pbr-alpha.unit.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/deferred-lighting-ssao.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=deferred-lighting-ssao.test.d.ts.map

package/dist/__tests__/deferred-lighting-ssao.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"deferred-lighting-ssao.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/deferred-lighting-ssao.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/fog-oracle.unit.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=fog-oracle.unit.test.d.ts.map

package/dist/__tests__/fog-oracle.unit.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"fog-oracle.unit.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/fog-oracle.unit.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/fog-orthographic-ray.unit.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=fog-orthographic-ray.unit.test.d.ts.map

package/dist/__tests__/fog-orthographic-ray.unit.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"fog-orthographic-ray.unit.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/fog-orthographic-ray.unit.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/fog-producer-matrix.integration.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=fog-producer-matrix.integration.test.d.ts.map

package/dist/__tests__/fog-producer-matrix.integration.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"fog-producer-matrix.integration.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/fog-producer-matrix.integration.test.ts"],"names":[],"mappings":""}