@forgeax/engine-render 0.1.21 → 0.1.24

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,
@@ -722,12 +717,10 @@ function recordSpriteEntityDraws(
       spritePass.setVertexBuffer(0, spriteEntry.mesh.vertexBuffer.handle);
       lastSpriteVertexBuffer = spriteEntry.mesh.vertexBuffer;
     }
-    if (
-      spriteEntry.mesh.indexBuffer !== null &&
-      spriteEntry.mesh.indexBuffer !== lastSpriteIndexBuffer
-    ) {
-      spritePass.setIndexBuffer(spriteEntry.mesh.indexBuffer.handle, spriteEntry.mesh.indexFormat);
-      lastSpriteIndexBuffer = spriteEntry.mesh.indexBuffer;
+    const indexBuffer = spriteEntry.mesh.indexBuffer;
+    if (indexBuffer !== null && indexBuffer !== lastSpriteIndexBuffer) {
+      spritePass.setIndexBuffer(indexBuffer.handle, spriteEntry.mesh.indexFormat);
+      lastSpriteIndexBuffer = indexBuffer;
     }
 
     // Instance buffer resolution: same cap-gate logic as the geometry
@@ -837,21 +830,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,35 +946,15 @@ 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]);
 
+    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
@@ -1032,7 +999,6 @@ function recordSpriteEntityDraws(
       bindGroupCounts,
     );
 
-    const materialSlot = materialSlotIndices[i]?.[0] ?? 0;
     spritePass.setBindGroup(1, spritePassBg, [materialSlot * MATERIAL_PER_ENTITY_STRIDE]);
     spritePass.setBindGroup(3, spriteInstancesBg);
     spritePass.drawIndexed(spriteEntry.mesh.indexCount, spriteInstanceCount, 0, 0, 0);

package/src/record/main-pass.ts

@@ -16,6 +16,7 @@ import type { ReflectionProbeSelectionResult } from '../reflection/projection';
 import type { RenderRecordPhase } from '../render-contract';
 import type { MaterialSnapshot } from '../render-system-extract';
 import { resolveReflectionProbeBinding } from './frame-lighting';
