@forgeax/engine-render 0.1.19 → 0.1.20

package/src/render-system-extract.ts

@@ -142,6 +142,7 @@ import type {
   ParamSchemaEntry,
   PrimitiveTopology,
   SkeletonAsset,
+  TextureAsset,
 } from '@forgeax/engine-types';
 import {
   ASSET_ERROR_HINTS,
@@ -209,6 +210,15 @@ export { extractCameraSnapshots } from './extract/camera';
 
 import type { SkinPaletteAllocator } from './systems/skin-palette-allocator';
 import type { SkinPaletteSlice } from './systems/skin-palette-types';
+import { resolveSelectedVolumetricLight } from './volume/capability';
+import {
+  type ValidatedVolumetricFog,
+  type VolumeDensityBinding,
+  VolumetricFog,
+  type VolumetricFogAuthoring,
+} from './volume/component';
+import { extractVolumetricFog } from './volume/extract';
+import type { VolumeProjectorTuple } from './volume/temporal';
 
 /**
  * DirectionalLightSnapshot — sun-like infinite light variant of the
@@ -221,6 +231,7 @@ import type { SkinPaletteSlice } from './systems/skin-palette-types';
  */
 export interface DirectionalLightSnapshot {
   readonly kind: 'directional';
+  readonly entity?: EntityHandle;
   readonly direction: Vec3;
   readonly color: Vec3;
   readonly intensity: number;
@@ -234,6 +245,7 @@ export interface DirectionalLightSnapshot {
  */
 export interface PointLightSnapshot {
   readonly kind: 'point';
+  readonly entity?: EntityHandle | number;
   readonly position: Vec3;
   readonly color: Vec3;
   readonly intensity: number;
@@ -317,10 +329,15 @@ export interface PointShadowSnapshot {
  * is false, dir degenerates, or the light is clipped). shadowAtlasTile
  * (i32 sentinel -1) is the allocated tile index 0..3 or -1 for unassigned
  * (plan-strategy D-4). mapSize / nearPlane / farPlane are the source
- * component shadow parameters carried through to the record stage.
+ * component shadow parameters carried through to the record stage. The
+ * author-facing `shadowIntensity` remains in [0,1] and is copied unchanged;
+ * shader consumers apply it only to shadow visibility, never to candela
+ * radiance.
  */
 export interface SpotLightSnapshot {
   readonly kind: 'spot';
+  /** Entity identity is branded in extracted frames; numeric fixtures remain compatible. */
+  readonly entity?: EntityHandle | number;
   readonly position: Vec3;
   readonly direction: Vec3;
   readonly color: Vec3;
@@ -335,6 +352,17 @@ export interface SpotLightSnapshot {
   readonly nearPlane: number;
   readonly farPlane: number;
   readonly shadowAtlasTile: number;
+  /** Fraction of sampled shadow visibility to retain; 1 = fully opaque shadow. */
+  readonly shadowIntensity?: number;
+  readonly depthBias?: number;
+  readonly normalBias?: number;
+  readonly pcfKernelSize?: number;
+  /** Authoritative TextureAsset projector resolved from the SpotLight handle. */
+  readonly projectorHandle?: Handle<'TextureAsset', 'shared'>;
+  readonly projectorAsset?: TextureAsset;
+  readonly projectorGuid?: string;
+  readonly projectorGeneration?: number;
+  readonly projectorRevision?: number;
 }
 
 /**
@@ -505,6 +533,37 @@ export interface SkyboxSnapshot {
   readonly entityHandle: number;
 }
 
+/**
+ * Resource-owner projection for the single ECS VolumetricFog singleton.
+ *
+ * The renderer carries the validated authoring facts and the source POD all
+ * the way to the record stage.  No profile flag or source/catalog byte is
+ * allowed to enable the graph: `status: 'available'` is produced only after
+ * the ECS component, its shared TextureAsset, and the volume validator all
+ * agree on one linear 3D density owner.
+ */
+export interface ExtractedVolumetricFog {
+  readonly status: 'off' | 'available' | 'degraded';
+  readonly fog?: ValidatedVolumetricFog;
+  readonly densityHandle?: Handle<'TextureAsset', 'shared'>;
+  readonly densityAsset?: TextureAsset;
+  readonly guid?: string;
+  readonly generation?: number;
+  readonly digest?: string;
+  readonly worldId?: number;
+  /** Required same-World light selected by the authoring component. */
+  readonly lightEntity?: EntityHandle;
+  readonly lightKind?: 'directional' | 'point' | 'spot';
+  /** Optional Point+Spot pair identities consumed by the volume integrator. */
+  readonly pointLightEntity?: EntityHandle;
+  readonly spotLightEntity?: EntityHandle;
+  /** Accepted projector tuple shared by surface and volume when authored. */
+  readonly projector?: VolumeProjectorTuple;
+  /** The resolved projector payload shared with the surface light snapshot. */
+  readonly projectorHandle?: Handle<'TextureAsset', 'shared'>;
+  readonly projectorAsset?: TextureAsset;
+}
+
 export interface RenderableSnapshot {
   readonly assetHandle: number;
   readonly transform: TransformSnapshot;
@@ -1006,6 +1065,8 @@ export interface ExtractedFrame {
   readonly environment: EnvironmentFrame | undefined;
   /** False when the resource-owner world failed environment/fog selection. */
   readonly environmentReady: boolean;
+  /** One resource-owner volume projection; absent means no authored fog. */
+  readonly volumetricFog?: ExtractedVolumetricFog;
   readonly renderables: RenderableSnapshot[];
   /**
    * Single dispatch list sorted by queue value (ascending, stable sort).
@@ -2308,6 +2369,178 @@ function selectFogFrame(world: World): FogFrame | undefined {
   throw fogSelection.error;
 }
 
+function textureDigest(texture: TextureAsset): string {
+  // The render inspection needs a stable identity token, not a second byte
+  // store.  FNV-1a is deterministic, synchronous, and deliberately labelled
+  // as a non-cryptographic digest so it cannot be mistaken for Catalog proof.
+  let hash = 2166136261;
+  for (const byte of texture.data) hash = Math.imul(hash ^ byte, 16777619) >>> 0;
+  return `fnv1a:${hash.toString(16).padStart(8, '0')}`;
+}
+
+function extractVolumeSnapshot(
+  world: World,
+  assets: AssetRegistry | null | undefined,
+  worldInternal: WorldInternalView,
+): ExtractedVolumetricFog | undefined {
+  const query = world.query({ read: [VolumetricFog] }).unwrap();
+  const authorings: VolumetricFogAuthoring[] = [];
+  let selectedLight:
+    | {
+        readonly entity: EntityHandle;
+        readonly kind: 'directional' | 'point' | 'spot';
+        readonly pointLightEntity?: EntityHandle;
+        readonly spotLightEntity?: EntityHandle;
+      }
+    | undefined;
+  let first:
+    | {
+        readonly densityHandle: Handle<'TextureAsset', 'shared'>;
+        readonly densityAsset: TextureAsset;
+        readonly guid: string;
+      }
+    | undefined;
+
+  for (const row of query) {
+    const source = row.get(VolumetricFog);
+    if (source.light === null) continue;
+    const selected = resolveSelectedVolumetricLight(world, source.light);
+    if (selected.status === 'available') {
+      const pairSpot = source.spotLight === null ? undefined : source.spotLight;
+      selectedLight ??= {
+        entity: selected.entity,
+        kind: selected.kind,
+        ...(selected.kind === 'point' ? { pointLightEntity: selected.entity } : {}),
+        ...(pairSpot === undefined ? {} : { spotLightEntity: pairSpot }),
+      };
+    }
+    const densityHandle = toShared<'TextureAsset'>(Math.round(Number(source.density)));
+    const resolved = resolveAssetHandle<TextureAsset>(world, densityHandle);
+    if (!resolved.ok || resolved.value.kind !== 'texture') {
+      worldInternal._routeError(
+        resolved.ok
+          ? new RhiError({
+              code: 'asset-not-registered',
+              expected: 'VolumetricFog.density resolves to a TextureAsset',
+              hint: 'load a TextureAsset before assigning it to VolumetricFog.density',
+              detail: { assetHandle: Number(densityHandle) },
+            })
+          : resolved.error,
+        { severity: Severity.Error, systemName: 'RenderSystem.extract (volumetric-density)' },
+      );
+      return { status: 'degraded' };
+    }
+    const densityAsset = resolved.value;
+    const guid = assets?.guidOf(densityAsset) ?? `handle:${Number(densityHandle)}`;
+    const shape = densityAsset.shape;
+    const density: VolumeDensityBinding =
+      shape.viewDimension === '3d'
+        ? {
+            guid,
+            generation: 1,
+            shape: {
+              viewDimension: '3d',
+              extent: {
+                width: shape.extent.width,
+                height: shape.extent.height,
+                depth: shape.extent.depth,
+              },
+            },
+            format: densityAsset.format,
+            colorSpace: densityAsset.colorSpace,
+          }
+        : {
+            guid,
+            generation: 1,
+            shape: {
+              viewDimension: shape.viewDimension,
+              extent:
+                shape.viewDimension === '2d-array'
+                  ? {
+                      width: shape.extent.width,
+                      height: shape.extent.height,
+                      layers: shape.extent.layers,
+                    }
+                  : { width: shape.extent.width, height: shape.extent.height },
+            },
+            format: densityAsset.format,
+            colorSpace: densityAsset.colorSpace,
+          };
+    const authoring: VolumetricFogAuthoring = {
+      light: source.light,
+      density,
+      bounds: {
+        min: [source.boundsMin[0] ?? 0, source.boundsMin[1] ?? 0, source.boundsMin[2] ?? 0],
+        max: [source.boundsMax[0] ?? 0, source.boundsMax[1] ?? 0, source.boundsMax[2] ?? 0],
+      },
+      extinction: [source.extinction[0] ?? 0, source.extinction[1] ?? 0, source.extinction[2] ?? 0],
+      albedo: [source.albedo[0] ?? 0, source.albedo[1] ?? 0, source.albedo[2] ?? 0],
+      emission: [source.emission[0] ?? 0, source.emission[1] ?? 0, source.emission[2] ?? 0],
+      anisotropy: source.anisotropy,
+      maxDistance: source.maxDistance,
+    };
+    authorings.push(authoring);
+    first ??= { densityHandle, densityAsset, guid };
+  }
+
+  if (authorings.length === 0) return undefined;
+  const extracted = extractVolumetricFog(authorings);
+  if (!extracted.ok) {
+    worldInternal._routeError(extracted.error, {
+      severity: Severity.Error,
+      systemName: 'RenderSystem.extract (volumetric-fog)',
+    });
+    return {
+      status: 'degraded',
+      ...(first === undefined
+        ? {}
+        : {
+            densityHandle: first.densityHandle,
+            densityAsset: first.densityAsset,
+            guid: first.guid,
+            generation: 1,
+            digest: textureDigest(first.densityAsset),
+            ...(selectedLight === undefined
+              ? {}
+              : {
+                  lightEntity: selectedLight.entity,
+                  lightKind: selectedLight.kind,
+                  ...(selectedLight.pointLightEntity === undefined
+                    ? {}
+                    : { pointLightEntity: selectedLight.pointLightEntity }),
+                  ...(selectedLight.spotLightEntity === undefined
+                    ? {}
+                    : { spotLightEntity: selectedLight.spotLightEntity }),
+                }),
+          }),
+    };
+  }
+  if (extracted.value.status === 'off' || first === undefined) return { status: 'off' };
+  const selectedLightFields =
+    selectedLight === undefined
+      ? {}
+      : {
+          lightEntity: selectedLight.entity,
+          lightKind: selectedLight.kind,
+          ...(selectedLight.pointLightEntity === undefined
+            ? {}
+            : { pointLightEntity: selectedLight.pointLightEntity }),
+          ...(selectedLight.spotLightEntity === undefined
+            ? {}
+            : { spotLightEntity: selectedLight.spotLightEntity }),
+        };
+  return {
+    status: 'available',
+    fog: extracted.value.fog,
+    densityHandle: first.densityHandle,
+    densityAsset: first.densityAsset,
+    guid: first.guid,
+    generation: 1,
+    digest: textureDigest(first.densityAsset),
+    ...selectedLightFields,
+  };
+}
+
 export function extractFrames(
   worlds: readonly World[],
   owner: number | ExtractFramesOwner,
@@ -2565,6 +2798,7 @@ export function extractFrames(
     directionalCsmConfig,
     directionalCsmDirection,
   };
+  const volumetricFog = resourceOwnerFrame?.volumetricFog;
   const skylight = resourceOwnerFrame?.skylight;
   const skylightCount = resourceOwnerFrame?.skylightCount ?? 0;
   const skybox = resourceOwnerFrame?.skybox;
@@ -2613,6 +2847,9 @@ export function extractFrames(
   return {
     cameras,
     lights,
+    ...(volumetricFog === undefined
+      ? {}
+      : { volumetricFog: { ...volumetricFog, worldId: resourceOwner } }),
     renderables,
     dispatch: dispatchEntries,
     skylight,
@@ -2732,6 +2969,7 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
   // `row.get(X) !== undefined`); K-3 invariant preserved (`_getArrayView`
   // calls survive untouched, only the entity source changes).
   const worldInternal = createWorldInternalView(world);
+  let volumetricFog = extractVolumeSnapshot(world, assets, worldInternal);
 
   const cameras = extractCameraSnapshots(world);
 
@@ -2763,6 +3001,7 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
     const intensity = l.intensity;
     const snapshot: DirectionalLightSnapshot = {
       kind: 'directional',
+      entity: row.entity,
       direction: vec3.create(l.direction[0] ?? 0, l.direction[1] ?? -1, l.direction[2] ?? 0),
       color: vec3.create(
         (l.color[0] ?? 1) * intensity,
@@ -2818,6 +3057,7 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
       worldMat !== undefined ? mat4.getTranslation(vec3.create(), worldMat) : vec3.create(0, 0, 0);
     pointSnapshots.push({
       kind: 'point',
+      entity: entityId,
       position,
       color: vec3.create(
         (p.color[0] ?? 1) * intensity,
@@ -2889,11 +3129,20 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
     const sMapSize = s.mapSize;
     const sNearPlane = s.nearPlane;
     const sFarPlane = s.farPlane;
+    const shadowIntensity = s.shadowIntensity;
+    // `shared<T>` columns are u32-backed and zero-filled when the optional
+    // field is absent. Treat only a positive handle as an authored projector;
+    // checking nullish values alone would turn the zero sentinel into a
+    // phantom projector matrix and an avoidable asset-not-found diagnostic.
+    const hasProjector = Number(s.projector) > 0;
 
     let lightViewProj: Float32Array | undefined;
     let shadowAtlasTile = -1;
 
-    if (castShadow && hasValidDirection) {
+    // A projector needs the same perspective transform even when its SpotLight
+    // has no shadow atlas tile. The matrix remains a derived light fact; the
+    // shadow tile stays -1 so shadow visibility is still independently gated.
+    if ((castShadow || hasProjector) && hasValidDirection) {
       const target = vec3.create(
         (position[0] ?? 0) + (dirN[0] ?? 0),
         (position[1] ?? 0) + (dirN[1] ?? 0),
@@ -2912,14 +3161,40 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
       mat4.multiply(lightViewProj as Mat4, proj, view);
 
       // D-4: allocate tile 0..3; 5th+ = -1 sentinel.
-      if (spotTileNext < 4) {
+      if (castShadow && spotTileNext < 4) {
         shadowAtlasTile = spotTileNext;
         spotTileNext += 1;
       }
     }
 
+    let projectorHandle: Handle<'TextureAsset', 'shared'> | undefined;
+    let projectorAsset: TextureAsset | undefined;
+    let projectorGuid: string | undefined;
+    if (hasProjector) {
+      const candidate = toShared<'TextureAsset'>(Math.round(Number(s.projector)));
+      const resolvedProjector = resolveAssetHandle<TextureAsset>(world, candidate);
+      if (!resolvedProjector.ok || resolvedProjector.value.kind !== 'texture') {
+        worldInternal._routeError(
+          resolvedProjector.ok
+            ? new RhiError({
+                code: 'asset-not-registered',
+                expected: 'SpotLight.projector resolves to a TextureAsset',
+                hint: 'load the authored projector TextureAsset before assigning SpotLight.projector',
+                detail: { assetHandle: Number(candidate) },
+              })
+            : resolvedProjector.error,
+          { severity: Severity.Error, systemName: 'RenderSystem.extract (spot-projector)' },
+        );
+      } else {
+        projectorHandle = candidate;
+        projectorAsset = resolvedProjector.value;
+        projectorGuid = assets?.guidOf(projectorAsset) ?? `handle:${Number(candidate)}`;
+      }
+    }
+
     spotSnapshots.push({
       kind: 'spot',
+      entity: row.entity,
       // D-6: position reflects world transform; direction stays sourced
       // from SpotLight.direction (NOT rotated by the parent).
       position,
@@ -2940,9 +3215,59 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
       nearPlane: sNearPlane,
       farPlane: sFarPlane,
       shadowAtlasTile,
+      shadowIntensity,
+      depthBias: s.depthBias,
+      normalBias: s.normalBias,
+      pcfKernelSize: s.pcfKernelSize,
+      ...(projectorHandle === undefined ||
+      projectorAsset === undefined ||
+      projectorGuid === undefined
+        ? {}
+        : {
+            projectorHandle,
+            projectorAsset,
+            projectorGuid,
+            projectorGeneration: 1,
+            projectorRevision: 1,
+          }),
     });
   }
 
+  // The SpotLight is the sole projector owner. Once all light snapshots have
+  // been extracted, publish its accepted TextureAsset tuple on the volume
+  // snapshot so surface and volume consume the same identity and revision.
+  let volumeSpot: SpotLightSnapshot | undefined;
+  const extractedFog = volumetricFog;
+  if (extractedFog !== undefined) {
+    if (extractedFog.spotLightEntity !== undefined) {
+      volumeSpot = spotSnapshots.find((light) => light.entity === extractedFog.spotLightEntity);
+    } else if (extractedFog.lightKind === 'spot') {
+      volumeSpot = spotSnapshots.find((light) => light.entity === extractedFog.lightEntity);
+    }
+  }
+  if (
+    volumetricFog !== undefined &&
+    volumetricFog.status === 'available' &&
+    volumeSpot?.projectorAsset !== undefined &&
+    volumeSpot.projectorHandle !== undefined
+  ) {
+    const projectorHandle = volumeSpot.projectorHandle;
+    const projectorAsset = volumeSpot.projectorAsset;
+    volumetricFog = {
+      ...volumetricFog,
+      projector: {
+        guid: volumeSpot.projectorGuid ?? `handle:${Number(volumeSpot.projectorHandle)}`,
+        generation: volumeSpot.projectorGeneration ?? 1,
+        view: '2d',
+        sampler: 'linear-clamp-to-edge',
+        projection: 'spot-projection',
+        revision: volumeSpot.projectorRevision ?? 1,
+      },
+      projectorHandle,
+      projectorAsset,
+    };
+  }
+
   // bug-20260710-editor-cross-world-shadow: CSM matrices are computed by the
   // shared pure {@link computeDirectionalCsm}, called here per-world with THIS
   // world's own `cameras[0]`. In a single-world app the light and camera share
@@ -4670,6 +4995,7 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
     lights,
     environment,
     environmentReady: true,
+    ...(volumetricFog === undefined ? {} : { volumetricFog }),
     renderables,
     dispatch,
     skylight,

package/src/render-system.ts

@@ -80,6 +80,7 @@ import {
 import { createPointsLinesLaneAdapter, type PointsLinesBackend } from './points-lines/record';
 import type { PointsLinesRetainedSnapshot } from './points-lines/snapshot';
 import type { PointsLinesRecordOwner, PointsLinesRecordSubmission } from './record/render-context';
+import { inspectVolumetricFog } from './volume/inspection';
 
 export type { RenderSceneInspection } from './inspection-types';
 
@@ -120,11 +121,13 @@ import type {
   RenderFrameState,
 } from './record/frame-snapshot';
 import { getTextureIdentity } from './record/frame-snapshot';
+import type { GpuTimingCapture } from './record/gpu-timing';
 import { applyParamSnapshotToUbo, residentTextureView } from './record/main-pass-material';
 import type { RenderSystemInternals } from './record/render-context';
 import {
   type RenderFeatureGraphCandidate,
   resetRenderFeatureGraphState,
+  settleVolumetricFogGraphCandidate,
 } from './record/typed-frame-graph';
 import {
   type CameraSnapshot,
@@ -145,6 +148,7 @@ import {
   TRANSPARENT_SORT_MODE_LAYER_YZ,
   TRANSPARENT_SORT_MODE_LAYER_Z,
 } from './systems/transparent-sort-config';
+import { createTemporalFrameTransaction, type TemporalFrame } from './temporal/frame';
 import { retireTemporalGpuState } from './temporal/gpu';
 import { inspectTemporal, type TemporalInspection } from './temporal/inspection';
 import {
@@ -325,6 +329,7 @@ export interface RenderSystem {
     worlds: readonly World[],
     opts: DrawOwnerOptions,
     renderReadLeases?: readonly RenderReadLease[],
+    timingCapture?: GpuTimingCapture,
   ): boolean;
   /** Release renderer-owned persistent state for one detached World. */
   detachScene(world: World): void;
@@ -392,6 +397,10 @@ export interface RenderSystem {
     readonly createBindGroup: number;
     readonly keys: readonly string[];
   };
+  /** Latest accepted-submit temporal POD; absent until the first accepted frame. */
+  readonly temporalFrame: TemporalFrame | undefined;
+  /** Current renderer-owned volumetric fog inspection snapshot. */
+  readonly volumetricFog: import('./volume/inspection').VolumetricFogInspection;
   /** Configure the sole Standard graph owner before the first frame. */
   configureStandard(config: RenderPipelineAsset['config']): void;
   /** Register one engine-owned post-process shader used by the Standard lane. */
@@ -949,10 +958,26 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
     graphGeneration: 0,
     successfulTemporalFrameIndex: 0,
     lastSuccessfulBloom: 'off',
+    temporalFrameTransaction: createTemporalFrameTransaction({ deviceEpoch: 0 }),
+    temporalFrameInput: undefined,
     directionalShadowCache: null,
     directionalShadowCacheRecorded: false,
     compiledFrameGraph: null,
     compiledFrameGraphTopologyKey: null,
+    volumetricFogPreviousGraph: null,
+    volumetricFogPreviousGraphKey: null,
+    volumetricFogCandidateGraph: null,
+    volumetricFogParamsBuffers: [null, null],
+    volumetricFogParamsPendingSlot: null,
+    volumetricFogParamsAcceptedSlot: null,
+    volumetricFogAcceptedParams: undefined,
+    volumetricFogPendingParams: undefined,
+    volumetricFogInspection: inspectVolumetricFog({ authored: false, capability: 'available' }),
+    volumetricFogAccepted: undefined,
+    volumetricFogAcceptedContext: undefined,
+    volumetricFogHistoryGraph: null,
+    volumetricFogHistorySlot: null,
+    volumetricFogHistorySignature: null,
     retiredCompiledFrameGraphs: new Set(),
     currentFrameObservationSource: undefined,
     lastSuccessfulCameraAntialias: undefined,
@@ -1657,6 +1682,7 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
       worlds: readonly World[],
       opts: DrawOwnerOptions,
       renderReadLeases?: readonly RenderReadLease[],
+      timingCapture?: GpuTimingCapture,
     ): boolean {
       preparedWorlds = worlds;
       const profileSession = internals.profiler?.activeSession();
@@ -1732,6 +1758,7 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
           lights,
           environment,
           environmentReady,
+          volumetricFog,
           renderables,
           dispatch,
           skylight,
@@ -1961,6 +1988,8 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
             environment?.fogSignature ?? '',
             environmentReady && environment !== undefined,
             persistentRenderScene.transmissionTopologyDemand(),
+            volumetricFog,
+            timingCapture,
           ),
         );
         if (submitted) {
@@ -2061,6 +2090,20 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
       frameState.graphTargetCapture = request;
     },
     bindGroupCounts: bindGroupCounts,
+    get temporalFrame(): TemporalFrame | undefined {
+      const accepted = frameState.temporalFrame;
+      if (accepted === undefined) return undefined;
+      return {
+        ...accepted,
+        currentViewProjection: new Float32Array(accepted.currentViewProjection),
+        previousViewProjection:
+          accepted.previousViewProjection === undefined
+            ? undefined
+            : new Float32Array(accepted.previousViewProjection),
+        jitter: [accepted.jitter[0], accepted.jitter[1]],
+        viewport: { ...accepted.viewport },
+      };
+    },
     frustumStats: lastFrustumStats,
     visibilityStats: lastVisibilityStats,
     get meshMaterialBindings(): readonly MeshMaterialBindingObservation[] {
@@ -2075,6 +2118,9 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
     get perFrameGraphInfo(): CompiledRenderGraphInfo | undefined {
       return frameState.compiledFrameGraph?.inspect();
     },
+    get volumetricFog(): import('./volume/inspection').VolumetricFogInspection {
+      return frameState.volumetricFogInspection;
+    },
     configureStandard(config: RenderPipelineAsset['config']): void {
       const profileConfig = internals.standardProfile;
       const resolvedConfig =
@@ -2214,6 +2260,22 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
         retireTemporalGpuState(retiring);
       }
       frameState.retiringTemporalGpuStates.clear();
+      settleVolumetricFogGraphCandidate(frameState, false);
+      for (const buffer of frameState.volumetricFogParamsBuffers) {
+        if (buffer === null) continue;
+        const destroyed = internals.device.destroyBuffer(buffer);
+        if (!destroyed.ok) internals.errorRegistry.fire(destroyed.error);
+      }
+      frameState.volumetricFogParamsBuffers = [null, null];
+      frameState.volumetricFogParamsPendingSlot = null;
+      frameState.volumetricFogParamsAcceptedSlot = null;
+      frameState.volumetricFogAcceptedParams = undefined;
+      frameState.volumetricFogPendingParams = undefined;
+      frameState.volumetricFogAccepted = undefined;
+      frameState.volumetricFogAcceptedContext = undefined;
+      frameState.volumetricFogHistoryGraph = null;
+      frameState.volumetricFogHistorySlot = null;
+      frameState.volumetricFogHistorySignature = null;
       const compiled = frameState.compiledFrameGraph;
       frameState.compiledFrameGraph = null;
       frameState.compiledFrameGraphTopologyKey = null;
@@ -2269,9 +2331,26 @@ export function createRenderSystem(internals: RenderSystemInternals): RenderSyst
       // must be discarded, not merely marked for destruction: their opaque
       // handles cannot be used on the fresh device and the next draw must
       // lazily build a new graph from the preserved ECS / asset POD caches.
+      settleVolumetricFogGraphCandidate(frameState, false);
       frameState.compiledFrameGraph?.retire().catch(() => undefined);
       frameState.compiledFrameGraph = null;
       frameState.compiledFrameGraphTopologyKey = null;
+      frameState.volumetricFogPreviousGraph = null;
+      frameState.volumetricFogPreviousGraphKey = null;
+      frameState.volumetricFogCandidateGraph = null;
+      frameState.volumetricFogAccepted = undefined;
+      frameState.volumetricFogAcceptedContext = undefined;
+      frameState.volumetricFogHistoryGraph = null;
+      frameState.volumetricFogHistorySlot = null;
+      frameState.volumetricFogHistorySignature = null;
+      // The old device owns these transient params buffers. Discard their
+      // handles without calling destroy() on the lost device; the next frame
+      // must allocate fresh buffers on the replacement device.
+      frameState.volumetricFogParamsBuffers = [null, null];
+      frameState.volumetricFogParamsPendingSlot = null;
+      frameState.volumetricFogParamsAcceptedSlot = null;
+      frameState.volumetricFogAcceptedParams = undefined;
+      frameState.volumetricFogPendingParams = undefined;
       frameState.directionalShadowCache = null;
       frameState.directionalShadowCacheRecorded = false;
       frameState.currentFrameObservationSource = undefined;