@forgeax/engine-render 0.1.7 → 0.1.20

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,
@@ -16,7 +16,11 @@ import {
 } from '../gpu-usage';
 import { assembleMaterialWithSkylightEntries } from '../ibl/skylight-bind-group';
 import type { InstanceBufferCacheEntry } from '../instance-buffer-cache';
-import { buildPbrMaterialUserRegionEntries } from '../pbr-pipeline';
+import {
+  buildPbrMaterialUserRegionEntries,
+  SHADOW_CASTER_SHADER_ID,
+  shadowCasterVariantSet,
+} from '../pbr-pipeline';
 import type { DispatchEntry, ExtractedLights } from '../render-system-extract';
 import { matchPass } from '../systems/pass-selector';
 import { worldEntityKey } from './frame-snapshot';
@@ -25,6 +29,8 @@ import {
   getOrCreatePerEntity,
   MAX_UNIFORM_INSTANCES,
   MESH_PER_ENTITY_STRIDE,
+  MESH_SSBO_BYTES,
+  MESH_UBO_FULL_ARRAY_BYTES,
   packInstanceStorageBuffer,
 } from './mesh-ssbo';
 import type { _InternalRenderPipelineContext } from './render-context';
@@ -75,6 +81,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,
@@ -88,6 +95,9 @@ function ensureTypedShadowViewBg(
         pipelineState.shadowParamsBuffer,
         pipelineState.shadowCasterCascadeBuffer,
         pipelineState.shadowFallbackTextureView,
+        ...(projectorAvailable
+          ? [pipelineState.defaultWhiteTextureView, pipelineState.defaultSampler]
+          : []),
         pipelineState.pointsLinesViewBuffer ?? pipelineState.viewUniformBuffer,
       ],
       variant,
@@ -159,6 +169,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;
@@ -175,11 +200,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;
@@ -188,17 +228,97 @@ function shadowShaderMap(c: _InternalRenderPipelineContext): ReadonlyMap<number,
 function shadowPipeline(c: _InternalRenderPipelineContext): RenderPipeline | null {
   return (
     c.runtime.getMaterialShaderPipeline?.(
-      'forgeax::default-shadow-caster',
+      SHADOW_CASTER_SHADER_ID,
       false,
       undefined,
       'triangle-list',
       undefined,
+      shadowCasterVariantSet(c.runtime.device.caps.storageBuffer, false),
+      'shadow-caster',
+      undefined,
+      undefined,
+      undefined,
+      undefined,
+      undefined,
+      undefined,
+      undefined,
       undefined,
+      'pbr',
+    ) ?? null
+  );
+}
+
+function skinnedShadowPipeline(
+  c: _InternalRenderPipelineContext,
+  entry: _InternalRenderPipelineContext['validatedOrdered'][number],
+): RenderPipeline | null {
+  return (
+    c.runtime.getMaterialShaderPipeline?.(
+      SHADOW_CASTER_SHADER_ID,
+      false,
+      undefined,
+      entry.mesh.submeshes[0]?.topology ?? 'triangle-list',
+      entry.mesh.indexFormat,
+      shadowCasterVariantSet(c.runtime.device.caps.storageBuffer, true),
       'shadow-caster',
+      undefined,
+      1,
+      undefined,
+      undefined,
+      undefined,
+      undefined,
+      entry.mesh.layoutProjection,
+      undefined,
+      'pbr-skin',
     ) ?? null
   );
 }
 