+import { getOpaqueResourceIdentity } from './frame-snapshot';
 import { recordGeometryDraws } from './main-pass-geometry';
 import {
   applyMaterialTextureUvScales,
@@ -42,6 +43,18 @@ export function standardReflectionProbeIndex(
 
 const ZERO_SKYLIGHT_PAYLOAD = new Float32Array([0, 0, 0, 0, 0, 0, 0, 1]);
 
+function materialDiagnosticsEnabled(): boolean {
+  if (typeof globalThis !== 'object' || globalThis === null || !('process' in globalThis)) {
+    return false;
+  }
+  const processValue = (
+    globalThis as {
+      readonly process?: { readonly env?: Record<string, string | undefined> };
+    }
+  ).process;
+  return processValue?.env?.FORGEAX_MATERIAL_DIAGNOSTICS === '1';
+}
+
 export type MainPassOptions = {
   readonly colorViews?: readonly (TextureView | null)[];
   readonly colorFormats?: readonly GPUTextureFormat[];
@@ -52,8 +65,6 @@ export type MainPassOptions = {
   readonly transmissionBackdropView?: TextureView | null;
 };
 
-const TRANSMISSION_VARIANT_SET = 'TRANSMISSION_AVAILABLE=true';
-
 function isTransmissionMaterial(material: MaterialSnapshot): boolean {
   return (
     material.materialShaderId === 'forgeax::default-standard-pbr' &&
@@ -284,10 +295,6 @@ export function recordMainPass(
       : {
           ...c,
           splitLdrSprite: recordMode === 'transparent' ? false : c.splitLdrSprite,
-          validatedOrdered: c.validatedOrdered.map((entry) => ({
-            ...entry,
-            ...(recordMode === 'transmission' ? { variantSet: TRANSMISSION_VARIANT_SET } : {}),
-          })),
         };
 
   if (clusteredBindGroupMissing) {
@@ -420,6 +427,64 @@ export function recordMainPass(
             brdfLutSampler: skylightFallback.sampler,
             intensityBuffer: skylightFallback.intensityBuffer,
           };
+    if (materialDiagnosticsEnabled()) {
+      const activeCache =
+        activeViews === undefined ? undefined : getOrCreateIblCache(runtime.deviceScope);
+      const prefilterViewMipCount =
+        activeCache?.prefilterFaceViewsByMip?.length ?? (activeViews === undefined ? 1 : 0);
+      frameState.iblBindingInspection = {
+        status: 'binding-chain-consistent',
+        frameId: frameState.frameNumber,
+        deviceGeneration: runtime.deviceScope.generation,
+        active: activeViews === undefined ? 'fallback' : 'active',
+        cache: {
+          identity: getOpaqueResourceIdentity((activeCache ?? skylightFallback) as object),
+          generation: runtime.deviceScope.generation,
+          prefilterMipCount: prefilterViewMipCount,
+          prefilterViewMipCount,
+        },
+        sampler: {
+          expected: {
+            magFilter: 'linear',
+            minFilter: 'linear',
+            mipmapFilter: 'linear',
+            addressModeU: 'clamp-to-edge',
+            addressModeV: 'clamp-to-edge',
+            addressModeW: 'clamp-to-edge',
+          },
+          identities: [
+            getOpaqueResourceIdentity(skylightResources.irradianceSampler as object),
+            getOpaqueResourceIdentity(skylightResources.prefilterSampler as object),
+            getOpaqueResourceIdentity(skylightResources.brdfLutSampler as object),
+          ],
+        },
+        resources: {
+          irradiance: {
+            viewIdentity: getOpaqueResourceIdentity(skylightResources.irradianceView as object),
+            samplerIdentity: getOpaqueResourceIdentity(
+              skylightResources.irradianceSampler as object,
+            ),
+            deviceGeneration: runtime.deviceScope.generation,
+          },
+          prefilter: {
+            viewIdentity: getOpaqueResourceIdentity(skylightResources.prefilterView as object),
+            samplerIdentity: getOpaqueResourceIdentity(
+              skylightResources.prefilterSampler as object,
+            ),
+            deviceGeneration: runtime.deviceScope.generation,
+          },
+          brdfLut: {
+            viewIdentity: getOpaqueResourceIdentity(skylightResources.brdfLutView as object),
+            samplerIdentity: getOpaqueResourceIdentity(skylightResources.brdfLutSampler as object),
+            deviceGeneration: runtime.deviceScope.generation,
+          },
+          intensityBufferIdentity: getOpaqueResourceIdentity(
+            skylightResources.intensityBuffer as object,
+          ),
+        },
+        errors: [],
+      };
+    }
     // Per-entity material uploads (D-P9 retained path).
     // feat-20260613 fix-issue-1 (D-8 channelMap split): the payload mirrors
     // the post-split sidecar paramSchema for default-standard-pbr (14 entries
@@ -490,6 +555,7 @@ export function recordMainPass(
       },
       materialBgShared: frameState.materialBgShared,
       materialBgAssemblyCache: c.materialBgAssemblyCache,
+      frameState,
       bindGroupCounts,
       ...(transmissionBackdropView === undefined ? {} : { transmissionBackdropView }),
     };
@@ -551,6 +617,28 @@ export function recordMainPass(
           mat.materialParamSchema ??
           (materialShaderId !== undefined ? runtime.getParamSchema?.(materialShaderId) : undefined);
         applyParamSnapshotToUbo(slotPayloadF32, schema, mat.paramSnapshot);
+        const processValue = (
+          globalThis as {
+            process?: { env?: Record<string, string | undefined> };
+          }
+        ).process;
+        if (
+          processValue?.env?.FORGEAX_MATERIAL_PIPELINE_DIAGNOSTICS === '1' &&
+          (materialShaderId === 'forgeax::default-standard-pbr' ||
+            materialShaderId === 'forgeax::pbr-skin')
+        ) {
+          console.error(
+            `[render-material] UBO receipt: ${JSON.stringify({
+              entityIndex: entry.renderableIndex,
+              materialHandle: mat.materialHandle,
+              materialShaderId,
+              clearcoat: slotPayloadF32[32],
+              clearcoatRoughness: slotPayloadF32[33],
+              clearcoatNormalScale: slotPayloadF32[34],
+              paramSnapshot: mat.paramSnapshot,
+            })}`,
+          );
+        }
         applyMaterialTextureUvScales(slotPayloadF32, mat, world);
         // Missing-texture detection: structural debug-pink fallback overrides
         // the baseColor/colorTint slot when a bound baseColorTexture handle

package/src/record/mesh-ssbo.ts

@@ -79,12 +79,18 @@ export function extractEntryResourceHandle(entry: {
   return v as object;
 }
 
+// Object-only terminal marker keeps a shorter resource chain from colliding
+// with a longer chain that shares the same prefix.
+const BIND_GROUP_CHAIN_LEAF_KEY: object = {};
+
 /**
  * feat-20260622-handle-to-id-allocator-elimination M2 / w7: walks a nested
  * WeakMap chain to find or create a BindGroup leaf. Each handle in the
- * `handles` array is a chain node; the final leaf is a Map<string, BindGroup>
- * keyed by `variant` (D-2). Chain keys are always object references, never
- * numeric ids — GC reclaims entries for dead handles automatically.
+ * `handles` array is a chain node; a dedicated object terminal marker points
+ * to the final Map<string, BindGroup> keyed by `variant` (D-2). The marker
+ * prevents variable-depth chains with a shared prefix from treating a nested
+ * WeakMap as a leaf. Chain keys are always object references, never numeric
+ * ids — GC reclaims entries for dead handles automatically.
  *
  * On cache hit returns the cached BindGroup. On miss calls `factory`,
  * bumps `bindGroupCounts.createBindGroup`, stores the result at the leaf,
@@ -99,9 +105,7 @@ export function getOrCreateFromChain(
   counts: { createBindGroup: number; keys: string[] },
 ): BindGroup {
   let node = root;
-  for (let i = 0; i < handles.length - 1; i++) {
-    // biome-ignore lint/style/noNonNullAssertion: handles length guards the index
-    const h = handles[i]!;
+  for (const h of handles) {
     let next = node.get(h) as WeakMap<object, unknown> | undefined;
     if (next === undefined) {
       next = new WeakMap();
@@ -109,12 +113,10 @@ export function getOrCreateFromChain(
     }
     node = next;
   }
-  // biome-ignore lint/style/noNonNullAssertion: known non-empty at call sites
-  const last = handles[handles.length - 1]!;
-  let leaf = node.get(last) as Map<string, BindGroup> | undefined;
+  let leaf = node.get(BIND_GROUP_CHAIN_LEAF_KEY) as Map<string, BindGroup> | undefined;
   if (leaf === undefined) {
     leaf = new Map();
-    node.set(last, leaf);
+    node.set(BIND_GROUP_CHAIN_LEAF_KEY, leaf);
   }
   const hit = leaf.get(variant);
   if (hit !== undefined) return hit;
@@ -125,6 +127,26 @@ export function getOrCreateFromChain(
   return bg;
 }
 
+/**
+ * Read a cached bind group using the same variable-depth chain contract as
+ * `getOrCreateFromChain`. Readers must traverse the terminal marker instead
+ * of assuming that the last handle directly stores the variant map.
+ */
+export function findFromChain(
+  root: WeakMap<object, unknown>,
+  handles: readonly object[],
+  variant: string,
+): BindGroup | undefined {
+  let node = root;
+  for (const handle of handles) {
+    const next = node.get(handle);
+    if (next === undefined) return undefined;
+    node = next as WeakMap<object, unknown>;
+  }
+  const leaf = node.get(BIND_GROUP_CHAIN_LEAF_KEY) as Map<string, BindGroup> | undefined;
+  return leaf?.get(variant);
+}
+
 /**
  * feat-20260622-handle-to-id-allocator-elimination M2 / w8: per-entity bind
  * group lookup-or-create helper (D-2). Two-step lookup: outer Map.get(outerKey)
@@ -325,6 +347,8 @@ export function isMeshSsboDevMode(): boolean {
  * @internal
  */
 let _meshSsboScratch = new Uint8Array(0);
+/** @internal */
+let _meshSsboScratchFloats = new Float32Array(0);
 
 /**
  * feat-20260704 M3/w21: per-renderable `entity_world` upload (batched). All N
@@ -358,60 +382,69 @@ export function uploadMeshSsboBatch(
   // Grow the module-scoped scratch monotonically; zero the used range.
   if (_meshSsboScratch.length < neededBytes) {
     _meshSsboScratch = new Uint8Array(neededBytes);
+    _meshSsboScratchFloats = new Float32Array(_meshSsboScratch.buffer);
   } else {
     _meshSsboScratch.fill(0, 0, neededBytes);
   }
   const normalMatrixScratch = mat3.create();
+  const strideFloats = MESH_PER_ENTITY_STRIDE / Float32Array.BYTES_PER_ELEMENT;
   for (let i = 0; i < slotCount; i++) {
     const entry = validatedOrdered[i];
     if (entry === undefined) continue;
-    // Float32Array view into this entity's 256-byte slot (current world,
-    // normal, previous world, and reactive metadata use 45 floats; the
-    // remaining padding stays zero). Byte offset i*256 is always
-    // 4-byte aligned since MESH_PER_ENTITY_STRIDE=256 is divisible by 4.
-    const slot = new Float32Array(_meshSsboScratch.buffer, i * MESH_PER_ENTITY_STRIDE, 48);
+    // Address the reusable flat view directly. Constructing one typed-array
+    // wrapper per visible entity made this otherwise contiguous upload create
+    // tens of thousands of short-lived JS objects every frame.
+    const slot = i * strideFloats;
     const isFoldHead = foldDispatchPlan?.headBuckets.has(i) === true;
     if (isFoldHead) {
       // identity mat4
-      slot[0] = 1;
-      slot[5] = 1;
-      slot[10] = 1;
-      slot[15] = 1;
+      _meshSsboScratchFloats[slot] = 1;
+      _meshSsboScratchFloats[slot + 5] = 1;
+      _meshSsboScratchFloats[slot + 10] = 1;
+      _meshSsboScratchFloats[slot + 15] = 1;
       // identity mat3 normal (cols at slot offsets 16/20/24)
-      slot[16] = 1;
-      slot[20] = 1;
-      slot[24] = 1;
+      _meshSsboScratchFloats[slot + 16] = 1;
+      _meshSsboScratchFloats[slot + 20] = 1;
+      _meshSsboScratchFloats[slot + 24] = 1;
       // Fold heads use the instance storage path; keep the mesh temporal
       // fields deterministic for shader variants that still read the slot.
-      slot[28] = 1;
-      slot[33] = 1;
-      slot[38] = 1;
-      slot[43] = 1;
-      slot[44] = 1;
+      _meshSsboScratchFloats[slot + 28] = 1;
+      _meshSsboScratchFloats[slot + 33] = 1;
+      _meshSsboScratchFloats[slot + 38] = 1;
+      _meshSsboScratchFloats[slot + 43] = 1;
+      _meshSsboScratchFloats[slot + 44] = 1;
     } else {
       const worldFromLocal = entry.source.transform.world;
-      for (let k = 0; k < 16; k++) slot[k] = worldFromLocal[k] ?? 0;
+      for (let k = 0; k < 16; k++) _meshSsboScratchFloats[slot + k] = worldFromLocal[k] ?? 0;
       const normal = mat3.normalMatrix(normalMatrixScratch, worldFromLocal);
-      slot[16] = normal[0] ?? 0;
-      slot[17] = normal[1] ?? 0;
-      slot[18] = normal[2] ?? 0;
-      slot[20] = normal[3] ?? 0;
-      slot[21] = normal[4] ?? 0;
-      slot[22] = normal[5] ?? 0;
-      slot[24] = normal[6] ?? 0;
-      slot[25] = normal[7] ?? 0;
-      slot[26] = normal[8] ?? 0;
+      _meshSsboScratchFloats[slot + 16] = normal[0] ?? 0;
+      _meshSsboScratchFloats[slot + 17] = normal[1] ?? 0;
+      _meshSsboScratchFloats[slot + 18] = normal[2] ?? 0;
+      _meshSsboScratchFloats[slot + 20] = normal[3] ?? 0;
+      _meshSsboScratchFloats[slot + 21] = normal[4] ?? 0;
+      _meshSsboScratchFloats[slot + 22] = normal[5] ?? 0;
+      _meshSsboScratchFloats[slot + 24] = normal[6] ?? 0;
+      _meshSsboScratchFloats[slot + 25] = normal[7] ?? 0;
+      _meshSsboScratchFloats[slot + 26] = normal[8] ?? 0;
       const previousWorld = entry.source.temporal?.previousTransform.world ?? worldFromLocal;
-      for (let k = 0; k < 16; k++) slot[28 + k] = previousWorld[k] ?? 0;
-      const reactiveMaterial = entry.source.materials.some(
-        (material) =>
+      for (let k = 0; k < 16; k++) {
+        _meshSsboScratchFloats[slot + 28 + k] = previousWorld[k] ?? 0;
+      }
+      let reactiveMaterial = false;
+      for (const material of entry.source.materials) {
+        const shader = material.materialShaderId;
+        if (
           material.transparent === true ||
-          material.materialShaderId === 'forgeax::sprite' ||
-          material.materialShaderId === 'forgeax::sprite-lit' ||
-          (material.materialShaderId !== undefined &&
-            !material.materialShaderId.startsWith('forgeax::')),
-      );
-      slot[44] = entry.source.temporal?.reactive === true || reactiveMaterial ? 1 : 0;
+          shader === 'forgeax::sprite' ||
+          shader === 'forgeax::sprite-lit' ||
+          (shader !== undefined && !shader.startsWith('forgeax::'))
+        ) {
+          reactiveMaterial = true;
+          break;
+        }
+      }
+      _meshSsboScratchFloats[slot + 44] =
+        entry.source.temporal?.reactive === true || reactiveMaterial ? 1 : 0;
     }
   }
   if (neededBytes > 0) {