@forgeax/engine-render 0.1.31 → 0.1.33

package/src/render-pipeline.ts

@@ -37,6 +37,7 @@ import type {
 } from '@forgeax/engine-rhi';
 import { ok, type Result } from '@forgeax/engine-types';
 import type { Tonemap } from './components/camera';
+import type { DepthOfFieldSide } from './components/depth-of-field';
 import type { DirectionalShadowFilterLabel } from './components/directional-shadow-filter';
 import type { RenderError } from './errors/render';
 import type { RenderFeatureTargetKind } from './features/targets';
@@ -223,6 +224,8 @@ export interface RenderPipelineTopology {
   readonly clearOnly?: boolean | undefined;
   /** Selected atmosphere requires the graph-owned sky producer and background. */
   readonly atmosphere?: boolean | undefined;
+  /** Finite-depth distance / exponential-height fog; no volume history. */
+  readonly analyticFog?: boolean | undefined;
   /** Whether Standard main draws carry the producer-owned fallback MRT. */
   readonly reflectionFallback?: { readonly enabled: boolean } | undefined;
   readonly surface: {
@@ -234,7 +237,19 @@ export interface RenderPipelineTopology {
   };
   /** Renderer-owned immutable dimensions for Standard graph consumers. */
   readonly extent?: RenderExtent;
-  readonly camera: Pick<RenderPipelineContext['camera'], 'tonemap' | 'antialias' | 'bloom'>;
+  readonly camera: Pick<
+    RenderPipelineContext['camera'],
+    'tonemap' | 'antialias' | 'bloom' | 'bloomIntensity'
+  > & {
+    /** Shape-only DoF admission; optical values remain per-frame UBO data. */
+    readonly depthOfField?:
+      | {
+          readonly blurSide: DepthOfFieldSide;
+          readonly useNear: boolean;
+          readonly useFar: boolean;
+        }
+      | undefined;
+  };
   /** Frame-stable Standard output policy; no raw RHI handles enter topology. */
   readonly output?: {
     readonly autoExposure: boolean;
@@ -475,6 +490,12 @@ export interface GpuDrivenStandardPbrFrameResources {
 
 export interface RenderPipelineBuildContext<FrameCtx extends RenderPipelineFrame> {
   readonly graph: RenderGraphBuilder<FrameCtx>;
+  /** Per-frame camera values consumed by optical fullscreen features. */
+  readonly camera?: {
+    readonly depthOfField?:
+      | import('./features/depth-of-field/depth-of-field-params').DepthOfFieldParams
+      | undefined;
+  };
   /** Optional Standard-only output-domain coverage producer input. */
   readonly targetCoverage?: import('./temporal/target-coverage-attachment').TargetCoverageAttachment;
   /** Explicit receipt-bound color domains requested for this frame. */

package/src/render-system-extract-tail.ts

@@ -86,6 +86,7 @@ import {
   gpuDrivenSourceDrawItemIndex,
 } from './extract/gpu-driven';
 import type { VisibilitySnapshot } from './extract/visibility';
+import { MotionBlurValidationError } from './features/motion-blur/motion-blur-params';
 import type {
   RenderFeatureHiddenEntityReport,
   RenderFeatureWorldVisibilitySnapshot,
@@ -120,6 +121,7 @@ import type {
   ExtractPipelineSurface,
   InstancesSnapshot,
   LightProbeSnapshot,
+  MaterialProgramSelection,
   MaterialSnapshot,
   MaterialSnapshotCache,
   MaterialSnapshotCachesByWorld,
@@ -161,7 +163,7 @@ import {
   materialColorParameterSchema,
   materialNormalScale,
   materialParamSchemaForMaterial,
-  materialProgramKeysForMaterial,
+  materialProgramSelectionsForMaterial,
   materialSceneIndexProgramKeysForMaterial,
   materialStandardTextureMask,
   materialTextureFields,
@@ -191,6 +193,25 @@ function skinPaletteIdentity(world: World, entity: number): string {
   return `skin:${world.identity}:${entity}`;
 }
 
+function materialProgramSelectionRequiresSkin(selection: {
+  readonly abi?: {
+    readonly skinPaletteAddress?: unknown;
+    readonly vertexInputs?: readonly { readonly semantic?: unknown }[];
+  };
+}): boolean {
+  if (selection.abi?.skinPaletteAddress !== undefined) return true;
+  const semantics = new Set((selection.abi?.vertexInputs ?? []).map((input) => input.semantic));
+  return semantics.has('skinIndex') && semantics.has('skinWeight');
+}
+
+function isMissingMaterialProgram(error: unknown): boolean {
+  return (
+    error !== null &&
+    typeof error === 'object' &&
+    (error as { readonly code?: unknown }).code === 'material-specialization-not-cooked'
+  );
+}
+
 export function extractFrames(
   worlds: readonly World[],
   owner: number | ExtractFramesOwner,
@@ -330,6 +351,11 @@ export function extractFrames(
 
       framesByWorld.set(wi, frame);
     } catch (err) {
+      // Camera effect parameters are part of the public render contract. Keep
+      // their typed validation error on the renderer path so draw() can return
+      // a RenderError and publish the invalid inspection state; ordinary
+      // per-world extraction failures retain the existing world-local route.
+      if (err instanceof MotionBlurValidationError) throw err;
       // Per-world failure: route to world's own error handler, skip contribution.
       try {
         createWorldInternalView(world)._routeError(err, {
@@ -482,8 +508,8 @@ export function extractFrames(
   // bug-20260710-editor-cross-world-shadow: RECOMPUTE directional CSM matrices
   // against the surfaced camera. In a single-world app the per-world extract
   // already produced correct matrices (light+camera share the world), and this
-  // recompute reproduces them byte-identically (same config, same camera). In
-  // the editor super-composite the directional light's world has NO camera, so
+  // recompute uses the same config and camera. In the editor super-composite
+  // the directional light's world has NO camera, so
   // its per-world `lightViewProj` is undefined/degenerate; the surfaced camera
   // lives in the cameraOwner world. Pairing them here is the ONLY place both
   // are visible. Point/spot shadows are camera-independent (light-space only)
@@ -1226,9 +1252,9 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
   // 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
-  // the world, so this per-world result is final (byte-identical to the prior
-  // inline block). In the editor super-composite the light's world may have no
-  // camera → this yields no matrices; {@link extractFrames} then RECOMPUTES at
+  // the world, so this per-world result is final. In the editor
+  // super-composite the light's world may have no camera → this yields no
+  // matrices; {@link extractFrames} then RECOMPUTES at
   // the merge layer using the surfaced (cameraOwner) camera + the raw config
   // carried on ExtractedLights. The raw config + direction are surfaced
   // unconditionally so the merge layer can re-run the builder.
@@ -1551,6 +1577,8 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
       mieCoefficient: value.mieCoefficient,
       mieDirectionalG: value.mieDirectionalG,
       sunAngularRadius: value.sunAngularRadius,
+      circumsolarStrength: value.circumsolarStrength,
+      circumsolarWidth: value.circumsolarWidth,
     } as const;
     environmentCandidates.push({
       kind: 'atmosphere',
@@ -1861,6 +1889,13 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
       if (!authorVisible && !retainHidden) {
         continue;
       }
+      // A scalar shared<T> field uses slot 0 as the schema-level unbound
+      // sentinel. An entity carrying an unbound MeshFilter is not a
+      // renderable yet; keep it out of frame validation. Non-zero handles
+      // still follow the normal resolve/error path below.
+      if (isRenderable && fAssetHandle === 0) {
+        continue;
+      }
       const layerVal = fLayerValue ?? 0;
       // bug-20260709-builtin-quad-withoutaabb-disables-sprite-frustum-cu M2.5
       // (carries PR #598 feat-20260703 D-7): dispatch entries for this entity
@@ -2030,6 +2065,7 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
           : undefined;
 
       let materialSnap: MaterialSnapshot;
+      let materialProgramSelections: readonly MaterialProgramSelection[] | undefined;
 
       if (cachedMaterial !== undefined) {
         materialSnap = cachedMaterial.snapshot;
@@ -2143,11 +2179,59 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
                     ...context.materialContext,
                     geometry: hasSkin ? ('skinned' as const) : context.materialContext.geometry,
                   };
-            const materialProgramKeys = materialProgramKeysForMaterial(
-              asset,
-              assets,
-              materialContext,
-            );
+            try {
+              materialProgramSelections = materialProgramSelectionsForMaterial(
+                asset,
+                assets,
+                materialContext,
+              );
+            } catch (error) {
+              // A standalone mesh can only satisfy a cooked skinned program
+              // through a Skin-bearing mesh. Probe that same exact owner
+              // selection only when the resolved mesh really lacks the
+              // advertised attributes; otherwise retain the producer's exact
+              // publication error instead of guessing from module names/order.
+              if (isMissingMaterialProgram(error) && materialContext?.geometry === 'mesh') {
+                try {
+                  const skinnedSelections = materialProgramSelectionsForMaterial(asset, assets, {
+                    ...materialContext,
+                    geometry: 'skinned',
+                  });
+                  if (
+                    skinnedSelections?.some(materialProgramSelectionRequiresSkin) === true &&
+                    gpuDrivenMesh !== undefined
+                  ) {
+                    const hasSkinIndex = gpuDrivenMesh.attributes.skinIndex !== undefined;
+                    const hasSkinWeight = gpuDrivenMesh.attributes.skinWeight !== undefined;
+                    if (!hasSkinIndex || !hasSkinWeight) {
+                      const missing =
+                        !hasSkinIndex && !hasSkinWeight
+                          ? 'both'
+                          : !hasSkinIndex
+                            ? 'skinIndex'
+                            : 'skinWeight';
+                      worldInternal._routeError(new MaterialSkinAttrMissingError(entity, missing), {
+                        severity: Severity.Error,
+                        systemName: 'RenderSystem.extract (material-skin-attr-missing)',
+                      });
+                      continue;
+                    }
+                  }
+                } catch {
+                  // Preserve the original exact-context publication error.
+                }
+              }
+              throw error;
+            }
+            const materialProgramKeys =
+              materialProgramSelections === undefined
+                ? undefined
+                : Object.fromEntries(
+                    materialProgramSelections.map(({ pass, specializationKey }) => [
+                      pass,
+                      specializationKey,
+                    ]),
+                  );
             const materialSceneIndexProgramKeys = materialSceneIndexProgramKeysForMaterial(
               asset,
               assets,
@@ -2208,7 +2292,9 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
                 skinSkeletonView !== undefined &&
                 skinSkeletonView !== undefined &&
                 skinSkeletonView !== 0;
-              const isPbrSkinMaterial = isStandardPbrSkinMaterialShader(firstPassShader);
+              const isPbrSkinMaterial =
+                materialProgramSelections?.some(materialProgramSelectionRequiresSkin) === true ||
+                isStandardPbrSkinMaterialShader(firstPassShader);
               if (hasSkinSkel && !isPbrSkinMaterial) {
                 worldInternal._routeError(new SkinMaterialMismatchError(entity, firstPassShader), {
                   severity: Severity.Error,
@@ -2759,7 +2845,10 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
         // reinterpret a skinned vertex stream through an ordinary mesh group.
         if (skinSlice === undefined && hasSkin) {
           releaseSkinIdentity();
-          if (materialSnap.materialShaderId === 'forgeax::pbr-skin') {
+          if (
+            materialSnap.materialShaderId === 'forgeax::pbr-skin' ||
+            materialProgramSelections?.some(materialProgramSelectionRequiresSkin) === true
+          ) {
             pendingDispatch.length = 0;
             continue;
           }
@@ -3017,6 +3106,7 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
           }
           instancesSnap = {
             transforms: collectionResult.value.transforms,
+            generations: collectionResult.value.generations,
             instanceCount: collectionResult.value.count,
             collectionId: collectionResult.value.collectionId,
             revision: collectionResult.value.revision,

package/src/render-system-extract.ts

@@ -27,7 +27,7 @@ import type { MaterialCookProgramContext } from '@forgeax/engine-pack/material-c
 //                                   fire; no renderable; no dispatch.
 //     - case B (material === 0)   : missing-spec sentinel; defaultMaterial
 //                                   Snapshot fills the slot. No fire.
-//     - case C (handle unresolved): assets.get(handle).err with the entity
+//     - case C (non-zero handle unresolved): assets.get(handle).err with the entity
 //                                   carrying the full T+MF+MR renderable
 //                                   archetype -> structured RhiError(
 //                                   `asset-not-registered`) routed through
@@ -61,8 +61,8 @@ import type { MaterialCookProgramContext } from '@forgeax/engine-pack/material-c
 //                               material; hint literal: `'pass
 //                               undefined or omit field to request
 //                               default material'` (AC-10).
-//   - case C dangling-ref     : `assets.get(handle).err` (strict path,
-//                               isRenderable === true) ->
+//   - case C dangling-ref     : `assets.get(handle).err` for a non-zero
+//                               handle (strict path, isRenderable === true) ->
 //                               `RhiError({ code: 'asset-not-
 //                               registered', detail: { assetHandle },
 //                               hint: 'register material via
@@ -73,7 +73,9 @@ import type { MaterialCookProgramContext } from '@forgeax/engine-pack/material-c
 //                               entity skipped from
 //                               RenderableSnapshot[] +
 //                               MaterialDispatchSnapshot[]; mirrors
-//                               `MeshFilter.assetHandle` dangling path
+//                               `MeshFilter.assetHandle` dangling path. A
+//                               scalar shared<T> slot 0 is the unbound,
+//                               non-renderable state and is skipped
 //                               (charter proposition 5; AC-11).
 //
 // Renderer-owned Large Instances:
@@ -96,7 +98,14 @@ import {
   selectMaterialPassProgram,
   walkMaterialPassesOverSharedRefs,
 } from '@forgeax/engine-assets-runtime';
-import type { Component, ComponentSchema, EntityHandle, Query, World } from '@forgeax/engine-ecs';
+import {
+  type Component,
+  type ComponentSchema,
+  type EntityHandle,
+  type Query,
+  Time,
+  type World,
+} from '@forgeax/engine-ecs';
 import { readRenderArrayView, routeWorldError } from '@forgeax/engine-ecs/projection';
 import { type Mat4, mat4, type Vec3, vec3 } from '@forgeax/engine-math';
 import { AssetGuid, type AssetGuid as AssetGuidBytes } from '@forgeax/engine-pack/guid';
@@ -116,6 +125,7 @@ import type {
   MaterialColorParameterSchema,
   MaterialParameter,
   MaterialPass,
+  MaterialProgramAbi,
   MaterialRenderState,
   MaterialTextureCoordinates,
   MaterialTextureValue,
@@ -132,7 +142,6 @@ import {
 import { buildCubeCameraFaceViews } from './capture/cube-views';
 import {
   antialiasFromF32,
-  bloomEnabledFromF32,
   CAMERA_EXPOSURE_MODE_MANUAL,
   Camera,
   CubeCamera,
@@ -147,8 +156,10 @@ import {
   ScreenSpaceReflection,
   tonemapFromF32,
   tonemapToU32,
+  validateCameraBloom,
   validateDynamicResolutionCamera,
 } from './components';
+import { DepthOfField } from './components/depth-of-field';
 import type { DirectionalShadowQuality } from './components/directional-shadow-filter';
 import type { LightValidationError } from './components/light-helpers';
 import { selectEnvironment } from './environment/frame';
@@ -165,6 +176,11 @@ import type {
 } from './extract/environment';
 import type { GpuDrivenDrawSnapshot } from './extract/gpu-driven';
 import { resolveVisibility, type VisibilitySnapshot } from './extract/visibility';
+import {
+  depthOfFieldRequestFailure,
+  resolveDepthOfFieldParams,
+} from './features/depth-of-field/depth-of-field-params';
+import { resolveMotionBlurParams } from './features/motion-blur/motion-blur-params';
 import type {
   RenderFeatureHiddenEntityReport,
   RenderFeatureWorldVisibilitySnapshot,
@@ -659,6 +675,8 @@ export interface ExtractedVolumetricFog {
   readonly generation?: number;
   readonly digest?: string;
   readonly worldId?: number;
+  /** Canonical simulation time projected from this World for authored medium motion. */
+  readonly worldTimeSeconds?: number;
   /** Required same-World light selected by the authoring component. */
   readonly lightEntity?: EntityHandle;
   readonly lightKind?: 'directional' | 'point' | 'spot';
@@ -810,6 +828,9 @@ export type RenderableReactiveReason =
 export interface RenderableTemporalSnapshot {
   readonly previousEpoch: number | undefined;
   readonly previousSource: RenderablePreviousSource;
+  /** True only when current and previous geometry belong to one stable source identity. */
+  readonly motionValid: boolean;
+  /** Color-history invalidation is independent from motion validity. */
   readonly reactive: boolean;
   readonly reactiveReasons: readonly RenderableReactiveReason[];
   readonly previousTransform: TransformSnapshot;
@@ -830,6 +851,8 @@ export interface InstancesSnapshot {
   readonly collectionId?: InstanceCollectionId;
   /** Packed column-major mat4 transforms (16 f32 per instance). */
   readonly transforms: Float32Array;
+  /** Monotonic per-ordinal identity generations, when the collection owns them. */
+  readonly generations?: Uint32Array;
   /** Number of instances (transforms.length / 16). */
   readonly instanceCount: number;
   /** Collection revision captured by this detached frame snapshot. */
@@ -1543,6 +1566,53 @@ export function materialProgramKeysForMaterial(
   return materialProgramKeysForAddress(material, assets, context, 'direct');
 }
 
+/**
+ * Return the exact direct/scene-index programs selected for one renderer
+ * context.  The selection result is kept next to the key projection so
+ * consumers that validate a mesh contract can inspect the producer ABI
+ * without rebuilding pass/context matching from payload order.
+ */
+export interface MaterialProgramSelection {
+  readonly pass: string;
+  readonly context: MaterialCookProgramContext;
+  readonly specializationKey: string;
+  readonly abi?: MaterialProgramAbi;
+}
+
+export function materialProgramSelectionsForMaterial(
+  material: MaterialAsset,
+  assets: AssetRegistry,
+  context: MaterialCookProgramContext | undefined,
+  address: 'direct' | 'scene-index' = 'direct',
+): readonly MaterialProgramSelection[] | undefined {
+  const projection = assets.getMaterialProjectionForPayload(material);
+  if (projection === undefined) return undefined;
+  if (context === undefined)
+    throw new Error('Published material selection requires renderer-owned compiler context');
+  return projection.passes.map((pass) => {
+    const mode = String(
+      (pass.renderState?.tags as Record<string, unknown> | undefined)?.LightMode ?? pass.name,
+    );
+    const passKind = /shadow/i.test(mode)
+      ? ('shadow' as const)
+      : /depth/i.test(mode)
+        ? ('depth' as const)
+        : ('forward' as const);
+    const selectedContext: MaterialCookProgramContext = {
+      ...context,
+      pass: passKind,
+      pipeline: /deferred|gbuffer/i.test(mode) ? 'deferred' : context.pipeline,
+    };
+    const selected = selectMaterialPassProgram(projection, pass.name, selectedContext, address);
+    return {
+      pass: pass.name,
+      context: selectedContext,
+      specializationKey: selected.specializationKey,
+      ...(selected.abi === undefined ? {} : { abi: selected.abi }),
+    };
+  });
+}
+
 /** Resolve the producer's scene-index program key for each cooked Pass. */
 export function materialSceneIndexProgramKeysForMaterial(
   material: MaterialAsset,
@@ -1597,26 +1667,12 @@ function materialProgramKeysForAddress(
   context: MaterialCookProgramContext | undefined,
   address: 'direct' | 'scene-index',
 ): Readonly<Record<string, string>> | undefined {
-  const projection = assets.getMaterialProjectionForPayload(material);
-  if (projection === undefined) return undefined;
-  if (context === undefined)
-    throw new Error('Published material selection requires renderer-owned compiler context');
-  const entries: [string, string][] = [];
-  for (const pass of projection.passes) {
-    const mode = String(
-      (pass.renderState?.tags as Record<string, unknown> | undefined)?.LightMode ?? pass.name,
-    );
-    const selectedContext: MaterialCookProgramContext = {
-      ...context,
-      pass: /shadow/i.test(mode) ? 'shadow' : /depth/i.test(mode) ? 'depth' : 'forward',
-      pipeline: /deferred|gbuffer/i.test(mode) ? 'deferred' : context.pipeline,
-    };
-    entries.push([
-      pass.name,
-      selectMaterialPassProgram(projection, pass.name, selectedContext, address).specializationKey,
-    ]);
-  }
-  return entries.length === 0 ? undefined : Object.fromEntries(entries);
+  const selections = materialProgramSelectionsForMaterial(material, assets, context, address);
+  return selections === undefined
+    ? undefined
+    : Object.fromEntries(
+        selections.map(({ pass, specializationKey }) => [pass, specializationKey]),
+      );
 }
 
 export function runtimeMaterialShaderIdForMaterial(
@@ -2712,9 +2768,10 @@ export interface DirectionalCsmResult {
  * the caller leaves lightViewProj undefined rather than emitting zero matrices
  * that the WGSL reader would sample as NaN → "fully lit").
  *
- * Byte-identical to the prior inline computation for the single-world case
- * (same PSSM lambda, same toward-light Z reach RC-2 fix, same clip-space
- * matrix / tile-placement-in-shader split).
+ * Keeps the prior PSSM lambda, toward-light Z reach RC-2 fix, and clip-space
+ * matrix / tile-placement-in-shader split. The XY fit is additionally snapped
+ * to the cascade's shadow-texel grid so camera motion cannot continuously
+ * shimmer a receiver across raster texel boundaries.
  */
 export function computeDirectionalCsm(
   direction: Vec3,
@@ -2820,6 +2877,29 @@ export function computeDirectionalCsm(
       if ((ls[2] ?? 0) < minZ) minZ = ls[2] ?? 0;
       if ((ls[2] ?? 0) > maxZ) maxZ = ls[2] ?? 0;
     }
+    // Stabilize the orthographic receiver grid against sub-texel camera
+    // motion. The raster pass writes each cascade into a square `mapSize`
+    // viewport, so the light-space texel pitch is the fitted extent divided
+    // by that viewport size. Snap the fitted center to that grid and retain a
+    // half-texel guard on each side; caster and receiver projections then move
+    // together in whole shadow texels without clipping a frustum corner when
+    // the rounded center shifts by half a texel.
+    const texelX = (maxX - minX) / config.mapSize;
+    const texelY = (maxY - minY) / config.mapSize;
+    if (Number.isFinite(texelX) && texelX > 0) {
+      const centerX = (minX + maxX) * 0.5;
+      const snappedCenterX = Math.round(centerX / texelX) * texelX;
+      const halfWidth = (maxX - minX) * 0.5 + texelX * 0.5;
+      minX = snappedCenterX - halfWidth;
+      maxX = snappedCenterX + halfWidth;
+    }
+    if (Number.isFinite(texelY) && texelY > 0) {
+      const centerY = (minY + maxY) * 0.5;
+      const snappedCenterY = Math.round(centerY / texelY) * texelY;
+      const halfHeight = (maxY - minY) * 0.5 + texelY * 0.5;
+      minY = snappedCenterY - halfHeight;
+      maxY = snappedCenterY + halfHeight;
+    }
     // Orthographic projection from light-space AABB. RC-2: whole-frustum
     // toward-light extreme for the near bound; per-cascade far (minZ) + X/Y.
     const nearZ = Math.max(maxZ, lightSpaceMaxZFull);
@@ -2924,15 +3004,29 @@ function collectCameraSnapshots(world: World): CameraSnapshot[] {
   const cameraQuery = world
     .query({
       read: [Camera],
-      optional: [MotionBlur, DynamicResolution, ScreenSpaceReflection],
+      optional: [MotionBlur, DynamicResolution, ScreenSpaceReflection, DepthOfField],
       with: [Transform, GlobalTransform],
     })
     .unwrap();
   for (const row of cameraQuery) {
     const cam = row.get(Camera);
     const motionBlur = row.get(MotionBlur);
+    const motionBlurResult = resolveMotionBlurParams(motionBlur);
+    if (!motionBlurResult.ok) throw motionBlurResult.error;
+    const motionBlurParams = motionBlurResult.value;
+    const depthOfField = row.get(DepthOfField);
     const dynamicResolution = row.get(DynamicResolution);
     const screenSpaceReflection = row.get(ScreenSpaceReflection);
+    const projection = cameraProjectionFromF32(cam.projection);
+    const depthOfFieldResult = resolveDepthOfFieldParams(depthOfField, {
+      projection,
+      fov: cam.fov,
+      near: cam.near,
+      far: cam.far,
+    });
+    const depthOfFieldError = depthOfFieldResult.ok
+      ? undefined
+      : depthOfFieldRequestFailure(depthOfFieldResult.error);
     const entity = row.entity;
     const view = worldInternal._getArrayView(entity, GlobalTransform, 'world');
     if (view === undefined) continue;
@@ -2967,7 +3061,7 @@ function collectCameraSnapshots(world: World): CameraSnapshot[] {
       aspect: cam.aspect,
       near: cam.near,
       far: cam.far,
-      projection: cameraProjectionFromF32(cam.projection),
+      projection,
       orthoLeft: cam.left,
       orthoRight: cam.right,
       orthoBottom: cam.bottom,
@@ -2980,23 +3074,35 @@ function collectCameraSnapshots(world: World): CameraSnapshot[] {
       ...(dynamicResolutionResult.value === undefined
         ? {}
         : { dynamicResolution: dynamicResolutionResult.value }),
-      bloom: bloomEnabledFromF32(cam.bloom),
+      bloom: validateCameraBloom(
+        cam.bloom,
+        cam.bloomThreshold,
+        cam.bloomIntensity,
+        cam.bloomSoftKnee,
+        cam.bloomScatter,
+      ),
       bloomThreshold: cam.bloomThreshold,
       bloomIntensity: cam.bloomIntensity,
-      bloomBlurRadius: cam.bloomBlurRadius,
+      bloomSoftKnee: cam.bloomSoftKnee,
+      bloomScatter: cam.bloomScatter,
       clearColor: [
         cam.clearColor[0] ?? 0,
         cam.clearColor[1] ?? 0,
         cam.clearColor[2] ?? 0,
         cam.clearColor[3] ?? 1,
       ],
-      ...(motionBlur === undefined
+      ...(depthOfFieldResult.ok && depthOfFieldResult.value !== undefined
+        ? { depthOfField: depthOfFieldResult.value }
+        : {}),
+      ...(depthOfFieldError === undefined ? {} : { depthOfFieldError }),
+      ...(motionBlurParams === undefined
         ? {}
         : {
             motionBlur: {
-              shutterAngle: motionBlur.shutterAngle,
-              maxRadiusPixels: motionBlur.maxRadiusPixels,
-              sampleCount: motionBlur.sampleCount,
+              shutterAngle: motionBlurParams.shutterAngle,
+              maxRadiusPixels: motionBlurParams.maxRadiusPixels,
+              sampleCount: motionBlurParams.sampleCount,
+              targetFps: motionBlurParams.targetFps,
             },
           }),
       ...(screenSpaceReflection === undefined
@@ -3254,6 +3360,8 @@ export function extractVolumeSnapshot(
   assets: AssetRegistry | null | undefined,
   worldInternal: WorldInternalView,
 ): ExtractedVolumetricFog | undefined {
+  const elapsed = world.getResource(Time).elapsed;
+  const worldTimeSeconds = Number.isFinite(elapsed) ? Math.max(0, elapsed) : 0;
   const query = world.query({ read: [VolumetricFog] }).unwrap();
   const authorings: VolumetricFogAuthoring[] = [];
   let selectedLight:
@@ -3299,7 +3407,7 @@ export function extractVolumeSnapshot(
           : resolved.error,
         { severity: Severity.Error, systemName: 'RenderSystem.extract (volumetric-density)' },
       );
-      return { status: 'degraded' };
+      return { status: 'degraded', worldTimeSeconds };
     }
     const densityAsset = resolved.value;
     const guid = assets?.guidOf(densityAsset) ?? `handle:${Number(densityHandle)}`;
@@ -3363,6 +3471,7 @@ export function extractVolumeSnapshot(
     });
     return {
       status: 'degraded',
+      worldTimeSeconds,
       ...(first === undefined
         ? {}
         : {
@@ -3402,6 +3511,7 @@ export function extractVolumeSnapshot(
         };
   return {
     status: 'available',
+    worldTimeSeconds,
     fog: extracted.value.fog,
     densityHandle: first.densityHandle,
     densityAsset: first.densityAsset,