@forgeax/engine-render 0.1.19 → 0.1.21

package/src/record/render-context.ts

@@ -11,6 +11,7 @@ import type {
   PipelineLayout,
   Result,
   RhiCanvasContext,
+  RhiCommandEncoder,
   RhiDevice,
   RenderPipeline as RhiRenderPipeline,
   Sampler,
@@ -41,10 +42,20 @@ import {
 import type { SkylightFallback } from '../ibl/skylight-bind-group';
 import type { BloomInspection } from '../inspection-types';
 import type { HealthListenerRegistry, RhiErrorListenerRegistry } from '../lifecycle';
+import type { PipelineGroup2Contract } from '../pbr-pipeline';
+import type { StandardTopologyInputValue } from '../pipeline/standard-lighting/topology';
 import type { StandardProfile } from '../pipeline/standard-profile';
 import type { PipelineBuilderShaderModuleFactory } from '../pipeline-builder';
 import type { PointsLinesInspection } from '../points-lines/inspection';
 import type { PointsLinesRecordPlan } from '../points-lines/record';
+import type { ReflectionProbeTable } from '../reflection/gpu-table';
+import type { ReflectionProbeSelectionResult } from '../reflection/projection';
+import type { GpuPassTimingReason } from './gpu-pass-timing/errors';
+import type {
+  GpuPassTimingCapture,
+  GpuPassTimingFrameIdentity,
+  GpuPassTimingSession,
+} from './gpu-pass-timing/session';
 
 export interface PointsLinesRecordSubmission {
   readonly plan: PointsLinesRecordPlan;
@@ -53,10 +64,23 @@ export interface PointsLinesRecordSubmission {
   readonly layoutProjection: VertexLayoutProjection;
 }
 
+export interface ReflectionProbeRecordState {
+  readonly table: ReflectionProbeTable;
+  readonly selections: ReadonlyMap<string, ReflectionProbeSelectionResult>;
+  readonly graph: import('./typed-frame-graph').ReflectionProbeGraphState;
+  readonly completeSubmission: (submitted: boolean, completed?: Promise<unknown>) => void;
+}
+
+export interface MaterialShaderPipelineEntry {
+  readonly pipeline: RhiRenderPipeline;
+  readonly group2Contract: PipelineGroup2Contract;
+}
+
 import type {
   RenderDebugOverlay,
   RenderPipelineContext,
   RenderRecordPhase,
+  VolumetricFogShaderSources,
 } from '../render-contract';
 import type {
   DispatchEntry,
@@ -65,6 +89,8 @@ import type {
   SkylightSnapshot,
 } from '../render-system-extract';
 import type { SkinPaletteAllocator } from '../systems/skin-palette-allocator';
+import type { RenderTarget } from '../targets/contracts';
+import type { RenderTargetPhysical } from '../targets/physical';
 import type {
   BindGroupCounts,
   BloomFrameReceipts,
@@ -101,6 +127,23 @@ export interface RenderSystemRuntime {
     shaderModuleMode?: RenderFeatureShaderModuleMode,
     layoutKindOverride?: 'pbr' | 'pbr-skin',
   ) => RhiRenderPipeline | null;
+  readonly getMaterialShaderPipelineEntry?: (
+    materialShaderId: string,
+    isHdr: boolean,
+    renderState?: MaterialRenderState,
+    topology?: PrimitiveTopology,
+    indexFormat?: 'uint16' | 'uint32',
+    variantSet?: string,
+    passKind?: PassKind,
+    meshAttributes?: VertexAttributeMap,
+    sampleCount?: number,
+    colorFormatOverride?: GPUTextureFormat,
+    shaderUvSetCount?: number,
+    depthFormatOverride?: GPUTextureFormat | null,
+    vertexLayout?: string,
+    vertexLayoutProjection?: VertexLayoutProjection,
+    shaderModuleMode?: RenderFeatureShaderModuleMode,
+  ) => MaterialShaderPipelineEntry | null;
   readonly getMaterialShaderBindingContract?: (
     materialShaderId: string,
   ) => 'group-0' | 'group-0-resource' | 'view-only' | 'view-and-scene-depth' | 'render-material';
@@ -115,10 +158,15 @@ export interface RenderSystemRuntime {
     id: string,
     bgl: BindGroupLayout,
     colorFormat: GPUTextureFormat,
+    entry?: import('../fullscreen-post-process-pass').PostProcessShaderEntry,
   ) => RhiRenderPipeline | null;
   readonly clearPostProcessPipelineCache?: (id: string) => void;
   readonly invalidateShaderModule?: (label: string) => void;
   readonly dynamicTextureStore?: DynamicTextureStore | undefined;
+  /** Resolves a render-target source to the active generation-owned GPU view. */
+  readonly resolveRenderTargetTextureSource?: (
+    source: import('../targets/contracts').RenderTargetTextureSource,
+  ) => import('../targets/material-source').RenderTargetMaterialSourceBinding | undefined;
 }
 
 /** Renderer-owned bridge from retained Points/Lines facts into main geometry. */
@@ -230,12 +278,16 @@ export interface BloomPersistentBundle {
 }
 
 export interface PipelineState {
+  /** Device that owns every opaque handle in this pipeline state. */
+  readonly device: RhiDevice;
   readonly meshes: ReadonlyMap<number, MeshGpuHandles>;
   readonly format: TextureFormat;
   readonly colorAttachmentFormat: TextureFormat;
   /** Surface route committed by configureSurface for inspection provenance. */
   readonly surfaceProfile?: 'dual-view' | 'raw-only';
   readonly viewBindGroupLayout: BindGroupLayout;
+  /** Device capability gate for the optional SpotLight projector binding. */
+  readonly projectorAvailable?: boolean;
   readonly materialBindGroupLayout: BindGroupLayout;
   readonly meshBindGroupLayout: BindGroupLayout;
   readonly viewUniformBuffer: Buffer;
@@ -260,6 +312,8 @@ export interface PipelineState {
   readonly hdrpClusterMembershipBindGroupLayout: BindGroupLayout | null;
   readonly pbrSkinPipelineLayout: PipelineLayout | null;
   readonly pbrSkinMeshBindGroupLayout: BindGroupLayout | null;
+  readonly hdrpSkinPipelineLayout: PipelineLayout | null;
+  readonly hdrpSkinMeshBindGroupLayout: BindGroupLayout | null;
   readonly skinPaletteAllocator: SkinPaletteAllocator | null;
   readonly defaultWhiteTextureView: TextureView;
   readonly defaultNormalTextureView: TextureView;
@@ -277,6 +331,12 @@ export interface RenderSystemInternals extends RenderSystemRuntime {
   readonly standardPipeline: RenderFrameState['activePipeline'];
   readonly featureHost?: RenderFeatureHost | undefined;
   readonly shaderModuleFactory?: PipelineBuilderShaderModuleFactory;
+  readonly createShaderModule?: (
+    device: import('@forgeax/engine-rhi').RhiDevice,
+    descriptor: { readonly code: string; readonly label?: string },
+  ) => Promise<
+    Result<import('@forgeax/engine-rhi').ShaderModule, import('@forgeax/engine-rhi').RhiError>
+  >;
   /** Optional handle-first factory for feature-owned generated shader programs. */
   readonly immediateShaderModuleFactory?: PipelineBuilderShaderModuleFactory;
   readonly profiler?: Profiler | undefined;
@@ -302,6 +362,18 @@ export interface RenderSystemInternals extends RenderSystemRuntime {
         label: string,
       ) => RhiRenderPipeline | null)
     | undefined;
+  gpuPassTimingSession?: GpuPassTimingSession | undefined;
+  gpuPassTimingCapture?: GpuPassTimingCapture | undefined;
+  gpuPassTimingSubmittedWork?: Promise<void> | undefined;
+  gpuPassTimingFrameIdentity?: GpuPassTimingFrameIdentity | undefined;
+  gpuPassTimingBeginReason?: GpuPassTimingReason | undefined;
+  readonly getRenderTargetPhysical?: (target: RenderTarget) => RenderTargetPhysical | undefined;
+  readonly encodeRenderTargetReadbacks?: (
+    encoder: RhiCommandEncoder,
+    faces?: readonly number[],
+  ) => void;
+  /** Composed renderer utility sources installed atomically at build-ready. */
+  volumetricFogShaders?: VolumetricFogShaderSources | undefined;
 }
 
 export interface _StandardForwardSceneView {
@@ -313,6 +385,8 @@ export interface _StandardForwardSceneView {
   readonly validated: readonly ValidatedRenderable[];
   readonly validatedOrdered: readonly ValidatedRenderable[];
   readonly viewBindGroup: BindGroup | null;
+  /** Dynamic View-UBO slot used by auxiliary cube/probe face cameras. */
+  readonly viewBindGroupDynamicOffset?: number;
   readonly meshBindGroup: BindGroup | null;
   readonly frameState: RenderFrameState;
   readonly dispatchCounts: DispatchCounts;
@@ -335,6 +409,8 @@ export interface _StandardForwardSceneView {
   readonly dispatch: readonly DispatchEntry[];
   readonly hdrpClusterBindGroup: BindGroup | null;
   readonly hdrpClusterMembershipBindGroup: BindGroup | null;
+  /** Prepared Standard lighting declaration accepted by this graph frame. */
+  readonly standardLighting?: StandardTopologyInputValue;
   readonly foldDispatchPlan: FoldDispatchPlan | null;
   readonly materialSlotIndices: readonly (readonly number[])[];
   readonly materialSlots: readonly MaterialSnapshot[];
@@ -342,6 +418,7 @@ export interface _StandardForwardSceneView {
   readonly materialSlotCount: number;
   readonly pointsLines: PointsLinesRecordOwner | undefined;
   readonly materialBgAssemblyCache: Map<string, MaterialBgAssemblyCacheEntry>;
+  readonly reflectionProbes?: ReflectionProbeRecordState;
   materialUboPayloadCache?: {
     readonly materialSlots: readonly MaterialSnapshot[];
     readonly materialSlotCount: number;

package/src/record/shadow-pass.ts

@@ -7,7 +7,7 @@ import {
   type RhiQueue,
   type RhiRenderPassEncoder,
 } from '@forgeax/engine-rhi';
-import type { PassSelector } from '@forgeax/engine-types';
+import type { MaterialRenderState, PassSelector } from '@forgeax/engine-types';
 import { GpuBuffer } from '../gpu-resource';
 import {
   GPU_BUFFER_USAGE_COPY_DST,
@@ -18,6 +18,8 @@ import { assembleMaterialWithSkylightEntries } from '../ibl/skylight-bind-group'
 import type { InstanceBufferCacheEntry } from '../instance-buffer-cache';
 import {
   buildPbrMaterialUserRegionEntries,
+  createPbrSkinMeshBindGroupEntries,
+  pbrSkinMeshDynamicOffsets,
   SHADOW_CASTER_SHADER_ID,
   shadowCasterVariantSet,
 } from '../pbr-pipeline';
@@ -81,6 +83,7 @@ function ensureTypedShadowViewBg(
   const { runtime, frameState, pipelineState } = c;
   const shadowSampler = pipelineState.perPassResources.shadowSampler;
   if (shadowSampler === null) return null;
+  const projectorAvailable = pipelineState.projectorAvailable !== false;
   try {
     return getOrCreateFromChain(
       frameState.viewBindGroupCache,
@@ -94,6 +97,9 @@ function ensureTypedShadowViewBg(
         pipelineState.shadowParamsBuffer,
         pipelineState.shadowCasterCascadeBuffer,
         pipelineState.shadowFallbackTextureView,
+        ...(projectorAvailable
+          ? [pipelineState.defaultWhiteTextureView, pipelineState.defaultSampler]
+          : []),
         pipelineState.pointsLinesViewBuffer ?? pipelineState.viewUniformBuffer,
       ],
       variant,
@@ -165,6 +171,21 @@ function ensureTypedShadowViewBg(
                 },
               },
             },
+            ...(projectorAvailable
+              ? [
+                  {
+                    binding: 11,
+                    resource: {
+                      kind: 'textureView' as const,
+                      value: pipelineState.defaultWhiteTextureView,
+                    },
+                  },
+                  {
+                    binding: 12,
+                    resource: { kind: 'sampler' as const, value: pipelineState.defaultSampler },
+                  },
+                ]
+              : []),
           ],
         });
         if (!created.ok) throw created.error;
@@ -181,11 +202,26 @@ function ensureTypedShadowViewBg(
   }
 }
 
-function shadowShaderMap(c: _InternalRenderPipelineContext): ReadonlyMap<number, string> {
-  const shaders = new Map<number, string>();
+interface ShadowDispatch {
+  readonly materialShaderId: string;
+  readonly renderState: MaterialRenderState | undefined;
+}
+
+type ShadowDispatchMap = ReadonlyMap<number, ReadonlyMap<number, ShadowDispatch>>;
+
+function shadowShaderMap(c: _InternalRenderPipelineContext): ShadowDispatchMap {
+  const shaders = new Map<number, Map<number, ShadowDispatch>>();
   for (const entry of c.dispatch) {
     if (entry.tags.LightMode === 'ShadowCaster' && entry.materialShaderId !== undefined) {
-      shaders.set(entry.renderableIndex, entry.materialShaderId);
+      let byMaterial = shaders.get(entry.renderableIndex);
+      if (byMaterial === undefined) {
+        byMaterial = new Map<number, ShadowDispatch>();
+        shaders.set(entry.renderableIndex, byMaterial);
+      }
+      byMaterial.set(entry.materialHandle, {
+        materialShaderId: entry.materialShaderId,
+        renderState: entry.renderState,
+      });
     }
   }
   return shaders;
@@ -256,27 +292,12 @@ function skinnedShadowMeshBindGroup(
       const created = c.runtime.device.createBindGroup({
         label: 'shadow-pbr-skin-mesh-bg',
         layout,
-        entries: [
-          {
-            binding: 0,
-            resource: {
-              kind: 'buffer',
-              value: {
-                buffer: c.pipelineState.meshStorageBuffer.buffer,
-                size: c.runtime.device.caps.storageBuffer
-                  ? MESH_SSBO_BYTES
-                  : MESH_UBO_FULL_ARRAY_BYTES,
-              },
-            },
-          },
-          {
-            binding: 1,
-            resource: {
-              kind: 'buffer',
-              value: { buffer: skin.buffer, size: allocator.bindingWindowBytes },
-            },
-          },
-        ],
+        entries: createPbrSkinMeshBindGroupEntries(
+          c.pipelineState.meshStorageBuffer.buffer,
+          c.runtime.device.caps.storageBuffer ? MESH_SSBO_BYTES : MESH_UBO_FULL_ARRAY_BYTES,
+          skin.buffer,
+          allocator.bindingWindowBytes,
+        ),
       });
       if (!created.ok) throw created.error;
       return created.value;
@@ -304,7 +325,7 @@ export function encodeDirectionalShadowPass(
   c.frameState.directionalShadowCacheRecorded = true;
   pass.setViewport(viewport.x, viewport.y, viewport.w, viewport.h, 0, 1);
   pass.setPipeline(pipeline);
-  pass.setBindGroup(0, viewBg, [0]);
+  pass.setBindGroup(0, viewBg, [0, 0]);
   pass.setBindGroup(1, materialBg, [0]);
   recordShadowCasterDraws(
     c,
@@ -334,7 +355,7 @@ export function encodePointShadowPass(
   const materialBg = ensureSpotShadowMaterialBg(c);
   if (pipeline === null || viewBg === null || materialBg === null) return;
   pass.setPipeline(pipeline);
-  pass.setBindGroup(0, viewBg, [0]);
+  pass.setBindGroup(0, viewBg, [0, 0]);
   pass.setBindGroup(1, materialBg, [0]);
   recordShadowCasterDraws(
     c,
@@ -382,7 +403,7 @@ export function encodeSpotShadowPass(
     1,
   );
   pass.setPipeline(pipeline);
-  pass.setBindGroup(0, viewBg, [0]);
+  pass.setBindGroup(0, viewBg, [0, 0]);
   pass.setBindGroup(1, materialBg, [0]);
   // Reuse the shared caster recorder. The compact spot-only loop used to
   // depend on instance bindings created by a directional pass, so a scene
@@ -488,8 +509,8 @@ export function buildMatchedMaterialHandlesByRenderable(
  * groups (@group 0/1) are already set by the caller; this loop owns @group
  * 2/3 + the vertex/index/pipeline de-dup state. Receives the explicit
  * `_InternalRenderPipelineContext` (`c`) plus the caller-resolved shadow
- * pipeline, mesh bind group, pass-selector match set, and per-renderable
- * custom-caster shader map so no cross-function mutable state is introduced.
+ * pipeline, mesh bind group, pass-selector match set, and per-material
+ * ShadowCaster dispatch map so no cross-function mutable state is introduced.
  */
 function recordShadowCasterDraws(
   c: _InternalRenderPipelineContext,
@@ -497,7 +518,7 @@ function recordShadowCasterDraws(
   shadowPipeline: RenderPipeline,
   shadowMeshBindGroup: BindGroup,
   matchedIndices: Set<number> | null,
-  shadowShaderByRenderableIdx: ReadonlyMap<number, string>,
+  shadowDispatchByRenderableIdx: ShadowDispatchMap,
 ): void {
   const { runtime, pipelineState, validatedOrdered } = c;
   // M-3 / w12: vertexBuffer/indexBuffer state locals migrate to GpuBuffer
@@ -520,41 +541,14 @@ function recordShadowCasterDraws(
     // feat-20260609 M2: skip entities that don't match the pass selector.
     if (matchedIndices !== null && !matchedIndices.has(entry.renderableIndex)) continue;
 
-    // bug-20260619-csm RC-3 (AC-10, D-3): resolve the per-entity shadow
-    // PSO from its ShadowCaster shader id. Default casters keep the
-    // vertex-only `forgeax::default-shadow-caster` PSO bound above; a
-    // material with a custom ShadowCaster shader (cutout alpha-test) gets
-    // its own fragment-carrying PSO so `discard` runs in the depth pass.
-    const entryShadowShaderId = shadowShaderByRenderableIdx.get(entry.renderableIndex);
-    let entryShadowPipeline = shadowPipeline;
     if (entry.source.skin !== undefined) {
       const skinPipeline = skinnedShadowPipeline(c, entry);
       if (skinPipeline === null) continue;
-      entryShadowPipeline = skinPipeline;
-    } else if (
-      entryShadowShaderId !== undefined &&
-      entryShadowShaderId !== SHADOW_CASTER_SHADER_ID
-    ) {
-      // Custom ShadowCaster PSO; same cache path as the default above
-      // (passKind 'shadow-caster'). On a cache miss (async build in
-      // flight / build failure) fall back to the default PSO so the
-      // caster still writes depth rather than dropping its draw.
-      entryShadowPipeline =
-        runtime.getMaterialShaderPipeline?.(
-          entryShadowShaderId,
-          false, // isHdr — shadow depth pass is always LDR
-          undefined, // renderState
-          'triangle-list', // topology — shadow PSO targets triangle-list
-          undefined, // indexFormat
-          undefined, // variantSet — shadow caster has no variant axes
-          'shadow-caster', // passKind
-        ) ?? shadowPipeline;
-    }
-    if (entryShadowPipeline !== shadowLastPipeline && entryShadowPipeline !== null) {
-      shadowPass.setPipeline(entryShadowPipeline);
-      shadowLastPipeline = entryShadowPipeline;
+      if (skinPipeline !== shadowLastPipeline) {
+        shadowPass.setPipeline(skinPipeline);
+        shadowLastPipeline = skinPipeline;
+      }
     }
-
     // feat-20260604-mesh-topology-debug-draw M5 / w14 (AC-09, D-A6): the
     // shadow caster PSO is triangle-list; it only projects triangle faces.
     // line-list / line-strip / point-list meshes have no surface to cast a
@@ -587,10 +581,11 @@ function recordShadowCasterDraws(
     if (entry.source.skin !== undefined) {
       const skinMeshBindGroup = skinnedShadowMeshBindGroup(c, entry);
       if (skinMeshBindGroup === null) continue;
-      shadowPass.setBindGroup(2, skinMeshBindGroup, [
-        i * MESH_PER_ENTITY_STRIDE,
-        entry.source.skin.byteOffset,
-      ]);
+      shadowPass.setBindGroup(
+        2,
+        skinMeshBindGroup,
+        pbrSkinMeshDynamicOffsets(i * MESH_PER_ENTITY_STRIDE, entry.source.skin.byteOffset),
+      );
     } else {
       shadowPass.setBindGroup(2, shadowMeshBindGroup, [i * MESH_PER_ENTITY_STRIDE]);
     }
@@ -599,6 +594,7 @@ function recordShadowCasterDraws(
     let shadowInstanceBuffer: Buffer = pipelineState.identityInstanceBuffer;
     let shadowInstanceCount = 1;
     const shadowInst = entry.source.instances;
+    if (shadowInst?.instanceCount === 0) continue;
     if (shadowInst !== undefined) {
       const uniformFallback = runtime.device.caps.storageBuffer === false;
       // Over-cap uniform fallback can't fit the per-instance window — bind
@@ -708,6 +704,48 @@ function recordShadowCasterDraws(
       if (sm.topology !== 'triangle-list' && sm.topology !== 'triangle-strip') {
         continue;
       }
+
+      // Resolve the ShadowCaster PSO for the material bound to this submesh.
+      // Built-in materials normally use the shared vertex-only caster, but an
+      // authored `cullMode:'none'`/`frontFace` must still reach that PSO so
+      // two-sided casters (such as the Three.js teapot) populate the atlas
+      // from both faces. Custom ShadowCaster shaders retain their own path.
+      const submeshMaterial = entry.source.materials[sm.materialSlot] ?? entry.source.material;
+      const shadowDispatch = shadowDispatchByRenderableIdx
+        .get(entry.renderableIndex)
+        ?.get(submeshMaterial.materialHandle ?? 0);
+      const entryShadowShaderId = shadowDispatch?.materialShaderId;
+      const entryShadowRenderState = shadowDispatch?.renderState;
+      // A skinned caster's pipeline was selected above together with its
+      // two-binding mesh/palette group. Keep that pairing for every submesh;
+      // resetting to the static shadow pipeline here would bind the skin
+      // group against `pbr-pl` and Dawn rejects the draw at submit time.
+      let entryShadowPipeline =
+        entry.source.skin !== undefined ? shadowLastPipeline : shadowPipeline;
+      if (
+        entry.source.skin === undefined &&
+        entryShadowShaderId !== undefined &&
+        (entryShadowShaderId !== 'forgeax::default-shadow-caster' ||
+          entryShadowRenderState !== undefined)
+      ) {
+        // On a cache miss (async build in flight / build failure), fall back
+        // to the default PSO so the caster still writes depth rather than
+        // dropping its draw.
+        entryShadowPipeline =
+          runtime.getMaterialShaderPipeline?.(
+            entryShadowShaderId,
+            false, // isHdr — shadow depth pass is always LDR
+            entryShadowRenderState,
+            'triangle-list', // topology — shadow PSO targets triangle-list
+            undefined, // indexFormat
+            undefined, // variantSet — shadow caster has no variant axes
+            'shadow-caster', // passKind
+          ) ?? shadowPipeline;
+      }
+      if (entryShadowPipeline !== shadowLastPipeline && entryShadowPipeline !== null) {
+        shadowPass.setPipeline(entryShadowPipeline);
+        shadowLastPipeline = entryShadowPipeline;
+      }
       if (entry.mesh.indexed) {
         shadowPass.drawIndexed(sm.indexCount, shadowInstanceCount, sm.indexOffset, 0, 0);
       } else {

package/src/record/skybox-post-pass.ts

@@ -2,6 +2,8 @@ import type { ResolveContext } from '@forgeax/engine-render-graph';
 import { RhiError, type RhiRenderPassEncoder, type TextureView } from '@forgeax/engine-rhi';
 import { toShared } from '@forgeax/engine-types';
 import { buildBeginRenderPassDescriptor } from '../pipeline-spec';
+import { FXAA_POST_PROCESS_ID } from '../render-contract';
+import { resolveOutputDither } from '../render-pipeline';
 import type { BloomFrameReceipts } from './frame-snapshot';
 import { getOrCreateFromChain } from './mesh-ssbo';
 import type { _InternalRenderPipelineContext } from './render-context';
@@ -579,19 +581,29 @@ export function recordFxaaPass(
     fxaaActive &&
     pipelineState.perPassResources.fxaaPipeline !== null &&
     pipelineState.perPassResources.fxaaBindGroupLayout !== null &&
-    pipelineState.perPassResources.fxaaSampler !== null
+    pipelineState.perPassResources.fxaaSampler !== null &&
+    runtime.getPostProcessParamsBuffer !== undefined
   ) {
     const inputView = resolve.resolve('ldrColor') as TextureView | undefined;
     if (inputView === undefined) return;
 
-    // Compose the 2-entry FXAA BindGroup (input texture + sampler). The
+    const fxaaParams = runtime.getPostProcessParamsBuffer(FXAA_POST_PROCESS_ID);
+    if (fxaaParams === undefined) return;
+    const params = new Float32Array(4);
+    params[0] = resolveOutputDither(c.frameState.installedPipelineConfig) ? 1 : 0;
+    const paramsWrite = runtime.device.queue.writeBuffer(fxaaParams, 0, params);
+    if (!paramsWrite.ok) throw paramsWrite.error;
+
+    // Compose the 3-entry FXAA BindGroup (input texture + sampler + params).
     // graph view identity changes when the graph reallocates on resize, so
-    // the identity-keyed cache rebuilds against the live target.
+    // the identity-keyed cache rebuilds against the live target. The params
+    // buffer is also a key so a device recovery cannot retain a bind group
+    // pointing at the retired resource.
     const fxaaBglLayout = pipelineState.perPassResources.fxaaBindGroupLayout;
     const fxaaSampler = pipelineState.perPassResources.fxaaSampler;
     const fxaaBg = getOrCreateFromChain(
       c.frameState.postProcessBgCache,
-      [inputView],
+      [inputView, fxaaParams],
       'fxaa',
       () => {
         const fxaaBgRes = runtime.device.createBindGroup({
@@ -609,6 +621,10 @@ export function recordFxaaPass(
               binding: 1,
               resource: { kind: 'sampler', value: fxaaSampler },
             },
+            {
+              binding: 2,
+              resource: { kind: 'buffer', value: { buffer: fxaaParams } },
+            },
           ],
         });
         if (!fxaaBgRes.ok) throw fxaaBgRes.error;