@forgeax/engine-shader 0.1.19 → 0.1.21

package/src/common.wgsl

@@ -36,6 +36,36 @@ fn linearToSrgbOetf(color : vec3<f32>) -> vec3<f32> {
   return select(high, low, safe <= vec3<f32>(0.0031308));
 }
 
+// Shared final-surface dither.  The output transform and FXAA are both
+// display-encoded fullscreen writers, so they must use one owner-level
+// algorithm rather than carrying subtly different copies in each pass.
+// The bounded shift is ±0.5/255 per channel, matching Three.js's optional
+// material dithering amplitude while the screen-space hash remains stable for
+// a still frame.  Callers decide whether this writer is the final 8-bit
+// boundary; intermediate float targets must leave it disabled.
+fn hash32(value : u32) -> u32 {
+  var hash = value;
+  hash = (hash ^ 61u) ^ (hash >> 16u);
+  hash = hash + (hash << 3u);
+  hash = hash ^ (hash >> 4u);
+  hash = hash * 668265261u;
+  hash = hash ^ (hash >> 15u);
+  return hash;
+}
+
+fn ditherNoise(pixelPosition : vec2<f32>) -> f32 {
+  let pixel = vec2<u32>(pixelPosition);
+  let seed = (pixel.x * 1973u) ^ (pixel.y * 9277u) ^ 89173u;
+  return f32(hash32(seed) & 1023u) / 1023.0;
+}
+
+fn ditherUnorm8(value : vec3<f32>, pixelPosition : vec2<f32>) -> vec3<f32> {
+  let noise = ditherNoise(pixelPosition);
+  var shift = vec3<f32>(0.25 / 255.0, -0.25 / 255.0, 0.25 / 255.0);
+  shift = mix(2.0 * shift, -2.0 * shift, noise);
+  return clamp(value + shift, vec3<f32>(0.0), vec3<f32>(1.0));
+}
+
 // @forgeax/engine-shader - common.wgsl (M5 T-18 feat-20260512-naga-oil-composition-hmr).
 //
 // Shared view + mesh structs extracted from pbr.wgsl + unlit.wgsl via
