@forgeax/engine-render 0.1.32 → 0.1.34

package/src/gpu-scene.ts

@@ -1,6 +1,7 @@
 import type { Buffer, Result, RhiDevice } from '@forgeax/engine-rhi';
 import { err, ok, RhiError } from '@forgeax/engine-rhi';
 import { createStandardPbrArtifactReceipt } from '@forgeax/engine-shader';
+import { GpuDirtyRanges } from './gpu-dirty-ranges';
 import {
   GPU_SCENE_LAYOUTS,
   type GpuSceneTableLayout,
@@ -13,10 +14,14 @@ import {
 } from './gpu-usage';
 import type { GpuSceneInspection } from './inspection-types';
 import { packMaterialProgramRow, packStandardPbrMaterialRow } from './material-row';
+import type { MaterialSnapshot } from './render-system-extract';
 import type { RenderSceneApplyResult, RenderSceneSlot } from './scene/render-scene-types';
 
 export type { GpuSceneInspection } from './inspection-types';
 
+type GpuSceneTemporalSnapshot = NonNullable<RenderSceneSlot['snapshot']['temporal']>;
+type GpuSceneTemporalResolver = (slot: RenderSceneSlot) => GpuSceneTemporalSnapshot | undefined;
+
 const PRIMITIVE = GPU_SCENE_LAYOUTS.primitive;
 const INSTANCE = GPU_SCENE_LAYOUTS.instance;
 const TRANSFORM = GPU_SCENE_LAYOUTS.transform;
@@ -203,24 +208,61 @@ function stableU32(value: string): number {
   return hash >>> 0;
 }
 
-function coalesceSlots(
-  slots: readonly number[],
-): readonly { readonly start: number; readonly end: number }[] {
-  const ordered = [...new Set(slots)].sort((a, b) => a - b);
-  const ranges: Array<{ start: number; end: number }> = [];
-  for (const slot of ordered) {
-    const previous = ranges.at(-1);
-    if (previous !== undefined && previous.end === slot) {
-      previous.end = slot + 1;
-    } else {
-      ranges.push({ start: slot, end: slot + 1 });
-    }
+/**
+ * Build a lookup from the current instance identity to its submitted ordinal.
+ * The GPU table is physically compacted by ordinal, so this small CPU lookup
+ * is the seam that keeps a stable logical instance from inheriting another
+ * row's previous transform after reorder. A missing or duplicate generation
+ * deliberately returns no proof and makes the caller seed the current pose.
+ */
+function previousInstanceOrdinals(
+  current: NonNullable<RenderSceneSlot['snapshot']['instances']> | undefined,
+  temporal: GpuSceneTemporalSnapshot | undefined,
+): Map<number, number> | undefined {
+  const previous = temporal?.previousInstances;
+  const currentGenerations = current?.generations;
+  const previousGenerations = previous?.generations;
+  if (
+    temporal?.motionValid !== true ||
+    current === undefined ||
+    previous === undefined ||
+    currentGenerations === undefined ||
+    previousGenerations === undefined ||
+    currentGenerations.length !== current.instanceCount ||
+    previousGenerations.length !== previous.instanceCount ||
+    current.transforms.length < current.instanceCount * 16 ||
+    previous.transforms.length < previous.instanceCount * 16
+  ) {
+    return undefined;
   }
-  return ranges;
+  const currentSet = new Set<number>();
+  for (const generation of currentGenerations) {
+    if (generation === 0 || currentSet.has(generation)) return undefined;
+    currentSet.add(generation);
+  }
+  const ordinals = new Map<number, number>();
+  for (let ordinal = 0; ordinal < previousGenerations.length; ordinal += 1) {
+    const generation = previousGenerations[ordinal] ?? 0;
+    if (generation === 0 || ordinals.has(generation)) return undefined;
+    ordinals.set(generation, ordinal);
+  }
+  return ordinals;
+}
+
+function instanceIdentityChanged(
+  resident: Uint32Array | undefined,
+  current: Uint32Array | undefined,
+  ordinal: number,
+): boolean {
+  if (resident === undefined || current === undefined) return resident !== current;
+  return resident[ordinal] !== current[ordinal];
 }
 
 /** Persistent GPU tables derived only from renderer projection slots. */
 export class GpuScene {
+  private readonly dirtyRanges = new GpuDirtyRanges();
+  private readonly rowScratch = new Uint8Array(Math.max(PRIMITIVE.stride, DRAW_TEMPLATE.stride));
+  private readonly rowScratchView = new DataView(this.rowScratch.buffer);
   private disposed = false;
   private tableBytes: Record<GpuSceneTableName, ArrayBuffer>;
   private transformBytes: Uint8Array;
@@ -238,6 +280,8 @@ export class GpuScene {
   private sceneContentRevision = 0;
   private identityUploaded = false;
   private readonly allocations = new Map<number, PrimitiveAllocation>();
+  /** Current stable instance identities retained beside compact GPU rows. */
+  private readonly instanceGenerations = new Map<number, Uint32Array>();
   private readonly instances = new StableRangeAllocator();
   private readonly transforms = new StableRangeAllocator();
   private readonly draws = new StableRangeAllocator();
@@ -322,7 +366,10 @@ export class GpuScene {
     return allocation.materialStart + materialSlot;
   }
 
-  sync(delta: RenderSceneApplyResult): Result<GpuSceneSyncResult, RhiError> {
+  sync(
+    delta: RenderSceneApplyResult,
+    temporalResolver?: GpuSceneTemporalResolver,
+  ): Result<GpuSceneSyncResult, RhiError> {
     for (const transformIndex of this.pendingTemporalUploads) {
       this.writesByTable.transform.push(transformIndex);
     }
@@ -386,6 +433,9 @@ export class GpuScene {
       if (!grown.ok) return grown;
     }
 
+    // A shared material has one packed value per publication, independent of
+    // how many primitives reference it. Do not retain mutable caller snapshots.
+    const materialRows = new Map<MaterialSnapshot, Uint8Array>();
     const publications = [...delta.createdSlots, ...delta.updatedSlots, ...delta.recreatedSlots];
     const newSlots = new Set(
       [...delta.createdSlots, ...delta.recreatedSlots].map((record) => record.slot),
@@ -393,11 +443,11 @@ export class GpuScene {
     for (const record of publications) {
       const reset = newSlots.has(record.slot) || allocationResets.has(record.slot);
       if (reset || contentUpdatedSlotIds.has(record.slot)) {
-        this.writeSlot(record, reset, writesByTable);
+        this.writeSlot(record, reset, writesByTable, materialRows, temporalResolver?.(record));
         continue;
       }
       if (instanceUpdatedSlotIds.has(record.slot))
-        this.writeInstanceTransforms(record, writesByTable);
+        this.writeInstanceTransforms(record, writesByTable, temporalResolver?.(record));
       this.writeRootTransform(record, false, writesByTable);
     }
     const uploaded = this.uploadRows(writesByTable);
@@ -425,7 +475,7 @@ export class GpuScene {
     if (this.pendingTemporalTransforms.size === 0) return ok(undefined);
     const currentOffset = offset(TRANSFORM, 'currentWorld');
     const previousOffset = offset(TRANSFORM, 'previousWorld');
-    const ranges = coalesceSlots([...this.pendingTemporalTransforms]);
+    const ranges = this.dirtyRanges.coalesce([...this.pendingTemporalTransforms]);
     for (const range of ranges) {
       for (let index = range.start; index < range.end; index += 1) {
         this.pendingTemporalUploads.add(index);
@@ -459,6 +509,7 @@ export class GpuScene {
 
   rebuild(slots: readonly RenderSceneSlot[]): Result<GpuSceneSyncResult, RhiError> {
     this.allocations.clear();
+    this.instanceGenerations.clear();
     this.instances.reset();
     this.transforms.reset(1);
     this.draws.reset();
@@ -490,7 +541,8 @@ export class GpuScene {
     }
     for (const bytes of Object.values(this.tableBytes)) new Uint8Array(bytes).fill(0);
     this.writeIdentityTransform();
-    for (const slot of slots) this.writeSlot(slot, true, writesByTable);
+    const materialRows = new Map<MaterialSnapshot, Uint8Array>();
+    for (const slot of slots) this.writeSlot(slot, true, writesByTable, materialRows);
     let bytes = 0;
     for (const name of TABLE_NAMES) {
       const table = this.tableBytes[name];
@@ -551,65 +603,51 @@ export class GpuScene {
     record: RenderSceneSlot,
     resetPrevious: boolean,
     writes: Record<GpuSceneTableName, number[]>,
+    materialRows: Map<MaterialSnapshot, Uint8Array>,
+    temporal?: GpuSceneTemporalSnapshot,
   ): void {
     const allocation = this.allocations.get(record.slot);
     if (allocation === undefined) throw new RangeError('GPU Scene allocation unavailable');
-    const primitiveOffset = record.slot * PRIMITIVE.stride;
-    const primitive = new DataView(this.tableBytes.primitive);
+    this.rowScratch.fill(0);
+    const primitive = this.rowScratchView;
     const bounds = record.snapshot.localAabb;
-    primitive.setUint32(primitiveOffset + offset(PRIMITIVE, 'generation'), record.generation, true);
+    primitive.setUint32(offset(PRIMITIVE, 'generation'), record.generation, true);
     primitive.setUint32(
-      primitiveOffset + offset(PRIMITIVE, 'flags'),
+      offset(PRIMITIVE, 'flags'),
       PRIMITIVE_ACTIVE |
         (bounds === undefined ? 0 : PRIMITIVE_HAS_BOUNDS) |
         (record.snapshot.gpuDrivenDraws === undefined ? 0 : PRIMITIVE_GPU_DRIVEN),
       true,
     );
-    primitive.setUint32(
-      primitiveOffset + offset(PRIMITIVE, 'transformIndex'),
-      allocation.transformStart,
-      true,
-    );
-    primitive.setUint32(
-      primitiveOffset + offset(PRIMITIVE, 'materialIndex'),
-      allocation.materialStart,
-      true,
-    );
-    primitive.setUint32(
-      primitiveOffset + offset(PRIMITIVE, 'drawTemplateIndex'),
-      allocation.drawStart,
-      true,
-    );
-    primitive.setUint32(
-      primitiveOffset + offset(PRIMITIVE, 'instanceStart'),
-      allocation.instanceStart,
-      true,
-    );
-    primitive.setUint32(
-      primitiveOffset + offset(PRIMITIVE, 'instanceCount'),
-      allocation.instanceCount,
-      true,
-    );
-    primitive.setUint32(
-      primitiveOffset + offset(PRIMITIVE, 'assetHandle'),
-      record.snapshot.assetHandle,
-      true,
-    );
-    writeVec4(primitive, primitiveOffset + offset(PRIMITIVE, 'localBoundsMin'), [
+    primitive.setUint32(offset(PRIMITIVE, 'transformIndex'), allocation.transformStart, true);
+    primitive.setUint32(offset(PRIMITIVE, 'materialIndex'), allocation.materialStart, true);
+    primitive.setUint32(offset(PRIMITIVE, 'drawTemplateIndex'), allocation.drawStart, true);
+    primitive.setUint32(offset(PRIMITIVE, 'instanceStart'), allocation.instanceStart, true);
+    primitive.setUint32(offset(PRIMITIVE, 'instanceCount'), allocation.instanceCount, true);
+    primitive.setUint32(offset(PRIMITIVE, 'assetHandle'), record.snapshot.assetHandle, true);
+    writeVec4(primitive, offset(PRIMITIVE, 'localBoundsMin'), [
       bounds?.[0] ?? 0,
       bounds?.[1] ?? 0,
       bounds?.[2] ?? 0,
       0,
     ]);
-    writeVec4(primitive, primitiveOffset + offset(PRIMITIVE, 'localBoundsMax'), [
+    writeVec4(primitive, offset(PRIMITIVE, 'localBoundsMax'), [
       bounds?.[3] ?? 0,
       bounds?.[4] ?? 0,
       bounds?.[5] ?? 0,
       0,
     ]);
 
+    if (this.writeRow('primitive', record.slot, this.rowScratch) || resetPrevious)
+      writes.primitive.push(record.slot);
+
     const instance = new DataView(this.tableBytes.instance);
     const transform = this.transformView;
+    const instances = record.snapshot.instances;
+    const previousInstances = temporal?.previousInstances;
+    const previousOrdinals = previousInstanceOrdinals(instances, temporal);
+    const currentGenerations = instances?.generations;
+    const residentGenerations = this.instanceGenerations.get(record.slot);
     for (let ordinal = 0; ordinal < allocation.instanceCount; ordinal += 1) {
       const instanceIndex = allocation.instanceStart + ordinal;
       const instanceOffset = instanceIndex * INSTANCE.stride;
@@ -636,7 +674,7 @@ export class GpuScene {
         writeChangedU32(instance, instanceOffset + offset(INSTANCE, 'flags'), PRIMITIVE_ACTIVE) ||
         metadataChanged;
       if (allocation.instanceTransformCount > 0) {
-        const transforms = record.snapshot.instances?.transforms;
+        const transforms = instances?.transforms;
         const hasLocal = transforms !== undefined && transforms.length >= (ordinal + 1) * 16;
         const local = hasLocal ? transforms : IDENTITY_MATRIX;
         const sourceOffset = hasLocal ? ordinal * 16 : 0;
@@ -647,30 +685,76 @@ export class GpuScene {
           local,
           sourceOffset,
         );
-        if (resetPrevious)
-          writeChangedMat4(
-            transform,
-            localOffset + offset(TRANSFORM, 'previousWorld'),
-            local,
-            sourceOffset,
-          );
-        else if (changed) this.pendingTemporalTransforms.add(transformIndex);
-        if (changed || resetPrevious) writes.transform.push(transformIndex);
+        const identityChanged = instanceIdentityChanged(
+          residentGenerations,
+          currentGenerations,
+          ordinal,
+        );
+        if (resetPrevious) {
+          const previousOrdinal = previousOrdinals?.get(currentGenerations?.[ordinal] ?? 0);
+          const previousSource =
+            previousOrdinal === undefined || previousInstances === undefined
+              ? undefined
+              : previousInstances.transforms;
+          if (previousSource === undefined || previousOrdinal === undefined) {
+            writeChangedMat4(
+              transform,
+              localOffset + offset(TRANSFORM, 'previousWorld'),
+              local,
+              sourceOffset,
+            );
+          } else {
+            writeChangedMat4(
+              transform,
+              localOffset + offset(TRANSFORM, 'previousWorld'),
+              previousSource,
+              previousOrdinal * 16,
+            );
+            this.pendingTemporalTransforms.add(transformIndex);
+          }
+        } else if (changed || identityChanged) {
+          const previousOrdinal = previousOrdinals?.get(currentGenerations?.[ordinal] ?? 0);
+          const previousSource =
+            previousOrdinal === undefined || previousInstances === undefined
+              ? undefined
+              : previousInstances.transforms;
+          if (previousSource === undefined || previousOrdinal === undefined) {
+            // A changed row without an identity proof must not borrow the
+            // compacted row's old velocity. Seed only this row and keep other
+            // stable instances eligible for motion.
+            writeChangedMat4(
+              transform,
+              localOffset + offset(TRANSFORM, 'previousWorld'),
+              local,
+              sourceOffset,
+            );
+          } else {
+            writeChangedMat4(
+              transform,
+              localOffset + offset(TRANSFORM, 'previousWorld'),
+              previousSource,
+              previousOrdinal * 16,
+            );
+          }
+          this.pendingTemporalTransforms.add(transformIndex);
+        }
+        if (changed || identityChanged || resetPrevious) writes.transform.push(transformIndex);
       }
       if (metadataChanged || resetPrevious) writes.instance.push(instanceIndex);
     }
 
+    this.rememberInstanceGenerations(record.slot, currentGenerations, allocation.instanceCount);
+
     this.writeRootTransform(record, resetPrevious, writes);
-    writes.primitive.push(record.slot);
 
-    const draw = new DataView(this.tableBytes.drawTemplate);
+    const draw = this.rowScratchView;
     const drawSnapshots = record.snapshot.gpuDrivenDraws ?? [];
     for (let ordinal = 0; ordinal < allocation.drawCount; ordinal += 1) {
       const drawIndex = allocation.drawStart + ordinal;
-      const drawOffset = drawIndex * DRAW_TEMPLATE.stride;
+      this.rowScratch.fill(0);
       const drawSnapshot = drawSnapshots[ordinal];
       draw.setUint32(
-        drawOffset + offset(DRAW_TEMPLATE, 'pipelineClass'),
+        offset(DRAW_TEMPLATE, 'pipelineClass'),
         drawSnapshot === undefined
           ? 0
           : stableU32(
@@ -681,58 +765,77 @@ export class GpuScene {
         true,
       );
       draw.setUint32(
-        drawOffset + offset(DRAW_TEMPLATE, 'materialIndex'),
+        offset(DRAW_TEMPLATE, 'materialIndex'),
         allocation.materialStart + (drawSnapshot?.materialSlot ?? 0),
         true,
       );
       draw.setUint32(
-        drawOffset + offset(DRAW_TEMPLATE, 'firstIndex'),
+        offset(DRAW_TEMPLATE, 'firstIndex'),
         drawSnapshot?.prepared?.first ?? drawSnapshot?.first ?? 0,
         true,
       );
       draw.setUint32(
-        drawOffset + offset(DRAW_TEMPLATE, 'indexCount'),
+        offset(DRAW_TEMPLATE, 'indexCount'),
         drawSnapshot?.prepared?.count ?? drawSnapshot?.count ?? 0,
         true,
       );
       draw.setInt32(
-        drawOffset + offset(DRAW_TEMPLATE, 'baseVertex'),
+        offset(DRAW_TEMPLATE, 'baseVertex'),
         drawSnapshot?.prepared?.baseVertex ?? drawSnapshot?.baseVertex ?? 0,
         true,
       );
-      draw.setUint32(drawOffset + offset(DRAW_TEMPLATE, 'firstInstance'), 0, true);
-      draw.setUint32(drawOffset + offset(DRAW_TEMPLATE, 'passFlags'), 0, true);
-      draw.setUint32(drawOffset + offset(DRAW_TEMPLATE, 'reserved'), 0, true);
-      writes.drawTemplate.push(drawIndex);
+      draw.setUint32(offset(DRAW_TEMPLATE, 'firstInstance'), 0, true);
+      draw.setUint32(offset(DRAW_TEMPLATE, 'passFlags'), 0, true);
+      draw.setUint32(offset(DRAW_TEMPLATE, 'reserved'), 0, true);
+      if (this.writeRow('drawTemplate', drawIndex, this.rowScratch) || resetPrevious)
+        writes.drawTemplate.push(drawIndex);
     }
 
-    this.writeMaterialSlot(record, writes);
+    this.writeMaterialSlot(record, writes, materialRows, resetPrevious);
+  }
+
+  /** Compare against the resident CPU bytes; pending upload rows survive failure. */
+  private writeRow(table: GpuSceneTableName, index: number, row: Uint8Array): boolean {
+    const stride = TABLE_LAYOUTS[table].stride;
+    const destination = new Uint8Array(this.tableBytes[table], index * stride, stride);
+    let changed = false;
+    for (let byte = 0; byte < stride; byte += 1) {
+      const value = row[byte] ?? 0;
+      if (destination[byte] === value) continue;
+      destination[byte] = value;
+      changed = true;
+    }
+    return changed;
   }
 
   private writeMaterialSlot(
     record: RenderSceneSlot,
     writes: Record<GpuSceneTableName, number[]>,
+    materialRows: Map<MaterialSnapshot, Uint8Array>,
+    reset: boolean,
   ): void {
     const allocation = this.allocations.get(record.slot);
     if (allocation === undefined) throw new RangeError('GPU Scene allocation unavailable');
     for (let ordinal = 0; ordinal < allocation.materialCount; ordinal += 1) {
       const materialIndex = allocation.materialStart + ordinal;
-      const materialOffset = materialIndex * MATERIAL.stride;
       const snapshot = record.snapshot.materials[ordinal] ?? record.snapshot.material;
-      const shaderId = snapshot.materialShaderId;
-      const schema = snapshot.materialParamSchema;
-      const row =
-        shaderId !== undefined &&
-        shaderId !== 'forgeax::default-standard-pbr' &&
-        shaderId !== 'forgeax::pbr-skin' &&
-        shaderId !== 'forgeax::default-standard-pbr-skin' &&
-        schema !== undefined
-          ? packMaterialProgramRow(schema, snapshot, MATERIAL.stride)
-          : packStandardPbrMaterialRow(STANDARD_PBR_RECEIPT, snapshot);
-      const destination = new Uint8Array(this.tableBytes.material, materialOffset, MATERIAL.stride);
-      destination.fill(0);
-      if (row !== undefined) destination.set(row.subarray(0, MATERIAL.stride));
-      writes.material.push(materialIndex);
+      let row = materialRows.get(snapshot);
+      if (row === undefined) {
+        const shaderId = snapshot.materialShaderId;
+        const schema = snapshot.materialParamSchema;
+        row =
+          shaderId !== undefined &&
+          shaderId !== 'forgeax::default-standard-pbr' &&
+          shaderId !== 'forgeax::pbr-skin' &&
+          shaderId !== 'forgeax::default-standard-pbr-skin' &&
+          schema !== undefined
+            ? packMaterialProgramRow(schema, snapshot, MATERIAL.stride)
+            : packStandardPbrMaterialRow(STANDARD_PBR_RECEIPT, snapshot);
+        row ??= new Uint8Array(MATERIAL.stride);
+        materialRows.set(snapshot, row);
+      }
+      if (this.writeRow('material', materialIndex, row) || reset)
+        writes.material.push(materialIndex);
     }
   }
 
@@ -740,6 +843,7 @@ export class GpuScene {
   private writeInstanceTransforms(
     record: RenderSceneSlot,
     writes: Record<GpuSceneTableName, number[]>,
+    temporal?: GpuSceneTemporalSnapshot,
   ): void {
     const allocation = this.allocations.get(record.slot);
     const instances = record.snapshot.instances;
@@ -749,21 +853,74 @@ export class GpuScene {
     if (allocation.instanceTransformCount !== instances.instanceCount) {
       throw new RangeError('GPU Scene instance update changed instance count');
     }
+    const previousOrdinals = previousInstanceOrdinals(instances, temporal);
+    const previousInstances = temporal?.previousInstances;
+    const currentGenerations = instances.generations;
+    const residentGenerations = this.instanceGenerations.get(record.slot);
     for (let ordinal = 0; ordinal < allocation.instanceTransformCount; ordinal += 1) {
       const transformIndex = allocation.instanceTransformStart + ordinal;
       const transformOffset = transformIndex * TRANSFORM.stride;
-      if (
-        writeChangedMat4(
-          this.transformView,
-          transformOffset + offset(TRANSFORM, 'currentWorld'),
-          instances.transforms,
-          ordinal * 16,
-        )
-      ) {
+      const changed = writeChangedMat4(
+        this.transformView,
+        transformOffset + offset(TRANSFORM, 'currentWorld'),
+        instances.transforms,
+        ordinal * 16,
+      );
+      const identityChanged = instanceIdentityChanged(
+        residentGenerations,
+        currentGenerations,
+        ordinal,
+      );
+      if (changed || identityChanged) {
+        const previousOrdinal = previousOrdinals?.get(currentGenerations?.[ordinal] ?? 0);
+        const previousSource =
+          previousOrdinal === undefined || previousInstances === undefined
+            ? undefined
+            : previousInstances.transforms;
+        if (previousSource === undefined || previousOrdinal === undefined) {
+          writeChangedMat4(
+            this.transformView,
+            transformOffset + offset(TRANSFORM, 'previousWorld'),
+            instances.transforms,
+            ordinal * 16,
+          );
+        } else {
+          writeChangedMat4(
+            this.transformView,
+            transformOffset + offset(TRANSFORM, 'previousWorld'),
+            previousSource,
+            previousOrdinal * 16,
+          );
+        }
         this.pendingTemporalTransforms.add(transformIndex);
         writes.transform.push(transformIndex);
       }
     }
+    this.rememberInstanceGenerations(
+      record.slot,
+      currentGenerations,
+      allocation.instanceTransformCount,
+    );
+  }
+
+  private rememberInstanceGenerations(
+    slot: number,
+    generations: Uint32Array | undefined,
+    instanceCount: number,
+  ): void {
+    if (generations === undefined || generations.length !== instanceCount) {
+      this.instanceGenerations.delete(slot);
+      return;
+    }
+    const resident = this.instanceGenerations.get(slot);
+    if (
+      resident !== undefined &&
+      resident.length === generations.length &&
+      resident.every((generation, ordinal) => generation === generations[ordinal])
+    ) {
+      return;
+    }
+    this.instanceGenerations.set(slot, generations.slice());
   }
 
   private writeRootTransform(
@@ -795,6 +952,7 @@ export class GpuScene {
     }
     const allocation = this.allocations.get(slot);
     if (allocation === undefined) return;
+    this.instanceGenerations.delete(slot);
     this.clearAllocation(allocation, writes);
     this.allocations.delete(slot);
   }
@@ -805,7 +963,7 @@ export class GpuScene {
     let rangeCount = 0;
     let bytes = 0;
     for (const name of TABLE_NAMES) {
-      const ranges = coalesceSlots(rows[name]);
+      const ranges = this.dirtyRanges.coalesce(rows[name]);
       rangeCount += ranges.length;
       for (const range of ranges) {
         const layout = TABLE_LAYOUTS[name];

package/src/hdrp-buffers.ts

@@ -559,6 +559,7 @@ export function createHdrpUnifiedBindGroup(
   hdrpBuffers: HdrpBuffers,
   meshStorageBuffer: Buffer,
   ssaoOptions: SsaoBindOptions = { enabled: false },
+  meshBindingBytes = MESH_PER_ENTITY_STRIDE,
 ): BindGroup | null {
   const fallback = getOrCreateSsaoFallbackTexture(runtime);
   if (fallback === null) return null;
@@ -579,7 +580,7 @@ export function createHdrpUnifiedBindGroup(
           value: {
             buffer: meshStorageBuffer,
             offset: 0,
-            size: MESH_PER_ENTITY_STRIDE,
+            size: meshBindingBytes,
           },
         },
       },
@@ -602,17 +603,17 @@ export function createHdrpSkinUnifiedBindGroup(
   paletteBuffer: Buffer,
   paletteBindingWindowBytes: number,
   ssaoOptions: SsaoBindOptions = { enabled: false },
+  meshBindingBytes = MESH_PER_ENTITY_STRIDE,
 ): BindGroup | null {
   const fallback = getOrCreateSsaoFallbackTexture(runtime);
   if (fallback === null) return null;
-  const meshSize = MESH_PER_ENTITY_STRIDE;
   const result = runtime.device.createBindGroup({
     label: 'hdrp-skin-unified-bg-group2',
     layout,
     entries: [
       ...createPbrSkinMeshBindGroupEntries(
         meshStorageBuffer,
-        meshSize,
+        meshBindingBytes,
         paletteBuffer,
         paletteBindingWindowBytes,
       ),