@forgeax/engine-render 0.1.28 → 0.1.30

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

@@ -1,3 +1,4 @@
+import { transmissionBackdropAvailable } from '../assembly/device-feature-admission';
 import { getOrCreateIblCache } from '../ibl/IblPipelineCache';
 import type { _InternalRenderPipelineContext } from './render-context';
 // @forgeax/engine-runtime - RenderSystem record stage: main-pass-material.
@@ -23,6 +24,7 @@ import {
   DEFAULT_MSDF_TEXT_PARAM_SCHEMA,
   DEFAULT_SPRITE_PARAM_SCHEMA,
   DEFAULT_UNLIT_PARAM_SCHEMA,
+  STANDARD_PHYSICAL_TEXTURE_FIELDS,
   STANDARD_PIPELINE_PARAM_SCHEMA,
 } from '@forgeax/engine-shader';
 import type {
@@ -51,7 +53,7 @@ import {
   physicalTextureFields,
 } from '../pbr-pipeline';
 import { deriveTextureExtent } from '../render-data';
-import type { MaterialSnapshot } from '../render-system-extract';
+import type { MaterialSnapshot, SkylightSnapshot } from '../render-system-extract';
 import type { RenderTargetTextureSource } from '../targets/contracts';
 import {
   type RenderTargetMaterialSourceBinding,
@@ -548,6 +550,44 @@ function materialUboFloatView(payload: MaterialUboPayload): Float32Array {
     : new Float32Array(payload);
 }
 
+function materialUboDataView(payload: MaterialUboPayload): DataView {
+  if (payload instanceof Float32Array || payload instanceof Uint8Array) {
+    return new DataView(payload.buffer, payload.byteOffset, payload.byteLength);
+  }
+  return new DataView(payload);
+}
+
+/** Write one schema value with the scalar type's actual WGSL bit encoding. */
+function writeNumericParamValue(
+  view: DataView,
+  entry: { readonly offset: number; readonly size: number; readonly type: string },
+  value: number | readonly number[],
+): void {
+  const values = typeof value === 'number' ? [value] : value;
+  const width = entry.size / 4;
+  const writeCount = Math.min(values.length, width);
+  for (let index = 0; index < writeCount; index += 1) {
+    const component = values[index];
+    if (typeof component !== 'number') continue;
+    const byteOffset = entry.offset + index * 4;
+    switch (entry.type) {
+      case 'i32':
+        view.setInt32(byteOffset, component, true);
+        break;
+      case 'u32':
+        view.setUint32(byteOffset, component, true);
+        break;
+      case 'f32':
+      case 'vec2':
+      case 'vec3':
+      case 'vec4':
+      case 'color':
+        view.setFloat32(byteOffset, component, true);
+        break;
+    }
+  }
+}
+
 export function applyMaterialTextureUvScales(
   payload: MaterialUboPayload,
   material: MaterialSnapshot,
@@ -745,7 +785,7 @@ export function writePbrMaterialUboPayload(
     );
   }
   buf.fill(0);
-  const f32 = materialUboFloatView(buf);
+  const dataView = materialUboDataView(buf);
   const schema =
     material.materialParamSchema === undefined || material.materialParamSchema.length === 0
       ? STANDARD_PIPELINE_PARAM_SCHEMA
@@ -782,15 +822,10 @@ export function writePbrMaterialUboPayload(
     const value =
       snapshot?.[entry.name] ??
       fallback(entry.name, schema.find((item) => item.name === entry.name) ?? entry);
-    const offset = entry.offset / 4;
-    const width = entry.size / 4;
     if (typeof value === 'number') {
-      f32[offset] = value;
+      writeNumericParamValue(dataView, entry, value);
     } else if (Array.isArray(value)) {
-      for (let index = 0; index < Math.min(width, value.length); index += 1) {
-        const component = value[index];
-        if (typeof component === 'number') f32[offset + index] = component;
-      }
+      writeNumericParamValue(dataView, entry, value);
     }
   }
 }
@@ -839,28 +874,18 @@ export function applyParamSnapshotToUbo(
 ): void {
   if (paramSchema === undefined) return;
   if (paramSnapshot === undefined) return;
-  const f32 = materialUboFloatView(payload);
+  const dataView = materialUboDataView(payload);
   const { uboLayout } = derivedParamSchema(paramSchema);
   for (const entry of uboLayout.entries) {
     const value = paramSnapshot[entry.name];
     if (value === undefined) continue;
-    const f32Offset = entry.offset / 4;
-    const f32Width = entry.size / 4;
     if (typeof value === 'number') {
-      // Scalar f32 / i32 / u32 -- single-slot write. (i32 / u32 still arrive
-      // as a JS number; the GPU side reads the four bytes as the declared
-      // type, so an f32 write is the correct bit pattern when the caller
-      // already produced an integer value.)
-      if (f32Width >= 1) f32[f32Offset] = value;
+      writeNumericParamValue(dataView, entry, value);
       continue;
     }
     if (Array.isArray(value)) {
       const arr = value as readonly number[];
-      const writeCount = Math.min(arr.length, f32Width);
-      for (let i = 0; i < writeCount; i++) {
-        const v = arr[i];
-        if (typeof v === 'number') f32[f32Offset + i] = v;
-      }
+      writeNumericParamValue(dataView, entry, arr);
     }
     // string values (texture GUIDs) belong to texture bindings, not the
     // UBO; derive's uboLayout.entries already strips non-numeric schema
@@ -869,6 +894,31 @@ export function applyParamSnapshotToUbo(
   }
 }
 
+/**
+ * Seed a schema-driven UBO with the defaults declared by its numeric contract.
+ *
+ * Prepared graphics (VFX and other feature-owned materials) do not pass
+ * through the extracted `MaterialSnapshot` writer, so their payload starts as
+ * zeroed storage. Applying the schema defaults first keeps that path
+ * byte-compatible with the ordinary material writer while preserving the
+ * snapshot writer's intentional overlay semantics.
+ */
+export function applyParamSchemaDefaultsToUbo(
+  payload: MaterialUboPayload,
+  paramSchema: readonly ParamSchemaEntry[] | undefined,
+): void {
+  if (paramSchema === undefined) return;
+  const defaults: Record<string, number | readonly number[]> = {};
+  for (const entry of derivedParamSchema(paramSchema).uboLayout.entries) {
+    const schemaEntry = paramSchema.find((candidate) => candidate.name === entry.name);
+    const value = schemaEntry?.default;
+    if (typeof value === 'number' || Array.isArray(value)) {
+      defaults[entry.name] = value as number | readonly number[];
+    }
+  }
+  applyParamSnapshotToUbo(payload, paramSchema, defaults);
+}
+
 /**
  * feat-20260704 M3/w19: shared per-submesh material bind-group assembly, hoisted
  * from the `buildPerSubmeshMaterialBg` closure inside recordMainPass so both the
@@ -898,10 +948,12 @@ export interface PerSubmeshMaterialBgDeps {
   readonly resolveReflectionProbeResources?: (
     materialWorld: World,
     entityKey: number,
-  ) => SkylightBindGroupResources | undefined;
+  ) => { readonly resources: SkylightBindGroupResources; readonly probeIndex: number } | undefined;
   readonly materialBgShared: Map<string, WeakMap<object, unknown>>;
   /** Cross-frame final BG reuse keyed by the stable source material handle. */
   readonly materialBgAssemblyCache: Map<string, MaterialBgAssemblyCacheEntry>;
+  /** Producer-owned numeric scene rows consumed by scene-index PBR draws. */
+  readonly sceneMaterialBuffer?: Buffer;
   /** Active transmission backdrop; undefined/null means layout placeholder. */
   readonly transmissionBackdropView?: TextureView | null;
   readonly bindGroupCounts: BindGroupCounts;
@@ -956,6 +1008,7 @@ export function isMaterialBgAssemblyCacheHit(
   skylightResources: SkylightBindGroupResources,
   materialResourceEpoch: number,
   transmissionBackdropView?: TextureView | null,
+  sceneMaterialBuffer?: Buffer,
 ): cached is MaterialBgAssemblyCacheEntry {
   if (transmissionBackdropView != null) return false;
   return (
@@ -963,9 +1016,11 @@ export function isMaterialBgAssemblyCacheHit(
     cached.materialResourceEpoch === materialResourceEpoch &&
     cached.materialBgl === materialBgl &&
     cached.materialBuffer === materialBuffer &&
+    cached.sceneMaterialBuffer === sceneMaterialBuffer &&
     cached.skylightResources.irradianceView === skylightResources.irradianceView &&
     cached.skylightResources.irradianceSampler === skylightResources.irradianceSampler &&
     cached.skylightResources.prefilterView === skylightResources.prefilterView &&
+    cached.skylightResources.skylightPrefilterView === skylightResources.skylightPrefilterView &&
     cached.skylightResources.prefilterSampler === skylightResources.prefilterSampler &&
     cached.skylightResources.brdfLutView === skylightResources.brdfLutView &&
     cached.skylightResources.brdfLutSampler === skylightResources.brdfLutSampler &&
@@ -995,13 +1050,13 @@ export function buildPerSubmeshMaterialBg(
     bindGroupCounts,
     frameState,
   } = deps;
-  const effectiveSkylightResources =
-    resolveReflectionProbeResources?.(materialWorld, entityKey) ?? skylightResources;
+  const selectedProbe = resolveReflectionProbeResources?.(materialWorld, entityKey);
+  const effectiveSkylightResources = selectedProbe?.resources ?? skylightResources;
   const smMaterialHandle = submeshMaterial.materialHandle;
   const materialCacheKey =
     smMaterialHandle === undefined
       ? undefined
-      : `${materialWorld.identity}:${smMaterialHandle}:${materialShaderId ?? ''}`;
+      : `${materialWorld.identity}:${smMaterialHandle}:${materialShaderId ?? ''}:${selectedProbe?.probeIndex ?? 'sky'}`;
   const smHasVideoFields = (submeshMaterial.videoTextureFields?.size ?? 0) > 0;
   const smShaderId = materialShaderId;
   // The cooked shader schema owns the resource ABI. A material snapshot may
@@ -1028,6 +1083,9 @@ export function buildPerSubmeshMaterialBg(
       ? BUILTIN_USER_REGION_TEXTURE_FIELDS
       : userRegionTextureFieldOrder(smSchema).filter((field) => !physicalFields.includes(field));
   const hasActiveTransmissionBackdrop = transmissionBackdropView != null;
+  const sceneMaterialBuffer = runtime.device.caps.storageBuffer
+    ? (deps.sceneMaterialBuffer ?? pipelineState.meshStorageBuffer.buffer)
+    : undefined;
   const diagnosticsEnabled = materialDiagnosticsEnabled();
   if (smMaterialHandle !== undefined && !smHasVideoFields && !hasActiveTransmissionBackdrop) {
     const cached =
@@ -1041,6 +1099,7 @@ export function buildPerSubmeshMaterialBg(
         effectiveSkylightResources,
         store.materialResourceEpoch,
         transmissionBackdropView,
+        sceneMaterialBuffer,
       )
     ) {
       if (diagnosticsEnabled) {
@@ -1051,31 +1110,34 @@ export function buildPerSubmeshMaterialBg(
           [
             {
               binding: 1 + smUserRegionFields.length * 2,
-              resource: { kind: 'textureView', value: skylightResources.irradianceView },
+              resource: { kind: 'textureView', value: effectiveSkylightResources.irradianceView },
             },
             {
               binding: 2 + smUserRegionFields.length * 2,
-              resource: { kind: 'sampler', value: skylightResources.irradianceSampler },
+              resource: { kind: 'sampler', value: effectiveSkylightResources.irradianceSampler },
             },
             {
               binding: 3 + smUserRegionFields.length * 2,
-              resource: { kind: 'textureView', value: skylightResources.prefilterView },
+              resource: { kind: 'textureView', value: effectiveSkylightResources.prefilterView },
             },
             {
               binding: 4 + smUserRegionFields.length * 2,
-              resource: { kind: 'sampler', value: skylightResources.prefilterSampler },
+              resource: { kind: 'sampler', value: effectiveSkylightResources.prefilterSampler },
             },
             {
               binding: 5 + smUserRegionFields.length * 2,
-              resource: { kind: 'textureView', value: skylightResources.brdfLutView },
+              resource: { kind: 'textureView', value: effectiveSkylightResources.brdfLutView },
             },
             {
               binding: 6 + smUserRegionFields.length * 2,
-              resource: { kind: 'sampler', value: skylightResources.brdfLutSampler },
+              resource: { kind: 'sampler', value: effectiveSkylightResources.brdfLutSampler },
             },
             {
               binding: 7 + smUserRegionFields.length * 2,
-              resource: { kind: 'buffer', value: { buffer: skylightResources.intensityBuffer } },
+              resource: {
+                kind: 'buffer',
+                value: { buffer: effectiveSkylightResources.intensityBuffer },
+              },
             },
           ],
           1 + smUserRegionFields.length * 2,
@@ -1194,7 +1256,9 @@ export function buildPerSubmeshMaterialBg(
       }
     }
     physicalTextureInjections.push({
-      slot,
+      slot: STANDARD_PHYSICAL_TEXTURE_FIELDS.indexOf(
+        field as (typeof STANDARD_PHYSICAL_TEXTURE_FIELDS)[number],
+      ),
       sampler: smSamplerForField(field),
       view,
     });
@@ -1210,12 +1274,33 @@ export function buildPerSubmeshMaterialBg(
   const smMergedEntries = assembleMaterialWithSkylightEntries(
     smBaseEntries,
     effectiveSkylightResources,
-    {
-      sampler: transmissionSampler,
-      ...(transmissionBackdropView === undefined ? {} : { backdropView: transmissionBackdropView }),
-    } satisfies TransmissionBindGroupResources,
+    transmissionBackdropAvailable(runtime.device.limits.maxSampledTexturesPerShaderStage)
+      ? ({
+          sampler: transmissionSampler,
+          ...(transmissionBackdropView === undefined
+            ? {}
+            : { backdropView: transmissionBackdropView }),
+        } satisfies TransmissionBindGroupResources)
+      : null,
     physicalTextureInjections,
   );
+  // Storage-capable devices share one Standard material BGL with the
+  // scene-index GPU lane. Even direct draws need a complete entry for
+  // binding(46), although their shader does not read the scene table. Reuse
+  // the storage-backed mesh table as a neutral placeholder until a
+  // producer-owned GPU scene table is available; GPU-driven draws replace it
+  // with `deps.sceneMaterialBuffer`.
+  if (runtime.device.caps.storageBuffer) {
+    smMergedEntries.push({
+      binding: 46,
+      resource: {
+        kind: 'buffer' as const,
+        value: {
+          buffer: deps.sceneMaterialBuffer ?? pipelineState.meshStorageBuffer.buffer,
+        },
+      },
+    });
+  }
   const createBindGroup = (): BindGroup => {
     const result = runtime.device.createBindGroup({
       label: 'pbr-material-skylight-bg',
@@ -1291,6 +1376,7 @@ export function buildPerSubmeshMaterialBg(
         materialResourceEpoch: store.materialResourceEpoch,
         materialBgl: smMaterialBgl,
         materialBuffer: pipelineState.materialUniformBuffer.buffer,
+        ...(sceneMaterialBuffer === undefined ? {} : { sceneMaterialBuffer }),
         skylightResources: effectiveSkylightResources,
         bindGroup: smBindGroup,
       });
@@ -1302,8 +1388,21 @@ export function buildPerSubmeshMaterialBg(
 const ZERO_SKYLIGHT_PAYLOAD = new Float32Array([0, 0, 0, 0, 0, 0, 0, 1]);
 
 /** The same scene resources back material bindings in depth and color passes. */
-export function prepareMaterialSkylight(c: _InternalRenderPipelineContext) {
-  const { runtime, pipelineState, skylight, skylightCount } = c;
+/**
+ * Resolve the renderer-owned Skylight bundle for both ordinary geometry and
+ * prepared RenderFeature materials.  Feature preparation runs before the
+ * main pass is encoded, so it cannot rely on the geometry pass to initialize
+ * the intensity buffer or to select the current IBL views.  Keeping this
+ * small argument-based helper as the single resolver makes the two paths use
+ * identical resources while retaining the existing frame-local write.
+ */
+export function resolveMaterialSkylight(
+  runtime: Pick<RenderSystemRuntime, 'device' | 'deviceScope'>,
+  pipelineState: Pick<PipelineState, 'skylightFallback'>,
+  skylight: SkylightSnapshot | undefined,
+  skylightCount: number,
+  environmentIbl?: _InternalRenderPipelineContext['environmentIbl'],
+) {
   const skylightFallback = pipelineState.skylightFallback;
   if (skylightFallback === null) {
     throw new RhiError({
@@ -1356,6 +1455,13 @@ export function prepareMaterialSkylight(c: _InternalRenderPipelineContext) {
       };
     }
   }
+  if (environmentIbl !== undefined && skylight !== undefined && skylight.equirectHandle === 0) {
+    activeViews = {
+      irr: environmentIbl.irradiance,
+      pref: environmentIbl.prefilter,
+      brdf: activeViews?.brdf ?? skylightFallback.brdfLutView,
+    };
+  }
   const skylightResources =
     activeViews !== undefined
       ? {
@@ -1378,3 +1484,14 @@ export function prepareMaterialSkylight(c: _InternalRenderPipelineContext) {
         };
   return { skylightResources, activeViews };
 }
+
+/** The same scene resources back material bindings in depth and color passes. */
+export function prepareMaterialSkylight(c: _InternalRenderPipelineContext) {
+  return resolveMaterialSkylight(
+    c.runtime,
+    c.pipelineState,
+    c.skylight,
+    c.skylightCount,
+    c.environmentIbl,
+  );
+}

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

@@ -5,24 +5,18 @@
 import type { World } from '@forgeax/engine-ecs';
 import {
   type BindGroup,
-  type BindGroupEntry,
   type Buffer,
   type RenderPipeline,
   RhiError,
   type RhiRenderPassEncoder,
-  type TextureView,
 } from '@forgeax/engine-rhi';
-import type { Handle, MaterialRenderState } from '@forgeax/engine-types';
+import type { MaterialRenderState } from '@forgeax/engine-types';
 import { GpuBuffer } from '../gpu-resource';
 import {
   GPU_BUFFER_USAGE_COPY_DST,
   GPU_BUFFER_USAGE_STORAGE,
   GPU_BUFFER_USAGE_UNIFORM,
 } from '../gpu-usage';
-import {
-  assembleMaterialWithSkylightEntries,
-  type SkylightBindGroupResources,
-} 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';
@@ -35,67 +29,15 @@ import type {
 import { worldEntityKey } from './frame-snapshot';
 import { recordGeometryDraws, resolveGeometryInstancesBindGroup } from './main-pass-geometry';
 import {
-  BUILTIN_USER_REGION_TEXTURE_FIELDS,
-  defaultViewForUserRegionField,
-  residentTextureView,
-} from './main-pass-material';
-import {
-  extractEntryResourceHandle,
-  getOrCreatePerEntity,
   MAX_UNIFORM_INSTANCES,
   MESH_PER_ENTITY_STRIDE,
   packInstanceStorageBuffer,
 } from './mesh-ssbo';
 import type { _InternalRenderPipelineContext } from './render-context';
-import { MATERIAL_PER_ENTITY_STRIDE, STANDARD_PBR_UBO_SIZE } from './render-context';
+import { MATERIAL_PER_ENTITY_STRIDE } from './render-context';
 
 export type { SpriteInstancesSnapshot };
 
-/**
- * Build the sprite material's Standard user-region from the shared field-order
- * owner. The sprite shader uses the same Standard material bind-group layout;
- * keeping this projection derived from the shared list prevents IBL injection
- * from moving ahead of newly added material texture pairs.
- */
-export function buildSpritePassBaseMaterialEntries(
-  pipelineState: _InternalRenderPipelineContext['pipelineState'],
-  spriteTexView: TextureView,
-): BindGroupEntry[] {
-  const entries: BindGroupEntry[] = [
-    {
-      binding: 0,
-      resource: {
-        kind: 'buffer' as const,
-        value: {
-          buffer: pipelineState.materialUniformBuffer.buffer,
-          offset: 0,
-          size: STANDARD_PBR_UBO_SIZE,
-        },
-      },
-    },
-  ];
-  for (const [index, field] of BUILTIN_USER_REGION_TEXTURE_FIELDS.entries()) {
-    const view =
-      field === 'baseColorTexture'
-        ? spriteTexView
-        : defaultViewForUserRegionField(field, pipelineState);
-    entries.push(
-      {
-        binding: 1 + index * 2,
-        resource: {
-          kind: 'sampler' as const,
-          value: index === 0 ? pipelineState.nearestSampler : pipelineState.defaultSampler,
-        },
-      },
-      {
-        binding: 2 + index * 2,
-        resource: { kind: 'textureView' as const, value: view },
-      },
-    );
-  }
-  return entries;
-}
-
 /**
  * Build the interleaved sprite instance payload consumed by this record owner.
  * The extract stage validates the two packed arrays before they reach this
@@ -204,7 +146,6 @@ export function recordSpritePass(
     materialWorld: World,
     materialShaderId?: string,
   ) => BindGroup,
-  skylightResources: SkylightBindGroupResources,
   graphPass?: RhiRenderPassEncoder,
   selectedDispatch?: readonly DispatchEntry[],
 ): boolean {
@@ -405,7 +346,7 @@ export function recordSpritePass(
       c,
       spritePass,
       matchedIndices,
-      skylightResources,
+      resolveMaterialBindGroup,
       spritePH,
       spritePH_withRegion,
       spriteLitPH,
@@ -509,7 +450,12 @@ function recordSpriteEntityDraws(
   c: _InternalRenderPipelineContext,
   spritePass: RhiRenderPassEncoder,
   matchedIndices: Set<number> | null,
-  skylightResources: SkylightBindGroupResources,
+  resolveMaterialBindGroup: (
+    materialSlot: number,
+    material: MaterialSnapshot,
+    entityKey: number,
+    materialWorld: World,
+  ) => BindGroup,
   spritePH: RenderPipeline | null,
   spritePH_withRegion: RenderPipeline | null,
   spriteLitPH: RenderPipeline | null,
@@ -518,10 +464,8 @@ function recordSpriteEntityDraws(
   const {
     runtime,
     world,
-    store,
     pipelineState,
     frameState,
-    bindGroupCounts,
     validatedOrdered,
     meshBindGroup,
     foldDispatchPlan,
@@ -853,48 +797,13 @@ function recordSpriteEntityDraws(
 
     const materialSlot = materialSlotIndices[i]?.[0] ?? 0;
 
-    // Per-entity sprite material bind group: same standard PBR user-region
-    // layout as in the geometry pass sprite branch + Skylight merged entries
-    // the geometry pass sprite branch + Skylight merged entries (same
-    // skylightResources in scope from above). Texture view is resolved
-    // from the sprite material's baseColorTexture handle.
-    const spriteTexHandle = spriteEntry.source.material.baseColorTexture as
-      | Handle<'TextureAsset', 'shared'>
-      | undefined;
-    let spriteTexView = pipelineState.defaultWhiteTextureView;
-    if (spriteTexHandle !== undefined) {
-      const tv = residentTextureView(spriteEntry.world ?? world, store, runtime, spriteTexHandle);
-      if (tv !== undefined) spriteTexView = tv as never;
-    }
-    const spritePassBaseMaterialEntries = buildSpritePassBaseMaterialEntries(
-      pipelineState,
-      spriteTexView,
-    );
-    const spritePassMergedEntries = assembleMaterialWithSkylightEntries(
-      spritePassBaseMaterialEntries,
-      skylightResources,
-    );
-
-    // Sprite-pass material BG cache: keyed on shader id (shared across all
-    // sprite entities) so entities using the same atlas texture share one
-    // BindGroup instead of creating one per entity (O5 fix — inner WeakMap
-    // chain naturally deduplicates by GPU resource object identity, so two
-    // entities with different atlases still get distinct BGs).
-    const spritePassBg: BindGroup = getOrCreatePerEntity(
-      frameState.materialBgShared,
-      'forgeax::sprite',
-      spritePassMergedEntries.map((e) => extractEntryResourceHandle(e)),
-      'sprite-pass-material',
-      () => {
-        const result = runtime.device.createBindGroup({
-          label: 'sprite-pass-material-bg',
-          layout: pipelineState.materialBindGroupLayout,
-          entries: spritePassMergedEntries,
-        });
-        if (!result.ok) throw result.error;
-        return result.value;
-      },
-      bindGroupCounts,
+    // The same material owner serves HDR and linear-LDR draws. Do not
+    // replace authored samplers, texture sources or cooked layouts here.
+    const spritePassBg = resolveMaterialBindGroup(
+      materialSlot,
+      spriteEntry.source.material,
+      spriteEntry.source.entityKey,
+      spriteEntry.world ?? world,
     );
 
     spritePass.setBindGroup(1, spritePassBg, [materialSlot * MATERIAL_PER_ENTITY_STRIDE]);