@forgeax/engine-render 0.1.27 → 0.1.29

package/src/record/mesh-ssbo.ts

@@ -1,5 +1,6 @@
 import { mat3 } from '@forgeax/engine-math';
 import { type BindGroup, type Buffer, RhiError, type RhiQueue } from '@forgeax/engine-rhi';
+import { ok, type Result } from '@forgeax/engine-types';
 import type { DispatchEntry } from '../render-system-extract';
 import {
   TRANSPARENT_SORT_MODE_LAYER_Y,
@@ -127,6 +128,42 @@ export function getOrCreateFromChain(
   return bg;
 }
 
+/**
+ * Result-preserving sibling of `getOrCreateFromChain`.  RHI creation can fail
+ * transiently during recovery or capability probing; a failed attempt must
+ * not enter the cache and must remain a structured Result for the caller.
+ */
+export function getOrCreateFromChainResult<E>(
+  root: WeakMap<object, unknown>,
+  handles: readonly object[],
+  variant: string,
+  factory: () => Result<BindGroup, E>,
+  counts: { createBindGroup: number; keys: string[] },
+): Result<BindGroup, E> {
+  let node = root;
+  for (const h of handles) {
+    let next = node.get(h) as WeakMap<object, unknown> | undefined;
+    if (next === undefined) {
+      next = new WeakMap();
+      node.set(h, next);
+    }
+    node = next;
+  }
+  let leaf = node.get(BIND_GROUP_CHAIN_LEAF_KEY) as Map<string, BindGroup> | undefined;
+  if (leaf === undefined) {
+    leaf = new Map();
+    node.set(BIND_GROUP_CHAIN_LEAF_KEY, leaf);
+  }
+  const hit = leaf.get(variant);
+  if (hit !== undefined) return ok(hit);
+  const created = factory();
+  if (!created.ok) return created;
+  counts.createBindGroup += 1;
+  counts.keys.push(variant);
+  leaf.set(variant, created.value);
+  return created;
+}
+
 /**
  * Read a cached bind group using the same variable-depth chain contract as
  * `getOrCreateFromChain`. Readers must traverse the terminal marker instead
@@ -376,6 +413,7 @@ export function uploadMeshSsboBatch(
   meshStorageBuffer: { readonly buffer: Buffer },
   validatedOrdered: readonly ValidatedRenderable[],
   foldDispatchPlan: FoldDispatchPlan | null,
+  startSlot = 0,
 ): void {
   const slotCount = validatedOrdered.length;
   const neededBytes = slotCount * MESH_PER_ENTITY_STRIDE;
@@ -450,7 +488,7 @@ export function uploadMeshSsboBatch(
   if (neededBytes > 0) {
     const meshUpload = queue.writeBuffer(
       meshStorageBuffer.buffer,
-      0,
+      startSlot * MESH_PER_ENTITY_STRIDE,
       _meshSsboScratch,
       0,
       neededBytes,
@@ -511,17 +549,26 @@ export interface FoldBucket {
  * minimal shape. The gate read inside the helper uses `=== true` /
  * `!== true` so both `false` and `undefined` enter the singleton branch.
  *
- * feat-20260625-refactor-sprite-as-transparent-mesh R2 fix-up: gate
- * migrated from `shadingModel === 'sprite'` (the union member was
- * removed in M3 / w15) to `transparent === true` (the new SSOT for
- * "routes through the LDR split sub-pass" — same predicate the
- * `splitLdrSprite` filter at render-system-record.ts:4826/5612 uses).
+ * feat-20260625-refactor-sprite-as-transparent-mesh R2 fix-up: the
+ * transparent flag identifies the LDR split sub-pass, while the shader id
+ * identifies the sprite owner that is safe to fold. Standard PBR Alpha Blend
+ * remains singleton so its geometry pass keeps one projection row per draw.
  */
 export interface FoldRenderableLike {
   readonly transform: { readonly world: Float32Array };
   readonly material: { readonly transparent?: boolean | undefined };
 }
 
+const FOLDABLE_TRANSPARENT_SHADER_IDS = new Set(['forgeax::sprite', 'forgeax::sprite-lit']);
+
+function isFoldEligible(entry: DispatchEntry, renderables: readonly FoldRenderableLike[]): boolean {
+  return (
+    renderables[entry.renderableIndex]?.material.transparent === true &&
+    entry.materialShaderId !== undefined &&
+    FOLDABLE_TRANSPARENT_SHADER_IDS.has(entry.materialShaderId)
+  );
+}
+
 /**
  * Linear-scan fold operator (plan-strategy D-1).
  *
@@ -588,7 +635,7 @@ export function foldDispatchBuckets(
   // identity and renders the 3D geometry at the origin — collapsing the
   // frame to black (hello-room CI regression).
   //
-  // Concept-count fix: encode "fold is transparent-sub-pass-only" at the
+  // Concept-count fix: encode "fold is transparent-sprite-sub-pass-only" at the
   // head selection point — the gate is the single bucket-key invariant
   // that makes both dispatch sites correct without coupling identity-
   // overwrite logic to a separate check (avoiding the D-9 shared-exit
@@ -603,10 +650,9 @@ export function foldDispatchBuckets(
   //
   // feat-20260625 R2 fix-up: pre-feat the gate was `shadingModel ===
   // 'sprite'`; M3 / w15 narrowed the shadingModel union to
-  // `'unlit' | undefined` (the `'sprite'` discriminator was the design
-  // ablation target), so the gate now reads `material.transparent` —
-  // the new SSOT for "routes through the LDR split sub-pass" mirrored
-  // on `computeSplitLdrSprite` + the `splitLdrSprite` skip filter.
+  // `'unlit' | undefined`. The current gate retains the transparent SSOT
+  // and adds the explicit sprite shader identity so Standard PBR Alpha Blend
+  // cannot enter this fold path.
   const buckets: FoldBucket[] = [];
   let runStart = 0;
   while (runStart < orderedEntries.length) {
@@ -621,8 +667,7 @@ export function foldDispatchBuckets(
     // carrier (extract stage derives it from the first pass's
     // `renderState.blend !== undefined`, post-feat-20260626-collapse;
     // see `MaterialSnapshot.transparent`).
-    const headTransparent = renderables[head.renderableIndex]?.material.transparent;
-    if (headTransparent !== true) {
+    if (!isFoldEligible(head, renderables)) {
       buckets.push(makeSingletonBucket(head, renderables, mode));
       runStart += 1;
       continue;
@@ -638,8 +683,7 @@ export function foldDispatchBuckets(
       // Same materialHandle implies same transparent flag in production
       // (material asset identity), but the check costs O(1) per cand and
       // makes the bucket invariant locally readable.
-      const candTransparent = renderables[cand.renderableIndex]?.material.transparent;
-      if (candTransparent !== true) break;
+      if (!isFoldEligible(cand, renderables)) break;
       const candSortKey = readSortKey(mode, cand.renderableIndex, renderables);
       if (candSortKey !== headSortKey) break;
       runEnd += 1;

package/src/record/prepared-material-bindings.ts

@@ -0,0 +1,234 @@
+import { resolveAssetHandle } from '@forgeax/engine-assets-runtime';
+import type { World } from '@forgeax/engine-ecs';
+import type { BindGroupEntry, BindGroupLayout, Buffer } from '@forgeax/engine-rhi';
+import { err, ok } from '@forgeax/engine-rhi';
+import {
+  derive,
+  type Handle,
+  type MaterialAsset,
+  type MaterialTextureValue,
+  materialValuesToLinearRuntime,
+  type SamplerAsset,
+} from '@forgeax/engine-types';
+import { GPU_BUFFER_USAGE_COPY_DST, GPU_BUFFER_USAGE_UNIFORM } from '../gpu-usage';
+import type { SkylightBindGroupResources } from '../ibl/skylight-bind-group';
+import { assembleMaterialWithSkylightEntries } from '../ibl/skylight-bind-group';
+import {
+  applyParamSchemaDefaultsToUbo,
+  applyParamSnapshotToUbo,
+  defaultViewForUserRegionField,
+  residentTextureView,
+} from './main-pass-material';
+import type { RenderSystemInternals } from './render-context';
+
+export type PreparedResolverCaches = {
+  readonly preparedPipelineIds: WeakMap<object, string>;
+  readonly preparedMaterialPipelineShaders: WeakMap<object, string>;
+  readonly preparedGroup0Pipelines: WeakSet<object>;
+  readonly preparedViewOnlyPipelines: WeakSet<object>;
+  readonly preparedRenderMaterialPipelines: WeakSet<object>;
+  readonly preparedAssetHandles: WeakMap<World, Map<string, number>>;
+};
+
+export function createPreparedResolverCaches(): PreparedResolverCaches {
+  return {
+    preparedPipelineIds: new WeakMap(),
+    preparedMaterialPipelineShaders: new WeakMap(),
+    preparedGroup0Pipelines: new WeakSet(),
+    preparedViewOnlyPipelines: new WeakSet(),
+    preparedRenderMaterialPipelines: new WeakSet(),
+    preparedAssetHandles: new WeakMap(),
+  };
+}
+
+function preparedHandle<Brand extends string>(
+  runtime: RenderSystemInternals,
+  caches: PreparedResolverCaches,
+  world: World,
+  guid: string,
+  brand: Brand,
+): Handle<Brand, 'shared'> | undefined {
+  let handles = caches.preparedAssetHandles.get(world);
+  if (handles === undefined) {
+    handles = new Map();
+    caches.preparedAssetHandles.set(world, handles);
+  }
+  const key = `${brand}:${guid.toLowerCase()}`;
+  const cached = handles.get(key);
+  if (cached !== undefined) return cached as Handle<Brand, 'shared'>;
+  const asset = runtime.assets.lookup(guid);
+  if (asset === undefined) return undefined;
+  const handle = world.allocSharedRef(brand, asset);
+  handles.set(key, handle as number);
+  return handle;
+}
+
+export function preparedMaterialBindings(
+  runtime: RenderSystemInternals,
+  caches: PreparedResolverCaches,
+  worlds: readonly World[],
+  materialShaderId: string,
+  worldIndex: number,
+  materialGuid: string,
+  layout: BindGroupLayout,
+  skylightResources?: SkylightBindGroupResources,
+) {
+  const world = worlds[worldIndex];
+  const material = runtime.assets.lookup(materialGuid) as MaterialAsset | undefined;
+  const pipelineState = runtime.getPipelineState();
+  if (world === undefined || material?.kind !== 'material' || pipelineState === null) {
+    return err(new Error('prepared material asset is unavailable'));
+  }
+  const schema = runtime.getParamSchema?.(materialShaderId) ?? [];
+  // Feature materials share the ordinary linear parameter domain and semantic texture defaults.
+  const values = materialValuesToLinearRuntime(
+    material.values,
+    [...schema, ...(material.parameters ?? [])],
+    material.colorSpace,
+  );
+  const derived = derive(schema);
+  const fields = [...derived.textureFieldNames];
+  let buffer: Buffer | undefined;
+  let payloadByteLength = 0;
+  if (derived.uboLayout.totalBytes > 0) {
+    const payload = new Uint8Array(Math.max(16, derived.uboLayout.totalBytes));
+    applyParamSchemaDefaultsToUbo(payload, schema);
+    applyParamSnapshotToUbo(
+      payload,
+      schema,
+      values as Readonly<Record<string, number | readonly number[]>>,
+    );
+    const created = runtime.device.createBuffer({
+      label: `prepared-material:${materialGuid}`,
+      size: payload.byteLength,
+      usage: GPU_BUFFER_USAGE_UNIFORM | GPU_BUFFER_USAGE_COPY_DST,
+    });
+    if (!created.ok) return created;
+    buffer = created.value;
+    payloadByteLength = payload.byteLength;
+    const written = runtime.device.queue.writeBuffer(buffer, 0, payload);
+    if (!written.ok) {
+      runtime.device.destroyBuffer(buffer);
+      return written;
+    }
+  }
+  const textureResources: Array<{
+    sampler: import('@forgeax/engine-rhi').Sampler;
+    view: import('@forgeax/engine-rhi').TextureView;
+  }> = [];
+  for (const field of fields) {
+    if (field === undefined) continue;
+    const value = values[field];
+    const textureValue =
+      typeof value === 'object' && value !== null && 'texture' in value
+        ? (value as MaterialTextureValue)
+        : undefined;
+    let sampler = pipelineState.defaultSampler;
+    if (textureValue?.sampler !== undefined) {
+      const handle = preparedHandle(
+        runtime,
+        caches,
+        world,
+        String(textureValue.sampler),
+        'SamplerAsset',
+      );
+      if (handle !== undefined) {
+        const asset = resolveAssetHandle<SamplerAsset>(world, handle);
+        if (asset.ok) {
+          const resident = runtime.gpuStore.ensureSamplerResident(handle, asset.value, world);
+          if (resident.ok) sampler = resident.value;
+        }
+      }
+    }
+    let view = defaultViewForUserRegionField(field, pipelineState, schema);
+    if (textureValue !== undefined) {
+      const handle = preparedHandle(
+        runtime,
+        caches,
+        world,
+        String(textureValue.texture),
+        'TextureAsset',
+      );
+      if (handle !== undefined) {
+        view = residentTextureView(world, runtime.gpuStore, runtime, handle) ?? view;
+      }
+    }
+    textureResources.push({ sampler, view });
+  }
+  const entries: BindGroupEntry[] = [];
+  let textureIndex = 0;
+  for (let index = 0; index < derived.bglEntries.length; index += 1) {
+    const expected = derived.bglEntries[index];
+    if (expected?.buffer?.type === 'uniform' && buffer !== undefined) {
+      entries.push({
+        binding: expected.binding,
+        resource: { kind: 'buffer', value: { buffer, size: payloadByteLength } },
+      });
+      continue;
+    }
+    const textureResource = textureResources[textureIndex];
+    if (
+      expected?.sampler?.type === 'filtering' &&
+      derived.bglEntries[index + 1]?.texture !== undefined &&
+      textureResource !== undefined
+    ) {
+      entries.push({
+        binding: expected.binding,
+        resource: { kind: 'sampler', value: textureResource.sampler },
+      });
+      continue;
+    }
+    if (expected?.texture !== undefined && textureResource !== undefined) {
+      entries.push({
+        binding: expected.binding,
+        resource: { kind: 'textureView', value: textureResource.view },
+      });
+      textureIndex += 1;
+      continue;
+    }
+    if (buffer !== undefined) runtime.device.destroyBuffer(buffer);
+    return err(new Error('prepared material schema contains unsupported binding kinds'));
+  }
+  const fallback = pipelineState.skylightFallback;
+  if (fallback === null) {
+    if (buffer !== undefined) runtime.device.destroyBuffer(buffer);
+    return err(new Error('prepared material skylight fallback is unavailable'));
+  }
+  const completeEntries = assembleMaterialWithSkylightEntries(
+    entries,
+    skylightResources ?? {
+      irradianceView: fallback.irradianceView,
+      irradianceSampler: fallback.sampler,
+      prefilterView: fallback.prefilterView,
+      prefilterSampler: fallback.sampler,
+      brdfLutView: fallback.brdfLutView,
+      brdfLutSampler: fallback.sampler,
+      intensityBuffer: fallback.intensityBuffer,
+    },
+  );
+  // Per-shader PBR layouts reserve the scene-material SSBO at binding 46 on
+  // storage-capable devices. Prepared feature materials use this same layout,
+  // so they must provide the neutral producer-owned table even when their
+  // authored shader does not read it. Omitting the entry makes Dawn reject the
+  // bind group before submission.
+  if (runtime.device.caps.storageBuffer) {
+    completeEntries.push({
+      binding: 46,
+      resource: {
+        kind: 'buffer',
+        value: { buffer: pipelineState.meshStorageBuffer.buffer },
+      },
+    });
+  }
+  const group = runtime.device.createBindGroup({ layout, entries: completeEntries });
+  if (!group.ok) {
+    if (buffer !== undefined) runtime.device.destroyBuffer(buffer);
+    return group;
+  }
+  if (buffer === undefined) return group;
+  return ok({
+    handle: group.value,
+    dynamicOffsets: [0],
+    release: () => runtime.device.destroyBuffer(buffer),
+  });
+}

package/src/record/recovery-pipeline.ts

@@ -1,13 +1,9 @@
 import {
+  DEFAULT_VERTEX_ATTRIBUTE_MAP,
   deriveVertexLayoutProjection,
   type VertexLayoutProjection,
 } from '@forgeax/engine-geometry';
-import type {
-  MaterialRenderState,
-  PassKind,
-  PrimitiveTopology,
-  VertexAttributeMap,
-} from '@forgeax/engine-types';
+import type { MaterialRenderState, PassKind, PrimitiveTopology } from '@forgeax/engine-types';
 import { SPRITE_PREMULTIPLIED_ALPHA_BLEND } from '../materials';
 import {
   isStandardPbrMaterialShader,
@@ -35,60 +31,13 @@ import { geometryRenderStateForTopology } from './main-pass-material';
 import type {
   MaterialShaderPipelineEntry,
   PipelineState,
-  RecoveryColdWorkGuard,
   RenderSystemInternals,
 } from './render-context';
 
 export interface RecoveryPipelineReadiness {
   readonly pipelineSpecs: readonly PipelineSpec[];
   /** Re-resolve every candidate request and assert a stable cache hit. */
-  readonly assertFirstRecoveryFrame: () => void;
-}
-
-/**
- * Create the one-shot assertion used by the first frame after publication.
- * Recording a miss is a failure at the owner seam; the draw path never gets a
- * chance to submit a frame that hides a shader/pipeline or static-residency
- * cold build behind an apparently successful receipt.
- */
-export function createRecoveryColdWorkGuard(): RecoveryColdWorkGuard {
-  let armed = false;
-  let finished = false;
-  let pipelineColdWork = 0;
-  let uploadColdWork = 0;
-  const fail = (kind: 'pipeline' | 'upload'): never => {
-    if (kind === 'pipeline') pipelineColdWork += 1;
-    else uploadColdWork += 1;
-    throw new Error(
-      `recovery first frame performed cold ${kind} work ` +
-        `(pipeline=${pipelineColdWork}, upload=${uploadColdWork})`,
-    );
-  };
-  return {
-    arm(): void {
-      armed = true;
-      finished = false;
-      pipelineColdWork = 0;
-      uploadColdWork = 0;
-    },
-    notePipelineColdWork(): void {
-      if (armed && !finished) fail('pipeline');
-    },
-    noteUploadColdWork(): void {
-      if (armed && !finished) fail('upload');
-    },
-    finish(): void {
-      if (!armed || finished) return;
-      finished = true;
-      armed = false;
-      if (pipelineColdWork !== 0 || uploadColdWork !== 0) {
-        throw new Error(
-          `recovery first frame cold-work assertion failed ` +
-            `(pipeline=${pipelineColdWork}, upload=${uploadColdWork})`,
-        );
-      }
-    },
-  };
+  readonly assertPreparedCache: () => void;
 }
 
 interface RecoveryPipelineRequest {
@@ -96,13 +45,6 @@ interface RecoveryPipelineRequest {
   readonly resolve: () => MaterialShaderPipelineEntry | null;
 }
 
-const DEFAULT_VERTEX_ATTRIBUTES: VertexAttributeMap = {
-  position: new Float32Array(0),
-  normal: new Float32Array(0),
-  uv: new Float32Array(0),
-  tangent: new Float32Array(0),
-};
-
 function optionalRenderState(
   state: MaterialRenderState | undefined,
 ): { readonly renderState: MaterialRenderState } | Record<string, never> {
@@ -174,6 +116,9 @@ function addRequest(input: {
   readonly additionalColorFormats?: readonly GPUTextureFormat[];
   readonly depthFormatOverride?: GPUTextureFormat | null;
   readonly vertexLayoutProjection?: VertexLayoutProjection;
+  readonly vertexEntry?: string;
+  readonly fragmentEntry?: string;
+  readonly layoutKindOverride?: 'pbr' | 'pbr-skin';
   readonly preserveUndefinedVariant?: boolean;
   readonly variantAlreadyResolved?: boolean;
 }): void {
@@ -204,6 +149,8 @@ function addRequest(input: {
       id: input.materialShaderId,
       passKind,
       variantSet: resolvedVariantSet,
+      ...(input.vertexEntry === undefined ? {} : { vertexEntry: input.vertexEntry }),
+      ...(input.fragmentEntry === undefined ? {} : { fragmentEntry: input.fragmentEntry }),
     }),
     attachments: Object.freeze({
       colorFormats: Object.freeze([...colorFormats]),
@@ -213,7 +160,7 @@ function addRequest(input: {
     geometry: Object.freeze({
       topology: input.topology ?? 'triangle-list',
       stripIndexFormat: input.indexFormat,
-      vertexLayout: DEFAULT_VERTEX_ATTRIBUTES,
+      vertexLayout: DEFAULT_VERTEX_ATTRIBUTE_MAP,
       ...(projection === undefined ? {} : { vertexLayoutProjection: projection }),
       ...(shaderUvSetCount !== undefined && shaderUvSetCount > 1
         ? {
@@ -243,8 +190,11 @@ function addRequest(input: {
       undefined,
       projection,
       undefined,
+      input.layoutKindOverride,
       undefined,
       input.additionalColorFormats,
+      input.vertexEntry,
+      input.fragmentEntry,
     ) ?? null;
   input.requests.push({ spec, resolve });
 }
@@ -261,12 +211,7 @@ function addStandardMaterialRequests(input: {
   readonly colorFormatOverride?: GPUTextureFormat;
   readonly reflectionFallbackAvailable: boolean;
 }): void {
-  const pointsLinesProjection = deriveVertexLayoutProjection({
-    position: new Float32Array(0),
-    normal: new Float32Array(0),
-    uv: new Float32Array(0),
-    tangent: new Float32Array(0),
-  });
+  const pointsLinesProjection = deriveVertexLayoutProjection(DEFAULT_VERTEX_ATTRIBUTE_MAP);
   for (const entry of input.validated) {
     if (entry.source.pointsLines !== undefined) {
       const pointsLinesMaterial = entry.source.material;
@@ -299,7 +244,7 @@ function addStandardMaterialRequests(input: {
     // The probe record is an object-level ABI extension of the built-in
     // Standard PBR family. Recovery must request the same variant that the
     // live record path will select, otherwise the first post-recovery draw
-    // discovers a cold PSO and the cold-work guard correctly rejects it.
+    // discovers avoidable cold PSO work.
     const probeBlendRecordAvailable =
       input.internals.device.caps.storageBuffer && entry.source.probeBlendRecord !== undefined;
     const standardPbrCapabilityVariantSet = standardTopologyVariantSet(
@@ -376,9 +321,7 @@ function addStandardMaterialRequests(input: {
           : undefined
         : entry.variantSet === undefined
           ? materialCapabilityVariantSet
-          : materialCapabilityVariantSet === ''
-            ? entry.variantSet
-            : `${materialCapabilityVariantSet}+${entry.variantSet}`;
+          : `${materialCapabilityVariantSet}+${entry.variantSet}`;
       const reflectionFallbackVariant =
         input.reflectionFallbackAvailable && materialShaderId === 'forgeax::default-standard-pbr'
           ? (() => {
@@ -527,80 +470,60 @@ function addShadowRequests(input: {
   readonly validated: readonly ValidatedRenderable[];
   readonly dispatch: readonly DispatchEntry[];
 }): void {
-  addRequest({
-    requests: input.requests,
-    requestKeys: input.requestKeys,
-    internals: input.internals,
-    pipelineState: input.pipelineState,
-    materialShaderId: SHADOW_CASTER_SHADER_ID,
-    isHdrTarget: false,
-    topology: 'triangle-list',
-    variantSet: shadowCasterVariantSet(input.internals.device.caps.storageBuffer, false),
-    passKind: 'shadow-caster',
-    sampleCount: 1,
-    variantAlreadyResolved: true,
-  });
-  const customByRenderable = new Map<
-    number,
-    Map<number, { id: string; state: MaterialRenderState | undefined }>
-  >();
-  for (const dispatch of input.dispatch) {
-    if (dispatch.tags.LightMode !== 'ShadowCaster' || dispatch.materialShaderId === undefined)
+  // Recovery has no record context, so it cannot use the context-backed
+  // shadowShaderMap. Group the producer dispatch facts directly and warm every
+  // authored ShadowCaster pass for the matching renderable/material pair.
+  const dispatches = new Map<number, Map<number, DispatchEntry[]>>();
+  for (const candidate of input.dispatch) {
+    if (candidate.tags.LightMode !== 'ShadowCaster' || candidate.materialShaderId === undefined)
       continue;
-    let materials = customByRenderable.get(dispatch.renderableIndex);
-    if (materials === undefined) {
-      materials = new Map();
-      customByRenderable.set(dispatch.renderableIndex, materials);
+    const byMaterial = dispatches.get(candidate.renderableIndex);
+    if (byMaterial === undefined) {
+      dispatches.set(candidate.renderableIndex, new Map([[candidate.materialHandle, [candidate]]]));
+    } else {
+      const entries = byMaterial.get(candidate.materialHandle);
+      if (entries === undefined) byMaterial.set(candidate.materialHandle, [candidate]);
+      else entries.push(candidate);
     }
-    materials.set(dispatch.materialHandle, {
-      id: dispatch.materialShaderId,
-      state: dispatch.renderState,
-    });
   }
   for (const entry of input.validated) {
-    const triangles = entry.mesh.submeshes.filter(
-      (submesh) => submesh.topology === 'triangle-list' || submesh.topology === 'triangle-strip',
-    );
-    if (triangles.length === 0) continue;
-    if (entry.source.skin !== undefined) {
-      addRequest({
-        requests: input.requests,
-        requestKeys: input.requestKeys,
-        internals: input.internals,
-        pipelineState: input.pipelineState,
-        materialShaderId: SHADOW_CASTER_SHADER_ID,
-        isHdrTarget: false,
-        topology: entry.mesh.submeshes[0]?.topology ?? 'triangle-list',
-        indexFormat: entry.mesh.indexFormat,
-        variantSet: shadowCasterVariantSet(input.internals.device.caps.storageBuffer, true),
-        passKind: 'shadow-caster',
-        sampleCount: 1,
-        vertexLayoutProjection: entry.mesh.layoutProjection,
-        variantAlreadyResolved: true,
-      });
-    }
-    for (const submesh of triangles) {
+    for (const submesh of entry.mesh.submeshes) {
+      if (submesh.topology !== 'triangle-list' && submesh.topology !== 'triangle-strip') continue;
       const material = entry.source.materials[submesh.materialSlot] ?? entry.source.material;
-      const custom = customByRenderable
-        .get(entry.renderableIndex)
-        ?.get(material.materialHandle ?? 0);
-      if (
-        entry.source.skin === undefined &&
-        custom !== undefined &&
-        (custom.id !== 'forgeax::default-shadow-caster' || custom.state !== undefined)
-      ) {
+      const shadowDispatches =
+        dispatches.get(entry.renderableIndex)?.get(material.materialHandle ?? 0) ?? [];
+      for (const dispatch of shadowDispatches.length === 0 ? [undefined] : shadowDispatches) {
+        const materialShaderId =
+          dispatch?.materialShaderId === 'forgeax::default-standard-pbr' ||
+          dispatch?.materialShaderId === undefined
+            ? SHADOW_CASTER_SHADER_ID
+            : dispatch.materialShaderId;
         addRequest({
           requests: input.requests,
           requestKeys: input.requestKeys,
           internals: input.internals,
           pipelineState: input.pipelineState,
-          materialShaderId: custom.id,
+          materialShaderId,
           isHdrTarget: false,
-          ...optionalRenderState(custom.state),
-          topology: 'triangle-list',
+          ...optionalRenderState(dispatch?.renderState),
+          topology: submesh.topology,
+          indexFormat: entry.mesh.indexFormat,
+          ...optionalVariant(
+            materialShaderId === SHADOW_CASTER_SHADER_ID
+              ? shadowCasterVariantSet(
+                  input.internals.device.caps.storageBuffer,
+                  entry.source.skin !== undefined,
+                )
+              : undefined,
+          ),
           passKind: 'shadow-caster',
           sampleCount: 1,
-          preserveUndefinedVariant: true,
+          vertexLayoutProjection: entry.mesh.layoutProjection,
+          layoutKindOverride: entry.source.skin === undefined ? 'pbr' : 'pbr-skin',
+          ...(dispatch?.vertexEntry === undefined ? {} : { vertexEntry: dispatch.vertexEntry }),
+          ...(dispatch?.fragmentEntry === undefined
+            ? {}
+            : { fragmentEntry: dispatch.fragmentEntry }),
           variantAlreadyResolved: true,
         });
       }
@@ -671,7 +594,7 @@ export function prepareRecoveryPipelineReadiness(input: {
       dispatch: input.dispatch,
     });
   }
-  const assertFirstRecoveryFrame = (): void => {
+  const assertPreparedCache = (): void => {
     for (const request of requests) {
       const first = request.resolve();
       const second = request.resolve();
@@ -687,9 +610,9 @@ export function prepareRecoveryPipelineReadiness(input: {
       }
     }
   };
-  assertFirstRecoveryFrame();
+  assertPreparedCache();
   return {
     pipelineSpecs: Object.freeze(requests.map((request) => request.spec)),
-    assertFirstRecoveryFrame,
+    assertPreparedCache,
   };
 }