@forgeax/engine-render 0.1.32 → 0.1.33

package/src/record/frame.ts

@@ -1,3 +1,5 @@
+import { encodeAnalyticFogParams } from '../environment/analytic-fog';
+import type { FogFrame } from '../extract/environment';
 import { collectGpuDrivenMaterialArtifacts } from '../gpu-driven/material-artifacts';
 import { materialBindingKey, projectMaterialBindingClasses } from '../gpu-driven/material-bindings';
 import { uploadMaterialUniforms } from './material-uniforms';
@@ -5,7 +7,7 @@ import { uploadMaterialUniforms } from './material-uniforms';
 // Extracted from render-system-record.ts (feat-20260704 M3/w17, pure move).
 
 import { HANDLE_NINESLICE_QUAD, resolveAssetHandle } from '@forgeax/engine-assets-runtime';
-import type { World } from '@forgeax/engine-ecs';
+import { Time, type World } from '@forgeax/engine-ecs';
 import type { RenderReadLease } from '@forgeax/engine-ecs/projection';
 import { deriveVertexCount } from '@forgeax/engine-geometry';
 import { frustum, mat4, vec3 } from '@forgeax/engine-math';
@@ -44,6 +46,7 @@ import {
 } from '../features/depth-of-field/depth-of-field-params';
 import type { GpuDrivenProduction, PreparedGpuDrivenFrame } from '../gpu-driven/production-raster';
 import type { ShadowViewIdentity } from '../gpu-driven/shadow-views';