+function skinnedShadowMeshBindGroup(
+  c: _InternalRenderPipelineContext,
+  entry: _InternalRenderPipelineContext['validatedOrdered'][number],
+): BindGroup | null {
+  const skin = entry.source.skin;
+  const layout = c.pipelineState.pbrSkinMeshBindGroupLayout;
+  const allocator = c.pipelineState.skinPaletteAllocator;
+  if (skin === undefined || layout === null || allocator === null) return null;
+  return getOrCreateFromChain(
+    c.frameState.meshBindGroupCache,
+    [c.pipelineState.meshStorageBuffer.buffer, skin.buffer],
+    'shadow-pbr-skin-mesh',
+    () => {
+      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 },
+            },
+          },
+        ],
+      });
+      if (!created.ok) throw created.error;
+      return created.value;
+    },
+    c.bindGroupCounts,
+  );
+}
+
 export function encodeDirectionalShadowPass(
   c: _InternalRenderPipelineContext,
   pass: RhiRenderPassEncoder,
@@ -402,8 +522,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,
@@ -411,7 +531,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
@@ -434,37 +554,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 (
-      entryShadowShaderId !== undefined &&
-      entryShadowShaderId !== 'forgeax::default-shadow-caster'
-    ) {
-      // 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 (entry.source.skin !== undefined) {
+      const skinPipeline = skinnedShadowPipeline(c, entry);
+      if (skinPipeline === null) continue;
+      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
@@ -494,7 +591,16 @@ function recordShadowCasterDraws(
       }
     }
 
-    shadowPass.setBindGroup(2, shadowMeshBindGroup, [i * MESH_PER_ENTITY_STRIDE]);
+    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,
+      ]);
+    } else {
+      shadowPass.setBindGroup(2, shadowMeshBindGroup, [i * MESH_PER_ENTITY_STRIDE]);
+    }
 
     // C1 + C2 (w12): per-entity instance buffer + instanceCount
     let shadowInstanceBuffer: Buffer = pipelineState.identityInstanceBuffer;
@@ -609,6 +715,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 {
@@ -663,24 +811,15 @@ function ensureSpotShadowMaterialBg(c: _InternalRenderPipelineContext): BindGrou
   });
   const merged =
     fb !== null
