@forgeax/engine-render 0.1.21 → 0.1.23

package/src/record/main-pass-geometry.ts

@@ -22,6 +22,7 @@ import type { InstanceBufferCacheEntry } from '../instance-buffer-cache';
 import { SPRITE_PREMULTIPLIED_ALPHA_BLEND } from '../materials';
 import {
   createPbrSkinMeshBindGroupEntries,
+  isStandardPbrMaterialShader,
   pbrSkinMeshDynamicOffsets,
   SKIN_MATERIAL_SHADER_ID,
 } from '../pbr-pipeline';
@@ -35,6 +36,11 @@ import type { PointsLinesRecordPlan } from '../points-lines/record';
 import { POINTS_LINES_MATERIAL_SHADER_ID } from '../points-lines/record';
 import type { RenderRecordPhase } from '../render-contract';
 import type { MaterialSnapshot } from '../render-system-extract';
+import {
+  PROBE_BLEND_RECORD_BYTE_SIZE,
+  PROBE_BLEND_RECORD_STRIDE,
+  probeBlendRecordOffset,
+} from '../scene/probe-blend-record';
 import { worldEntityKey } from './frame-snapshot';
 import {
   geometryRenderStateForTopology,
@@ -58,12 +64,15 @@ import { POINTS_LINES_VIEW_SLOT_STRIDE, writePointsLinesViewUbo } from './view-u
 type GeometryInstanceDraw = {
   readonly instanceBuffer: Buffer;
   readonly instanceBindGroup: BindGroup;
+  /** -1 means the no-probe layout and therefore no dynamic offset. */
+  readonly probeOffset: number;
   readonly instanceCount: number;
 };
 
 type GeometryBindingState = {
   pipeline: RenderPipeline | null;
   instancesBuffer: Buffer | null;
+  probeOffset: number;
 };
 
 type MaterialPipelineLookup = {
@@ -77,6 +86,7 @@ type MaterialPipelineLookup = {
   readonly layoutProjection: import('@forgeax/engine-geometry').VertexLayoutProjection;
   readonly sampleCount: number;
   readonly colorFormatOverride: GPUTextureFormat | undefined;
+  readonly additionalColorFormats: readonly GPUTextureFormat[] | undefined;
   readonly handle: MaterialShaderPipelineEntry | null;
 };
 
@@ -138,9 +148,17 @@ function submitSubmeshDraws(
     state.pipeline = pipeline;
   }
   for (const instanceDraw of instanceDraws) {
-    if (instanceDraw.instanceBuffer !== state.instancesBuffer) {
-      pass.setBindGroup(3, instanceDraw.instanceBindGroup);
+    if (
+      instanceDraw.instanceBuffer !== state.instancesBuffer ||
+      instanceDraw.probeOffset !== state.probeOffset
+    ) {
+      if (instanceDraw.probeOffset < 0) {
+        pass.setBindGroup(3, instanceDraw.instanceBindGroup);
+      } else {
+        pass.setBindGroup(3, instanceDraw.instanceBindGroup, [instanceDraw.probeOffset]);
+      }
       state.instancesBuffer = instanceDraw.instanceBuffer;
+      state.probeOffset = instanceDraw.probeOffset;
     }
     if (indexed) {
       pass.drawIndexed(indexCount, instanceDraw.instanceCount, indexOffset, 0, 0);
@@ -226,12 +244,14 @@ export function recordGeometryDraws(
   const bindingState: GeometryBindingState = {
     pipeline: null,
     instancesBuffer: null,
+    probeOffset: -1,
   };
   const identityInstanceBuffer = pipelineState.identityInstanceBuffer;
   const identityInstanceDraws: readonly GeometryInstanceDraw[] = [
     {
       instanceBuffer: identityInstanceBuffer,
-      instanceBindGroup: resolveGeometryInstancesBindGroup(c, identityInstanceBuffer),
+      instanceBindGroup: resolveGeometryInstancesBindGroup(c, identityInstanceBuffer, undefined),
+      probeOffset: -1,
       instanceCount: 1,
     },
   ];
@@ -253,6 +273,9 @@ export function recordGeometryDraws(
   // renderer's authoritative cache still owns lifetime/invalidation, while
   // this frame-local table removes the hot call/lookup overhead.
   const materialPipelineLookupCache = new Map<string, Map<string, MaterialPipelineLookup[]>>();
+  const recordOcclusionCandidate = (draw: () => void): void => {
+    draw();
+  };
   const resolveMaterialPipeline = (
     materialShaderId: string,
     renderState: MaterialSnapshot['renderState'],
@@ -262,6 +285,19 @@ export function recordGeometryDraws(
     colorFormat: GPUTextureFormat | undefined,
     layoutProjection: import('@forgeax/engine-geometry').VertexLayoutProjection,
   ): MaterialShaderPipelineEntry | null => {
+    // The fallback MRT is an extension of the built-in Standard PBR output
+    // contract only.  The render pass may carry a second attachment whenever
+    // another renderable needs S_fallback, but shaders such as unlit, sprite,
+    // and the skin PBR variant still expose only @location(0).  Passing that
+    // attachment into their PSO would make WebGPU reject the pipeline before
+    // the first draw ("Color target has no corresponding fragment stage
+    // output").  Keep the graph attachment shared while deriving pipeline
+    // targets from the shader's actual output contract.
+    const reflectionFallbackFormats =
+      materialShaderId === 'forgeax::default-standard-pbr' &&
+      c.reflectionFallbackColorFormat !== undefined
+        ? [c.reflectionFallbackColorFormat]
+        : undefined;
     const renderStateKey = renderStateHash(renderState);
     const shaderLookupCache = materialPipelineLookupCache.get(materialShaderId);
     const cachedLookups = shaderLookupCache?.get(renderStateKey);
@@ -276,7 +312,8 @@ export function recordGeometryDraws(
           cached.passKind === passKind &&
           cached.layoutProjection.digest === layoutProjection.digest &&
           cached.sampleCount === sampleCount &&
-          cached.colorFormatOverride === colorFormat
+          cached.colorFormatOverride === colorFormat &&
+          cached.additionalColorFormats?.join(',') === reflectionFallbackFormats?.join(',')
         ) {
           return cached.handle;
         }
@@ -292,6 +329,12 @@ export function recordGeometryDraws(
       return null;
     }
     const resolvedVariantSet = resolvedVariantSetResult.value;
+    const fallbackVariantSet =
+      materialShaderId !== 'forgeax::default-standard-pbr'
+        ? resolvedVariantSet
+        : c.reflectionFallbackColorFormat !== undefined && resolvedVariantSet === ''
+          ? ''
+          : `${resolvedVariantSet === undefined || resolvedVariantSet === '' ? '' : `${resolvedVariantSet}+`}REFLECTION_FALLBACK_AVAILABLE=${c.reflectionFallbackColorFormat !== undefined}`;
     const resolvePipeline = () =>
       runtime.getMaterialShaderPipelineEntry?.(
         materialShaderId,
@@ -299,7 +342,7 @@ export function recordGeometryDraws(
         renderState,
         topology,
         indexFormat,
-        resolvedVariantSet,
+        fallbackVariantSet,
         passKind,
         undefined,
         sampleCount,
@@ -308,6 +351,9 @@ export function recordGeometryDraws(
         undefined,
         undefined,
         layoutProjection,
+        undefined,
+        undefined,
+        reflectionFallbackFormats,
       ) ?? null;
     const handle =
       profilePhase === undefined
@@ -332,6 +378,7 @@ export function recordGeometryDraws(
         layoutProjection,
         sampleCount,
         colorFormatOverride: colorFormat,
+        additionalColorFormats: reflectionFallbackFormats,
         handle,
       };
       if (shaderLookupCache === undefined) {
@@ -361,7 +408,12 @@ export function recordGeometryDraws(
 
     if (
       passKind === 'forward' &&
-      c.gpuDrivenEntityKeys.has(worldEntityKey(entry.source.worldId, entry.source.entityKey))
+      c.gpuDrivenEntityKeys.has(
+        worldEntityKey(
+          c.gpuDrivenWorldKeys?.[entry.source.worldId] ?? entry.source.worldId,
+          entry.source.entityKey,
+        ),
+      )
     ) {
       continue;
     }
@@ -454,12 +506,11 @@ export function recordGeometryDraws(
       const pointsLinesMeshGroup = meshBindGroup ?? meshGroup2;
       if (pointsLinesMeshGroup === null) continue;
       pass.setBindGroup(2, pointsLinesMeshGroup, meshGroup2DynamicOffsets);
-      pass.setBindGroup(
-        3,
+      const pointsLinesInstancesBg =
         identityInstanceDraws[0]?.instanceBindGroup ??
-          resolveGeometryInstancesBindGroup(c, identityInstanceBuffer),
-      );
-      recordPointsLinesDraw(pass, pointsLinesSubmission.plan);
+        resolveGeometryInstancesBindGroup(c, identityInstanceBuffer, undefined);
+      pass.setBindGroup(3, pointsLinesInstancesBg);
+      recordOcclusionCandidate(() => recordPointsLinesDraw(pass, pointsLinesSubmission.plan));
       pass.setBindGroup(0, viewBindGroup as BindGroup, [viewBindGroupDynamicOffset, 0]);
       continue;
     }
@@ -487,7 +538,7 @@ export function recordGeometryDraws(
     // length instead.
     if (pipelineTag === 'unlit') dispatchCounts.unlit += 1;
 
-    const instanceDraws = resolveGeometryInstanceBuffer(c, entry, identityInstanceDraws);
+    const instanceDraws = resolveGeometryInstanceBuffer(c, entry, identityInstanceDraws, false);
     if (instanceDraws === null) continue;
 
     // feat-20260611 R2 / M8 / w28 (IS-14): skin entries need a 3-binding
@@ -518,6 +569,8 @@ export function recordGeometryDraws(
     meshGroup2DynamicOffsets[0] = i * MESH_PER_ENTITY_STRIDE;
     let group2DynamicOffsets: readonly number[] = meshGroup2DynamicOffsets;
     const isSkinEntry = entry.source.skin !== undefined;
+    const probeBlendRecordAvailable =
+      runtime.device.caps.storageBuffer && entry.source.probeBlendRecord !== undefined;
     // feat-20260612-skin-palette-per-frame-upload M1 / m1-3 + M6: the
     // record stage reads the GPU buffer reference through
     // `entry.source.skin.buffer` (per-slice carrier set at extract time
@@ -567,6 +620,7 @@ export function recordGeometryDraws(
         c.standardLighting,
         runtime.device.caps.storageBuffer,
         entry.mesh.layoutProjection.attributes.some((attribute) => attribute.key === 'color'),
+        probeBlendRecordAvailable,
       ),
     );
     if (!skinVariantSetResult.ok) runtime.errorRegistry.fire(skinVariantSetResult.error);
@@ -588,6 +642,9 @@ export function recordGeometryDraws(
             undefined,
             undefined,
             entry.mesh.layoutProjection,
+            undefined,
+            undefined,
+            undefined,
           ) ?? null)
         : null;
     if (skinResources !== null && skinPsoProbe !== null) {
@@ -794,6 +851,8 @@ export function recordGeometryDraws(
         entry.source.skin !== undefined
           ? SKIN_MATERIAL_SHADER_ID
           : submeshMaterial.materialShaderId;
+      const probeBlendAvailable =
+        probeBlendRecordAvailable && isStandardPbrMaterialShader(smMaterialShaderId);
       const isSpriteShader =
         smMaterialShaderId === 'forgeax::sprite' || smMaterialShaderId === 'forgeax::sprite-lit';
       // Preserve the dedicated sprite-pass state when the linear-LDR graph
@@ -869,6 +928,7 @@ export function recordGeometryDraws(
           c.standardLighting,
           runtime.device.caps.storageBuffer,
           hasVertexColor,
+          probeBlendAvailable,
         );
         // Sprite's base request must retain the boot-selected artifact. Only
         // SpriteInstances uses the explicit empty key for the
@@ -884,19 +944,12 @@ export function recordGeometryDraws(
             : capabilityVariantSet === ''
               ? entry.variantSet
               : `${capabilityVariantSet}+${entry.variantSet}`;
-        const projectionVariantSetResult = isSpriteShader
-          ? ({ ok: true, value: variantSet } as const)
-          : variantSetFromVertexLayoutProjection(entry.mesh.layoutProjection, variantSet);
-        if (!projectionVariantSetResult.ok) {
-          runtime.errorRegistry.fire(projectionVariantSetResult.error);
-          continue;
-        }
         const cachedPipeline = resolveMaterialPipeline(
           smMaterialShaderId,
           pipelineRenderState,
           smTopology,
           entry.mesh.indexFormat,
-          projectionVariantSetResult.value,
+          variantSet,
           colorFormatOverride,
           entry.mesh.layoutProjection,
         );
@@ -922,6 +975,18 @@ export function recordGeometryDraws(
       if (smPipelineHandle === null) {
         continue;
       }
+      // The probe record is an ABI extension of the built-in Standard PBR
+      // shaders only. RenderScene may retain a record on every projected
+      // renderable, but unlit/custom shaders still use the one-binding
+      // instances BGL and must never receive the probe bind group. Resolve
+      // this per submesh so mixed-material meshes cannot cross the layouts.
+      const instanceDraws = resolveGeometryInstanceBuffer(
+        c,
+        entry,
+        identityInstanceDraws,
+        probeBlendAvailable,
+      );
+      if (instanceDraws === null) continue;
       // Standard clustered PBR variants declare the unified cluster/SSAO
       // group(2) layout. Unlit and other URP-layout materials must bind the
       // ordinary mesh group instead; choosing one group for the whole pass
@@ -941,18 +1006,7 @@ export function recordGeometryDraws(
       pass.setBindGroup(2, group2BindGroup, group2DynamicOffsets);
 
       if (profilePhase === undefined) {
-        submitSubmeshDraws(
-          pass,
-          bindingState,
-          smPipelineHandle,
-          instanceDraws,
-          entry.mesh.indexed,
-          sm.indexCount,
-          sm.vertexCount,
-          sm.indexOffset,
-        );
-      } else {
-        profileGeometrySegment(c, passKind, 'draw-submit', () =>
+        recordOcclusionCandidate(() =>
           submitSubmeshDraws(
             pass,
             bindingState,
@@ -964,6 +1018,21 @@ export function recordGeometryDraws(
             sm.indexOffset,
           ),
         );
+      } else {
+        profileGeometrySegment(c, passKind, 'draw-submit', () =>
+          recordOcclusionCandidate(() =>
+            submitSubmeshDraws(
+              pass,
+              bindingState,
+              smPipelineHandle,
+              instanceDraws,
+              entry.mesh.indexed,
+              sm.indexCount,
+              sm.vertexCount,
+              sm.indexOffset,
+            ),
+          ),
+        );
       }
     }
   }
@@ -978,10 +1047,35 @@ function resolveGeometryInstanceBuffer(
   c: _InternalRenderPipelineContext,
   entry: _InternalRenderPipelineContext['validatedOrdered'][number],
   identityInstanceDraws: readonly GeometryInstanceDraw[],
+  useProbeBlend: boolean,
 ): readonly GeometryInstanceDraw[] | null {
   const { runtime, pipelineState, frameState } = c;
   const inst = entry.source.instances;
-  if (inst === undefined) return identityInstanceDraws;
+  const probeBinding =
+    !useProbeBlend ||
+    !runtime.device.caps.storageBuffer ||
+    entry.source.probeBlendRecord === undefined
+      ? undefined
+      : resolveProbeBlendBuffer(
+          c,
+          entry.source.probeBlendRecord,
+          worldEntityKey(entry.source.worldId, entry.source.entityKey),
+        );
+  if (inst === undefined) {
+    const identity = identityInstanceDraws[0];
+    if (identity === undefined) return null;
+    return [
+      {
+        ...identity,
+        instanceBindGroup: resolveGeometryInstancesBindGroup(
+          c,
+          pipelineState.identityInstanceBuffer,
+          probeBinding?.buffer,
+        ),
+        probeOffset: probeBinding?.offset ?? -1,
+      },
+    ];
+  }
   // A present, empty Instances array means zero draws. Do not fall back to
   // the shared identity buffer, which would silently render one instance.
   if (inst.instanceCount === 0) return [];
@@ -1022,7 +1116,12 @@ function resolveGeometryInstanceBuffer(
         }
         draws.push({
           instanceBuffer: buffer.handle,
-          instanceBindGroup: resolveGeometryInstancesBindGroup(c, buffer.handle),
+          instanceBindGroup: resolveGeometryInstancesBindGroup(
+            c,
+            buffer.handle,
+            probeBinding?.buffer,
+          ),
+          probeOffset: probeBinding?.offset ?? -1,
           instanceCount: count,
         });
       }
@@ -1114,25 +1213,80 @@ function resolveGeometryInstanceBuffer(
   return [
     {
       instanceBuffer,
-      instanceBindGroup: resolveGeometryInstancesBindGroup(c, instanceBuffer),
+      instanceBindGroup: resolveGeometryInstancesBindGroup(c, instanceBuffer, probeBinding?.buffer),
+      probeOffset: probeBinding?.offset ?? -1,
       instanceCount,
     },
   ];
 }
 
-function resolveGeometryInstancesBindGroup(
+export function resolveProbeBlendBuffer(
+  c: _InternalRenderPipelineContext,
+  record: import('../scene/probe-blend-record').ProbeBlendRecord | undefined,
+  entityKey?: number,
+): { readonly buffer: Buffer; readonly offset: number } {
+  const { runtime, frameState } = c;
+  const usage = runtime.device.caps.storageBuffer
+    ? GPU_BUFFER_USAGE_STORAGE | GPU_BUFFER_USAGE_COPY_DST
+    : GPU_BUFFER_USAGE_UNIFORM | GPU_BUFFER_USAGE_COPY_DST;
+  if (record === undefined) throw new Error('probe blend record is required for probe allocation');
+  if (entityKey === undefined) throw new Error('probe blend record requires an entity key');
+  const offset = probeBlendRecordOffset(record.objectKey);
+  const requiredCapacity = record.objectKey + 2;
+  let buffer = frameState.probeBlendRecordBuffer;
+  if (buffer === undefined || frameState.probeBlendRecordBufferCapacity < requiredCapacity) {
+    const created = runtime.device.createBuffer({
+      label: 'probe-blend-records',
+      size: requiredCapacity * PROBE_BLEND_RECORD_STRIDE,
+      usage,
+      mappedAtCreation: false,
+    });
+    if (!created.ok) throw created.error;
+    buffer = new GpuBuffer(runtime.device, created.value);
+    frameState.probeBlendRecordBuffer = buffer;
+    frameState.probeBlendRecordBufferCapacity = requiredCapacity;
+    // The cache is tied to the previous backing allocation. A new buffer has
+    // no valid record contents, so every later object must upload its full
+    // 160B payload even when generation/bytes match the old allocation.
+    frameState.probeBlendBuffers.clear();
+  }
+  const cached = frameState.probeBlendBuffers.get(entityKey);
+  const unchanged =
+    cached !== undefined &&
+    cached.generation === record.generation &&
+    cached.bytes.length === record.bytes.length &&
+    cached.bytes.every((value, index) => value === record.bytes[index]);
+  if (!unchanged) {
+    const uploaded = runtime.device.queue.writeBuffer(buffer.handle, offset, record.bytes);
+    if (!uploaded.ok) throw uploaded.error;
+    // Publish the generation only after the complete 160B queue write succeeds.
+    frameState.probeBlendBuffers.set(entityKey, {
+      generation: record.generation,
+      bytes: new Uint8Array(record.bytes),
+    });
+  }
+  return { buffer: buffer.handle, offset };
+}
+
+export function resolveGeometryInstancesBindGroup(
   c: _InternalRenderPipelineContext,
   instanceBuffer: Buffer,
+  probeBuffer?: Buffer,
 ): BindGroup {
   const { runtime, pipelineState, frameState, bindGroupCounts } = c;
+  const layout =
+    probeBuffer === undefined
+      ? pipelineState.instancesBindGroupLayout
+      : pipelineState.probeInstancesBindGroupLayout;
+  if (layout === undefined) throw new Error('probe instances bind-group layout is unavailable');
   return getOrCreateFromChain(
     frameState.instancesBgShared,
-    [pipelineState.instancesBindGroupLayout, instanceBuffer],
-    'instances',
+    probeBuffer === undefined ? [layout, instanceBuffer] : [layout, instanceBuffer, probeBuffer],
+    probeBuffer === undefined ? 'instances-no-probe' : 'instances-probe',
     () => {
       const result = runtime.device.createBindGroup({
         label: 'pbr-instances-bg',
-        layout: pipelineState.instancesBindGroupLayout,
+        layout,
         entries: [
           {
             binding: 0,
@@ -1141,6 +1295,17 @@ function resolveGeometryInstancesBindGroup(
               value: { buffer: instanceBuffer },
             },
           },
+          ...(probeBuffer === undefined
+            ? []
+            : [
+                {
+                  binding: 1,
+                  resource: {
+                    kind: 'buffer' as const,
+                    value: { buffer: probeBuffer, offset: 0, size: PROBE_BLEND_RECORD_BYTE_SIZE },
+                  },
+                },
+              ]),
         ],
       });
       if (!result.ok) throw result.error;

package/src/record/main-pass-material.ts

@@ -441,6 +441,13 @@ export interface StandardReflectionProbeMaterialProjection {
   readonly fallbackToSkylight: boolean;
 }
 
+/** Keeps the fallback output as a same-pass, linear-HDR material projection. */
+export function standardPbrFallbackDemand(
+  projection: StandardReflectionProbeMaterialProjection,
+): boolean {
+  return projection.probeIndex !== undefined || projection.fallbackToSkylight;
+}
+
 /** Projects the selected scene row into the Standard material lane. */
 export function projectReflectionProbeMaterialBinding(
   binding: StandardReflectionProbeBinding,
@@ -662,7 +669,7 @@ export function defaultViewForUserRegionField(
  * `renderableIndex` per RenderSystem lifetime via the `seenIndices` Set
  * (the same warn-once anchor pattern used for missing-texture sprites).
  *
- * @param transformWorld The entity's resolved Transform.world mat4 (16 floats column-major).
+ * @param transformWorld The entity's resolved GlobalTransform.world mat4 (16 floats column-major).
  * @param slices         The four anchor distances `[left, top, right, bottom]`
  *                       (sentinel `bottom < 0` for tile mode is consumed via abs()).
  * @param renderableIndex The entity index into the validated renderables list.

package/src/record/main-pass-sprite-draws.ts

@@ -25,7 +25,10 @@ import {
 } from '../ibl/skylight-bind-group';
 import type { InstanceBufferCacheEntry } from '../instance-buffer-cache';
 import { SPRITE_PREMULTIPLIED_ALPHA_BLEND } from '../materials';
-import { SPRITE_PASS_PER_INSTANCE_REGION_VARIANT_SET } from '../pbr-pipeline';
+import {
+  isStandardPbrMaterialShader,
+  SPRITE_PASS_PER_INSTANCE_REGION_VARIANT_SET,
+} from '../pbr-pipeline';
 import {
   buildBeginRenderPassDescriptor,
   standardTopologyVariantSet,
@@ -33,6 +36,7 @@ import {
 } from '../pipeline-spec';
 import type { MaterialSnapshot, SpriteInstancesSnapshot } from '../render-system-extract';
 import { worldEntityKey } from './frame-snapshot';
+import { resolveGeometryInstancesBindGroup, resolveProbeBlendBuffer } from './main-pass-geometry';
 import {
   BUILTIN_USER_REGION_TEXTURE_FIELDS,
   defaultViewForUserRegionField,
@@ -463,7 +467,7 @@ function recordSpriteTransparentPbrDraws(
   ) => BindGroup,
   meshGroup2: BindGroup | null,
 ): void {
-  const { runtime, pipelineState, frameState, bindGroupCounts, validatedOrdered } = c;
+  const { runtime, pipelineState, validatedOrdered } = c;
   const isHdrTarget =
     c.tonemapActive || transparentPassColorFormat(c, pipelineState) === 'rgba16float';
   let lastPbrSubPipelineHandle: typeof pipelineState.unlitPipeline = null;
@@ -497,48 +501,6 @@ function recordSpriteTransparentPbrDraws(
       spritePass.setIndexBuffer(entry.mesh.indexBuffer.handle, entry.mesh.indexFormat);
       lastPbrSubIndexBuffer = entry.mesh.indexBuffer;
     }
-    // Identity instance BG (instanceCount=1); reuse the per-entity cache.
-    const identityInstBg: BindGroup = getOrCreatePerEntity(
-      frameState.instancesBgPerEntity,
-      worldEntityKey(entry.source.worldId, entry.source.entityKey),
-      [pipelineState.identityInstanceBuffer],
-      'instances',
-      () => {
-        const result = runtime.device.createBindGroup({
-          label: 'pbr-transparent-sub-instances-bg',
-          layout: pipelineState.instancesBindGroupLayout,
-          entries: [
-            {
-              binding: 0,
-              resource: {
-                kind: 'buffer',
-                value: { buffer: pipelineState.identityInstanceBuffer },
-              },
-            },
-          ],
-        });
-        if (!result.ok) throw result.error;
-        return result.value;
-      },
-      bindGroupCounts,
-    );
-    spritePass.setBindGroup(3, identityInstBg);
-
-    const subVariantSet = standardTopologyVariantSet(
-      c.standardLighting,
-      runtime.device.caps.storageBuffer,
-      entry.mesh.layoutProjection.attributes.some((attribute) => attribute.key === 'color'),
-    );
-    const projectionVariantSetResult = variantSetFromVertexLayoutProjection(
-      entry.mesh.layoutProjection,
-      subVariantSet,
-    );
-    if (!projectionVariantSetResult.ok) {
-      runtime.errorRegistry.fire(projectionVariantSetResult.error);
-      continue;
-    }
-    const projectionVariantSet = projectionVariantSetResult.value;
-
     for (let smIdx = 0; smIdx < entry.mesh.submeshes.length; smIdx++) {
       const sm = entry.mesh.submeshes[smIdx];
       if (sm === undefined) continue;
@@ -549,6 +511,39 @@ function recordSpriteTransparentPbrDraws(
       if (submeshMaterial.transparent !== true) continue;
       const smShaderId = submeshMaterial.materialShaderId;
       if (smShaderId === undefined) continue;
+      const probeBlendAvailable =
+        runtime.device.caps.storageBuffer &&
+        entry.source.probeBlendRecord !== undefined &&
+        isStandardPbrMaterialShader(smShaderId);
+      const probeBinding = probeBlendAvailable
+        ? resolveProbeBlendBuffer(
+            c,
+            entry.source.probeBlendRecord,
+            worldEntityKey(entry.source.worldId, entry.source.entityKey),
+          )
+        : undefined;
+      const identityInstBg = resolveGeometryInstancesBindGroup(
+        c,
+        pipelineState.identityInstanceBuffer,
+        probeBinding?.buffer,
+      );
+      if (probeBinding === undefined) spritePass.setBindGroup(3, identityInstBg);
+      else spritePass.setBindGroup(3, identityInstBg, [probeBinding.offset]);
+      const subVariantSet = standardTopologyVariantSet(
+        c.standardLighting,
+        runtime.device.caps.storageBuffer,
+        entry.mesh.layoutProjection.attributes.some((attribute) => attribute.key === 'color'),
+        probeBlendAvailable,
+      );
+      const projectionVariantSetResult = variantSetFromVertexLayoutProjection(
+        entry.mesh.layoutProjection,
+        subVariantSet,
+      );
+      if (!projectionVariantSetResult.ok) {
+        runtime.errorRegistry.fire(projectionVariantSetResult.error);
+        continue;
+      }
+      const projectionVariantSet = projectionVariantSetResult.value;
       const subPipelineEntry =
         c.runtime.getMaterialShaderPipelineEntry?.(
           smShaderId,
@@ -837,21 +832,15 @@ function recordSpriteEntityDraws(
           );
           spriteInstanceCount = spriteInst.instanceCount;
           spriteInstanceBuffer = pipelineState.identityInstanceBuffer;
-          const spriteInstBgResult = runtime.device.createBindGroup({
-            label: 'sprite-pass-instances-bg',
-            layout: pipelineState.instancesBindGroupLayout,
-            entries: [
-              {
-                binding: 0,
-                resource: {
-                  kind: 'buffer',
-                  value: { buffer: spriteInstanceBuffer },
-                },
-              },
-            ],
-          });
-          if (!spriteInstBgResult.ok) throw spriteInstBgResult.error;
-          spritePass.setBindGroup(3, spriteInstBgResult.value as BindGroup);
+          // Sprite shaders do not declare the Standard PBR Probe ABI. A
+          // retained scene record must therefore not change their group(3)
+          // bind-group shape.
+          const spriteInstBg = resolveGeometryInstancesBindGroup(
+            c,
+            spriteInstanceBuffer,
+            undefined,
+          );
+          spritePass.setBindGroup(3, spriteInstBg);
           spritePass.drawIndexed(spriteEntry.mesh.indexCount, spriteInstanceCount, 0, 0, 0);
           continue;
         }
@@ -959,32 +948,10 @@ function recordSpriteEntityDraws(
         ? c.hdrpClusterBindGroup
         : meshBindGroup;
 
-    // M3 / w12: LDR sprite split pass per-entity instances BG cache.
-    // Same pattern as #7.
-    const spriteInstancesBg: BindGroup = getOrCreatePerEntity(
-      frameState.instancesBgPerEntity,
-      worldEntityKey(spriteEntry.source.worldId, spriteEntry.source.entityKey),
-      [spriteInstanceBuffer],
-      'instances',
-      () => {
-        const result = runtime.device.createBindGroup({
-          label: 'sprite-pass-instances-bg',
-          layout: pipelineState.instancesBindGroupLayout,
-          entries: [
-            {
-              binding: 0,
-              resource: {
-                kind: 'buffer',
-                value: { buffer: spriteInstanceBuffer },
-              },
-            },
-          ],
-        });
-        if (!result.ok) throw result.error;
-        return result.value;
-      },
-      bindGroupCounts,
-    );
+    // M3 / w12: LDR sprite split pass per-entity instances BG cache. Sprite
+    // shaders do not declare the Standard PBR Probe ABI, so retained probe
+    // records stay out of this bind-group path.
+    const spriteInstancesBg = resolveGeometryInstancesBindGroup(c, spriteInstanceBuffer, undefined);
 
     spritePass.setBindGroup(2, spriteGroup2 as BindGroup, [i * MESH_PER_ENTITY_STRIDE]);