+import type { GpuDrivenLodSubmitIdentity } from '../gpu-driven/view-gpu';
 import { GpuBuffer } from '../gpu-resource';
 import { GPU_TEXTURE_USAGE_COPY_SRC } from '../gpu-texture-usage';
 import {
@@ -304,6 +307,14 @@ export async function observeCurrentFrame(
 }
 
 import { acknowledgeRenderFeatureSubmission } from '../features/host';
+import {
+  effectiveMotionBlurSampleCount,
+  isMotionBlurIntervalValid,
+  MOTION_BLUR_PARAMS_BYTE_SIZE,
+  motionBlurExposureScale,
+  motionBlurSampleDelta,
+  motionBlurTemporalDemand,
+} from '../features/motion-blur/motion-blur-params';
 import { createTemporalView, resolveTemporalReset, type TemporalView } from '../temporal/view';
 import { inspectVolumetricFog } from '../volume/inspection';
 import {
@@ -904,6 +915,7 @@ function volumeTemporalSignature(
     densityGeneration: prepared.densityGeneration,
     width,
     height,
+    ...(fog.worldTimeSeconds === undefined ? {} : { worldTimeSeconds: fog.worldTimeSeconds }),
     ...(fog.lightKind === undefined ? {} : { lightKind: fog.lightKind }),
     ...(fog.lightEntity === undefined ? {} : { lightEntity: fog.lightEntity }),
     ...(fog.pointLightEntity === undefined ? {} : { pointLightEntity: fog.pointLightEntity }),
@@ -1008,7 +1020,7 @@ function prepareVolumetricFogFrame(
     }
     return undefined;
   }
-  const params = new Float32Array(32);
+  const params = new Float32Array(36);
   params.set(fog.fog.bounds.min, 0);
   params.set(fog.fog.bounds.max, 4);
   params.set(fog.fog.extinction, 8);
@@ -1029,10 +1041,8 @@ function prepareVolumetricFogFrame(
   const lightColor = selectedSpot?.color ?? lights.directional?.color ?? vec3.create(0, 0, 0);
   if (lightDirection === undefined || lightColor === undefined) return undefined;
   params.set(lightDirection, 20);
-  // Reuse the vec4 padding lane as the renderer-owned frame phase for
-  // sub-froxel jitter. The temporal resolver consumes it without growing the
-  // public fog component or allocating another uniform buffer.
-  params[23] = frameState.frameNumber % 1024;
+  // Reserved padding: render frame identity must not move volume samples.
+  params[23] = 0;
   const selectedPointIndex =
     selectedPoint === undefined
       ? -1
@@ -1065,6 +1075,10 @@ function prepareVolumetricFogFrame(
     frameState.temporalFrame !== undefined && frameState.temporalFrame.resetReason === 'none'
       ? 1
       : 0;
+  // World elapsed time is the sole authored-medium clock. The adjacent
+  // frame phase above remains the deterministic sub-froxel jitter identity;
+  // it never advances density motion.
+  params[32] = fog.worldTimeSeconds ?? 0;
 
   const paramsBuffer = stageVolumetricFogParams(internals, frameState, params);
   if (paramsBuffer === undefined) return undefined;
@@ -1219,6 +1233,8 @@ function mapSsrHistoryResetReason(
     case 'environment-change':
     case 'fog-change':
       return 'reflection-generation';
+    case 'time-discontinuity':
+      return 'camera-cut';
     case 'device-recover':
       return 'device-recovery';
     case 'submit-failure':
@@ -1227,6 +1243,50 @@ function mapSsrHistoryResetReason(
   }
 }
 
+interface FrameClockSample {
+  readonly deltaSeconds: number;
+  readonly elapsedSeconds: number | undefined;
+  /** Explicit host/replay clock was present but invalid. */
+  readonly invalidSampleTime: boolean;
+}
+
+/** Read the render sample clock from the camera's composition world once per frame. */
+function frameClockSample(
+  world: World,
+  worlds: readonly World[],
+  camera: CameraSnapshot,
+  sampleTimeSeconds?: number,
+): FrameClockSample {
+  const owner = worlds[camera.worldId ?? 0] ?? world;
+  const invalidSampleTime = sampleTimeSeconds !== undefined && !Number.isFinite(sampleTimeSeconds);
+  try {
+    const clock = owner.getResource(Time);
+    return {
+      deltaSeconds: Number.isFinite(clock.delta) ? Math.max(0, clock.delta) : 0,
+      // Keep the raw host sample even when ECS accepted only a clamped
+      // simulation delta. Temporal admission compares this value with the
+      // last successfully submitted sample and therefore sees real hitches.
+      elapsedSeconds:
+        sampleTimeSeconds === undefined
+          ? Number.isFinite(clock.elapsed)
+            ? clock.elapsed
+            : undefined
+          : Number.isFinite(sampleTimeSeconds)
+            ? sampleTimeSeconds
+            : undefined,
+      invalidSampleTime,
+    };
+  } catch {
+    // Test and recovery callers may provide a minimal World-shaped owner. An
+    // absent clock is an invalid temporal pair and therefore safely resets.
+    return {
+      deltaSeconds: 0,
+      elapsedSeconds: Number.isFinite(sampleTimeSeconds) ? sampleTimeSeconds : undefined,
+      invalidSampleTime,
+    };
+  }
+}
+
 function stageSsrHistoryCandidate(
   internals: RenderSystemInternals,
   frameState: RenderFrameState,
@@ -1611,6 +1671,7 @@ export function recordFrame(
     readonly activeEntityKeys?: ReadonlySet<number>;
     readonly activeEntityRevision?: number;
     readonly telemetryCandidateCount?: number;
+    readonly telemetrySubmit?: GpuDrivenLodSubmitIdentity;
     readonly occlusion?: OcclusionFrameProjection;
   },
   renderReadLeases?: readonly RenderReadLease[],
@@ -1631,6 +1692,9 @@ export function recordFrame(
   preparedLighting?: ReturnType<typeof prepareFrameLighting>,
   ssrDependencies?: SsrDependenciesInspection,
   onRenderableDraw?: (entry: ValidatedRenderable) => void,
+  analyticFog?: FogFrame,
+  sampleTimeSeconds?: number,
+  temporalReset = false,
 ): boolean {
   void shadowCasterEntityKeys;
   frameState.reflectionFallbackObservationSource = undefined;
@@ -2046,6 +2110,9 @@ export function recordFrame(
         ...(frameGpuDriven.telemetryCandidateCount === undefined
           ? {}
           : { telemetryCandidateCount: frameGpuDriven.telemetryCandidateCount }),
+        ...(frameGpuDriven.telemetrySubmit === undefined
+          ? {}
+          : { telemetrySubmit: frameGpuDriven.telemetrySubmit }),
         ...(frameGpuDriven.occlusion === undefined ? {} : { occlusion: frameGpuDriven.occlusion }),
         ...(frameGpuDriven.scene?.structureMetrics === undefined
           ? {}
@@ -2190,6 +2257,7 @@ export function recordFrame(
         undefined,
         ssrAdmission,
         renderExtent,
+        analyticFog !== undefined && analyticFog.density > 0 && analyticFog.maxOpacity > 0,
       ),
     );
     if (preflightGraph === null) {
@@ -2268,6 +2336,38 @@ export function recordFrame(
     const targetH = swapTarget.targetH;
 
     const previousTemporalView = frameState.lastSuccessfulTemporalView;
+    const motionBlurDemand =
+      camera.motionBlur === undefined
+        ? false
+        : motionBlurTemporalDemand({
+            shutterAngle: camera.motionBlur.shutterAngle,
+            maxRadiusPixels: camera.motionBlur.maxRadiusPixels,
+            sampleCount: camera.motionBlur.sampleCount,
+            targetFps: camera.motionBlur.targetFps ?? 60,
+          });
+    const temporalDemand = camera.antialias === 'taa' || motionBlurDemand;
+    const clock = frameClockSample(world, worlds, camera, sampleTimeSeconds);
+    const deltaSeconds =
+      temporalReset || clock.invalidSampleTime
+        ? Number.NaN
+        : motionBlurSampleDelta(
+            clock.elapsedSeconds,
+            previousTemporalView?.sampleTimeSeconds,
+            clock.deltaSeconds,
+          );
+    const intervalValid = isMotionBlurIntervalValid(deltaSeconds);
+    // An off MB-only frame still carries an unjittered temporal view so the
+    // accepted sample clock remains observable. Its history flag is false,
+    // however, and must form a new baseline when the effect is enabled again.
+    // A reset frame already has an explicit reason and is the valid baseline
+    // for the following pair, so it is deliberately excluded here.
+    const motionBlurFirstFrame =
+      motionBlurDemand &&
+      camera.antialias !== 'taa' &&
+      (previousTemporalView === undefined ||
+        (previousTemporalView.mode === 'off' &&
+          !previousTemporalView.historyValid &&
+          previousTemporalView.resetReason === undefined));
     const currentUnjitteredViewProjection = mat4.multiply(
       mat4.create(),
       computeProjectionMatrix(camera),
@@ -2294,19 +2394,32 @@ export function recordFrame(
             internalHeight: renderExtent.internalHeight,
           }),
       ...(camera.historyVersion === undefined ? {} : { historyVersion: camera.historyVersion }),
+      ...(clock.elapsedSeconds === undefined ? {} : { sampleTimeSeconds: clock.elapsedSeconds }),
       historyValid: false,
       currentUnjitteredViewProjection,
       currentCameraPosition,
     });
     const resetReason =
-      camera.antialias === 'taa' && environmentReady
-        ? resolveTemporalReset(previousTemporalView, temporalCandidate)
+      temporalDemand && environmentReady
+        ? (resolveTemporalReset(previousTemporalView, temporalCandidate) ??
+          (temporalReset || (motionBlurDemand && !intervalValid)
+            ? 'time-discontinuity'
+            : motionBlurFirstFrame
+              ? 'first-frame'
+              : undefined))
         : undefined;
     const canReusePrevious = previousTemporalView !== undefined && resetReason === undefined;
     const temporalView = createTemporalView({
       ...temporalCandidate.input,
       frameIndex: resetReason === undefined ? temporalCandidate.input.frameIndex : 0,
-      historyValid: camera.antialias === 'taa' && environmentReady && canReusePrevious,
+      // Motion Blur needs a finite positive pair before it can read the
+      // baseline. TAA-only frames retain their existing temporal contract and
+      // do not depend on the simulation clock being present in a test host.
+      historyValid:
+        temporalDemand &&
+        environmentReady &&
+        canReusePrevious &&
+        (!motionBlurDemand || intervalValid),
       resetReason,
       ...(canReusePrevious && previousTemporalView.currentUnjitteredViewProjection !== undefined
         ? {
@@ -2357,17 +2470,26 @@ export function recordFrame(
       );
       activeVolumetricFogContext = resolvedHistory.context;
       activeVolumetricFogSignature = resolvedHistory.signature;
-      const historyFlag = new Float32Array([activeVolumetricFogContext.historyValid ? 1 : 0]);
+      const previousTime = frameState.volumetricFogHistorySignature?.worldTimeSeconds;
+      const currentTime = resolvedHistory.signature.worldTimeSeconds;
+      // Adjacent UBO lanes: validity, World time, elapsed time since accepted history.
+      const historyParams = new Float32Array([
+        activeVolumetricFogContext.historyValid ? 1 : 0,
+        currentTime ?? 0,
+        previousTime === undefined || currentTime === undefined
+          ? 0
+          : Math.max(0, currentTime - previousTime),
+      ]);
       if (frameState.volumetricFogPendingParams !== undefined) {
-        frameState.volumetricFogPendingParams[31] = historyFlag[0] ?? 0;
+        frameState.volumetricFogPendingParams.set(historyParams, 31);
       }
-      const historyFlagWritten = internals.device.queue.writeBuffer(
+      const historyParamsWritten = internals.device.queue.writeBuffer(
         activeVolumetricFogContext.paramsBuffer,
         31 * Float32Array.BYTES_PER_ELEMENT,
-        historyFlag,
+        historyParams,
       );
-      if (!historyFlagWritten.ok) {
-        internals.errorRegistry.fire(historyFlagWritten.error);
+      if (!historyParamsWritten.ok) {
+        internals.errorRegistry.fire(historyParamsWritten.error);
         abortPreparedGpuDriven();
         return false;
       }
@@ -2652,14 +2774,33 @@ export function recordFrame(
     // builtin motion-blur pass receives its all-zero registration default and
     // becomes a no-op even though the temporal scene target is populated.
     const framePostProcessParams = new Map(postProcessParams);
+    if (analyticFog !== undefined)
+      framePostProcessParams.set(
+        'forgeax.analytic-fog',
+        encodeAnalyticFogParams(analyticFog, recordCamera),
+      );
     if (camera.motionBlur !== undefined) {
-      const motionBlurParams = new Uint8Array(16);
-      const motionBlurView = new DataView(motionBlurParams.buffer);
-      motionBlurView.setFloat32(0, camera.motionBlur.shutterAngle, true);
-      motionBlurView.setFloat32(4, camera.motionBlur.maxRadiusPixels, true);
-      motionBlurView.setUint32(8, camera.motionBlur.sampleCount, true);
-      motionBlurView.setUint32(12, temporalView?.historyValid === true ? 0 : 1, true);
-      framePostProcessParams.set('forgeax.motion-blur', motionBlurParams);
+      if (motionBlurDemand) {
+        const motionBlurParams = new Uint8Array(MOTION_BLUR_PARAMS_BYTE_SIZE);
+        const motionBlurView = new DataView(motionBlurParams.buffer);
+        const uniformDeltaSeconds = Number.isFinite(deltaSeconds) ? deltaSeconds : 0;
+        motionBlurView.setFloat32(0, camera.motionBlur.shutterAngle, true);
+        motionBlurView.setFloat32(4, camera.motionBlur.maxRadiusPixels, true);
+        motionBlurView.setUint32(
+          8,
+          effectiveMotionBlurSampleCount(camera.motionBlur.sampleCount),
+          true,
+        );
+        motionBlurView.setUint32(12, temporalView?.historyValid === true ? 0 : 1, true);
+        motionBlurView.setFloat32(16, camera.motionBlur.targetFps ?? 60, true);
+        motionBlurView.setFloat32(
+          20,
+          motionBlurExposureScale(uniformDeltaSeconds, camera.motionBlur.targetFps ?? 60),
+          true,
+        );
+        motionBlurView.setFloat32(24, uniformDeltaSeconds, true);
+        framePostProcessParams.set('forgeax.motion-blur', motionBlurParams);
+      }
     }
     if (camera.depthOfField !== undefined) {
       const dofParams = packDepthOfFieldParams(camera.depthOfField, {

package/src/record/main-pass-geometry.ts

@@ -1481,6 +1481,7 @@ function uploadInstanceRanges(
   ranges: readonly { readonly start: number; readonly end: number }[],
   storageBacked: boolean,
   sourceOffsetInstances = 0,
+  previousInst: NonNullable<RenderableSnapshot['temporal']>['previousInstances'] = undefined,
 ): InstanceUploadResult {
   const strideBytes =
     (storageBacked ? INSTANCE_STORAGE_STRIDE_FLOATS : 16) * Float32Array.BYTES_PER_ELEMENT;
@@ -1494,7 +1495,31 @@ function uploadInstanceRanges(
       (sourceOffsetInstances + start) * 16,
       (sourceOffsetInstances + end) * 16,
     );
-    const payload = storageBacked ? packInstanceStorageBuffer(source) : source;
+    // A generation-bearing previous collection is kept whole so a compacted
+    // or reordered current range can resolve its real prior ordinal. Without
+    // identity proof, keep the old range-local shape and let the packer seed
+    // on count mismatch rather than pairing an unrelated slot.
+    const hasIdentityProof =
+      inst.generations !== undefined && previousInst?.generations !== undefined;
+    const previousSource = hasIdentityProof
+      ? previousInst?.transforms
+      : previousInst?.transforms.subarray(
+          (sourceOffsetInstances + start) * 16,
+          (sourceOffsetInstances + end) * 16,
+        );
+    const currentGenerations = inst.generations?.subarray(
+      sourceOffsetInstances + start,
+      sourceOffsetInstances + end,
+    );
+    const previousGenerations = hasIdentityProof
+      ? previousInst?.generations
+      : previousInst?.generations?.subarray(
+          sourceOffsetInstances + start,
+          sourceOffsetInstances + end,
+        );
+    const payload = storageBacked
+      ? packInstanceStorageBuffer(source, previousSource, currentGenerations, previousGenerations)
+      : source;
     const written = c.runtime.device.queue.writeBuffer(buffer, start * strideBytes, payload);
     if (!written.ok) {
       c.runtime.errorRegistry.fire(written.error);
@@ -1673,6 +1698,7 @@ export function resolveStorageInstanceChunks(
         rangesToUpload,
         true,
         start,
+        entry.source.temporal?.previousInstances,
       );
       for (const range of upload.ranges) {
         uploadedRanges.push({ start: range.start + start, end: range.end + start });
@@ -1858,6 +1884,7 @@ function resolveGeometryInstanceBuffer(
             rangesToUpload,
             false,
             start,
+            entry.source.temporal?.previousInstances,
           );
           for (const range of upload.ranges) {
             uploadedRanges.push({ start: range.start + start, end: range.end + start });
@@ -1997,6 +2024,8 @@ function resolveGeometryInstanceBuffer(
               active.buffer.handle,
               ranges,
               !uniformFallback,
+              0,
+              entry.source.temporal?.previousInstances,
             );
             uploadRanges = upload.ranges;
             uploadedBytes = upload.bytes;

package/src/record/main-pass-sprite-draws.ts

@@ -690,7 +690,12 @@ function recordSpriteEntityDraws(
       {
         const instancePayload = uniformFallback
           ? spriteInst.transforms
-          : packInstanceStorageBuffer(spriteInst.transforms);
+          : packInstanceStorageBuffer(
+              spriteInst.transforms,
+              spriteEntry.source.temporal?.previousInstances?.transforms,
+              spriteInst.generations,
+              spriteEntry.source.temporal?.previousInstances?.generations,
+            );
         const requestedBytes = instancePayload.byteLength;
         const cap = runtime.device.limits.maxStorageBufferBindingSize;
         if (typeof cap === 'number' && requestedBytes > cap) {

package/src/record/mesh-ssbo.ts

@@ -43,23 +43,58 @@ export const MAX_UNIFORM_INSTANCES = 128;
 /** The storage-backed InstanceData layout is current + previous mat4. */
 export const INSTANCE_STORAGE_STRIDE_FLOATS = 32;
 
+function hasStableGenerationColumn(generations: Uint32Array | undefined, count: number): boolean {
+  if (generations === undefined || generations.length !== count) return false;
+  const seen = new Set<number>();
+  for (const generation of generations) {
+    if (generation === 0 || seen.has(generation)) return false;
+    seen.add(generation);
+  }
+  return true;
+}
+
 /**
  * Project the ECS transform snapshot into the storage-backed InstanceData
- * layout. The extract contract carries one current mat4 per instance; until
- * the ECS snapshot owns a previous-instance column, current is the honest
- * previous value as well. Uniform-backed variants keep the compact 16-float
- * payload and do not use this projection.
+ * layout. Unique identity generations select the previous matrix only when
+ * the producer proves that the instance survived. Replaced slots seed
+ * previous=current; reordered slots map back to the real prior ordinal so a
+ * compaction cannot exchange velocities. Uniform-backed variants keep the
+ * compact 16-float payload and do not use this projection.
  */
-export function packInstanceStorageBuffer(transforms: Float32Array): Float32Array {
+export function packInstanceStorageBuffer(
+  transforms: Float32Array,
+  previousTransforms: Float32Array = transforms,
+  generations?: Uint32Array,
+  previousGenerations?: Uint32Array,
+): Float32Array {
   const count = Math.floor(transforms.length / 16);
   const out = new Float32Array(count * INSTANCE_STORAGE_STRIDE_FLOATS);
+  const previousCount = Math.floor(previousTransforms.length / 16);
+  const generationInput = generations !== undefined || previousGenerations !== undefined;
+  const identityProof =
+    hasStableGenerationColumn(generations, count) &&
+    hasStableGenerationColumn(previousGenerations, previousCount);
+  const previousIndexByGeneration = identityProof
+    ? new Map(
+        Array.from(previousGenerations ?? [], (generation, index) => [generation, index] as const),
+      )
+    : undefined;
   for (let i = 0; i < count; i++) {
     const sourceBase = i * 16;
     const targetBase = i * INSTANCE_STORAGE_STRIDE_FLOATS;
+    const previousIndex = identityProof
+      ? previousIndexByGeneration?.get(generations?.[i] ?? 0)
+      : !generationInput && previousCount === count
+        ? i
+        : undefined;
+    const sameIdentity = previousIndex !== undefined && previousIndex < previousCount;
+    const previousBase = (previousIndex ?? i) * 16;
     for (let k = 0; k < 16; k++) {
       const value = transforms[sourceBase + k] ?? 0;
       out[targetBase + k] = value;
-      out[targetBase + 16 + k] = value;
+      out[targetBase + 16 + k] = sameIdentity
+        ? (previousTransforms[previousBase + k] ?? value)
+        : value;
     }
   }
   return out;
@@ -451,6 +486,7 @@ export function uploadMeshSsboBatch(
       _meshSsboScratchFloats[slot + 38] = 1;
       _meshSsboScratchFloats[slot + 43] = 1;
       _meshSsboScratchFloats[slot + 44] = 1;
+      _meshSsboScratchFloats[slot + 45] = 1;
     } else {
       const worldFromLocal = entry.source.transform.world;
       for (let k = 0; k < 16; k++) _meshSsboScratchFloats[slot + k] = worldFromLocal[k] ?? 0;
@@ -483,6 +519,7 @@ export function uploadMeshSsboBatch(
       }
       _meshSsboScratchFloats[slot + 44] =
         entry.source.temporal?.reactive === true || reactiveMaterial ? 1 : 0;
+      _meshSsboScratchFloats[slot + 45] = entry.source.temporal?.motionValid === false ? 0 : 1;
     }
   }
   if (neededBytes > 0) {

package/src/record/render-context.ts

@@ -337,17 +337,15 @@ export interface PerPassResources {
   readonly skyboxBindGroupLayout: BindGroupLayout | null;
   readonly skyboxSampler: Sampler | null;
   readonly skyboxRotationBuffer: Buffer | null;
-  bloomBrightPipeline: RhiRenderPipeline | null;
-  bloomBlurHPipeline: RhiRenderPipeline | null;
-  bloomBlurVPipeline: RhiRenderPipeline | null;
+  bloomDownsamplePipeline: RhiRenderPipeline | null;
+  bloomUpsamplePipeline: RhiRenderPipeline | null;
   bloomCompositePipeline: RhiRenderPipeline | null;
-  bloomBrightBindGroupLayout: BindGroupLayout | null;
-  bloomBlurBindGroupLayout: BindGroupLayout | null;
+  bloomDownsampleBindGroupLayout: BindGroupLayout | null;
+  bloomUpsampleBindGroupLayout: BindGroupLayout | null;
   bloomCompositeBindGroupLayout: BindGroupLayout | null;
   bloomSampler: Sampler | null;
-  bloomBrightParamsBuffer: Buffer | null;
-  bloomBlurHParamsBuffer: Buffer | null;
-  bloomBlurVParamsBuffer: Buffer | null;
+  bloomDownsampleParamsBuffer: Buffer | null;
+  bloomUpsampleParamsBuffer: Buffer | null;
   bloomCompositeParamsBuffer: Buffer | null;
   ensureBloomResources?: () => void;
   getBloomResources?: () => BloomPersistentBundle | null;
@@ -358,18 +356,6 @@ export interface PerPassResources {
   /** Drain candidate, active, and fence-retiring Bloom generations. */
   drainBloomResources?: () => void;
   inspectBloomResources?: (graph?: CompiledRenderGraphInfo) => BloomInspection;
-  bloomBrightTexture: Texture | null;
-  bloomBrightView: TextureView | null;
-  bloomBrightWidth: number;
-  bloomBrightHeight: number;
-  bloomBlurHTexture: Texture | null;
-  bloomBlurHView: TextureView | null;
-  bloomBlurHWidth: number;
-  bloomBlurHHeight: number;
-  bloomBlurVTexture: Texture | null;
-  bloomBlurVView: TextureView | null;
-  bloomBlurVWidth: number;
-  bloomBlurVHeight: number;
   ssaoCalcPipeline: RhiRenderPipeline | null;
   ssaoBlurPipeline: RhiRenderPipeline | null;
   ssaoBgl: BindGroupLayout | null;
@@ -392,17 +378,15 @@ export interface PerPassResources {
 export interface BloomPersistentBundle {
   readonly scope: DeviceScope;
   readonly generation: number;
-  readonly bloomBrightPipeline: RhiRenderPipeline | null;
-  readonly bloomBlurHPipeline: RhiRenderPipeline | null;
-  readonly bloomBlurVPipeline: RhiRenderPipeline | null;
+  readonly bloomDownsamplePipeline: RhiRenderPipeline | null;
+  readonly bloomUpsamplePipeline: RhiRenderPipeline | null;
   readonly bloomCompositePipeline: RhiRenderPipeline | null;
-  readonly bloomBrightBindGroupLayout: BindGroupLayout | null;
-  readonly bloomBlurBindGroupLayout: BindGroupLayout | null;
+  readonly bloomDownsampleBindGroupLayout: BindGroupLayout | null;
+  readonly bloomUpsampleBindGroupLayout: BindGroupLayout | null;
   readonly bloomCompositeBindGroupLayout: BindGroupLayout | null;
   readonly bloomSampler: Sampler | null;
-  readonly bloomBrightParamsBuffer: Buffer | null;
-  readonly bloomBlurHParamsBuffer: Buffer | null;
-  readonly bloomBlurVParamsBuffer: Buffer | null;
+  readonly bloomDownsampleParamsBuffer: Buffer | null;
+  readonly bloomUpsampleParamsBuffer: Buffer | null;
   readonly bloomCompositeParamsBuffer: Buffer | null;
 }
 

package/src/record/shadow-pass.ts

@@ -1503,7 +1503,12 @@ export function recordShadowCasterDraws(
           : GPU_BUFFER_USAGE_STORAGE | GPU_BUFFER_USAGE_COPY_DST;
         const instancePayload = uniformFallback
           ? shadowInst.transforms
-          : packInstanceStorageBuffer(shadowInst.transforms);
+          : packInstanceStorageBuffer(
+              shadowInst.transforms,
+              entry.source.temporal?.previousInstances?.transforms,
+              shadowInst.generations,
+              entry.source.temporal?.previousInstances?.generations,
+            );
         const requestedBytes = instancePayload.byteLength;
         const cap = runtime.device.limits.maxStorageBufferBindingSize;
         if (!uniformFallback && typeof cap === 'number' && cap > 0 && requestedBytes > cap) {