@forgeax/engine-render 0.1.31 → 0.1.33

package/src/record/typed-frame-graph.ts

@@ -22,12 +22,16 @@ import type {
 import { RhiError } from '@forgeax/engine-rhi';
 import { err, ok, type Result } from '@forgeax/engine-types';
 import { executeRendererFrameTransaction } from '../assembly/renderer-frame-transaction';
+import { standardBloomAdmitted } from '../bloom-admission';
 import { type RenderError, RenderFeatureStageFailedError } from '../errors/render';
+import { depthOfFieldTopology } from '../features/depth-of-field/depth-of-field-feature';
+import { resolveDepthOfFieldFrameParams } from '../features/depth-of-field/depth-of-field-params';
 import {
   getRenderFeaturePlanExecutionProjection,
   hasSubmissionSensitiveFeatures,
   type RenderFeaturePlanExecution,
 } from '../features/host';
+import { motionBlurTemporalDemand } from '../features/motion-blur/motion-blur-params';
 import {
   type RenderFeaturePlannedFrame,
   renderFeaturePlanSignature,
@@ -60,7 +64,11 @@ import {
 } from '../gpu-texture-usage';
 import { GPU_BUFFER_USAGE_COPY_DST, GPU_BUFFER_USAGE_UNIFORM } from '../gpu-usage';
 import { createStandardSurfaceLightingBindGroup } from '../hdrp-buffers';
-import type { RenderFeatureGraphInspection } from '../inspection-types';
+import type {
+  MotionBlurExecutionPass,
+  MotionBlurExecutionReceipt,
+  RenderFeatureGraphInspection,
+} from '../inspection-types';
 import type { RenderExtent } from '../pipeline/render-extent';
 import {
   type StandardTopologyInputValue,
@@ -433,7 +441,15 @@ export function shouldUseTemporalFrameTransaction(
 export function isMotionBlurTemporalDemand(
   motionBlur: CameraSnapshot['motionBlur'] | undefined,
 ): boolean {
-  return motionBlur?.shutterAngle !== undefined && motionBlur.shutterAngle > 0;
+  return (
+    motionBlur !== undefined &&
+    motionBlurTemporalDemand({
+      shutterAngle: motionBlur.shutterAngle,
+      maxRadiusPixels: motionBlur.maxRadiusPixels,
+      sampleCount: motionBlur.sampleCount,
+      targetFps: motionBlur.targetFps ?? 60,
+    })
+  );
 }
 
 /**
@@ -1362,6 +1378,7 @@ function topologyOf(
   standardLighting: StandardTopologyInputValue | undefined,
   ssr: SsrSpatialAdmission | undefined,
   renderExtent: RenderExtent | undefined,
+  analyticFog: boolean,
 ): Result<RenderPipelineTopology, RhiError> {
   const cascadeCount = Math.max(1, Math.min(4, Math.round(lights.cascadeCount ?? 1))) as
     | 1
@@ -1419,6 +1436,7 @@ function topologyOf(
             : undefined;
   const preparedLut =
     frameState.pendingStandardLutGpuResources ?? frameState.standardLutGpuResources;
+  const depthOfField = depthOfFieldTopology(camera.depthOfField);
   return ok({
     pipelineId: STANDARD_PIPELINE_ID,
     standardProfile: internals.standardProfile,
@@ -1427,6 +1445,7 @@ function topologyOf(
     reflectionFallback: { enabled: frameState.reflectionFallbackDemand === true },
     ssr,
     ...(renderExtent === undefined ? {} : { extent: renderExtent }),
+    analyticFog: !clearOnly && analyticFog,
     surface: {
       width,
       height,
@@ -1437,7 +1456,12 @@ function topologyOf(
     camera: {
       tonemap: camera.tonemap,
       antialias: camera.antialias,
-      bloom: camera.bloom,
+      // Bloom intensity is a frame parameter, not a graph identity. Fold
+      // only its zero/non-zero admission into the closed topology switch so
+      // positive intensity changes update the recorder UBO in place.
+      bloom: standardBloomAdmitted(camera) ? 'on' : 'off',
+      bloomIntensity: camera.bloomIntensity,
+      ...(depthOfField === undefined ? {} : { depthOfField }),
     },
     atmosphere: !clearOnly && frameState.environmentFrame?.source.kind === 'atmosphere',
     output: {
@@ -1754,18 +1778,66 @@ export function settleVolumetricFogGraphCandidate(
   if (candidate === null) return;
   const previous = frameState.volumetricFogPreviousGraph ?? null;
   const previousKey = frameState.volumetricFogPreviousGraphKey ?? null;
+  // A frame can replace both the volume and DoF topology at once. DoF owns
+  // the shared compiled graph's full projection (per-frame resolver,
+  // generation, and lighting signature), so let it settle the graph exactly
+  // once while volume clears only its own candidate marker.
+  const sharedWithDepthOfField = frameState.depthOfFieldCandidateGraph === candidate;
   if (submitted) {
-    if (previous !== null && previous !== candidate) retire(frameState, previous);
+    if (!sharedWithDepthOfField && previous !== null && previous !== candidate) {
+      retire(frameState, previous);
+    }
   } else {
-    if (candidate !== previous) retire(frameState, candidate);
-    frameState.compiledFrameGraph = previous;
-    frameState.compiledFrameGraphTopologyKey = previousKey;
+    if (!sharedWithDepthOfField) {
+      if (candidate !== previous) retire(frameState, candidate);
+      frameState.compiledFrameGraph = previous;
+      frameState.compiledFrameGraphTopologyKey = previousKey;
+    }
   }
   frameState.volumetricFogPreviousGraph = null;
   frameState.volumetricFogPreviousGraphKey = null;
   frameState.volumetricFogCandidateGraph = null;
 }
 
+/**
+ * Settle a DoF graph replacement at the same submit barrier as the frame.
+ * Graph compilation publishes a candidate for the current record pass, but a
+ * failed encode/finish/submit must restore every graph-owned LKG projection
+ * before the next frame can inspect or reuse it.
+ */
+export function settleDepthOfFieldGraphCandidate(
+  frameState: RenderFrameState,
+  submitted: boolean,
+): void {
+  const candidate = frameState.depthOfFieldCandidateGraph;
+  if (candidate === null || candidate === undefined) return;
+  // Sparse synthetic frame states used by graph tests predate the explicit
+  // transaction fields. Treat omitted pending values as the empty LKG rather
+  // than passing undefined into retirement or restoring an invalid key.
+  const previous = frameState.depthOfFieldPreviousGraph ?? null;
+  if (submitted) {
+    if (previous !== null && previous !== candidate) retire(frameState, previous);
+  } else {
+    if (candidate !== previous) retire(frameState, candidate);
+    frameState.compiledFrameGraph = previous;
+    frameState.compiledFrameGraphTopologyKey = frameState.depthOfFieldPreviousGraphKey ?? null;
+    if (frameState.depthOfFieldPreviousPerFrameGraph === undefined) {
+      delete frameState.perFrameGraph;
+    } else {
+      frameState.perFrameGraph = frameState.depthOfFieldPreviousPerFrameGraph;
+    }
+    frameState.graphGeneration = frameState.depthOfFieldPreviousGraphGeneration ?? 0;
+    frameState.standardLightingGraphSignature =
+      frameState.depthOfFieldPreviousStandardLightingGraphSignature ?? '';
+  }
+  frameState.depthOfFieldPreviousGraph = null;
+  frameState.depthOfFieldPreviousGraphKey = null;
+  frameState.depthOfFieldPreviousPerFrameGraph = undefined;
+  frameState.depthOfFieldPreviousGraphGeneration = 0;
+  frameState.depthOfFieldPreviousStandardLightingGraphSignature = '';
+  frameState.depthOfFieldCandidateGraph = null;
+}
+
 export function ensureCompiledFrameGraph(
   internals: RenderSystemInternals,
   frameState: RenderFrameState,
@@ -1787,10 +1859,23 @@ export function ensureCompiledFrameGraph(
   onRecoveryError?: (error: unknown) => void,
   ssr?: SsrSpatialAdmission,
   renderExtent?: RenderExtent,
+  analyticFog = false,
 ): CompiledRenderGraph<RenderPipelineFrame> | null {
   const featureMetrics = mutableFeatureGraphInspection(internals);
   featureMetrics.ensureCalls += 1;
   const requestedStandardLightingSignature = standardLightingTopologySignature(standardLighting);
+  const frameDepthOfField = resolveDepthOfFieldFrameParams(
+    camera.depthOfField,
+    camera.depthOfFieldError,
+    frameState.depthOfFieldAccepted?.params,
+  );
+  // A rejected authoring request remains visible on the source camera, while
+  // an accepted graph continues to receive its own params until a valid
+  // replacement or explicit component removal is submitted.
+  const graphCamera: CameraSnapshot =
+    frameDepthOfField === undefined || frameDepthOfField === camera.depthOfField
+      ? camera
+      : { ...camera, depthOfField: frameDepthOfField };
   const lastKnownGood = (): CompiledRenderGraph<RenderPipelineFrame> | null =>
     frameState.compiledFrameGraph !== null &&
     !hasSubmissionSensitiveFeatures(getRenderFeatureGraphState(internals).plans) &&
@@ -1825,7 +1910,7 @@ export function ensureCompiledFrameGraph(
     internals,
     frameState,
     pipelineState,
-    camera,
+    graphCamera,
     clearOnly,
     lights,
     surfaceWidth,
@@ -1840,6 +1925,7 @@ export function ensureCompiledFrameGraph(
     standardLighting,
     ssr,
     renderExtent,
+    analyticFog,
   );
   if (!topologyResult.ok) {
     featureMetrics.buildFailures += 1;
@@ -1854,6 +1940,16 @@ export function ensureCompiledFrameGraph(
   const featurePostProcessEntries =
     featureGraphCandidate?.fullscreenEffects ??
     getRenderFeatureGraphState(internals).fullscreenEffects;
+  // Motion Blur's compute plan intentionally has no raster fullscreen shader
+  // declaration, but it is still a post chain consumer: Standard Post owns
+  // the named `motion-input`/`motion-output` targets and must project it after
+  // TAA. Keep the identity in this deferred set alongside declared fullscreen
+  // effects so an early forward/deferred contribution cannot resolve its
+  // scene-data target against an incomplete target map.
+  const fullscreenFeatureIds = new Set([
+    ...featurePostProcessEntries.keys(),
+    'forgeax.motion-blur',
+  ]);
   const postProcessAdmission = resolvePostProcessChainAdmission(
     requestedPostEffects,
     (identity) => {
@@ -1901,8 +1997,19 @@ export function ensureCompiledFrameGraph(
         },
       }
     : topologyResult.value;
+  // Keep Bloom's positive parameter values out of the compiled identity. A
+  // crossing of zero has already changed topology.camera.bloom above; the
+  // remaining values are uploaded by the active recorder without rebuilding
+  // targets or pipelines.
+  const topologyIdentity = {
+    ...topology,
+    camera: {
+      ...topology.camera,
+      bloomIntensity: undefined,
+    },
+  };
   const key = JSON.stringify({
-    topology,
+    topology: topologyIdentity,
     // Observation domains are an explicit per-frame graph demand.  They are
     // part of the cache identity so a request made after the ordinary graph
     // was compiled can admit the matching tone/output capture boundaries on
@@ -2023,7 +2130,6 @@ export function ensureCompiledFrameGraph(
     return lastKnownGood();
   }
   const ssrHistory = ssr?.status === 'admitted' ? importSsrHistoryTargets(builder) : undefined;
-  let projectedFeatures = false;
   const featureProjection = createRenderFeatureProjectionState();
   let featureShadows:
     | ReturnType<typeof projectRenderFeatureShadows<RenderPipelineFrame>>
@@ -2032,6 +2138,7 @@ export function ensureCompiledFrameGraph(
   const built = frameState.activePipeline.build(
     {
       graph: builder,
+      camera: { depthOfField: graphCamera.depthOfField },
       observationCaptureDomains: internals.observationCaptureDomains,
       ...(autoExposureResources?.ok === true
         ? { standardOutput: { autoExposure: autoExposureResources.value } }
@@ -2092,11 +2199,20 @@ export function ensureCompiledFrameGraph(
         namedTargets = {},
         standardSurfaceAccesses = [],
       ) => {
-        if (projectedFeatures) return ok(undefined);
-        projectedFeatures = true;
-        if (projectedFeaturePlans.value.length === 0) return ok(undefined);
+        // Forward/deferred scene lanes contribute feature plans before the
+        // Standard post chain has created its named input/output targets.
+        // Fullscreen effects (Motion Blur included) must wait for that later
+        // call so their temporal input is resolved after TAA. Other feature
+        // plans can still be projected at the forward contribution point.
+        const plans =
+          Object.keys(namedTargets).length === 0
+            ? projectedFeaturePlans.value.filter(
+                (execution) => !fullscreenFeatureIds.has(execution.featureIdentity),
+              )
+            : projectedFeaturePlans.value;
+        if (plans.length === 0) return ok(undefined);
         const resolveTarget = targetResolver(targets, semanticTargets, namedTargets);
-        const projected = projectPlanExecutions(builder, projectedFeaturePlans.value, {
+        const projected = projectPlanExecutions(builder, plans, {
           state: featureProjection,
           resolveTarget,
           standardSurfaceAccesses,
@@ -2172,10 +2288,32 @@ export function ensureCompiledFrameGraph(
     return lastKnownGood();
   }
   const previous = frameState.compiledFrameGraph;
+  const depthOfFieldReplacement =
+    (frameState.depthOfFieldCandidateGraph === null ||
+      frameState.depthOfFieldCandidateGraph === undefined) &&
+    (topologyResult.value.camera.depthOfField !== undefined ||
+      frameState.depthOfFieldAccepted !== undefined);
   if (volumeTopologyCandidate) {
     frameState.volumetricFogPreviousGraph = previous;
     frameState.volumetricFogPreviousGraphKey = frameState.compiledFrameGraphTopologyKey;
     frameState.volumetricFogCandidateGraph = compiled.value;
+    if (depthOfFieldReplacement) {
+      frameState.depthOfFieldPreviousGraph = previous;
+      frameState.depthOfFieldPreviousGraphKey = frameState.compiledFrameGraphTopologyKey;
+      frameState.depthOfFieldPreviousPerFrameGraph = frameState.perFrameGraph;
+      frameState.depthOfFieldPreviousGraphGeneration = frameState.graphGeneration;
+      frameState.depthOfFieldPreviousStandardLightingGraphSignature =
+        frameState.standardLightingGraphSignature;
+      frameState.depthOfFieldCandidateGraph = compiled.value;
+    }
+  } else if (depthOfFieldReplacement) {
+    frameState.depthOfFieldPreviousGraph = previous;
+    frameState.depthOfFieldPreviousGraphKey = frameState.compiledFrameGraphTopologyKey;
+    frameState.depthOfFieldPreviousPerFrameGraph = frameState.perFrameGraph;
+    frameState.depthOfFieldPreviousGraphGeneration = frameState.graphGeneration;
+    frameState.depthOfFieldPreviousStandardLightingGraphSignature =
+      frameState.standardLightingGraphSignature;
+    frameState.depthOfFieldCandidateGraph = compiled.value;
   }
   frameState.compiledFrameGraph = compiled.value;
   frameState.compiledFrameGraphTopologyKey = key;
@@ -2209,10 +2347,99 @@ export function ensureCompiledFrameGraph(
   } else if (featureGraphCandidate !== undefined) {
     recordRenderFeatureCandidateEvent(internals, featureGraphCandidate, 'abandoned');
   }
-  if (!volumeTopologyCandidate && previous !== null) retire(frameState, previous);
+  if (!volumeTopologyCandidate && !depthOfFieldReplacement && previous !== null) {
+    retire(frameState, previous);
+  }
   return compiled.value;
 }
 
+/**
+ * Project one accepted Motion Blur compute execution from the same graph and
+ * resolved dispatch objects used by the encoder. A plan/capability candidate
+ * without both executed passes deliberately returns no receipt.
+ */
+function deriveMotionBlurExecutionReceipt(
+  internals: RenderSystemInternals,
+  frameState: RenderFrameState,
+): MotionBlurExecutionReceipt | undefined {
+  const graph = frameState.compiledFrameGraph;
+  const deviceGeneration = internals.deviceScope?.generation;
+  if (graph === null || deviceGeneration === undefined) return undefined;
+  const info = graph.inspect();
+  const graphPasses = new Map(info.passes.map((pass) => [pass.name, pass]));
+  const summaryGraphPass = graphPasses.get('motion-blur-tile-summary');
+  const reconstructGraphPass = graphPasses.get('motion-blur');
+  if (summaryGraphPass?.kind !== 'compute' || reconstructGraphPass?.kind !== 'compute') {
+    return undefined;
+  }
+  const planned = getRenderFeatureGraphState(internals).plans.find(
+    (candidate) => candidate.featureIdentity === 'forgeax.motion-blur',
+  );
+  const execution =
+    planned === undefined ? undefined : getRenderFeaturePlanExecutionProjection(planned);
+  if (execution === undefined || execution.featureIdentity !== 'forgeax.motion-blur') {
+    return undefined;
+  }
+  const executionPass = (name: 'motion-blur-tile-summary' | 'motion-blur') =>
+    execution.passes.find((pass) => pass.name === name);
+  const summary = executionPass('motion-blur-tile-summary');
+  const reconstruct = executionPass('motion-blur');
+  if (
+    summary?.gpuCompute === undefined ||
+    reconstruct?.gpuCompute === undefined ||
+    summary.resolvedGpuCompute === undefined ||
+    reconstruct.resolvedGpuCompute === undefined
+  ) {
+    return undefined;
+  }
+  const directWorkgroups = (
+    pass: NonNullable<typeof summary.resolvedGpuCompute>,
+  ): readonly [number, number, number] | undefined => {
+    const dispatch = pass.dispatches[0];
+    if (dispatch === undefined || !('workgroups' in dispatch)) return undefined;
+    return dispatch.workgroups;
+  };
+  const summaryWorkgroups = directWorkgroups(summary.resolvedGpuCompute);
+  const reconstructWorkgroups = directWorkgroups(reconstruct.resolvedGpuCompute);
+  if (summaryWorkgroups === undefined || reconstructWorkgroups === undefined) return undefined;
+  const outputResource = info.resources.find(
+    (resource) =>
+      resource.label === 'motion-blurred-color' ||
+      reconstructGraphPass.accesses.some(
+        (access) => access.resource === resource.label && access.usage === 'storage-write',
+      ),
+  );
+  if (
+    outputResource?.descriptor.kind !== 'texture' ||
+    outputResource.descriptor.format !== 'rgba16float'
+  ) {
+    return undefined;
+  }
+  const summaryReceipt: MotionBlurExecutionPass = {
+    name: 'motion-blur-tile-summary',
+    kind: 'compute',
+    entryPoint: 'tile_summary',
+    workgroups: summaryWorkgroups,
+  };
+  const reconstructReceipt: MotionBlurExecutionPass = {
+    name: 'motion-blur',
+    kind: 'compute',
+    entryPoint: 'reconstruct',
+    workgroups: reconstructWorkgroups,
+  };
+  return Object.freeze({
+    frameId: frameState.frameNumber,
+    deviceGeneration,
+    // RenderGraphBuilder generations are process-global. The renderer's
+    // frame-state generation is the identity used by inspection and by the
+    // same-frame admission check below, so retain that owner-scoped value.
+    graphGeneration: frameState.graphGeneration,
+    program: 'motion-blur-compute' as const,
+    outputFormat: 'rgba16float' as const,
+    passes: [summaryReceipt, reconstructReceipt] as const,
+  });
+}
+
 export function executeCompiledFrameGraph(
   internals: RenderSystemInternals,
   frameState: RenderFrameState,
@@ -2245,9 +2472,11 @@ export function executeCompiledFrameGraph(
     frameState.pendingAutoExposureState = undefined;
     frameState.pendingStandardLutState = undefined;
     settleVolumetricFogGraphCandidate(frameState, false);
+    settleDepthOfFieldGraphCandidate(frameState, false);
     rejectTemporalFrame();
     return false;
   }
+  const motionBlurExecution = deriveMotionBlurExecutionReceipt(internals, frameState);
   const legacyTimingInstrumentation =
     timingCapture === undefined ? undefined : createTimingInstrumentation(timingCapture);
   const timingHost = internals as RenderSystemInternals & {
@@ -2308,6 +2537,8 @@ export function executeCompiledFrameGraph(
         },
       }),
     );
+    settleVolumetricFogGraphCandidate(frameState, false);
+    settleDepthOfFieldGraphCandidate(frameState, false);
     return false;
   }
   const capturedGeneration = deviceScope?.generation;
@@ -2868,6 +3099,11 @@ export function executeCompiledFrameGraph(
     commit: () => {
       resolvedFrameHooks?.onSubmitted?.();
       legacySubmitCommit?.();
+      if (motionBlurExecution === undefined) {
+        delete frameState.motionBlurExecution;
+      } else {
+        frameState.motionBlurExecution = motionBlurExecution;
+      }
       if (frameState.temporalFrameInput !== undefined) {
         const temporal = frameState.temporalFrameTransaction.commit({ accepted: true });
         if (temporal.ok) {
@@ -3000,6 +3236,8 @@ export function executeCompiledFrameGraph(
       frameState.pendingAtmospherePublish?.();
       frameState.pendingAtmospherePublish = undefined;
       onSubmitted?.(internals.device.queue.onSubmittedWorkDone());
+      settleVolumetricFogGraphCandidate(frameState, true);
+      settleDepthOfFieldGraphCandidate(frameState, true);
     },
     abort: (failure) => {
       frameState.pendingAtmospherePublish = undefined;
@@ -3038,9 +3276,15 @@ export function executeCompiledFrameGraph(
         frameState.environmentLifecycle?.discard(frameState.environmentGeneration);
         frameState.environmentGeneration = undefined;
       }
+      settleVolumetricFogGraphCandidate(frameState, false);
+      settleDepthOfFieldGraphCandidate(frameState, false);
     },
   });
+  // The callbacks above settle the normal transaction path. Keep this guard
+  // for synthetic callers and any future early transaction result that does
+  // not enter a callback.
   settleVolumetricFogGraphCandidate(frameState, transaction.ok);
+  settleDepthOfFieldGraphCandidate(frameState, transaction.ok);
   if (!transaction.ok) rejectTemporalFrame();
   return transaction.ok;
 }

package/src/recovery/render-system-candidate.ts

@@ -11,6 +11,7 @@ import {
 } from '@forgeax/engine-rhi';
 import type { Handle, MeshAsset, SamplerAsset, TextureAsset } from '@forgeax/engine-types';
 import { toShared } from '@forgeax/engine-types';
+import { standardBloomAdmitted } from '../bloom-admission';
 import { createClusterBinScratch } from '../cluster-binner';
 import type { EnvironmentLifecycle } from '../environment/lifecycle';
 import {
@@ -19,6 +20,7 @@ import {
   type RenderFeaturePreparedGraphicsResolverInput,
   runRenderFeatureFrame,
 } from '../features/host';
+import { motionBlurTemporalDemand } from '../features/motion-blur/motion-blur-params';
 import type { RenderFeatureGpuWorkOwner } from '../features/prepared-gpu-work';
 import { resolveStandardRenderFeatureTargets } from '../features/targets';
 import {
@@ -232,6 +234,12 @@ export function createRenderSystemRecovery(
       directionalShadowCacheRecorded: false,
       compiledFrameGraph: null,
       compiledFrameGraphTopologyKey: null,
+      depthOfFieldPreviousGraph: null,
+      depthOfFieldPreviousGraphKey: null,
+      depthOfFieldPreviousPerFrameGraph: undefined,
+      depthOfFieldPreviousGraphGeneration: 0,
+      depthOfFieldPreviousStandardLightingGraphSignature: '',
+      depthOfFieldCandidateGraph: null,
       volumetricFogPreviousGraph: null,
       volumetricFogPreviousGraphKey: null,
       volumetricFogCandidateGraph: null,
@@ -526,6 +534,10 @@ export function createRenderSystemRecovery(
           worlds: seed.worlds,
           owner: seed.resourceOwner,
           frameNumber: candidateFrameState.frameNumber,
+          frameSize: {
+            width: runtime.internals.canvas.width,
+            height: runtime.internals.canvas.height,
+          },
           visibilitySnapshots: seed.frame.featureVisibilitySnapshots,
           hiddenEntityReports: seed.frame.hiddenEntityReports,
           targets: featureTargets,
@@ -788,29 +800,35 @@ export function createRenderSystemRecovery(
           throw new Error('recovery TAA pipeline is unavailable');
         }
       }
-      if (camera.motionBlur?.shutterAngle !== undefined && camera.motionBlur.shutterAngle > 0) {
+      if (
+        camera.motionBlur !== undefined &&
+        motionBlurTemporalDemand({
+          shutterAngle: camera.motionBlur.shutterAngle,
+          maxRadiusPixels: camera.motionBlur.maxRadiusPixels,
+          sampleCount: camera.motionBlur.sampleCount,
+          targetFps: camera.motionBlur.targetFps ?? 60,
+        })
+      ) {
         warmPostProcessPipeline('forgeax.motion-blur', 'rgba16float');
       }
       for (const id of candidatePostProcessIds) {
         warmPostProcessPipeline(id, runtime.pipelineState.format as GPUTextureFormat);
       }
-      if (camera.bloom === 'on' && camera.tonemap !== 'none') {
+      if (standardBloomAdmitted(camera)) {
         runtime.pipelineState.perPassResources.ensureBloomResources?.();
         const bloom = runtime.pipelineState.perPassResources.getBloomResources?.();
         if (
           bloom === null ||
           bloom === undefined ||
-          bloom.bloomBrightPipeline === null ||
-          bloom.bloomBlurHPipeline === null ||
-          bloom.bloomBlurVPipeline === null ||
+          bloom.bloomDownsamplePipeline === null ||
+          bloom.bloomUpsamplePipeline === null ||
           bloom.bloomCompositePipeline === null ||
-          bloom.bloomBrightBindGroupLayout === null ||
-          bloom.bloomBlurBindGroupLayout === null ||
+          bloom.bloomDownsampleBindGroupLayout === null ||
+          bloom.bloomUpsampleBindGroupLayout === null ||
           bloom.bloomCompositeBindGroupLayout === null ||
           bloom.bloomSampler === null ||
-          bloom.bloomBrightParamsBuffer === null ||
-          bloom.bloomBlurHParamsBuffer === null ||
-          bloom.bloomBlurVParamsBuffer === null ||
+          bloom.bloomDownsampleParamsBuffer === null ||
+          bloom.bloomUpsampleParamsBuffer === null ||
           bloom.bloomCompositeParamsBuffer === null
         ) {
           throw new Error('recovery Bloom resources are incomplete');

package/src/render-contract.ts

@@ -31,10 +31,15 @@ import type { EnvironmentInspection } from './environment/inspection.js';
 import type { GpuDrivenPreparationError } from './errors/gpu-driven.js';
 import type { RecoveryOutcome, RecoveryPhase } from './errors/recover.js';
 import type { RenderError } from './errors/render.js';
+import type {
+  DepthOfFieldParams,
+  DepthOfFieldRequestFailure,
+} from './features/depth-of-field/depth-of-field-params.js';
 import type { RenderFeature, RenderFeatureDiagnostics } from './features/types.js';
 import type { PostProcessShaderEntry } from './fullscreen-post-process-pass.js';
 import type {
   BloomInspection,
+  DepthOfFieldInspection,
   DirectionalShadowInspection,
   LightInspection,
   LodOcclusionInspection,
@@ -165,17 +170,24 @@ export interface CameraSnapshot {
   readonly bloom: BloomEnabled;
   readonly bloomThreshold: number;
   readonly bloomIntensity: number;
-  readonly bloomBlurRadius: number;
+  readonly bloomSoftKnee: number;
+  readonly bloomScatter: number;
   readonly clearColor: readonly [number, number, number, number];
   /** Optional active-camera SSR authoring fact, copied from the ECS schema. */
   readonly screenSpaceReflection?: ScreenSpaceReflectionData;
   /** Renderer-owned temporal projection used by Standard's TAA producer. */
   readonly temporal?: TemporalView;
+  /** Active-camera depth-of-field parameters, present only when demanded. */
+  readonly depthOfField?: DepthOfFieldParams;
+  /** Structured DoF validation facts; invalid requests remain inspectable. */
+  readonly depthOfFieldError?: DepthOfFieldRequestFailure;
   /** Active-camera motion blur parameters, present only when demanded. */
   readonly motionBlur?: {
     readonly shutterAngle: number;
     readonly maxRadiusPixels: number;
     readonly sampleCount: number;
+    /** Target presentation rate; zero follows the accepted frame interval. */
+    readonly targetFps?: number;
   };
 }
 
@@ -557,6 +569,19 @@ export interface RenderFrameInput {
   readonly leases: readonly RenderWorldLease[];
   readonly camera: FrameCamera;
   readonly environment: FrameEnvironment;
+  /**
+   * Monotonic host render-sample time in seconds. This is captured before ECS
+   * applies its simulation delta clamp, then accepted with frame submission.
+   * Omitting it keeps direct renderer callers on the ECS-clock fallback.
+   */
+  readonly sampleTimeSeconds?: number;
+  /**
+   * Mark the next submitted frame as a fresh temporal baseline. App sets this
+   * on resume so a short wall-clock pause cannot be mistaken for a valid
+   * motion pair; direct replay callers may use the same explicit lifecycle
+   * boundary.
+   */
+  readonly temporalReset?: boolean;
   /** Fixed-step publication consumed by dynamic geometry candidates. */
   readonly fixedStep?: number;
   /** Optional profiler correlation token owned by App and consumed by Render. */
@@ -776,6 +801,8 @@ export interface RenderInspection {
   readonly temporalTarget?: TemporalTargetInspection;
   /** Renderer-owned Motion Blur facts; absent when no component is active. */
   readonly motionBlur?: MotionBlurInspection;
+  /** Renderer-owned Depth of Field facts; absent when no component is active. */
+  readonly depthOfField?: DepthOfFieldInspection;
   /** Bounded renderer-owned LOD/occlusion facts; absent before a candidate frame. */
   readonly lodOcclusion?: LodOcclusionInspection;
 }
@@ -800,6 +827,10 @@ export type DrawOwnerOptions = {
   readonly resourceOwner: number;
   /** Optional FrameCamera entity selection; absent preserves ActiveCamera semantics. */
   readonly cameraEntityKey?: number;
+  /** Monotonic host render-sample time in seconds, before the ECS delta clamp. */
+  readonly sampleTimeSeconds?: number;
+  /** Explicit pause/resume or replay lifecycle boundary for temporal owners. */
+  readonly temporalReset?: boolean;
   readonly profileFrame?: ProfileFrameToken;
 };
 
@@ -898,9 +929,8 @@ export const RENDER_GRAPH_EXECUTION_PHASE_CATALOG = [
   'record/graph-execute/skybox',
   'record/graph-execute/main',
   'record/graph-execute/fxaa',
-  'record/graph-execute/bloom-bright',
-  'record/graph-execute/bloom-blur-h',
-  'record/graph-execute/bloom-blur-v',
+  'record/graph-execute/bloom-downsample',
+  'record/graph-execute/bloom-upsample',
   'record/graph-execute/bloom-composite',
   'record/graph-execute/ssr-hiz',
   'record/graph-execute/ssr-trace',

package/src/render-graph-primitives.ts

@@ -577,6 +577,7 @@ function dispatchFullscreenPass(
   graphDepthView?: TextureView,
   paramsOverride?: Uint8Array,
   fragmentEntryPoint?: string,
+  msaaActive = false,
 ): void {
   if (shader === 'fxaa') {
     if (resolveCtx === undefined) {
@@ -643,7 +644,7 @@ function dispatchFullscreenPass(
   const built = buildFullscreenPostProcessPass(
     { device: ctx.runtime.device, errorRegistry: ctx.runtime.errorRegistry },
     entry,
-    ctx.msaaActive,
+    msaaActive,
   );
   if (built === null) return;
 
@@ -842,6 +843,8 @@ export function encodeFullscreenPass(
     readonly depthView?: TextureView | undefined;
     readonly paramsOverride?: Uint8Array | undefined;
     readonly fragmentEntryPoint?: string | undefined;
+    /** The depth target's actual sample count, when this typed pass reads depth. */
+    readonly msaaActive?: boolean | undefined;
   },
 ): void {
   dispatchFullscreenPass(
@@ -858,5 +861,9 @@ export function encodeFullscreenPass(
     input.depthView,
     input.paramsOverride,
     input.fragmentEntryPoint,
+    // Legacy callers rely on the frame context's MSAA state. Typed callers
+    // pass the actual depth target sample count explicitly so a single-sample
+    // view can never select the multisampled shader by camera policy alone.
+    input.msaaActive ?? ctx.msaaActive,
   );
 }