-      ? assembleMaterialWithSkylightEntries(
-          fallbackEntries,
-          {
-            irradianceView: fb.irradianceView,
-            irradianceSampler: fb.sampler,
-            prefilterView: fb.prefilterView,
-            prefilterSampler: fb.sampler,
-            brdfLutView: fb.brdfLutView,
-            brdfLutSampler: fb.sampler,
-            intensityBuffer: fb.intensityBuffer,
-          },
-          {
-            emissiveSampler: pipelineState.defaultSampler,
-            emissiveView: pipelineState.defaultWhiteTextureView,
-            occlusionSampler: pipelineState.defaultSampler,
-            occlusionView: pipelineState.defaultWhiteTextureView,
-          },
-        )
+      ? assembleMaterialWithSkylightEntries(fallbackEntries, {
+          irradianceView: fb.irradianceView,
+          irradianceSampler: fb.sampler,
+          prefilterView: fb.prefilterView,
+          prefilterSampler: fb.sampler,
+          brdfLutView: fb.brdfLutView,
+          brdfLutSampler: fb.sampler,
+          intensityBuffer: fb.intensityBuffer,
+        })
       : fallbackEntries;
   const r = runtime.device.createBindGroup({
     label: 'shadow-material-bg',

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

@@ -1,7 +1,8 @@
 import type { ResolveContext } from '@forgeax/engine-render-graph';
-import type { RhiRenderPassEncoder, TextureView } from '@forgeax/engine-rhi';
+import { RhiError, type RhiRenderPassEncoder, type TextureView } from '@forgeax/engine-rhi';
 import { toShared } from '@forgeax/engine-types';
 import { buildBeginRenderPassDescriptor } from '../pipeline-spec';
+import type { BloomFrameReceipts } from './frame-snapshot';
 import { getOrCreateFromChain } from './mesh-ssbo';
 import type { _InternalRenderPipelineContext } from './render-context';
 import { VIEW_UNIFORM_BYTES } from './view-ubo';
@@ -177,30 +178,72 @@ export function encodeSkyboxPass(
 // Gate: bloom === 'off' || !tonemapActive => early-return (AC-04/AC-05).
 // The closures receive RenderPipelineContext and route to w15 record functions.
 
+const EMPTY_BLOOM_RECEIPTS: BloomFrameReceipts = {
+  uploadCount: 0,
+  bindGroupCount: 0,
+  encodeCount: 0,
+};
+
+function updateBloomReceipts(
+  c: _InternalRenderPipelineContext,
+  field: keyof BloomFrameReceipts,
+): void {
+  const current = c.frameState.bloomFrameReceipts ?? EMPTY_BLOOM_RECEIPTS;
+  c.frameState.bloomFrameReceipts = {
+    ...current,
+    [field]: current[field] + 1,
+  };
+}
+
+function stageBloomUpload(c: _InternalRenderPipelineContext): void {
+  updateBloomReceipts(c, 'uploadCount');
+}
+
+function stageBloomBindGroup(c: _InternalRenderPipelineContext): void {
+  updateBloomReceipts(c, 'bindGroupCount');
+}
+
+function stageBloomEncode(c: _InternalRenderPipelineContext): void {
+  updateBloomReceipts(c, 'encodeCount');
+}
+
+function throwBloomRecordFailure(expected: string): never {
+  throw new RhiError({
+    code: 'webgpu-runtime-error',
+    expected,
+    hint: 'repair the Bloom candidate resources before retrying the frame',
+  });
+}
+
 export function recordBloomBrightPass(
   _c: _InternalRenderPipelineContext,
   resolve?: ResolveContext,
   graphPass?: RhiRenderPassEncoder,
 ): void {
-  const { runtime, pipelineState, encoder, camera, tonemapActive, frameState, bindGroupCounts } =
-    _c;
-  const pp = pipelineState.perPassResources;
+  const { runtime, encoder, camera, tonemapActive, frameState, bindGroupCounts } = _c;
+  const pp = _c.bloomResources;
 
   // Double gate: bloom=off => zero-overhead; tonemap=none => no HDR domain
   if (camera.bloom !== 'on' || !tonemapActive) return;
+  if (pp === null || pp === undefined) {
+    throwBloomRecordFailure('Bloom persistent resources are ready before bright-pass encoding');
+  }
   if (
     pp.bloomBrightPipeline === null ||
     pp.bloomBrightBindGroupLayout === null ||
     pp.bloomSampler === null ||
     pp.bloomBrightParamsBuffer === null
-  )
-    return;
+  ) {
+    throwBloomRecordFailure('Bloom bright pass has pipeline, layout, sampler, and params buffer');
+  }
 
   // M1 / w7: bloom intermediate textures owned by render-graph. Resolve
   // the GPU TextureView via the resolve context passed by graph.execute().
   const bloomBrightView = resolve?.resolve('bloomBright') as TextureView | undefined;
   const hdrColorView = resolve?.resolve('hdrColor') as TextureView | undefined;
-  if (!bloomBrightView || !hdrColorView) return;
+  if (!bloomBrightView || !hdrColorView) {
+    throwBloomRecordFailure('Bloom bright pass resolves its source and target views');
+  }
   const bglBright = pp.bloomBrightBindGroupLayout;
   const bloomSampler = pp.bloomSampler;
   const paramsBuffer = pp.bloomBrightParamsBuffer;
@@ -213,6 +256,7 @@ export function recordBloomBrightPass(
   brightParams[3] = 0;
   const paramsWrite = runtime.device.queue.writeBuffer(paramsBuffer, 0, brightParams);
   if (!paramsWrite.ok) throw paramsWrite.error;
+  stageBloomUpload(_c);
 
   // 3. Identity-cached BindGroup (1 tex + 1 sampler + 1 UBO). Keyed on the
   // graph-resolved hdrColor TextureView: resize retires hdrColor and the new
@@ -249,7 +293,9 @@ export function recordBloomBrightPass(
     );
   pass.setPipeline(pp.bloomBrightPipeline);
   pass.setBindGroup(0, bindGroup);
+  stageBloomBindGroup(_c);
   pass.draw(3, 1, 0, 0);
+  stageBloomEncode(_c);
   if (graphPass === undefined) pass.end();
 }
 
@@ -258,32 +304,29 @@ export function recordBloomBlurHPass(
   resolve?: ResolveContext,
   graphPass?: RhiRenderPassEncoder,
 ): void {
-  const {
-    runtime,
-    pipelineState,
-    encoder,
-    camera,
-    targetW,
-    tonemapActive,
-    frameState,
-    bindGroupCounts,
-  } = _c;
-  const pp = pipelineState.perPassResources;
+  const { runtime, encoder, camera, targetW, tonemapActive, frameState, bindGroupCounts } = _c;
+  const pp = _c.bloomResources;
 
   if (camera.bloom !== 'on' || !tonemapActive) return;
+  if (pp === null || pp === undefined) {
+    throwBloomRecordFailure('Bloom persistent resources are ready before blur-H encoding');
+  }
   if (
     pp.bloomBlurHPipeline === null ||
     pp.bloomBlurBindGroupLayout === null ||
     pp.bloomSampler === null ||
     pp.bloomBlurHParamsBuffer === null
-  )
-    return;
+  ) {
+    throwBloomRecordFailure('Bloom blur-H pass has pipeline, layout, sampler, and params buffer');
+  }
 
   // M1 / w7: bloom intermediate textures owned by render-graph. Resolve
   // via the resolve context passed by graph.execute().
   const bloomBlurHView = resolve?.resolve('bloomBlurH') as TextureView | undefined;
   const bloomBrightView = resolve?.resolve('bloomBright') as TextureView | undefined;
-  if (!bloomBlurHView || !bloomBrightView) return;
+  if (!bloomBlurHView || !bloomBrightView) {
+    throwBloomRecordFailure('Bloom blur-H pass resolves its source and target views');
+  }
   const bglBlur = pp.bloomBlurBindGroupLayout;
   const bloomSampler = pp.bloomSampler;
   const paramsBuffer = pp.bloomBlurHParamsBuffer;
@@ -299,6 +342,7 @@ export function recordBloomBlurHPass(
   blurParams[3] = 0;
   const paramsWrite = runtime.device.queue.writeBuffer(paramsBuffer, 0, blurParams);
   if (!paramsWrite.ok) throw paramsWrite.error;
+  stageBloomUpload(_c);
 
   // 3. Identity-cached BindGroup (reads bloomBright from graph). Keyed on the
   // graph-resolved bloomBright view so resize rebuilds against the new texture.
@@ -334,7 +378,9 @@ export function recordBloomBlurHPass(
     );
   pass.setPipeline(pp.bloomBlurHPipeline);
   pass.setBindGroup(0, bindGroup);
+  stageBloomBindGroup(_c);
   pass.draw(3, 1, 0, 0);
+  stageBloomEncode(_c);
   if (graphPass === undefined) pass.end();
 }
 
@@ -343,32 +389,29 @@ export function recordBloomBlurVPass(
   resolve?: ResolveContext,
   graphPass?: RhiRenderPassEncoder,
 ): void {
-  const {
-    runtime,
-    pipelineState,
-    encoder,
-    camera,
-    targetH,
-    tonemapActive,
-    frameState,
-    bindGroupCounts,
-  } = _c;
-  const pp = pipelineState.perPassResources;
+  const { runtime, encoder, camera, targetH, tonemapActive, frameState, bindGroupCounts } = _c;
+  const pp = _c.bloomResources;
 
   if (camera.bloom !== 'on' || !tonemapActive) return;
+  if (pp === null || pp === undefined) {
+    throwBloomRecordFailure('Bloom persistent resources are ready before blur-V encoding');
+  }
   if (
     pp.bloomBlurVPipeline === null ||
     pp.bloomBlurBindGroupLayout === null ||
     pp.bloomSampler === null ||
     pp.bloomBlurVParamsBuffer === null
-  )
-    return;
+  ) {
+    throwBloomRecordFailure('Bloom blur-V pass has pipeline, layout, sampler, and params buffer');
+  }
 
   // M1 / w7: bloom intermediate textures owned by render-graph. Resolve
   // via the resolve context passed by graph.execute().
   const bloomBlurVView = resolve?.resolve('bloomBlurV') as TextureView | undefined;
   const bloomBlurHView = resolve?.resolve('bloomBlurH') as TextureView | undefined;
-  if (!bloomBlurVView || !bloomBlurHView) return;
+  if (!bloomBlurVView || !bloomBlurHView) {
+    throwBloomRecordFailure('Bloom blur-V pass resolves its source and target views');
+  }
   const bglBlur = pp.bloomBlurBindGroupLayout;
   const bloomSampler = pp.bloomSampler;
   const paramsBuffer = pp.bloomBlurVParamsBuffer;
@@ -384,6 +427,7 @@ export function recordBloomBlurVPass(
   blurParams[3] = 0;
   const paramsWrite = runtime.device.queue.writeBuffer(paramsBuffer, 0, blurParams);
   if (!paramsWrite.ok) throw paramsWrite.error;
+  stageBloomUpload(_c);
 
   // 3. Identity-cached BindGroup (reads bloomBlurH from graph). Keyed on the
   // graph-resolved bloomBlurH view so resize rebuilds against the new texture.
@@ -419,7 +463,9 @@ export function recordBloomBlurVPass(
     );
   pass.setPipeline(pp.bloomBlurVPipeline);
   pass.setBindGroup(0, bindGroup);
+  stageBloomBindGroup(_c);
   pass.draw(3, 1, 0, 0);
+  stageBloomEncode(_c);
   if (graphPass === undefined) pass.end();
 }
 
@@ -428,18 +474,23 @@ export function recordBloomCompositePass(
   resolve?: ResolveContext,
   graphPass?: RhiRenderPassEncoder,
 ): void {
-  const { runtime, pipelineState, encoder, camera, tonemapActive, frameState, bindGroupCounts } =
-    _c;
-  const pp = pipelineState.perPassResources;
+  const { runtime, encoder, camera, tonemapActive, frameState, bindGroupCounts } = _c;
+  const pp = _c.bloomResources;
 
   if (camera.bloom !== 'on' || !tonemapActive) return;
+  if (pp === null || pp === undefined) {
+    throwBloomRecordFailure('Bloom persistent resources are ready before composite encoding');
+  }
   if (
     pp.bloomCompositePipeline === null ||
     pp.bloomCompositeBindGroupLayout === null ||
     pp.bloomSampler === null ||
     pp.bloomCompositeParamsBuffer === null
-  )
-    return;
+  ) {
+    throwBloomRecordFailure(
+      'Bloom composite pass has pipeline, layout, sampler, and params buffer',
+    );
+  }
 
   // M1 / w7: hdrColor + bloomBlurV textures owned by render-graph.
   // bug-20260625: composite READS hdrColor (scene, binding 0) and WRITES the
@@ -447,7 +498,9 @@ export function recordBloomCompositePass(
   const hdrColorView = resolve?.resolve('hdrColor') as TextureView | undefined;
   const bloomBlurVView = resolve?.resolve('bloomBlurV') as TextureView | undefined;
   const hdrCompositedView = resolve?.resolve('hdrComposited') as TextureView | undefined;
-  if (!hdrColorView || !bloomBlurVView || !hdrCompositedView) return;
+  if (!hdrColorView || !bloomBlurVView || !hdrCompositedView) {
+    throwBloomRecordFailure('Bloom composite pass resolves its source and target views');
+  }
   const bglComposite = pp.bloomCompositeBindGroupLayout;
   const bloomSampler = pp.bloomSampler;
   const paramsBuffer = pp.bloomCompositeParamsBuffer;
@@ -460,6 +513,7 @@ export function recordBloomCompositePass(
   compositeParams[3] = 0;
   const paramsWrite = runtime.device.queue.writeBuffer(paramsBuffer, 0, compositeParams);
   if (!paramsWrite.ok) throw paramsWrite.error;
+  stageBloomUpload(_c);
 
   // 2. Identity-cached BindGroup (2 tex: hdrColor + bloomBlurV, 1 sampler,
   // 1 UBO). Keys on both sampled views: resize retires both hdrColor and
@@ -505,7 +559,9 @@ export function recordBloomCompositePass(
     );
   pass.setPipeline(pp.bloomCompositePipeline);
   pass.setBindGroup(0, bindGroup);
+  stageBloomBindGroup(_c);
   pass.draw(3, 1, 0, 0);
+  stageBloomEncode(_c);
   if (graphPass === undefined) pass.end();
 }