@forgeax/engine-render 0.1.32 → 0.1.33

package/src/scene/render-scene.ts

@@ -26,6 +26,7 @@ import {
 } from '../components';
 import type { DeviceScope, LifecycleResourceSpec } from '../device/device-scope';
 import { gpuDrivenShadowDrawKey } from '../extract/gpu-driven';
+import { motionBlurTemporalDemand } from '../features/motion-blur/motion-blur-params';
 import {
   BatchTopology,
   type BatchTopologyInspection,
@@ -115,6 +116,41 @@ interface WorldTransformSpan {
 
 type GlobalTransformChangeQuery = Query<readonly [typeof GlobalTransform]>;
 
+function sameInstanceIdentitySet(
+  current: Uint32Array | undefined,
+  previous: Uint32Array | undefined,
+): boolean {
+  // An instanced producer without generation tokens cannot prove that a
+  // compacted/reordered row is the same logical object. Keep that legacy
+  // snapshot conservative: the record stage will seed its previous matrix
+  // instead of borrowing a velocity from an unknown ordinal.
+  if (current === undefined || previous === undefined) return false;
+  const currentSet = new Set(current);
+  const previousSet = new Set(previous);
+  if (
+    currentSet.size !== current.length ||
+    previousSet.size !== previous.length ||
+    current.some((identity) => identity === 0) ||
+    previous.some((identity) => identity === 0)
+  ) {
+    return false;
+  }
+  if (current.length === previous.length) {
+    let sameOrder = true;
+    for (let index = 0; index < current.length; index += 1) {
+      if (current[index] !== previous[index]) {
+        sameOrder = false;
+        break;
+      }
+    }
+    if (sameOrder) return true;
+  }
+  // Reorder and retirement are valid when every current token is unique and
+  // survives. The set is built only on the topology-change path; steady pose
+  // updates stay on the linear same-order check and do not allocate.
+  return current.every((identity) => previousSet.has(identity));
+}
+
 /** The normal extract request used by the persistent scene owner. */
 export type PersistentRenderCandidateRequest =
   | 'full'
@@ -202,6 +238,9 @@ function ownSnapshot(snapshot: RenderableSnapshot): RenderableSnapshot {
           instances: {
             ...snapshot.instances,
             transforms: new Float32Array(snapshot.instances.transforms),
+            ...(snapshot.instances.generations === undefined
+              ? {}
+              : { generations: new Uint32Array(snapshot.instances.generations) }),
           },
         }),
     ...(snapshot.spriteInstances === undefined
@@ -442,6 +481,9 @@ export class RenderScene {
           instances: {
             ...operation.instances,
             transforms: new Float32Array(operation.instances.transforms),
+            ...(operation.instances.generations === undefined
+              ? {}
+              : { generations: new Uint32Array(operation.instances.generations) }),
           },
         };
         pending.instanceChanged = true;
@@ -922,16 +964,36 @@ export class RenderScene {
       reasons.includes('material-revision');
     const previous = seedCurrent || submitted === undefined ? slot.snapshot : submitted.snapshot;
     const previousWorld = this.previousWorldBySlot[slot.slot];
+    const currentInstances = slot.snapshot.instances;
+    const submittedInstances = submitted?.snapshot.instances;
+    const instancesCompatible =
+      currentInstances === undefined && submittedInstances === undefined
+        ? true
+        : currentInstances !== undefined &&
+          submittedInstances !== undefined &&
+          (currentInstances.collectionId === undefined ||
+            submittedInstances.collectionId === undefined ||
+            currentInstances.collectionId === submittedInstances.collectionId) &&
+          currentInstances.transforms.length >= currentInstances.instanceCount * 16 &&
+          submittedInstances.transforms.length >= submittedInstances.instanceCount * 16 &&
+          sameInstanceIdentitySet(currentInstances.generations, submittedInstances.generations);
+    const motionValid = !seedCurrent && previousWorld !== undefined && instancesCompatible;
     return {
       previousEpoch: seedCurrent ? undefined : this.submittedEpoch,
       previousSource: seedCurrent ? 'current-seed' : 'last-submitted',
+      motionValid,
       reactive: reasons.length > 0,
       reactiveReasons: reasons,
       previousTransform:
         seedCurrent || previousWorld === undefined
           ? previous.transform
           : { ...previous.transform, world: previousWorld },
-      previousInstances: previous.instances,
+      // A collection identity/count break is a temporal cut for that
+      // renderable. The record stage receives the current snapshot as its
+      // baseline, while stable collections retain the submitted column and
+      // use identity generations to map reordered entries and seed replaced
+      // entries.
+      previousInstances: seedCurrent ? slot.snapshot.instances : previous.instances,
       previousSkin: previous.skin,
       previousMorphWeights: previous.morph?.weights,
     };
@@ -1273,7 +1335,17 @@ function topologyDeltaForAvailable(
 
 function frameDemandsTemporal(frame: ExtractedFrame): boolean {
   const camera = frame.cameras[0];
-  return camera?.antialias === 'taa' || (camera?.motionBlur?.shutterAngle ?? 0) > 0;
+  const motionBlur = camera?.motionBlur;
+  return (
+    camera?.antialias === 'taa' ||
+    (motionBlur !== undefined &&
+      motionBlurTemporalDemand({
+        shutterAngle: motionBlur.shutterAngle,
+        maxRadiusPixels: motionBlur.maxRadiusPixels,
+        sampleCount: motionBlur.sampleCount,
+        targetFps: motionBlur.targetFps ?? 60,
+      }))
+  );
 }
 
 function cameraFrusta(cameras: readonly CameraSnapshot[]): readonly Float32Array[] {
@@ -2510,13 +2582,17 @@ export class PersistentRenderScene {
     // Previous transforms are consumed only by TAA and motion blur. Ordinary
     // frames must not copy and upload the complete GPU transform table.
     const gpuCommit = this.gpuScene?.commitTemporalFrame(this.temporalCapture !== undefined);
-    if (gpuCommit !== undefined && !gpuCommit.ok) return gpuCommit;
+    if (gpuCommit !== undefined && !gpuCommit.ok) {
+      this.temporalCapture = undefined;
+      return gpuCommit;
+    }
     const temporalCapture = this.temporalCapture;
     if (temporalCapture !== undefined) {
       try {
         temporalCapture.projection.commitSubmission(temporalCapture.capture);
       } catch (cause) {
         void cause;
+        this.temporalCapture = undefined;
         return err(
           new RhiError({
             code: 'internal-error',
@@ -2530,6 +2606,11 @@ export class PersistentRenderScene {
     return ok(undefined);
   }
 
+  /** Drop a staged temporal capture when the owning frame did not submit. */
+  discardTemporalFrame(): void {
+    this.temporalCapture = undefined;
+  }
+
   /** Capture current CPU scene facts; commitTemporalFrame publishes them only after submit. */
   prepareTemporalFrame(
     visible: readonly Pick<RenderableSnapshot, 'worldId' | 'entityKey'>[],
@@ -2912,7 +2993,7 @@ export class PersistentRenderScene {
             recreatedSlots: [],
             resynced: 0,
           })
-        : acquired.scene.sync(delta);
+        : acquired.scene.sync(delta, (slot) => projection.temporalSnapshotBySlot(slot.slot));
     if (!result.ok) {
       this.sceneTableUploadBytes = 0;
       this.failGpu(result.error);

package/src/temporal/__tests__/temporal-frame-transaction.unit.test.ts

@@ -0,0 +1,36 @@
+import { describe, expect, it } from 'vitest';
+import { createTemporalFrameTransaction } from '../frame';
+
+function frame(frameId: number, resetReason?: 'camera-cut') {
+  return {
+    frameId,
+    currentViewProjection: new Float32Array(16),
+    jitter: [0, 0] as [number, number],
+    viewport: { width: 64, height: 64 },
+    cameraPosition: [frameId, 0, 0] as [number, number, number],
+    ...(resetReason === undefined ? {} : { resetReason }),
+  };
+}
+
+describe('renderer temporal candidate lifecycle', () => {
+  it('projects a rejected submit while retaining the accepted baseline', () => {
+    const transaction = createTemporalFrameTransaction({ deviceEpoch: 4 });
+    transaction.stage(frame(1));
+    expect(transaction.commit({ accepted: true }).ok).toBe(true);
+    const baseline = transaction.snapshot();
+
+    transaction.stage(frame(2));
+    expect(transaction.commit({ accepted: false, reason: 'queue-submit-failed' }).ok).toBe(false);
+    expect(transaction.snapshot()).toEqual(baseline);
+    expect(transaction.inspect()).toEqual({
+      accepted: true,
+      staged: false,
+      lastFailure: 'queue-submit-failed',
+    });
+
+    transaction.stage(frame(3));
+    expect(transaction.commit({ accepted: true }).ok).toBe(true);
+    expect(transaction.inspect()).toEqual({ accepted: true, staged: false });
+    expect(transaction.snapshot().frameId).toBe(3);
+  });
+});

package/src/temporal/frame-coordinator.ts

@@ -1,4 +1,5 @@
 import { err, ok, type Result } from '@forgeax/engine-types';
+import { motionBlurTemporalDemand } from '../features/motion-blur/motion-blur-params';
 import type { CameraSnapshot } from '../render-contract';
 import { classifySceneDataCoverage, type SceneDataContributor } from './coverage';
 import { type TaaHistoryAttempt, TaaHistoryStore } from './taa-history-store';
@@ -301,7 +302,13 @@ export class TemporalFrameCoordinator<T = unknown> {
   ): TemporalView | undefined {
     const demanded =
       camera.antialias === 'taa' ||
-      (camera.motionBlur?.shutterAngle !== undefined && camera.motionBlur.shutterAngle > 0);
+      (camera.motionBlur !== undefined &&
+        motionBlurTemporalDemand({
+          shutterAngle: camera.motionBlur.shutterAngle,
+          maxRadiusPixels: camera.motionBlur.maxRadiusPixels,
+          sampleCount: camera.motionBlur.sampleCount,
+          targetFps: camera.motionBlur.targetFps ?? 60,
+        }));
     if (!demanded) return undefined;
     return projectTemporalView({
       camera,

package/src/temporal/frame.ts

@@ -40,10 +40,18 @@ export interface TemporalSubmitResult {
   readonly resetReason?: Exclude<TemporalResetReason, 'none' | 'queue-submit-failed'>;
 }
 
+/** Detached candidate/lifecycle facts consumed by Renderer inspection. */
+export interface TemporalFrameTransactionInspection {
+  readonly accepted: boolean;
+  readonly staged: boolean;
+  readonly lastFailure?: 'queue-submit-failed';
+}
+
 export interface TemporalFrameTransaction {
   stage(input: TemporalFrameInput): void;
   commit(submit: TemporalSubmitResult): Result<TemporalFrame, TemporalFrameSubmitError>;
   snapshot(): TemporalFrame;
+  inspect(): TemporalFrameTransactionInspection;
   /** Drop accepted/staged history after a producer or device generation cut. */
   reset(reason?: Extract<TemporalResetReason, 'signature-change' | 'device-recovery'>): void;
 }
@@ -85,6 +93,7 @@ export function createTemporalFrameTransaction(options: {
   let staged: TemporalFrameInput | undefined;
   let historyEpoch = 0;
   let pendingResetReason: Exclude<TemporalResetReason, 'none' | 'queue-submit-failed'> | undefined;
+  let lastFailure: TemporalFrameTransactionInspection['lastFailure'];
 
   return {
     stage(input) {
@@ -93,9 +102,11 @@ export function createTemporalFrameTransaction(options: {
     commit(submit) {
       if (!submit.accepted) {
         staged = undefined;
+        lastFailure = submit.reason ?? 'queue-submit-failed';
         return err(new TemporalFrameSubmitError(submit.reason ?? 'queue-submit-failed'));
       }
       if (staged === undefined) {
+        lastFailure = 'queue-submit-failed';
         return err(new TemporalFrameSubmitError('queue-submit-failed'));
       }
 
@@ -121,6 +132,7 @@ export function createTemporalFrameTransaction(options: {
       accepted = next;
       staged = undefined;
       pendingResetReason = undefined;
+      lastFailure = undefined;
       return ok(copyFrame(next));
     },
     snapshot() {
@@ -128,6 +140,13 @@ export function createTemporalFrameTransaction(options: {
         throw new Error('TemporalFrame snapshot is unavailable before commit');
       return copyFrame(accepted);
     },
+    inspect() {
+      return {
+        accepted: accepted !== undefined,
+        staged: staged !== undefined,
+        ...(lastFailure === undefined ? {} : { lastFailure }),
+      };
+    },
     reset(reason = 'signature-change') {
       accepted = undefined;
       staged = undefined;
@@ -136,6 +155,7 @@ export function createTemporalFrameTransaction(options: {
       // committed frame prevents stale motion vectors from crossing the
       // producer/device boundary.
       pendingResetReason = reason;
+      lastFailure = undefined;
     },
   };
 }

package/src/temporal/view.ts

@@ -21,6 +21,7 @@ export type TemporalResetReason =
   | 'view-switch'
   | 'environment-change'
   | 'fog-change'
+  | 'time-discontinuity'
   | 'device-recover'
   | 'submit-failure';
 
@@ -43,6 +44,8 @@ export interface TemporalViewInput {
   readonly previousUnjitteredViewProjection?: ArrayLike<number> | undefined;
   readonly currentCameraPosition?: readonly [number, number, number] | undefined;
   readonly previousCameraPosition?: readonly [number, number, number] | undefined;
+  /** Monotonic accepted sample time used to bridge failed render attempts. */
+  readonly sampleTimeSeconds?: number | undefined;
   readonly resetReason?: TemporalResetReason | undefined;
 }
 
@@ -65,6 +68,7 @@ interface TemporalViewSnapshot {
   readonly previousUnjitteredViewProjection: ArrayLike<number> | undefined;
   readonly currentCameraPosition: readonly [number, number, number] | undefined;
   readonly previousCameraPosition: readonly [number, number, number] | undefined;
+  readonly sampleTimeSeconds: number | undefined;
   readonly resetReason: TemporalResetReason | undefined;
 }
 
@@ -83,6 +87,8 @@ export interface TemporalView {
   /** Camera origins follow the same accepted-submit boundary as the matrices. */
   readonly currentCameraPosition: readonly [number, number, number] | undefined;
   readonly previousCameraPosition: readonly [number, number, number] | undefined;
+  /** Monotonic accepted sample time used to bridge failed render attempts. */
+  readonly sampleTimeSeconds: number | undefined;
   readonly currentProjection: 'jittered' | 'unjittered';
   readonly previousProjection: 'unjittered';
   readonly historyRequired: boolean;
@@ -131,6 +137,7 @@ export function createTemporalView(input: TemporalViewInput): TemporalView {
     previousUnjitteredViewProjection: input.previousUnjitteredViewProjection,
     currentCameraPosition: input.currentCameraPosition,
     previousCameraPosition: input.previousCameraPosition,
+    sampleTimeSeconds: input.sampleTimeSeconds,
     resetReason: input.resetReason,
   });
   const taa = input.antialias === 'taa';
@@ -156,6 +163,7 @@ export function createTemporalView(input: TemporalViewInput): TemporalView {
     previousUnjitteredViewProjection: input.previousUnjitteredViewProjection,
     currentCameraPosition: input.currentCameraPosition,
     previousCameraPosition: input.previousCameraPosition,
+    sampleTimeSeconds: input.sampleTimeSeconds,
     currentProjection: taa ? 'jittered' : 'unjittered',
     previousProjection: 'unjittered',
     historyRequired: taa,
@@ -167,8 +175,11 @@ export function resolveTemporalReset(
   previous: TemporalView | undefined,
   next: TemporalView,
 ): TemporalResetReason | undefined {
-  if (next.mode !== 'taa') return undefined;
-  if (previous === undefined || previous.mode !== 'taa') return 'first-frame';
+  // Motion Blur uses the unjittered `off` temporal mode as well as TAA. Keep
+  // the reset matrix shared so a camera switch, resize, or recovery cannot
+  // leak a previous motion vector merely because antialiasing is disabled.
+  if (previous === undefined) return 'first-frame';
+  if (next.mode === 'taa' && previous.mode !== 'taa') return 'first-frame';
   const before = previous.input;
   const after = next.input;
   if (before.width !== after.width || before.height !== after.height) return 'resize';

package/src/typed-render-graph-primitives.ts

@@ -1,10 +1,10 @@
-import type {
-  GraphAccess,
-  GraphResourceResolver,
-  GraphTextureView,
-  RenderGraphBuilder,
+import {
+  type GraphAccess,
+  type GraphResourceResolver,
+  type GraphTextureView,
+  type RenderGraphBuilder,
   RenderGraphError,
-  ResolveContext,
+  type ResolveContext,
 } from '@forgeax/engine-render-graph';
 import {
   type Buffer,
@@ -13,7 +13,7 @@ import {
   type TextureFormat,
   type TextureView,
 } from '@forgeax/engine-rhi';
-import { ok, type PassKind, type PassSelector, type Result } from '@forgeax/engine-types';
+import { err, ok, type PassKind, type PassSelector, type Result } from '@forgeax/engine-types';
 import {
   GPU_TEXTURE_USAGE_COPY_SRC,
   GPU_TEXTURE_USAGE_RENDER_ATTACHMENT,
@@ -28,10 +28,9 @@ import type {
 } from './record/render-context';
 import {
   encodeSkyboxPass,
-  recordBloomBlurHPass,
-  recordBloomBlurVPass,
-  recordBloomBrightPass,
   recordBloomCompositePass,
+  recordBloomDownsamplePass,
+  recordBloomUpsamplePass,
 } from './record/skybox-post-pass';
 import { STANDARD_OUTPUT_TRANSFORM_FEATURE_ID } from './render-contract';
 import {
@@ -502,57 +501,57 @@ export function addReflectionFallbackObservationPass(
 export interface TypedBloomTargets {
   readonly scene: RenderPipelineTarget;
   readonly composited: RenderPipelineTarget;
-  readonly bright: RenderPipelineTarget;
-  readonly blurH: RenderPipelineTarget;
-  readonly blurV: RenderPipelineTarget;
+  readonly downsample: readonly RenderPipelineTarget[];
+  readonly upsample: readonly RenderPipelineTarget[];
+  readonly levelDimensions: readonly { readonly width: number; readonly height: number }[];
 }
 
 /** The semantic Bloom pass owner; graph inspection consumes these same identities. */
 export const TYPED_BLOOM_PASS_NAMES = {
-  bright: 'bloom-bright',
-  blurH: 'bloom-blur-h',
-  blurV: 'bloom-blur-v',
+  downsample: 'bloom-downsample',
+  upsample: 'bloom-upsample',
   composite: 'bloom-composite',
 } as const;
 
+export function typedBloomLevelPassName(kind: 'downsample' | 'upsample', level: number): string {
+  return `${TYPED_BLOOM_PASS_NAMES[kind]}-${level}`;
+}
+
 export function addTypedBloomPasses(
   graph: RenderGraphBuilder<RenderPipelineFrame>,
   targets: TypedBloomTargets,
 ): Result<void, RenderGraphError> {
-  const named = {
+  const named: Record<string, RenderPipelineTarget> = {
     hdrColor: targets.scene,
     hdrComposited: targets.composited,
-    bloomBright: targets.bright,
-    bloomBlurH: targets.blurH,
-    bloomBlurV: targets.blurV,
   };
-  const descriptors = [
-    {
-      name: TYPED_BLOOM_PASS_NAMES.bright,
-      reads: [targets.scene],
-      write: targets.bright,
-      encode: recordBloomBrightPass,
-    },
-    {
-      name: TYPED_BLOOM_PASS_NAMES.blurH,
-      reads: [targets.bright],
-      write: targets.blurH,
-      encode: recordBloomBlurHPass,
-    },
-    {
-      name: TYPED_BLOOM_PASS_NAMES.blurV,
-      reads: [targets.blurH],
-      write: targets.blurV,
-      encode: recordBloomBlurVPass,
-    },
-    {
-      name: TYPED_BLOOM_PASS_NAMES.composite,
-      reads: [targets.scene, targets.blurV],
-      write: targets.composited,
-      encode: recordBloomCompositePass,
-    },
-  ] as const;
-  for (const descriptor of descriptors) {
+  targets.downsample.forEach((target, level) => {
+    named[`bloomDownsample${level}`] = target;
+  });
+  targets.upsample.forEach((target, level) => {
+    named[`bloomUpsample${level}`] = target;
+  });
+
+  const add = (
+    name: string,
+    reads: readonly RenderPipelineTarget[],
+    write: RenderPipelineTarget,
+    encode: (
+      frame: _InternalRenderPipelineContext,
+      resolve: ResolveContext,
+      pass: import('@forgeax/engine-rhi').RhiRenderPassEncoder,
+      level?: number,
+      size?: { readonly width: number; readonly height: number },
+    ) => void,
+    level?: number,
+  ): Result<void, RenderGraphError> => {
+    const descriptor = {
+      name,
+      reads,
+      write,
+      encode,
+      level,
+    };
     const added = graph.addRasterPass(descriptor.name, {
       accesses: [
         ...descriptor.reads.map((target) => ({
@@ -574,11 +573,85 @@ export function addTypedBloomPasses(
           frame as _InternalRenderPipelineContext,
           legacyResolver(resources, named),
           pass,
+          descriptor.level,
+          descriptor.level === undefined ? undefined : targets.levelDimensions[descriptor.level],
         ),
     });
+    return added.ok ? ok(undefined) : added;
+  };
+
+  for (const [level, write] of targets.downsample.entries()) {
+    const source = level === 0 ? targets.scene : targets.downsample[level - 1];
+    if (source === undefined) {
+      return err(
+        new RenderGraphError({
+          code: 'resource-resolution-failed',
+          expected: 'Bloom downsample levels form one adjacent pyramid',
+          hint: 'rebuild the Standard Bloom target declaration from one level list',
+          detail: { resourceLabel: `bloom-level-${level}` },
+        }),
+      );
+    }
+    const added = add(
+      typedBloomLevelPassName('downsample', level),
+      [source],
+      write,
+      (frame, resolve, pass, passLevel) =>
+        recordBloomDownsamplePass(
+          frame,
+          resolve,
+          pass,
+          passLevel ?? level,
+          targets.levelDimensions[passLevel ?? level],
+        ),
+      level,
+    );
     if (!added.ok) return added;
   }
-  return ok(undefined);
+  for (let level = targets.upsample.length - 1; level >= 0; level -= 1) {
+    const current = targets.downsample[level];
+    const coarse =
+      level === targets.downsample.length - 2
+        ? targets.downsample[level + 1]
+        : targets.upsample[level + 1];
+    const write = targets.upsample[level];
+    if (current === undefined || coarse === undefined || write === undefined) {
+      return err(
+        new RenderGraphError({
+          code: 'resource-resolution-failed',
+          expected: 'Bloom downsample and upsample levels form one adjacent pyramid',
+          hint: 'rebuild the Standard Bloom target declaration from one level list',
+          detail: { resourceLabel: `bloom-level-${level}` },
+        }),
+      );
+    }
+    const added = add(
+      typedBloomLevelPassName('upsample', level),
+      [current, coarse],
+      write,
+      (frame, resolve, pass, passLevel) =>
+        recordBloomUpsamplePass(frame, resolve, pass, passLevel ?? level),
+      level,
+    );
+    if (!added.ok) return added;
+  }
+  const finest = targets.upsample[0] ?? targets.downsample[0];
+  if (finest === undefined) {
+    return err(
+      new RenderGraphError({
+        code: 'resource-resolution-failed',
+        expected: 'Bloom has at least one downsample level',
+        hint: 'derive Bloom levels from a positive output extent',
+        detail: { resourceLabel: 'bloom-downsample-0' },
+      }),
+    );
+  }
+  return add(
+    TYPED_BLOOM_PASS_NAMES.composite,
+    [targets.scene, finest],
+    targets.composited,
+    (frame, resolve, pass) => recordBloomCompositePass(frame, resolve, pass),
+  );
 }
 
 export interface TypedSsaoTargets {

package/src/volume/component.ts

@@ -35,7 +35,6 @@ export interface VolumetricFogAuthoring {
   readonly light: EntityHandle;
   /** The optional same-World SpotLight paired with a PointLight. */
   readonly spotLight?: EntityHandle;
-  /** Linear scalar density over bounds; the renderer adds no noise or animation. */
   readonly density: VolumeDensityBinding;
   readonly bounds: VolumeBounds;
   readonly extinction: readonly [number, number, number];

package/src/volume/passes.ts

@@ -32,6 +32,7 @@ import {
   VOLUME_HISTORY_FORMAT,
   VOLUME_PACKING_Z,
   VOLUME_RESOLVED_FORMAT,
+  VOLUMETRIC_FOG_PARAMS_BYTES,
 } from './resources';
 import type { VolumeProjectorTuple } from './temporal';
 
@@ -214,7 +215,10 @@ function importVolumeInputs(
   if (!density.ok) return density;
   const params = graph.importBuffer(
     'volume-params',
-    { size: 128, usage: GPU_BUFFER_USAGE_UNIFORM | GPU_BUFFER_USAGE_COPY_DST },
+    {
+      size: VOLUMETRIC_FOG_PARAMS_BYTES,
+      usage: GPU_BUFFER_USAGE_UNIFORM | GPU_BUFFER_USAGE_COPY_DST,
+    },
     (frame) => {
       const context = frame.volumetricFog as VolumetricFogFrameContext | undefined;
       if (context === undefined) throw pipelineError('parameter residency');
@@ -481,9 +485,9 @@ export function addVolumetricFogPasses(
       const densitySampler = frame.runtime.device.createSampler({
         minFilter: 'linear',
         magFilter: 'linear',
-        addressModeU: 'clamp-to-edge',
-        addressModeV: 'clamp-to-edge',
-        addressModeW: 'clamp-to-edge',
+        addressModeU: 'repeat',
+        addressModeV: 'repeat',
+        addressModeW: 'repeat',
       });
       if (!densitySampler.ok) throw densitySampler.error;
       const bindings = volumeBindGroup(frame, integrate.layout, [

package/src/volume/resources.ts

@@ -15,7 +15,7 @@ export const VOLUME_RESOLVED_FORMAT = 'rgba16float' as const;
 export const VOLUME_DEPTH_FORMAT = 'r32float' as const;
 export const VOLUME_PACKING_Z = 4;
 /** Renderer-owned parameter allocation shared by staging and inspection. */
-export const VOLUMETRIC_FOG_PARAMS_BYTES = 8 * 16;
+export const VOLUMETRIC_FOG_PARAMS_BYTES = 9 * 16;
 
 export interface VolumetricFogExtent {
   readonly width: number;

package/src/volume/temporal.ts

@@ -5,6 +5,8 @@ export interface VolumeTemporalSignature {
   readonly densityGeneration: number;
   readonly width: number;
   readonly height: number;
+  /** World-owned authored-medium time; render frame identity never advances the medium. */
+  readonly worldTimeSeconds?: number;
   readonly lightKind?: 'directional' | 'point' | 'spot';
   readonly lightEntity?: number;
   readonly pointLightEntity?: number;
@@ -28,6 +30,7 @@ export type VolumeTemporalResetReason =
   | 'fog-revision'
   | 'light-revision'
   | 'density-generation'
+  | 'simulation-time'
   | 'resize'
   | 'reprojection-out-of-screen'
   | 'reprojection-depth-discontinuity';
@@ -92,6 +95,14 @@ export function resolveVolumeTemporalReset(
   if (previous.lightShadowRevision !== next.lightShadowRevision) {
     return { reset: true, reason: 'light-revision' };
   }
+  if (previous.worldTimeSeconds !== next.worldTimeSeconds) {
+    const delta = (next.worldTimeSeconds ?? NaN) - (previous.worldTimeSeconds ?? NaN);
+    // Small monotonic ticks animate the same medium. Reset only on a clock
+    // discontinuity; rejecting every tick prevents temporal reuse in live play.
+    if (!Number.isFinite(delta) || delta < 0 || delta > 0.1) {
+      return { reset: true, reason: 'simulation-time' };
+    }
+  }
   if (previous.densityGeneration !== next.densityGeneration) {
     return { reset: true, reason: 'density-generation' };
   }