@forgeax/engine-shader 0.1.28 → 0.1.29

package/src/surface_v1.wgsl

@@ -9,6 +9,12 @@ struct SurfaceInput {
   viewDirectionWS : vec3<f32>,
   uv0 : vec2<f32>,
   uv1 : vec2<f32>,
+  uv2 : vec2<f32>,
+  uv3 : vec2<f32>,
+  uv4 : vec2<f32>,
+  uv5 : vec2<f32>,
+  uv6 : vec2<f32>,
+  uv7 : vec2<f32>,
   vertexColor : vec4<f32>,
   frontFacing : bool,
 };

package/src/taa-resolve.wgsl

@@ -28,11 +28,13 @@ struct TaaResolveParams {
   currentJitterUv : vec2<f32>,
   historyValid : u32,
   temporalFrameIndex : u32,
+  hasSecondaryReactivity : u32,
 };
 
 struct TaaResolveOutput {
   @location(0) color : vec4<f32>,
   @location(1) temporal : vec4<f32>,
+  @location(2) stability : f32,
 };
 
 @group(1) @binding(0) var currentColor : texture_2d<f32>;
@@ -44,6 +46,39 @@ struct TaaResolveOutput {
 @group(1) @binding(6) var currentTemporal : texture_2d<f32>;
 @group(1) @binding(7) var currentTemporalSampler : sampler;
 @group(1) @binding(8) var<uniform> params : TaaResolveParams;
+@group(1) @binding(9) var historyStability : texture_2d<f32>;
+@group(1) @binding(10) var secondaryReactivity : texture_2d<f32>;
+
+fn sampleSecondaryReactivity(uv : vec2<f32>) -> f32 {
+  if (params.hasSecondaryReactivity == 0u) { return 0.0; }
+  let size = vec2<i32>(textureDimensions(secondaryReactivity));
+  let center = vec2<i32>(uv * vec2<f32>(size));
+  var reactive = 0.0;
+  // Conservatively cover the reconstruction footprint, including producers
+  // on a reduced-resolution lattice. Never interpolate a motion flag away.
+  for (var y = -3; y <= 3; y++) {
+    for (var x = -3; x <= 3; x++) {
+      let pixel = clamp(center + vec2<i32>(x, y), vec2<i32>(0), size - vec2<i32>(1));
+      let value = textureLoad(secondaryReactivity, pixel, 0).r;
+      if (value != value || abs(value) > 3.402823e+38) { return 1.0; }
+      reactive = max(reactive, clamp(value, 0.0, 1.0));
+    }
+  }
+  return reactive;
+}
+
+// One complete eight-phase jitter cycle must settle after motion/rejection.
+// Store the state in a private r8unorm attachment; temporal-v1's
+// reactive lane includes secondary-source changes; receiver velocity and depth
+// remain unchanged for downstream effects such as Motion Blur.
+const TAA_STABILITY_FRAMES : f32 = 8.0;
+const TAA_HISTORY_SETTLE_FRAMES : f32 = 128.0;
+
+fn taaStableAge(previous : f32, accepted : bool, temporal : vec4<f32>, priorMotion : vec2<f32>) -> f32 {
+  let stationary = max(length(temporal.xy), length(priorMotion)) < 1e-5;
+  let count = min(floor(clamp(previous, 0.0, 1.0) * 255.0 + 0.5), TAA_HISTORY_SETTLE_FRAMES);
+  return select(0.0, min(count + 1.0, TAA_HISTORY_SETTLE_FRAMES), accepted && temporal.w == 0.0 && stationary);
+}
 
 fn rgbToYCoCg(rgb : vec3<f32>) -> vec3<f32> {
   return vec3<f32>(
@@ -61,17 +96,170 @@ fn luminance(rgb : vec3<f32>) -> f32 {
   return dot(rgb, vec3<f32>(0.2126, 0.7152, 0.0722));
 }
 
-fn closestCurrentTemporal(pixel : vec2<i32>, dimensions : vec2<i32>) -> vec4<f32> {
+fn taaAccumulationWeight(frameIndex : u32, steadyWeight : f32) -> f32 {
+  let samples = f32(frameIndex);
+  return min(steadyWeight, samples / (samples + 1.0));
+}
+
+// Karis, High Quality Temporal Supersampling (SIGGRAPH 2014), slide 20.
+// With linear luminance, these normalized weights are equivalent to
+// T(C)=C/(1+luma(C)), temporal blending, then T^-1(C)=C/(1-luma(C)).
+// One scalar per color preserves chroma and avoids an unstable explicit
+// inverse near one. History and the post-processing output remain HDR.
+fn blendTaaHistory(current : vec3<f32>, history : vec3<f32>, historyWeight : f32) -> vec3<f32> {
+  let currentWeight = (1.0 - historyWeight) / (1.0 + max(0.0, luminance(current)));
+  let previousWeight = historyWeight / (1.0 + max(0.0, luminance(history)));
+  return (current * currentWeight + history * previousWeight) / max(currentWeight + previousWeight, 0.00001);
+}
+
+// Render-target FP16 conversion can consistently round down. Feeding that
+// error back every frame darkens history, increasingly so at high weights.
+// Choose between the two exactly representable neighbors without bias before
+// the attachment conversion. One shared RGB threshold preserves neutral color;
+// frame/pixel hashing avoids locking rounding to the eight jitter phases.
+fn taaRoundingNoise(pixel : vec2<u32>, frame : u32) -> f32 {
+  var bits = pixel.x * 0x9e3779b9u + pixel.y * 0x85ebca6bu + frame * 0xc2b2ae35u;
+  bits = (bits ^ (bits >> 16u)) * 0x7feb352du;
+  bits = (bits ^ (bits >> 15u)) * 0x846ca68bu;
+  bits = bits ^ (bits >> 16u);
+  return f32(bits >> 8u) / 16777216.0;
+}
+
+fn roundTaaHistory(color : vec3<f32>, noise : f32) -> vec3<f32> {
+  let magnitude = min(abs(color), vec3<f32>(65504.0));
+  let exponent = (bitcast<vec3<u32>>(magnitude) >> vec3<u32>(23u)) & vec3<u32>(255u);
+  // Normal spacing is 2^(exponent - 127 - 10); subnormals use 2^-24.
+  let step = bitcast<vec3<f32>>((max(exponent, vec3<u32>(113u)) - vec3<u32>(10u)) << vec3<u32>(23u));
+  let scaled = magnitude / step;
+  let integral = floor(scaled);
+  let rounded = (integral + select(vec3<f32>(0.0), vec3<f32>(1.0), vec3<f32>(noise) < scaled - integral)) * step;
+  return select(rounded, -rounded, color < vec3<f32>(0.0));
+}
+
+struct TaaCurrentTemporal {
+  temporal : vec4<f32>,
+  depthEdge : bool,
+};
+
+fn closestCurrentTemporal(pixel : vec2<i32>, dimensions : vec2<i32>) -> TaaCurrentTemporal {
   let clamped = clamp(pixel, vec2<i32>(0), dimensions - vec2<i32>(1));
-  return textureLoad(currentTemporal, clamped, 0);
+  var closest = textureLoad(currentTemporal, clamped, 0);
+  var farthestDepth = closest.z;
+  var hasBackground = closest.z < 0.0;
+  // Jitter changes coverage at silhouettes and subpixel gaps. Select the
+  // nearest valid surface in the reconstruction footprint, carrying its
+  // motion and reactive flag together. The negative clear depth is absent
+  // geometry, not a surface closer than every real sample.
+  for (var y = -1; y <= 1; y++) {
+    for (var x = -1; x <= 1; x++) {
+      let samplePixel = clamp(pixel + vec2<i32>(x, y), vec2<i32>(0), dimensions - vec2<i32>(1));
+      let candidate = textureLoad(currentTemporal, samplePixel, 0);
+      hasBackground = hasBackground || candidate.z < 0.0;
+      farthestDepth = max(farthestDepth, candidate.z);
+      if (candidate.z >= 0.0 && (closest.z < 0.0 || candidate.z < closest.z)) {
+        closest = candidate;
+      }
+    }
+  }
+  // Three.js TRAA exempts current depth edges from the disocclusion test.
+  // Use the existing logarithmic-depth tolerance, not a perspective threshold.
+  return TaaCurrentTemporal(closest, closest.z >= 0.0 &&
+    (hasBackground || farthestDepth - closest.z > 0.0025 + closest.z * 0.01));
 }
 
-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;
+struct TaaBounds {
+  minimum : vec3<f32>,
+  maximum : vec3<f32>,
+};
+
+fn taaBoundsSample(pixel : vec2<i32>, dimensions : vec2<i32>) -> vec3<f32> {
+  return rgbToYCoCg(textureLoad(currentColor, clamp(pixel, vec2<i32>(0), dimensions - vec2<i32>(1)), 0).rgb);
+}
+
+fn taaBoundsRow(pixel : vec2<i32>, dimensions : vec2<i32>, wide : bool) -> TaaBounds {
+  let a = taaBoundsSample(pixel + vec2<i32>(-1, 0), dimensions);
+  let b = taaBoundsSample(pixel, dimensions);
+  let c = taaBoundsSample(pixel + vec2<i32>(1, 0), dimensions);
+  var bounds = TaaBounds(min(min(a, b), c), max(max(a, b), c));
+  if (wide) {
+    let left = taaBoundsSample(pixel + vec2<i32>(-2, 0), dimensions);
+    let right = taaBoundsSample(pixel + vec2<i32>(2, 0), dimensions);
+    bounds.minimum = min(bounds.minimum, min(left, right));
+    bounds.maximum = max(bounds.maximum, max(left, right));
+  }
+  return bounds;
+}
+
+fn taaNeighborhood(uv : vec2<f32>, current : vec3<f32>, settled : bool) -> TaaBounds {
+  let dimensions = vec2<i32>(textureDimensions(currentColor));
+  let pixel = vec2<i32>(uv * vec2<f32>(dimensions));
+  let center = rgbToYCoCg(current);
+  let top = taaBoundsRow(pixel + vec2<i32>(0, -1), dimensions, settled);
+  let bottom = taaBoundsRow(pixel + vec2<i32>(0, 1), dimensions, settled);
+  var bounds = TaaBounds(
+    min(min(top.minimum, bottom.minimum), center),
+    max(max(top.maximum, bottom.maximum), center),
+  );
+  // Keep the moving eight-neighbor footprint and the settled symmetric 5x5
+  // support. Reduce directly in YCoCg instead of materializing 25 RGB values
+  // and then dynamically indexing them in a second loop.
+  if (settled) {
+    let first = taaBoundsRow(pixel + vec2<i32>(0, -2), dimensions, true);
+    let last = taaBoundsRow(pixel + vec2<i32>(0, 2), dimensions, true);
+    let middle = taaBoundsRow(pixel, dimensions, true);
+    bounds.minimum = min(bounds.minimum, min(min(first.minimum, last.minimum), middle.minimum));
+    bounds.maximum = max(bounds.maximum, max(max(first.maximum, last.maximum), middle.maximum));
+  } else {
+    let left = taaBoundsSample(pixel + vec2<i32>(-1, 0), dimensions);
+    let right = taaBoundsSample(pixel + vec2<i32>(1, 0), dimensions);
+    bounds.minimum = min(bounds.minimum, min(left, right));
+    bounds.maximum = max(bounds.maximum, max(left, right));
+  }
+  return bounds;
+}
+
+fn clipTaaHistory(neighbors : TaaBounds, history : vec3<f32>) -> vec3<f32> {
+  let clipMin = neighbors.minimum;
+  let clipMax = neighbors.maximum;
+  return yCoCgToRgb(clamp(rgbToYCoCg(history), clipMin, clipMax));
+}
+
+struct TaaClipDecision {
+  history : vec3<f32>,
+  state : f32,
+};
+
+fn resolveTaaClipping(clipped : vec3<f32>, history : vec3<f32>, previous : f32, age : f32) -> TaaClipDecision {
+  // Codes 0..128 are accepted stationary age. The remaining 42 codes store
+  // 1..7 consecutive misses in one of six signed RGB directions. Reversing
+  // direction or finding support breaks the streak, so one dark jitter phase
+  // cannot erase the accumulated coverage of a thin bright surface. Eight
+  // persistent misses restore clipping even without motion. Color clipping
+  // must not invalidate the accepted geometric reconstruction footprint.
+  if (age < TAA_HISTORY_SETTLE_FRAMES) {
+    // Release phase-local clipping while accumulation is still responsive.
+    // Waiting until the 0.99 history weight has engaged locks in the earlier
+    // clipped mean and makes a static image drift for hundreds more frames.
+    return TaaClipDecision(mix(clipped, history, smoothstep(TAA_STABILITY_FRAMES, 64.0, age)), age / 255.0);
+  }
+  let delta = clipped - history;
+  let magnitude = abs(delta);
+  var axis = 0u;
+  if (magnitude.y > magnitude.x) { axis = 1u; }
+  if (magnitude.z > magnitude[axis]) { axis = 2u; }
+  let scale = max(1.0, max(abs(history.x), max(abs(history.y), abs(history.z))));
+  if (magnitude[axis] <= scale * 0.00001) {
+    return TaaClipDecision(history, TAA_HISTORY_SETTLE_FRAMES / 255.0);
+  }
+  let direction = axis * 2u + select(0u, 1u, delta[axis] > 0.0);
+  let code = u32(floor(clamp(previous, 0.0, 1.0) * 255.0 + 0.5));
+  var streak = 1u;
+  if (code >= 129u && code <= 170u) {
+    let prior = code - 129u;
+    if (prior / 7u == direction) { streak = prior % 7u + 2u; }
+  }
+  if (streak >= 8u) { return TaaClipDecision(clipped, TAA_HISTORY_SETTLE_FRAMES / 255.0); }
+  return TaaClipDecision(history, f32(129u + direction * 7u + streak - 1u) / 255.0);
 }
 
 @vertex
@@ -81,10 +269,13 @@ fn vs_main(@builtin(vertex_index) vertexIndex : u32) -> FullscreenOutput {
 
 fn fs_taa_resolve(in : FullscreenOutput) -> TaaResolveOutput {
   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);
+  let currentUv = in.uv + params.currentJitterUv;
+  let current = textureSampleLevel(currentColor, currentSampler, currentUv, 0.0);
+  let pixel = vec2<i32>(currentUv * vec2<f32>(dimensions));
+  let currentSample = closestCurrentTemporal(pixel, dimensions);
+  let sceneTemporal = currentSample.temporal;
+  let temporal = vec4<f32>(sceneTemporal.xyz,
+    max(sceneTemporal.w, sampleSecondaryReactivity(currentUv)));
   let historyUv = in.uv - temporal.xy;
   let historyInBounds = all(historyUv >= vec2<f32>(0.0)) && all(historyUv <= vec2<f32>(1.0));
   let history = textureSampleLevel(historyColor, historySampler, historyUv, 0.0);
@@ -95,26 +286,29 @@ fn fs_taa_resolve(in : FullscreenOutput) -> TaaResolveOutput {
     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));
+    ((previousTemporal.z < 0.0 || depthDelta > depthThreshold) && !currentSample.depthEdge);
+  let historyPixel = clamp(vec2<i32>(historyUv * vec2<f32>(dimensions)), vec2<i32>(0), dimensions - vec2<i32>(1));
+  let priorStability = textureLoad(historyStability, historyPixel, 0).r;
+  let stableAge = taaStableAge(priorStability, !rejected, temporal, previousTemporal.xy);
+  let clipped = clipTaaHistory(taaNeighborhood(currentUv, current.rgb, stableAge >= TAA_STABILITY_FRAMES), history.rgb);
+  let clipping = resolveTaaClipping(clipped, history.rgb, priorStability, stableAge);
+  let clippedHistoryRgb = clipping.history;
   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 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 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);
+  // Motion ending is not the same as settled radiance. Keep fast recovery
+  // for 64 stationary frames before reducing the residual jitter response.
+  // Any rejection, receiver motion, or secondary reactivity resets this age.
+  let steadyWeight = mix(0.95, 0.99, smoothstep(64.0, TAA_HISTORY_SETTLE_FRAMES, stableAge));
+  let progressiveWeight = taaAccumulationWeight(params.temporalFrameIndex, steadyWeight);
+  // Depth is a disocclusion gate, not a continuous history fade. A sloped
+  // static surface changes sampled depth under jitter without changing its
+  // identity; attenuating accepted history makes those edges oscillate.
+  let historyWeight = progressiveWeight * reactiveFactor * velocityFactor;
+  let resolved = select(blendTaaHistory(current.rgb, clippedHistoryRgb, historyWeight), current.rgb, rejected);
   return TaaResolveOutput(
-    vec4<f32>(resolved, current.a),
+    vec4<f32>(roundTaaHistory(resolved, taaRoundingNoise(vec2<u32>(in.position.xy), params.temporalFrameIndex)), current.a),
     temporal,
+    clipping.state,
   );
 }
 

package/src/tbn.wgsl

@@ -10,7 +10,7 @@
 //
 // RG-only tangent normal decode mirrors pbr.wgsl pre-split semantics
 // (charter P5 byte-equivalent extraction). The default 1x1 normal fallback
-// texture RG=(128,128) decodes to tangent (0,0,1) -- zero perturbation when
+// half-float texture RG=(0.5,0.5) decodes exactly to tangent (0,0,1) when
 // normalTexture is absent (host-side defaultNormalTextureView). RG encoding
 // also matches BC5 / RG normal maps and tolerates RGB normal maps (b is
 // dropped, z is recomputed -- equivalent for unit vectors).

package/src/tonemap.wgsl

@@ -7,9 +7,8 @@
 // `reinhard-extended` remains Forgeax's existing luminance-domain curve; the
 // distinct `reinhard` mode is Three's per-channel Reinhard curve.
 
-#import forgeax_view::common::FullscreenOutput
-#import forgeax_view::common::fullscreen_triangle
-#import forgeax_view::common::{linearToSrgbOetf, ditherUnorm8}
+#import forgeax_view::common::{FullscreenOutput, ditherUnorm8, fullscreen_triangle}
+#import forgeax_view::output_encoding::{encodeOutput}
 
 const TONEMAP_LUMINANCE_EPSILON : f32 = 1e-5;
 
@@ -37,7 +36,7 @@ fn tonemapReinhardExtended(color : vec3<f32>) -> vec3<f32> {
   return color * scale;
 }
 
-fn tonemapLinear(color : vec3<f32>) -> vec3<f32> {
+fn toneMapLinearLdr(color : vec3<f32>) -> vec3<f32> {
   return clamp(color, vec3<f32>(0.0), vec3<f32>(1.0));
 }
 
@@ -151,30 +150,50 @@ fn tonemapNeutral(color : vec3<f32>) -> vec3<f32> {
   return mix(compressed, vec3<f32>(new_peak), g);
 }
 
-@fragment
-fn fs_main(in : FullscreenOutput) -> @location(0) vec4<f32> {
-  // Output Transform consumes linear HDR and emits display-encoded color.
-  let source = textureSample(hdr, samp, in.uv);
-  let sample : vec3<f32> = source.rgb;
+fn mapTonemap(sample : vec3<f32>) -> vec3<f32> {
   let exposed : vec3<f32> = sample * params.exposure;
   var mapped : vec3<f32>;
   switch (params.mode) {
     case 1u: { mapped = tonemapReinhardExtended(exposed); }
-    case 2u: { mapped = tonemapLinear(exposed); }
+    case 2u: { mapped = toneMapLinearLdr(exposed); }
     case 3u: { mapped = tonemapCineon(exposed); }
     case 4u: { mapped = tonemapAcesFilmic(exposed); }
     case 5u: { mapped = tonemapAgx(exposed); }
     case 6u: { mapped = tonemapNeutral(exposed); }
     case 7u: { mapped = tonemapReinhard(exposed); }
-    // Mode 0 skips the tone curve but still performs the output conversion.
-    default: { mapped = sample; }
+    // Mode 0 uses the explicit linear HDR to linear LDR identity/clamp.
+    default: { mapped = toneMapLinearLdr(sample); }
   }
-  // Every public mode reaches exactly one shared sRGB OETF.
-  let encoded = linearToSrgbOetf(mapped);
-  let output = select(
-    encoded,
-    ditherUnorm8(encoded, in.position.xy),
+  return mapped;
+}
+
+fn encodeFinal(linearColor : vec3<f32>, alpha : f32, position : vec4<f32>) -> vec4<f32> {
+  let encoded = encodeOutput(linearColor, alpha);
+  let outputRgb = select(
+    encoded.rgb,
+    ditherUnorm8(encoded.rgb, position.xy),
     params.ditherEnabled > 0.5,
   );
-  return vec4<f32>(output, source.a);
+  return vec4<f32>(outputRgb, encoded.a);
+}
+
+@fragment
+fn fs_main(in : FullscreenOutput) -> @location(0) vec4<f32> {
+  // Combined path: tone mapping and the one output encoding happen together.
+  let source = textureSample(hdr, samp, in.uv);
+  return encodeFinal(mapTonemap(source.rgb), source.a, in.position);
+}
+
+@fragment
+fn fs_tone_only(in : FullscreenOutput) -> @location(0) vec4<f32> {
+  // LUT-enabled path stops at linear LDR so the LUT never samples encoded data.
+  let source = textureSample(hdr, samp, in.uv);
+  return vec4<f32>(mapTonemap(source.rgb), source.a);
+}
+
+@fragment
+fn fs_encode_only(in : FullscreenOutput) -> @location(0) vec4<f32> {
+  // The final writer consumes linear LDR after LUT and optional FXAA.
+  let source = textureSample(hdr, samp, in.uv);
+  return encodeFinal(source.rgb, source.a, in.position);
 }

package/src/unlit.wgsl

@@ -67,7 +67,7 @@ struct VsIn {
 #endif
 };
 struct VsOut {
-  @builtin(position) clip : vec4<f32>,
+  @builtin(position) @invariant clip : vec4<f32>,
   @location(0) uv : vec2<f32>,
   @location(1) worldPos : vec3<f32>,
 #ifdef VERTEX_COLOR_AVAILABLE
@@ -124,7 +124,7 @@ fn fs_shadow(in : VsOut) {
 }
 
 struct TemporalVsOut {
-  @builtin(position) clip : vec4<f32>,
+  @builtin(position) @invariant clip : vec4<f32>,
   @location(0) uv : vec2<f32>,
   @location(1) @interpolate(perspective) currentClip : vec4<f32>,
   @location(2) @interpolate(perspective) previousClip : vec4<f32>,
@@ -144,7 +144,7 @@ fn vs_temporal(in : VsIn, @builtin(instance_index) idx : u32) -> TemporalVsOut {
 #endif
   var out : TemporalVsOut;
   out.currentClip = view.temporalCurrentViewProj * currentWorld;
-  out.clip = out.currentClip;
+  out.clip = view.worldViewProj * currentWorld;
   out.previousClip = view.temporalPreviousViewProj * previousWorld;
   out.uv = in.uv;
 #ifdef VERTEX_COLOR_AVAILABLE