@forgeax/engine-render 0.1.4 → 0.1.6

package/src/gpu-scene.ts

@@ -1,48 +1,28 @@
-import type { Buffer, Result, RhiDevice, RhiError } from '@forgeax/engine-rhi';
-import { err, ok } from '@forgeax/engine-rhi';
+import type { Buffer, Result, RhiDevice } from '@forgeax/engine-rhi';
+import { err, ok, RhiError } from '@forgeax/engine-rhi';
 import {
   GPU_SCENE_LAYOUTS,
-  GPU_SCENE_PRIMITIVE_FLAGS,
   type GpuSceneTableLayout,
   gpuSceneFieldOffset,
-  type SceneFactRevisionDomain,
 } from './gpu-scene-schema';
 import {
   GPU_BUFFER_USAGE_COPY_DST,
   GPU_BUFFER_USAGE_COPY_SRC,
   GPU_BUFFER_USAGE_STORAGE,
 } from './gpu-usage';
-import type {
-  RenderSceneApplyResult,
-  RenderSceneProjection,
-  RenderSceneProjectionSlot,
-  RenderSceneSubmissionDelta,
-  SpatialIndexInspection,
-} from './render-scene-projection';
-import type { RenderableTemporalSnapshot } from './render-system-extract';
+import type { GpuSceneInspection } from './inspection-types';
+import type { RenderSceneApplyResult, RenderSceneSlot } from './scene/render-scene-types';
+
+export type { GpuSceneInspection } from './inspection-types';
 
 const PRIMITIVE = GPU_SCENE_LAYOUTS.primitive;
 const INSTANCE = GPU_SCENE_LAYOUTS.instance;
 const TRANSFORM = GPU_SCENE_LAYOUTS.transform;
 const DRAW_TEMPLATE = GPU_SCENE_LAYOUTS.drawTemplate;
 const MATERIAL = GPU_SCENE_LAYOUTS.material;