@@ -50,7 +80,7 @@ fn linearToSrgbOetf(color : vec3<f32>) -> vec3<f32> {
 // aligned with Bevy's bevy_view::common and matches charter proposition 5
 // (consistent abstraction - one View struct everywhere).
 
-// View UBO byte layout (592 B std140):
+// View UBO byte layout (960 B payload, 1024 B slot):
 //   [  0.. 64) worldViewProj    mat4x4<f32>  (align 16, size 64)
 //   [ 64.. 80) lightDir         vec3<f32>    (align 16, 12+4 pad)
 //   [ 80.. 96) lightColor       vec3<f32>    (align 16, 12+4 pad)
@@ -68,16 +98,14 @@ fn linearToSrgbOetf(color : vec3<f32>) -> vec3<f32> {
 //   [500..504) cascadeBlend     f32           (align 4, size 4)
 //   [504..508) depthBias        f32           (align 4, size 4)
 //   [508..512) normalBias       f32           (align 4, size 4)
-//   [512..516) pcfKernelSize    f32           (align 4, size 4)
-//   [516..528) _align_pad      —             (mat4 array align=16, 12 B)
+//   [512..528) directional shadow carrier f32[4] (profile, radius, penumbra, reserved)
 //   [528..784) spotLightViewProj array<mat4x4<f32>,4>  (align 16, size 256)
 //   WGSL prefix = 784 B. Host UBO = VIEW_UBO_BYTES = 960 B (renderer-factory.ts);
 //   view-ubo.ts writes the full 240 f32 payload. The spot matrix
 //   array fold (feat-20260625 w25) removes the standalone @group(0) binding 9
 //   uniform buffer so the WebGL2 fallback fragment uniform-buffer count returns
 //   to 11 (GLES 3.0 max).
-//   temporal projection facts and Fog payload append after the spot matrix;
-//   total = 960 B.
+//   temporal projection facts append after the spot matrix; total = 960 B.
 //
 // Field order must stay byte-for-byte identical to every prior release
 // (charter P4 consistent abstraction); new fields append at the tail.
@@ -100,14 +128,15 @@ fn linearToSrgbOetf(color : vec3<f32>) -> vec3<f32> {
 // shadow_caster.wgsl indexes the 4 fields via `shadowCasterCascade.index`
 // (binding 5, written per shadow pass).
 //
-// feat-20260621-merge-directionallightshadow-into-directionallight M3 / m3-t3:
-// the merged DirectionalLight's shadow bias + PCF kernel width append at the
-// tail (depthBias / normalBias / pcfKernelSize at bytes 504/508/512, floats
-// 126/127/128). Tail-append only -- field order is byte-for-byte stable
+// feat-20260827-directional-csm-pcss-quality M1:
+// the merged DirectionalLight's shadow bias + accepted filter carrier occupy
+// the existing tail (depthBias / normalBias at bytes 504/508, carrier at
+// bytes 512..528, floats 126/127/128..131). Tail reuse only -- field order is
+// byte-for-byte stable
 // (charter P4); the prior 88 B host tail pad shrinks to 64 B, total stays
 // View slot remains within the existing 1024 B stride. lighting-directional.wgsl drives the
-// directional shadow bias (D-1: bias = max(normalBias*(1-N.L), depthBias)) and
-// a pcfKernelSize-wide PCF loop from these fields.
+// directional shadow bias (D-1: bias = max(normalBias*(1-N.L), depthBias));
+// directional shadow carrier is the receiver-facing profile/radius/penumbra POD.
 //
 // feat-20260625-spot-light-shadow-mapping w25 (scope-amend webkit-fallback):
 // the per-spot perspective `spotLightViewProj` matrices (4 lanes, fragment-read)
@@ -123,24 +152,11 @@ fn linearToSrgbOetf(color : vec3<f32>) -> vec3<f32> {
 // matrix in the same frame (same-frame write contention); the FRAGMENT read
 // channel has no such contention — the host writes all <=4 spot matrices once
 // per frame before the forward pass, so the fold is safe. mat4 array align=16:
-// the array lands at byte 528 (next 16 B-aligned offset after pcfKernelSize at
+// the array lands at byte 528 (next 16 B-aligned offset after the filter carrier at
 // byte 512..516), spanning bytes 528..784. The host allocates VIEW_UBO_BYTES =
 // 960 (renderer-factory.ts) and writes the full 240 f32
 // payload (render-system-record.ts). Lane N = the spot with `shadowAtlasTile
 // === N` (cap = 4); `evalSpotShadowed` reads `view.spotLightViewProj[tile]`.
-struct FogViewParams {
-  color         : vec3<f32>,
-  density       : f32,
-  heightFalloff : f32,
-  maxOpacity    : f32,
-};
-
-struct FogRay {
-  origin    : vec3<f32>,
-  direction : vec3<f32>,
-  distance  : f32,
-};
-
 struct View {
   worldViewProj   : mat4x4<f32>,
   lightDir        : vec3<f32>,
@@ -156,10 +172,10 @@ struct View {
   cascadeBlend    : f32,
   depthBias       : f32,
   normalBias      : f32,
-  pcfKernelSize   : f32,
+  directionalShadowFilter : vec4<f32>,
   // feat-20260625-spot-light-shadow-mapping w25: per-spot perspective
   // light-view-projection matrices, fragment-read. Auto-aligned to byte 528
-  // (mat4 array align=16, after pcfKernelSize at byte 512); spans bytes
+  // (mat4 array align=16, after the four directional carrier lanes at byte 512); spans bytes
   // 528..784. Lane N = spot with shadowAtlasTile === N (cap = 4). Zeroed lanes
   // are safe (sample gated on shadowAtlasTile >= 0 in default-standard-pbr.wgsl).
   spotLightViewProj : array<mat4x4<f32>, 4>,
@@ -167,7 +183,9 @@ struct View {
   temporalPreviousViewProj : mat4x4<f32>,
   // x = near, y = far, z = 1 for orthographic and 0 for perspective.
   temporalProjection : vec4<f32>,
-  fog                 : FogViewParams,
+  // Accepted camera origin at the previous submitted frame. This occupies
+  // the existing tail padding and keeps temporal reprojection on one SSOT.
+  temporalPreviousCameraPos : vec4<f32>,
 };
 
 // Per-instance mesh slot (feat-20260518-pbr-direct-lighting-mvp M2 / w8.5,
@@ -202,7 +220,7 @@ struct Mesh {
 //             color * intensity so the shader avoids the per-fragment mul)
 //     [   7 ] pad f32 = 0
 //
-//   SpotLight (64 B / 16 floats):
+//   SpotLight (80 B / 20 floats):
 //     [ 0..2 ] position vec3<f32>
 //     [   3 ] invRangeSquared f32
 //     [ 4..6 ] colorTimesIntensity vec3<f32>
@@ -211,9 +229,11 @@ struct Mesh {
 //     [ 8..10] direction vec3<f32> (raw outgoing vector; shader reads
 //             via dot(L, -direction) for cone angle test)
 //     [  11 ] cosOuter f32
-//     [12..14] spotPad vec3<f32> = 0 (std430 vec4-alignment padding)
+//     [12] depthBias f32, [13] normalBias f32, [14] pcfKernelSize f32
 //     [  15 ] shadowAtlasTile i32 (sentinel -1 = unassigned/clipped,
 //             0..3 = spot atlas tile index; feat-20260625 M2/M3 D-4)
+//     [  16 ] shadowIntensity f32 (fraction of sampled shadow to apply)
+//     [17..19] alignment tail padding
 //
 // WGSL std430 alignment audit: vec3<f32> alignof=16 / sizeof=12. The
 // f32 lane wedged immediately after each vec3 fills the 4 B remainder
@@ -221,10 +241,10 @@ struct Mesh {
 // prev.size, this.alignof) - for f32 alignof=4 the round-up is a
 // no-op, so position[3] / color[3] / direction[3] sit at byte
 // offsets 12 / 28 / 44 with zero internal padding). PointLight stays
-// 32 B; SpotLight grows to 64 B (feat-20260625 M2/M3 D-4): the trailing
-// `spotPad: vec3<f32>` + `shadowAtlasTile: i32` form one vec4-aligned block
-// at bytes 48..64, with `shadowAtlasTile` at byte 60. These struct sizes
-// match the host packers (packPointLight 32 B / packSpotLight 64 B) exactly.
+// 32 B; SpotLight grows from 64 B (feat-20260625 M2/M3 D-4) for the three
+// receiver controls plus `shadowAtlasTile: i32`, then to 80 B for the
+// parity-only `shadowIntensity` lane at byte 64. These struct sizes match the
+// host packers (packPointLight 32 B / packSpotLight 80 B) exactly.
 //
 // Header `count: u32` lives in a wrapper struct with the trailing
 // runtime-sized array. Array-of-vec4-aligned-struct alignof = 16, so
@@ -255,19 +275,14 @@ struct SpotLight {
   direction           : vec3<f32>,
   cosOuter            : f32,
   // feat-20260625-spot-light-shadow-mapping M3 / w13 (plan-strategy D-4):
-  // The prior 8-lane (48 B) SpotLight had no spare pad lane (unlike PointLight
-  // which repurposed `pointPadW`), so the clip-signal field needs a fresh
-  // vec4-aligned block. `spotPad` fills bytes 48..60 (host packSpotLight slots
-  // 12..14 stay zero); `shadowAtlasTile` (i32 sentinel, -1 = no shadow /
-  // clipped, 0..3 = spot atlas tile) lands at byte 60 (host slot 15, written
-  // through an Int32Array view). The fragment path gates on
-  // `shadowAtlasTile >= 0` (evalSpotShadowed vs evalSpot). Field names are
-  // unique across the composed module surface so naga_oil writeback
-  // substitution does not collide with prior `pad0` members. (naga_oil
-  // reserves the `__` identifier prefix, so the pad lane is `spotPad`, not
-  // `__pad`.)
-  spotPad             : vec3<f32>,
+  // The trailing vec4 transports receiver controls and the tile identity.
+  // Host packSpotLight writes slots 12..14 from the same snapshot; slot 15 is
+  // the i32 shadow tile sentinel and slot 16 carries shadowIntensity.
+  depthBias           : f32,
+  normalBias          : f32,
+  pcfKernelSize       : f32,
   shadowAtlasTile     : i32,
+  shadowIntensity     : f32,
 };
 
 struct PointLightsArray {
@@ -282,32 +297,6 @@ struct SpotLightsArray {
 
 @group(0) @binding(0) var<uniform> view : View;
 
-// Shared screen-space ray reconstruction for scene Fog producers. Keeping the
-// inverse-view and projection branch here prevents each producer from growing
-// a second Fog formula or drifting from the View ABI.
-fn fogWorldPoint(ndc : vec3<f32>) -> vec3<f32> {
-  let homogeneous = view.inverseViewProj * vec4<f32>(ndc, 1.0);
-  let divisor = select(1.0, homogeneous.w, abs(homogeneous.w) > 0.000001);
-  return homogeneous.xyz / divisor;
-}
-
-fn fogRayFromNdc(ndc : vec3<f32>) -> FogRay {
-  let worldPosition = fogWorldPoint(ndc);
-  let nearPosition = fogWorldPoint(vec3<f32>(ndc.xy, 0.0));
-  let farPosition = fogWorldPoint(vec3<f32>(ndc.xy, 1.0));
-  let perspective = view.temporalProjection.z < 0.5;
-  let perspectiveVector = worldPosition - view.cameraPos;
-  let orthographicVector = farPosition - nearPosition;
-  let direction = normalize(select(orthographicVector, perspectiveVector, perspective));
-  let origin = select(nearPosition, view.cameraPos, perspective);
-  let rayDistance = select(
-    max(dot(worldPosition - nearPosition, direction), 0.0),
-    length(perspectiveVector),
-    perspective,
-  );
-  return FogRay(origin, direction, rayDistance);
-}
-
 #if STORAGE_BUFFER_AVAILABLE == true
 @group(0) @binding(1) var<storage, read> pointLightsBuffer : PointLightsArray;
 @group(0) @binding(2) var<storage, read> spotLightsBuffer  : SpotLightsArray;
@@ -421,7 +410,17 @@ struct ShadowCasterCascade {
 // — folded there in feat-20260625 w25 (scope-amend) to keep the WebGL2 fallback
 // fragment uniform-buffer count <= 11; binding 8 is the last view-BG binding.
 @group(0) @binding(8) var spotShadowMap : texture_depth_2d;
-
+// Optional authored SpotLight projector. Surface and volume bind the same
+// accepted TextureAsset view and linear-clamp sampler; an unprojected spot
+// receives the renderer-owned white fallback. The declaration is capability
+// gated because the complete HDRP PBR view/material ABI reaches the WebGPU
+// minimum of 16 sampled textures without this optional cookie. Devices that
+// cannot expose the 17th sampled texture select the matching white-projector
+// shader variant and omit these resources from the view BGL.
+#ifdef PROJECTOR_AVAILABLE
+@group(0) @binding(11) var projectorTexture : texture_2d<f32>;
+@group(0) @binding(12) var projectorSampler : sampler;
+#endif
 #if STORAGE_BUFFER_AVAILABLE == true
 @group(2) @binding(0) var<storage, read> meshes : array<Mesh>;
 #else

package/src/default-standard-pbr-skin.wgsl

@@ -1,19 +1,19 @@
-#import forgeax_view::common::{View, FogViewParams, FogRay, Mesh, InstanceData, view, meshes, instances, PointLight, SpotLight, pointLightsBuffer, spotLightsBuffer, shadowMap, shadowSampler, sampleMaterialTexture}
+#import forgeax_view::common::{View, Mesh, InstanceData, view, meshes, instances, sampleMaterialTexture}
+#import forgeax_scene_temporal::{sceneViewZ}
 #import forgeax_pbr::temporal::{projectPbrSceneTemporal}
 #import forgeax_pbr::brdf::{f_schlick, v_smith, d_ggx}
 #import forgeax_pbr::ibl_sampling::{sampleIblDiffuse, sampleIblSpecular}
 #import forgeax_pbr::tbn::{decodeTangentSpaceNormalRg, scaleTangentSpaceNormal, applyTBN}
 #import forgeax_pbr::lighting_directional::{evalDirectionalNoShadow, evalDirectionalShadowFactor}
-#import forgeax_pbr::lighting_punctual::{evalPoint, evalSpot}
-#import forgeax_view::fog::{apply_fog}
-#ifdef POINT_SHADOW_AVAILABLE
-#import forgeax_pbr::lighting_punctual::{evalPointShadowed}
-#import forgeax_view::common::{shadowParams}
+#ifdef CLUSTER_FORWARD_AVAILABLE
+#import forgeax_standard::cluster::{evaluateStandardClusterLights}
 #endif
 
 #define_import_path forgeax_material::pbr-skin
 #pragma variant_axis STORAGE_BUFFER_AVAILABLE
+#pragma variant_axis CLUSTER_FORWARD_AVAILABLE
 #pragma variant_axis VERTEX_COLOR_AVAILABLE
+#pragma variant_axis DIRECTIONAL_PCSS_AVAILABLE
 
 // @forgeax/engine-shader - default-standard-pbr-skin.wgsl
 // (feat-20260523-skin-skeleton-animation M3 / T-29).
@@ -205,7 +205,6 @@ struct VsOut {
   @location(1) worldNormal : vec3<f32>,
   @location(2) uv : vec2<f32>,
   @location(3) worldTangent : vec4<f32>,
-  @location(4) @interpolate(flat) instanceIdx : u32,
   // feat-city-glb multi-UV tiling: second UV set varying at location 5
   // (parity with default-standard-pbr.wgsl).
   @location(5) uv1 : vec2<f32>,
@@ -218,6 +217,9 @@ struct VsOut {
 #ifdef VERTEX_COLOR_AVAILABLE
   @location(14) color : vec4<f32>,
 #endif
+  // Vertex-produced Standard cluster coordinates. Fragment builtin position
+  // is framebuffer-space and cannot recover the original clip-space NDC.
+  @location(6) ndc : vec3<f32>,
   @location(7) viewZ : f32,
 };
 
@@ -230,22 +232,6 @@ fn pick_channel(rgba : vec4<f32>, channelIndex : u32) -> f32 {
   }
 }
 
-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));
-}
-
 @vertex
 fn vs_main(in : VsIn, @builtin(instance_index) idx : u32) -> VsOut {
   // 4-bone weighted skinning (plan-strategy D-3 / D-3a).
@@ -315,11 +301,14 @@ fn vs_main(in : VsIn, @builtin(instance_index) idx : u32) -> VsOut {
 #ifdef VERTEX_COLOR_AVAILABLE
   out.color = in.color;
 #endif
-  out.instanceIdx = idx;
   // feat-20260613-csm-cascaded-shadow-maps M5 / w19: viewZ replaces the
   // prior light-space-position varying; evalDirectional picks the cascade
   // matrix per fragment from viewZ + worldPos.
-  out.viewZ = -out.clip.w;
+  let clipPos = out.clip;
+  out.ndc = vec3(clipPos.xy / clipPos.w, clipPos.z / clipPos.w);
+  // Keep the cluster depth exactly aligned with the CPU binner for both
+  // perspective and off-axis orthographic projections.
+  out.viewZ = sceneViewZ(out.clip, view.temporalProjection);
   return out;
 }
 
@@ -414,66 +403,18 @@ fn fs_main(in : VsOut) -> @location(0) vec4<f32> {
     );
     color = color + directionalShadow * material.clearcoat * directionalClearcoat;
   }
-  let pointCount = pointLightsBuffer.count;
-  for (var i: u32 = 0u; i < pointCount; i = i + 1u) {
-    let p = pointLightsBuffer.slots[i];
-#ifdef POINT_SHADOW_AVAILABLE
-    if (p.shadowAtlasLayer >= 0) {
-      let lane = shadowParams[p.shadowAtlasLayer];
-      color = color + evalPointShadowed(
-        p.position, p.colorTimesIntensity, p.invRangeSquared,
-        in.worldPos, n, v, albedo, metallic, a, f0,
-        p.shadowAtlasLayer, lane.x, lane.y, 0.005, 0.05,
-      );
-      if (material.clearcoat != 0.0) {
-        color = color + material.clearcoat * evalPointShadowed(
-          p.position, p.colorTimesIntensity, p.invRangeSquared,
-          in.worldPos, n, v, vec3<f32>(0.0), 1.0, coatAlpha, vec3<f32>(0.04),
-          p.shadowAtlasLayer, lane.x, lane.y, 0.005, 0.05,
-        );
-      }
-    } else {
-      color = color + evalPoint(
-        p.position, p.colorTimesIntensity, p.invRangeSquared,
-        in.worldPos, n, v, albedo, metallic, a, f0,
-      );
-      if (material.clearcoat != 0.0) {
-        color = color + material.clearcoat * evalPoint(
-          p.position, p.colorTimesIntensity, p.invRangeSquared,
-          in.worldPos, n, v, vec3<f32>(0.0), 1.0, coatAlpha, vec3<f32>(0.04),
-        );
-      }
-    }
-#else
-    color = color + evalPoint(
-      p.position, p.colorTimesIntensity, p.invRangeSquared,
-      in.worldPos, n, v, albedo, metallic, a, f0,
-    );
-    if (material.clearcoat != 0.0) {
-      color = color + material.clearcoat * evalPoint(
-        p.position, p.colorTimesIntensity, p.invRangeSquared,
-        in.worldPos, n, v, vec3<f32>(0.0), 1.0, coatAlpha, vec3<f32>(0.04),
-      );
-    }
-#endif
-  }
-  let spotCount = spotLightsBuffer.count;
-  for (var i: u32 = 0u; i < spotCount; i = i + 1u) {
-    let s = spotLightsBuffer.slots[i];
-    color = color + evalSpot(
-      s.position, s.direction, s.colorTimesIntensity,
-      s.cosInner, s.cosOuter, s.invRangeSquared,
-      in.worldPos, n, v, albedo, metallic, a, f0,
+#ifdef CLUSTER_FORWARD_AVAILABLE
+  color = color + evaluateStandardClusterLights(
+    in.ndc, in.viewZ, in.worldPos, n, v, albedo, metallic, a, f0, false,
+  );
+  if (material.clearcoat != 0.0) {
+    color = color + material.clearcoat * evaluateStandardClusterLights(
+      in.ndc, in.viewZ, in.worldPos, n, v,
+      vec3<f32>(0.0), 1.0, coatAlpha, vec3<f32>(0.04), false,
     );
-    if (material.clearcoat != 0.0) {
-      color = color + material.clearcoat * evalSpot(
-        s.position, s.direction, s.colorTimesIntensity,
-        s.cosInner, s.cosOuter, s.invRangeSquared,
-        in.worldPos, n, v, vec3<f32>(0.0), 1.0, coatAlpha, vec3<f32>(0.04),
-      );
-    }
   }
-  return applySceneFog(view, color, alpha, in.worldPos);
+#endif
+  return vec4<f32>(color, alpha);
 }
 
 struct TemporalVsOut {
@@ -488,6 +429,7 @@ struct TemporalVsOut {
   @location(7) uv7 : vec2<f32>,
   @location(8) @interpolate(perspective) currentClip : vec4<f32>,
   @location(9) @interpolate(perspective) previousClip : vec4<f32>,
+  @location(10) @interpolate(flat) reactive : f32,
 #ifdef VERTEX_COLOR_AVAILABLE
   @location(14) color : vec4<f32>,
 #endif
@@ -509,6 +451,11 @@ fn vs_temporal(in : VsIn, @builtin(instance_index) idx : u32) -> TemporalVsOut {
   out.currentClip = view.temporalCurrentViewProj * currentWorld;
   out.clip = out.currentClip;
   out.previousClip = view.temporalPreviousViewProj * previousWorld;
+#if STORAGE_BUFFER_AVAILABLE == true
+  out.reactive = meshes[0].temporal.x;
+#else
+  out.reactive = 1.0;
+#endif
   out.uv = in.uv;
   out.uv1 = in.uv1;
   out.uv2 = in.uv2;
@@ -534,11 +481,6 @@ fn temporalVertexAlpha(in : TemporalVsOut) -> f32 {
 
 @fragment
 fn fs_temporal(in : TemporalVsOut) -> @location(0) vec4<f32> {
-#if STORAGE_BUFFER_AVAILABLE == true
-  let reactive = meshes[0].temporal.x;
-#else
-  let reactive = 1.0;
-#endif
   return projectPbrSceneTemporal(
     material.baseColor.a * temporalVertexAlpha(in),
     material.alphaCutoff,
@@ -549,7 +491,7 @@ fn fs_temporal(in : TemporalVsOut) -> @location(0) vec4<f32> {
     in.currentClip,
     in.previousClip,
     view.temporalProjection,
-    reactive,
+    in.reactive,
     in.uv, in.uv1, in.uv2, in.uv3,
     in.uv4, in.uv5, in.uv6, in.uv7,
   );