-const PRIMITIVE_ACTIVE = GPU_SCENE_PRIMITIVE_FLAGS.active;
-const PRIMITIVE_HAS_BOUNDS = GPU_SCENE_PRIMITIVE_FLAGS.hasBounds;
-const PRIMITIVE_GPU_DRIVEN = GPU_SCENE_PRIMITIVE_FLAGS.gpuDriven;
-const PRIMITIVE_STATIC = GPU_SCENE_PRIMITIVE_FLAGS.static;
-const PRIMITIVE_DYNAMIC = GPU_SCENE_PRIMITIVE_FLAGS.dynamic;
-const PRIMITIVE_CASTER_ELIGIBLE = GPU_SCENE_PRIMITIVE_FLAGS.casterEligible;
-const PRIMITIVE_CASTER_INELIGIBLE = GPU_SCENE_PRIMITIVE_FLAGS.casterIneligible;
-const PRIMITIVE_CASTER_UNKNOWN = GPU_SCENE_PRIMITIVE_FLAGS.casterUnknown;
-const ALL_SCENE_FACT_DOMAINS: readonly SceneFactRevisionDomain[] = [
-  'transform',
-  'geometry',
-  'material',
-  'eligibility',
-  'space',
-  'batch',
-  'resource',
-];
+const PRIMITIVE_ACTIVE = 1;
+const PRIMITIVE_HAS_BOUNDS = 2;
+const PRIMITIVE_GPU_DRIVEN = 4;
 const IDENTITY_MATRIX = new Float32Array([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]);
 
 interface GpuSceneBuffers {
@@ -123,24 +103,6 @@ const TABLE_LAYOUTS = {
 
 const TABLE_NAMES = Object.keys(TABLE_LAYOUTS) as readonly GpuSceneTableName[];
 
-export interface GpuSceneTableInspection {
-  readonly capacity: number;
-  readonly bytes: number;
-}
-
-export interface GpuSceneInspection {
-  readonly capacity: number;
-  readonly tables: Readonly<Record<GpuSceneTableName, GpuSceneTableInspection>>;
-  readonly uploadRanges: number;
-  readonly uploadBytes: number;
-  readonly capacityGrows: number;
-  readonly fullRebuilds: number;
-  readonly clearedSlots: number;
-  readonly noChangeFrames: number;
-  /** Mirrored CPU broadphase evidence; RenderSceneProjection remains the owner. */
-  readonly spatialIndex: SpatialIndexInspection | undefined;
-}
-
 export interface GpuSceneSyncResult {
   readonly ranges: number;
   readonly bytes: number;
@@ -168,7 +130,23 @@ function createBuffers(device: RhiDevice, capacity: number): Result<GpuSceneBuff
     }
     created[name] = result.value;
   }
-  return ok(created as unknown as GpuSceneBuffers);
+  const { primitive, instance, transform, drawTemplate, material } = created;
+  if (
+    primitive === undefined ||
+    instance === undefined ||
+    transform === undefined ||
+    drawTemplate === undefined ||
+    material === undefined
+  ) {
+    return err(
+      new RhiError({
+        code: 'internal-error',
+        expected: 'GPU scene creates one buffer for every table',
+        hint: 'rebuild the renderer after inspecting the device resource failure',
+      }),
+    );
+  }
+  return ok({ primitive, instance, transform, drawTemplate, material });
 }
 
 function writeMat4(view: DataView, byteOffset: number, value: Float32Array): void {
@@ -227,8 +205,6 @@ export class GpuScene {
   private readonly transforms = new StableRangeAllocator();
   private readonly draws = new StableRangeAllocator();
   private readonly materials = new StableRangeAllocator();
-  private readonly pendingSubmittedSlots = new Set<number>();
-  private spatialIndex: SpatialIndexInspection | undefined;
 
   private constructor(
     private readonly device: RhiDevice,
@@ -272,42 +248,13 @@ export class GpuScene {
     return this.buffers.material;
   }
 
-  sync(
-    projection: RenderSceneProjection,
-    delta: RenderSceneApplyResult,
-  ): Result<GpuSceneSyncResult, RhiError> {
-    if (delta.spatialIndex !== undefined) this.spatialIndex = delta.spatialIndex.inspection;
-    const factDeltaBySlot = new Map(
-      delta.factDeltas.map((factDelta) => [factDelta.slot, factDelta]),
-    );
-    const writes = [
-      ...delta.createdSlots.map((record) => ({
-        record,
-        resetPrevious: true,
-        dirtyDomains: ALL_SCENE_FACT_DOMAINS,
-      })),
-      ...delta.updatedSlots.flatMap((record) => {
-        const factDelta = factDeltaBySlot.get(record.slot);
-        // An old caller may construct a delta without factDeltas. Preserve its
-        // previous full-write behavior for compatibility; projection deltas
-        // always carry the fine-grained entry.
-        if (factDelta === undefined) {
-          return [{ record, resetPrevious: false, dirtyDomains: ALL_SCENE_FACT_DOMAINS }];
-        }
-        if (factDelta.changedDomains.length === 0) return [];
-        return [{ record, resetPrevious: false, dirtyDomains: factDelta.changedDomains }];
-      }),
-      ...delta.recreatedSlots.map((record) => ({
-        record,
-        resetPrevious: true,
-        dirtyDomains: ALL_SCENE_FACT_DOMAINS,
-      })),
-    ];
+  sync(delta: RenderSceneApplyResult): Result<GpuSceneSyncResult, RhiError> {
+    const writes = [...delta.createdSlots, ...delta.updatedSlots, ...delta.recreatedSlots];
     const changedSlots = [
-      ...writes.map(({ record }) => record.slot),
+      ...writes.map((record) => record.slot),
       ...delta.removedSlots.map((r) => r.slot),
     ];
-    if (changedSlots.length === 0 && this.pendingSubmittedSlots.size === 0) {
+    if (changedSlots.length === 0) {
       this.noChangeFrames += 1;
       return ok({ ranges: 0, bytes: 0, grew: false, cleared: 0 });
     }
@@ -318,13 +265,7 @@ export class GpuScene {
       drawTemplate: [],
       material: [],
     };
-    for (const { record } of writes) this.ensureAllocation(record, writesByTable);
-    const changedSlotSet = new Set(changedSlots);
-    const submittedOnly = [...this.pendingSubmittedSlots].flatMap((slot) => {
-      if (changedSlotSet.has(slot)) return [];
-      const record = projection.slotByIndex(slot);
-      return record === undefined ? [] : [record];
-    });
+    for (const record of writes) this.ensureAllocation(record, writesByTable);
     const requiredCapacity = Math.max(
       Math.max(...changedSlots) + 1,
       this.instances.requiredCapacity(),
@@ -338,17 +279,9 @@ export class GpuScene {
       if (!grown.ok) return grown;
     }
 
-    for (const write of writes) {
-      const temporal = projection.temporalSnapshotBySlot(write.record.slot);
-      if (temporal !== undefined) {
-        this.writeSlot(write.record, temporal, writesByTable, write.dirtyDomains);
-      }
-    }
-    for (const record of submittedOnly) {
-      const temporal = projection.temporalSnapshotBySlot(record.slot);
-      if (temporal !== undefined) this.writePreviousTransforms(record, temporal, writesByTable);
-    }
-    this.pendingSubmittedSlots.clear();
+    for (const record of delta.createdSlots) this.writeSlot(record, true, writesByTable);
+    for (const record of delta.updatedSlots) this.writeSlot(record, false, writesByTable);
+    for (const record of delta.recreatedSlots) this.writeSlot(record, true, writesByTable);
     for (const record of delta.removedSlots) this.clearSlot(record.slot, writesByTable);
     const uploaded = this.uploadRows(writesByTable);
     if (!uploaded.ok) return uploaded;
@@ -361,9 +294,7 @@ export class GpuScene {
     });
   }
 
-  rebuild(projection: RenderSceneProjection): Result<GpuSceneSyncResult, RhiError> {
-    const slots = projection.slotsSnapshot();
-    this.spatialIndex = projection.inspect().spatialIndex;
+  rebuild(slots: readonly RenderSceneSlot[]): Result<GpuSceneSyncResult, RhiError> {
     this.allocations.clear();
     this.instances.reset();
     this.transforms.reset();
@@ -392,12 +323,7 @@ export class GpuScene {
       grew = true;
     }
     for (const bytes of Object.values(this.tableBytes)) new Uint8Array(bytes).fill(0);
-    for (const slot of slots) {
-      const temporal = projection.temporalSnapshotBySlot(slot.slot);
-      if (temporal !== undefined) {
-        this.writeSlot(slot, temporal, writesByTable, ALL_SCENE_FACT_DOMAINS);
-      }
-    }
+    for (const slot of slots) this.writeSlot(slot, true, writesByTable);
     let bytes = 0;
     for (const name of TABLE_NAMES) {
       const table = this.tableBytes[name];
@@ -408,26 +334,40 @@ export class GpuScene {
     this.uploadRanges += TABLE_NAMES.length;
     this.uploadBytes += bytes;
     this.fullRebuilds += 1;
-    this.pendingSubmittedSlots.clear();
     return ok({ ranges: TABLE_NAMES.length, bytes, grew, cleared: 0 });
   }
 
   inspect(): GpuSceneInspection {
     return {
       capacity: this.capacity,
-      tables: Object.fromEntries(
-        TABLE_NAMES.map((name) => [
-          name,
-          { capacity: this.capacity, bytes: this.tableBytes[name].byteLength },
-        ]),
-      ) as unknown as Readonly<Record<GpuSceneTableName, GpuSceneTableInspection>>,
+      tables: {
+        primitive: {
+          capacity: this.capacity,
+          bytes: this.tableBytes.primitive.byteLength,
+        },
+        instance: {
+          capacity: this.capacity,
+          bytes: this.tableBytes.instance.byteLength,
+        },
+        transform: {
+          capacity: this.capacity,
+          bytes: this.tableBytes.transform.byteLength,
+        },
+        drawTemplate: {
+          capacity: this.capacity,
+          bytes: this.tableBytes.drawTemplate.byteLength,
+        },
+        material: {
+          capacity: this.capacity,
+          bytes: this.tableBytes.material.byteLength,
+        },
+      },
       uploadRanges: this.uploadRanges,
       uploadBytes: this.uploadBytes,
       capacityGrows: this.capacityGrows,
       fullRebuilds: this.fullRebuilds,
       clearedSlots: this.clearedSlots,
       noChangeFrames: this.noChangeFrames,
-      spatialIndex: this.spatialIndex,
     };
   }
 
@@ -435,272 +375,195 @@ export class GpuScene {
     for (const buffer of Object.values(this.buffers)) this.device.destroyBuffer(buffer);
   }
 
-  stageSubmitted(delta: RenderSceneSubmissionDelta): void {
-    for (const slot of delta.slots) this.pendingSubmittedSlots.add(slot);
-  }
-
   private writeSlot(
-    record: RenderSceneProjectionSlot,
-    temporal: RenderableTemporalSnapshot,
+    record: RenderSceneSlot,
+    resetPrevious: boolean,
     writes: Record<GpuSceneTableName, number[]>,
-    dirtyDomains: readonly SceneFactRevisionDomain[],
   ): void {
     const allocation = this.allocations.get(record.slot);
     if (allocation === undefined) throw new RangeError('GPU Scene allocation unavailable');
-    const dirty = new Set(dirtyDomains);
-    const writePrimitive =
-      dirty.has('geometry') ||
-      dirty.has('eligibility') ||
-      dirty.has('batch') ||
-      dirty.has('resource');
-    const writeInstances = dirty.has('geometry');
-    const writeLocalTransforms = dirty.has('geometry');
-    const writeTransforms = dirty.has('geometry') || dirty.has('transform') || dirty.has('space');
-    const writeDrawTemplates = dirty.has('geometry') || dirty.has('batch');
-    const writeMaterials = dirty.has('geometry') || dirty.has('material') || dirty.has('resource');
     const primitiveOffset = record.slot * PRIMITIVE.stride;
     const primitive = new DataView(this.tableBytes.primitive);
-    if (writePrimitive) {
-      const bounds =
-        record.fact.bounds.status === 'present' ? record.fact.bounds.localAabb : undefined;
-      let flags = PRIMITIVE_ACTIVE;
-      if (record.fact.bounds.status === 'present') flags |= PRIMITIVE_HAS_BOUNDS;
-      if (record.snapshot.gpuDrivenDraws !== undefined) flags |= PRIMITIVE_GPU_DRIVEN;
-      if (record.fact.mobility === 'static') flags |= PRIMITIVE_STATIC;
-      if (record.fact.mobility === 'dynamic') flags |= PRIMITIVE_DYNAMIC;
-      if (record.fact.casterEligibility === 'eligible') flags |= PRIMITIVE_CASTER_ELIGIBLE;
-      if (record.fact.casterEligibility === 'ineligible') flags |= PRIMITIVE_CASTER_INELIGIBLE;
-      if (record.fact.casterEligibility === 'unknown') flags |= PRIMITIVE_CASTER_UNKNOWN;
-      primitive.setUint32(
-        primitiveOffset + offset(PRIMITIVE, 'generation'),
-        record.generation,
-        true,
-      );
-      primitive.setUint32(primitiveOffset + offset(PRIMITIVE, 'flags'), flags, true);
-      primitive.setUint32(
-        primitiveOffset + offset(PRIMITIVE, 'transformIndex'),
-        allocation.transformStart,
-        true,
+    const bounds = record.snapshot.localAabb;
+    primitive.setUint32(primitiveOffset + offset(PRIMITIVE, 'generation'), record.generation, true);
+    primitive.setUint32(
+      primitiveOffset + 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'), [
+      bounds?.[0] ?? 0,
+      bounds?.[1] ?? 0,
+      bounds?.[2] ?? 0,
+      0,
+    ]);
+    writeVec4(primitive, primitiveOffset + offset(PRIMITIVE, 'localBoundsMax'), [
+      bounds?.[3] ?? 0,
+      bounds?.[4] ?? 0,
+      bounds?.[5] ?? 0,
+      0,
+    ]);
+
+    const instance = new DataView(this.tableBytes.instance);
+    const transform = new DataView(this.tableBytes.transform);
+    for (let ordinal = 0; ordinal < allocation.instanceCount; ordinal += 1) {
+      const instanceIndex = allocation.instanceStart + ordinal;
+      const instanceOffset = instanceIndex * INSTANCE.stride;
+      const transformIndex = allocation.transformStart + 1 + ordinal;
+      instance.setUint32(instanceOffset + offset(INSTANCE, 'primitiveIndex'), record.slot, true);
+      instance.setUint32(instanceOffset + offset(INSTANCE, 'transformIndex'), transformIndex, true);
+      instance.setUint32(instanceOffset + offset(INSTANCE, 'customDataStart'), 0, true);
+      instance.setUint32(instanceOffset + offset(INSTANCE, 'flags'), PRIMITIVE_ACTIVE, true);
+      const local = record.snapshot.instances?.transforms.subarray(ordinal * 16, ordinal * 16 + 16);
+      const localWorld = local?.length === 16 ? local : IDENTITY_MATRIX;
+      const localOffset = transformIndex * TRANSFORM.stride;
+      const localCurrentOffset = localOffset + offset(TRANSFORM, 'currentWorld');
+      const localPreviousOffset = localOffset + offset(TRANSFORM, 'previousWorld');
+      const priorLocal = new Uint8Array(
+        this.tableBytes.transform.slice(localCurrentOffset, localCurrentOffset + 64),
       );
-      primitive.setUint32(
-        primitiveOffset + offset(PRIMITIVE, 'materialIndex'),
-        allocation.materialStart,
+      writeMat4(transform, localCurrentOffset, localWorld);
+      if (!resetPrevious && priorLocal.some((value) => value !== 0)) {
+        new Uint8Array(this.tableBytes.transform, localPreviousOffset, 64).set(priorLocal);
+      } else {
+        writeMat4(transform, localPreviousOffset, localWorld);
+      }
+      writes.instance.push(instanceIndex);
+      writes.transform.push(transformIndex);
+    }
+
+    const transformOffset = allocation.transformStart * TRANSFORM.stride;
+    const currentOffset = transformOffset + offset(TRANSFORM, 'currentWorld');
+    const previousOffset = transformOffset + offset(TRANSFORM, 'previousWorld');
+    const priorCurrent = new Uint8Array(
+      this.tableBytes.transform.slice(currentOffset, currentOffset + 64),
+    );
+    const hasPrior = !resetPrevious && priorCurrent.some((value) => value !== 0);
+    writeMat4(transform, currentOffset, record.snapshot.transform.world);
+    if (hasPrior) new Uint8Array(this.tableBytes.transform, previousOffset, 64).set(priorCurrent);
+    else writeMat4(transform, previousOffset, record.snapshot.transform.world);
+    writes.primitive.push(record.slot);
+    writes.transform.push(allocation.transformStart);
+
+    const draw = new DataView(this.tableBytes.drawTemplate);
+    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;
+      const drawSnapshot = drawSnapshots[ordinal];
+      draw.setUint32(
+        drawOffset + offset(DRAW_TEMPLATE, 'pipelineClass'),
+        drawSnapshot === undefined ? 0 : stableU32(drawSnapshot.pipelineClass),
         true,
       );
-      primitive.setUint32(
-        primitiveOffset + offset(PRIMITIVE, 'drawTemplateIndex'),
-        allocation.drawStart,
+      draw.setUint32(
+        drawOffset + offset(DRAW_TEMPLATE, 'materialIndex'),
+        allocation.materialStart + (drawSnapshot?.materialSlot ?? 0),
         true,
       );
-      primitive.setUint32(
-        primitiveOffset + offset(PRIMITIVE, 'instanceStart'),
-        allocation.instanceStart,
+      draw.setUint32(
+        drawOffset + offset(DRAW_TEMPLATE, 'firstIndex'),
+        drawSnapshot?.first ?? 0,
         true,
       );
-      primitive.setUint32(
-        primitiveOffset + offset(PRIMITIVE, 'instanceCount'),
-        allocation.instanceCount,
+      draw.setUint32(
+        drawOffset + offset(DRAW_TEMPLATE, 'indexCount'),
+        drawSnapshot?.count ?? 0,
         true,
       );
-      primitive.setUint32(
-        primitiveOffset + offset(PRIMITIVE, 'assetHandle'),
-        record.snapshot.assetHandle,
+      draw.setInt32(
+        drawOffset + offset(DRAW_TEMPLATE, 'baseVertex'),
+        drawSnapshot?.baseVertex ?? 0,
         true,
       );
-      writeVec4(primitive, primitiveOffset + offset(PRIMITIVE, 'localBoundsMin'), [
-        bounds?.[0] ?? 0,
-        bounds?.[1] ?? 0,
-        bounds?.[2] ?? 0,
-        0,
-      ]);
-      writeVec4(primitive, primitiveOffset + offset(PRIMITIVE, 'localBoundsMax'), [
-        bounds?.[3] ?? 0,
-        bounds?.[4] ?? 0,
-        bounds?.[5] ?? 0,
-        0,
-      ]);
-      writes.primitive.push(record.slot);
-    }
-
-    const instance = new DataView(this.tableBytes.instance);
-    const transform = new DataView(this.tableBytes.transform);
-    if (writeInstances || writeLocalTransforms) {
-      for (let ordinal = 0; ordinal < allocation.instanceCount; ordinal += 1) {
-        const instanceIndex = allocation.instanceStart + ordinal;
-        const instanceOffset = instanceIndex * INSTANCE.stride;
-        const transformIndex = allocation.transformStart + 1 + ordinal;
-        if (writeInstances) {
-          instance.setUint32(
-            instanceOffset + offset(INSTANCE, 'primitiveIndex'),
-            record.slot,
-            true,
-          );
-          instance.setUint32(
-            instanceOffset + offset(INSTANCE, 'transformIndex'),
-            transformIndex,
-            true,
-          );
-          instance.setUint32(instanceOffset + offset(INSTANCE, 'customDataStart'), 0, true);
-          instance.setUint32(instanceOffset + offset(INSTANCE, 'flags'), PRIMITIVE_ACTIVE, true);
-          writes.instance.push(instanceIndex);
-        }
-        if (writeLocalTransforms) {
-          const local = record.snapshot.instances?.transforms.subarray(
-            ordinal * 16,
-            ordinal * 16 + 16,
-          );
-          const localWorld = local?.length === 16 ? local : IDENTITY_MATRIX;
-          const localOffset = transformIndex * TRANSFORM.stride;
-          const localCurrentOffset = localOffset + offset(TRANSFORM, 'currentWorld');
-          const localPreviousOffset = localOffset + offset(TRANSFORM, 'previousWorld');
-          writeMat4(transform, localCurrentOffset, localWorld);
-          const previousLocal = temporal.previousInstances?.transforms.subarray(
-            ordinal * 16,
-            ordinal * 16 + 16,
-          );
-          writeMat4(
-            transform,
-            localPreviousOffset,
-            previousLocal?.length === 16 ? previousLocal : localWorld,
-          );
-          writes.transform.push(transformIndex);
-        }
-      }
-    }
-
-    if (writeTransforms) {
-      const transformOffset = allocation.transformStart * TRANSFORM.stride;
-      const currentOffset = transformOffset + offset(TRANSFORM, 'currentWorld');
-      const previousOffset = transformOffset + offset(TRANSFORM, 'previousWorld');
-      writeMat4(transform, currentOffset, record.snapshot.transform.world);
-      writeMat4(transform, previousOffset, temporal.previousTransform.world);
-      writes.transform.push(allocation.transformStart);
-    }
-
-    const draw = new DataView(this.tableBytes.drawTemplate);
-    const drawSnapshots = record.snapshot.gpuDrivenDraws ?? [];
-    if (writeDrawTemplates) {
-      for (let ordinal = 0; ordinal < allocation.drawCount; ordinal += 1) {
-        const drawIndex = allocation.drawStart + ordinal;
-        const drawOffset = drawIndex * DRAW_TEMPLATE.stride;
-        const drawSnapshot = drawSnapshots[ordinal];
-        draw.setUint32(
-          drawOffset + offset(DRAW_TEMPLATE, 'pipelineClass'),
-          drawSnapshot === undefined ? 0 : stableU32(drawSnapshot.pipelineClass),
-          true,
-        );
-        draw.setUint32(
-          drawOffset + offset(DRAW_TEMPLATE, 'materialIndex'),
-          allocation.materialStart + (drawSnapshot?.materialSlot ?? 0),
-          true,
-        );
-        draw.setUint32(
-          drawOffset + offset(DRAW_TEMPLATE, 'firstIndex'),
-          drawSnapshot?.first ?? 0,
-          true,
-        );
-        draw.setUint32(
-          drawOffset + offset(DRAW_TEMPLATE, 'indexCount'),
-          drawSnapshot?.count ?? 0,
-          true,
-        );
-        draw.setInt32(
-          drawOffset + offset(DRAW_TEMPLATE, '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(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);
     }
 
     const material = new DataView(this.tableBytes.material);
-    if (writeMaterials) {
-      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;
-        writeVec4(material, materialOffset + offset(MATERIAL, 'params0'), [
-          snapshot.baseColor?.[0] ?? 0,
-          snapshot.baseColor?.[1] ?? 0,
-          snapshot.baseColor?.[2] ?? 0,
-          1,
-        ]);
-        writeVec4(material, materialOffset + offset(MATERIAL, 'params1'), [
-          snapshot.metallic ?? 0,
-          snapshot.roughness ?? 1,
-          snapshot.clearcoat ?? 0,
-          snapshot.clearcoatRoughness ?? 0,
-        ]);
-        writeVec4(material, materialOffset + offset(MATERIAL, 'params2'), [
-          snapshot.emissive?.[0] ?? 0,
-          snapshot.emissive?.[1] ?? 0,
-          snapshot.emissive?.[2] ?? 0,
-          snapshot.emissiveIntensity ?? 0,
-        ]);
-        writeVec4(material, materialOffset + offset(MATERIAL, 'params3'), [
-          snapshot.normalScale ?? 1,
-          snapshot.occlusionStrength ?? 1,
-          0,
-          0,
-        ]);
-        material.setUint32(
-          materialOffset + offset(MATERIAL, 'resource0'),
-          snapshot.baseColorTexture ?? 0,
-          true,
-        );
-        material.setUint32(
-          materialOffset + offset(MATERIAL, 'resource1'),
-          snapshot.metallicRoughnessTexture ?? 0,
-          true,
-        );
-        material.setUint32(
-          materialOffset + offset(MATERIAL, 'resource2'),
-          snapshot.normalTexture ?? 0,
-          true,
-        );
-        material.setUint32(
-          materialOffset + offset(MATERIAL, 'resource3'),
-          snapshot.emissiveTexture ?? 0,
-          true,
-        );
-        writes.material.push(materialIndex);
-      }
-    }
-  }
-
-  private writePreviousTransforms(
-    record: RenderSceneProjectionSlot,
-    temporal: RenderableTemporalSnapshot,
-    writes: Record<GpuSceneTableName, number[]>,
-  ): void {
-    const allocation = this.allocations.get(record.slot);
-    if (allocation === undefined) return;
-    const transform = new DataView(this.tableBytes.transform);
-    const rootOffset =
-      allocation.transformStart * TRANSFORM.stride + offset(TRANSFORM, 'previousWorld');
-    writeMat4(transform, rootOffset, temporal.previousTransform.world);
-    writes.transform.push(allocation.transformStart);
-    for (let ordinal = 0; ordinal < allocation.instanceCount; ordinal += 1) {
-      const transformIndex = allocation.transformStart + 1 + ordinal;
-      const previous = temporal.previousInstances?.transforms.subarray(
-        ordinal * 16,
-        ordinal * 16 + 16,
+    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;
+      writeVec4(material, materialOffset + offset(MATERIAL, 'params0'), [
+        snapshot.baseColor?.[0] ?? 0,
+        snapshot.baseColor?.[1] ?? 0,
+        snapshot.baseColor?.[2] ?? 0,
+        1,
+      ]);
+      writeVec4(material, materialOffset + offset(MATERIAL, 'params1'), [
+        snapshot.metallic ?? 0,
+        snapshot.roughness ?? 1,
+        snapshot.clearcoat ?? 0,
+        snapshot.clearcoatRoughness ?? 0,
+      ]);
+      writeVec4(material, materialOffset + offset(MATERIAL, 'params2'), [
+        snapshot.emissive?.[0] ?? 0,
+        snapshot.emissive?.[1] ?? 0,
+        snapshot.emissive?.[2] ?? 0,
+        snapshot.emissiveIntensity ?? 0,
+      ]);
+      writeVec4(material, materialOffset + offset(MATERIAL, 'params3'), [
+        snapshot.normalScale ?? 1,
+        snapshot.occlusionStrength ?? 1,
+        0,
+        0,
+      ]);
+      material.setUint32(
+        materialOffset + offset(MATERIAL, 'resource0'),
+        snapshot.baseColorTexture ?? 0,
+        true,
       );
-      const current = record.snapshot.instances?.transforms.subarray(
-        ordinal * 16,
-        ordinal * 16 + 16,
+      material.setUint32(
+        materialOffset + offset(MATERIAL, 'resource1'),
+        snapshot.metallicRoughnessTexture ?? 0,
+        true,
       );
-      const value = previous?.length === 16 ? previous : current;
-      if (value?.length !== 16) continue;
-      writeMat4(
-        transform,
-        transformIndex * TRANSFORM.stride + offset(TRANSFORM, 'previousWorld'),
-        value,
+      material.setUint32(
+        materialOffset + offset(MATERIAL, 'resource2'),
+        snapshot.normalTexture ?? 0,
+        true,
       );
-      writes.transform.push(transformIndex);
+      material.setUint32(
+        materialOffset + offset(MATERIAL, 'resource3'),
+        snapshot.emissiveTexture ?? 0,
+        true,
+      );
+      writes.material.push(materialIndex);
     }
   }
 
@@ -743,7 +606,7 @@ export class GpuScene {
   }
 
   private ensureAllocation(
-    record: RenderSceneProjectionSlot,
+    record: RenderSceneSlot,
     writes: Record<GpuSceneTableName, number[]>,
   ): void {
     const instanceCount = Math.max(1, record.snapshot.instances?.instanceCount ?? 1);
@@ -848,8 +711,12 @@ export class GpuScene {
   }
 
   private allocateCpuTables(capacity: number): Record<GpuSceneTableName, ArrayBuffer> {
-    return Object.fromEntries(
-      TABLE_NAMES.map((name) => [name, new ArrayBuffer(capacity * TABLE_LAYOUTS[name].stride)]),
-    ) as unknown as Record<GpuSceneTableName, ArrayBuffer>;
+    return {
+      primitive: new ArrayBuffer(capacity * PRIMITIVE.stride),
+      instance: new ArrayBuffer(capacity * INSTANCE.stride),
+      transform: new ArrayBuffer(capacity * TRANSFORM.stride),
+      drawTemplate: new ArrayBuffer(capacity * DRAW_TEMPLATE.stride),
+      material: new ArrayBuffer(capacity * MATERIAL.stride),
+    };
   }
 }