@forgeax/engine-render 0.1.32 → 0.1.34

package/src/gpu-driven/resource-allocation.ts

@@ -0,0 +1,142 @@
+import type { GpuResourceAllocationInspection } from '../inspection-types';
+
+export interface GpuResourceAllocationToken {
+  readonly id: number;
+  readonly bytes: number;
+}
+
+/**
+ * Tracks logical Engine allocation ownership independently of physical GPU
+ * residency. A replacement is live and pending at the same time until the
+ * queue fence releases the old generation.
+ */
+export class GpuResourceAllocationLedger {
+  private nextId = 1;
+  private readonly live = new Map<number, number>();
+  private readonly pending = new Map<number, number>();
+  private liveBytes = 0;
+  private pendingBytes = 0;
+  private peakBytes = 0;
+  private successfulAllocationCount = 0;
+  private successfulAllocationBytes = 0;
+  private retiredBytes = 0;
+  private failedAllocationRollbacks = 0;
+  private failedAllocationRollbackBytes = 0;
+
+  allocate(bytes: number): GpuResourceAllocationToken {
+    if (!Number.isFinite(bytes) || bytes < 0) {
+      throw new RangeError(`GPU allocation bytes must be finite and non-negative (got ${bytes})`);
+    }
+    const token = { id: this.nextId++, bytes };
+    this.live.set(token.id, token.bytes);
+    this.liveBytes += token.bytes;
+    this.successfulAllocationCount += 1;
+    this.successfulAllocationBytes += token.bytes;
+    this.updatePeak();
+    return token;
+  }
+
+  retire(token: GpuResourceAllocationToken): void {
+    const bytes = this.live.get(token.id);
+    if (bytes === undefined) return;
+    this.live.delete(token.id);
+    this.liveBytes -= bytes;
+    this.pending.set(token.id, bytes);
+    this.pendingBytes += bytes;
+    this.updatePeak();
+  }
+
+  release(token: GpuResourceAllocationToken): void {
+    const pendingBytes = this.pending.get(token.id);
+    if (pendingBytes !== undefined) {
+      this.pending.delete(token.id);
+      this.pendingBytes -= pendingBytes;
+      this.retiredBytes += pendingBytes;
+      return;
+    }
+    const liveBytes = this.live.get(token.id);
+    if (liveBytes !== undefined) {
+      this.live.delete(token.id);
+      this.liveBytes -= liveBytes;
+      this.retiredBytes += liveBytes;
+    }
+  }
+
+  rollback(token: GpuResourceAllocationToken): void {
+    const bytes = this.live.get(token.id);
+    if (bytes === undefined) return;
+    this.live.delete(token.id);
+    this.liveBytes -= bytes;
+    this.failedAllocationRollbacks += 1;
+    this.failedAllocationRollbackBytes += bytes;
+  }
+
+  inspect(): GpuResourceAllocationInspection {
+    return {
+      unit: 'engine-allocation-bytes',
+      physicalResidency: 'unknown',
+      liveBytes: this.liveBytes,
+      pendingRetirementBytes: this.pendingBytes,
+      peakBytes: this.peakBytes,
+      successfulAllocationCount: this.successfulAllocationCount,
+      successfulAllocationBytes: this.successfulAllocationBytes,
+      pendingRetirementCount: this.pending.size,
+      retiredBytes: this.retiredBytes,
+      failedAllocationRollbacks: this.failedAllocationRollbacks,
+      failedAllocationRollbackBytes: this.failedAllocationRollbackBytes,
+    };
+  }
+
+  private updatePeak(): void {
+    this.peakBytes = Math.max(this.peakBytes, this.liveBytes + this.pendingBytes);
+  }
+}
+
+export function combineGpuResourceAllocationInspections(
+  inspections: readonly GpuResourceAllocationInspection[],
+): GpuResourceAllocationInspection | undefined {
+  if (inspections.length === 0) return undefined;
+  const liveBytes = inspections.reduce((sum, value) => sum + value.liveBytes, 0);
+  const pendingRetirementBytes = inspections.reduce(
+    (sum, value) => sum + value.pendingRetirementBytes,
+    0,
+  );
+  // Each owner reports its own historical high-water mark. Adding those
+  // marks invents overlap between replacements that happened at different
+  // times. The aggregate can prove the current simultaneous occupancy, or
+  // retain the largest owner-local mark as a conservative lower-bound fact
+  // when all resources have since retired; it cannot claim their historical
+  // sum without an event-time aggregate owner.
+  const peakBytes = Math.max(
+    liveBytes + pendingRetirementBytes,
+    ...inspections.map((value) => value.peakBytes),
+  );
+  return {
+    unit: 'engine-allocation-bytes',
+    physicalResidency: 'unknown',
+    liveBytes,
+    pendingRetirementBytes,
+    peakBytes,
+    successfulAllocationCount: inspections.reduce(
+      (sum, value) => sum + value.successfulAllocationCount,
+      0,
+    ),
+    successfulAllocationBytes: inspections.reduce(
+      (sum, value) => sum + value.successfulAllocationBytes,
+      0,
+    ),
+    pendingRetirementCount: inspections.reduce(
+      (sum, value) => sum + value.pendingRetirementCount,
+      0,
+    ),
+    retiredBytes: inspections.reduce((sum, value) => sum + value.retiredBytes, 0),
+    failedAllocationRollbacks: inspections.reduce(
+      (sum, value) => sum + value.failedAllocationRollbacks,
+      0,
+    ),
+    failedAllocationRollbackBytes: inspections.reduce(
+      (sum, value) => sum + value.failedAllocationRollbackBytes,
+      0,
+    ),
+  };
+}

package/src/gpu-driven/shadow-ownership.ts

@@ -0,0 +1,71 @@
+import type { World } from '@forgeax/engine-ecs';
+import { gpuDrivenShadowDrawKey } from '../extract/gpu-driven';
+import { worldEntityKey } from '../record/frame-snapshot';
+import type { ShadowCasterMembership } from '../render-system-extract';
+
+const WORLD_ENTITY_KEY_STRIDE = 4294967296;
+
+/**
+ * Extract emits world/entity keys in the transient `worlds[]` index domain,
+ * while PersistentRenderScene owns stable renderer-local World keys for the
+ * retained GPU scene. Rebase ShadowCaster ownership at this orchestration
+ * boundary before both GPU projection and CPU residual recording consume it.
+ */
+export function rebaseShadowCasterOwnership(
+  worlds: readonly World[],
+  stableWorldKeys: readonly number[],
+  entityKeys: ReadonlySet<number>,
+  drawKeys: ReadonlySet<string>,
+  membership: readonly ShadowCasterMembership[] | undefined,
+): {
+  readonly entityKeys: ReadonlySet<number>;
+  readonly drawKeys: ReadonlySet<string>;
+  readonly membership: readonly ShadowCasterMembership[] | undefined;
+} {
+  const rebaseWorldEntity = (composite: number): number => {
+    const transientWorldId = Math.floor(composite / WORLD_ENTITY_KEY_STRIDE);
+    if (
+      !Number.isInteger(transientWorldId) ||
+      transientWorldId < 0 ||
+      transientWorldId >= worlds.length
+    ) {
+      return composite;
+    }
+    const entityKey = composite - transientWorldId * WORLD_ENTITY_KEY_STRIDE;
+    return worldEntityKey(stableWorldKeys[transientWorldId] ?? transientWorldId, entityKey);
+  };
+
+  const stableMembership =
+    membership === undefined
+      ? undefined
+      : membership.map((entry) => ({
+          ...entry,
+          worldEntity: rebaseWorldEntity(entry.worldEntity),
+        }));
+  const stableDrawKeys =
+    stableMembership === undefined
+      ? new Set(
+          [...drawKeys].map((key) => {
+            const parts = key.split(':');
+            if (parts.length !== 4) return key;
+            const transientWorldEntity = Number(parts[0]);
+            if (!Number.isFinite(transientWorldEntity)) return key;
+            return `${rebaseWorldEntity(transientWorldEntity)}:${parts[1]}:${parts[2]}:${parts[3]}`;
+          }),
+        )
+      : new Set(
+          stableMembership.map((entry) =>
+            gpuDrivenShadowDrawKey(
+              entry.worldEntity,
+              entry.materialHandle,
+              entry.drawItemIndex,
+              entry.passIndex,
+            ),
+          ),
+        );
+  return {
+    entityKeys: new Set([...entityKeys].map(rebaseWorldEntity)),
+    drawKeys: stableDrawKeys,
+    membership: stableMembership,
+  };
+}

package/src/gpu-driven/view-gpu.ts

@@ -25,8 +25,20 @@ import {
   GPU_BUFFER_USAGE_UNIFORM,
 } from '../gpu-usage';
 import type { PipelineBuilderShaderModuleFactory } from '../pipeline-builder';
+import { getOpaqueResourceIdentity } from '../record/frame-snapshot';
+import type {
+  SurfaceGpuIndirectParameters,
+  SurfaceGpuIndirectReadbackError,
+  SurfaceGpuReadbackSnapshot,
+  SurfaceSubmissionCandidate,
+} from '../surface/submission-observation';
+import { decodeSurfaceIndirectParameters } from '../surface/submission-observation';
 import type { GpuDrivenCandidate, SubmissionPlan } from './batch-topology';
 import { GPU_DRIVEN_SKIN_FLAG } from './batch-topology';
+import {
+  GpuResourceAllocationLedger,
+  type GpuResourceAllocationToken,
+} from './resource-allocation';
 
 const COMPUTE_STAGE = 0x4;
 const WORKGROUP_SIZE = 64;
@@ -43,6 +55,7 @@ const COUNTER_WORDS = 2 + LOD_ROW_CAPACITY + 2;
 const GEOMETRY_WORK_COUNTER_OFFSET = 2 + LOD_ROW_CAPACITY;
 const ROOT_GEOMETRY_WORK_COUNTER_OFFSET = GEOMETRY_WORK_COUNTER_OFFSET + 1;
 const COUNTER_STRIDE = COUNTER_WORDS * 4;
+const INDIRECT_COMMAND_BYTES = 20;
 type GpuDrivenAdmissionCandidate = GpuDrivenCandidate & {
   readonly submitAdmission?: boolean;
 };
@@ -168,7 +181,7 @@ fn selectLodLevel(
 @group(0) @binding(4) var<storage, read> batches: array<BatchRecord>;
 @group(0) @binding(5) var<uniform> view: ViewConstants;
 @group(0) @binding(6) var<storage, read_write> counters: array<atomic<u32>>;
-@group(0) @binding(7) var<storage, read_write> visibleIndices: array<vec2<u32>>;
+@group(0) @binding(7) var<storage, read_write> visibleIndices: array<vec4<u32>>;
 @group(0) @binding(8) var<storage, read_write> indirectArgs: array<u32>;
 
 fn counterIndex(batchIndex: u32) -> u32 { return batchIndex * ${COUNTER_WORDS}u; }
@@ -253,9 +266,11 @@ fn cullView(@builtin(global_invocation_id) id: vec3<u32>) {
   if ((candidate.materialSlot & 0x80000000u) != 0u) {
     materialOrPalette = instance.customDataStart;
   }
-  visibleIndices[candidate.visibleBase + localVisible] = vec2<u32>(
+  visibleIndices[candidate.visibleBase + localVisible] = vec4<u32>(
     candidate.submitAdmission >> 1u,
     materialOrPalette,
+    candidate.primitiveIndex + 1u,
+    candidate.generation,
   );
 }
 
@@ -278,10 +293,22 @@ fn finalizeView(@builtin(global_invocation_id) id: vec3<u32>) {
   let candidate = candidates[batch.candidateBase];
   let selectedLod = selectLodLevel(candidate.projectedHeight, candidate.previousLevel, candidate.historyValid != 0u, candidate.lodRows, candidate.lodCount);
   let lod = candidate.lodRows[selectedLod];
-  indirectArgs[args] = select(batch.count, lod.indexCount, candidate.lodCount > 0u);
+  var drawCount = batch.count;
+  var drawFirst = batch.first;
+  var drawBaseVertex: i32 = 0;
+  if (candidate.lodCount > 0u) {
+    drawCount = lod.indexCount;
+    if (batch.indexed != 0u) {
+      drawFirst = lod.firstIndex;
+      drawBaseVertex = lod.baseVertex;
+    }
+  } else if (batch.indexed != 0u) {
+    drawBaseVertex = batch.baseVertex;
+  }
+  indirectArgs[args] = drawCount;
   indirectArgs[args + 1u] = visibleCount;
-  indirectArgs[args + 2u] = select(batch.first, lod.firstIndex, candidate.lodCount > 0u && batch.indexed != 0u);
-  indirectArgs[args + 3u] = select(0u, bitcast<u32>(lod.baseVertex), candidate.lodCount > 0u && batch.indexed != 0u);
+  indirectArgs[args + 2u] = drawFirst;
+  indirectArgs[args + 3u] = bitcast<u32>(drawBaseVertex);
   indirectArgs[args + 4u] = 0u;
 }
 `;
@@ -302,8 +329,17 @@ type LodTelemetryCopy = {
   readonly buffers: ViewBuffers;
   readonly plan: SubmissionPlan;
   readonly resourceGeneration: number;
+  readonly indirectBufferIdentity: number;
+  readonly indirectReadbackOffset: number;
+  readonly surfaceReadbackSnapshot?: () => SurfaceGpuReadbackSnapshot | undefined;
+  readonly submit?: GpuDrivenLodSubmitIdentity;
 };
 
+export interface GpuDrivenLodSubmitIdentity {
+  readonly frameId: number;
+  readonly deviceGeneration: number;
+}
+
 export interface GpuDrivenViewGraphResources {
   readonly primitive: GraphBuffer;
   readonly instance: GraphBuffer;
@@ -332,6 +368,8 @@ export interface GpuDrivenViewInspection {
   readonly bindGroupCreates: number;
   readonly bufferRebuilds: number;
   readonly resourceGeneration: number;
+  /** Logical Engine allocation facts; physical VRAM residency is unknown. */
+  readonly resourceAllocation: import('../inspection-types').GpuResourceAllocationInspection;
 }
 
 export interface GpuDrivenViewBufferCapacities {
@@ -342,6 +380,8 @@ export interface GpuDrivenViewBufferCapacities {
 }
 
 export interface GpuDrivenLodSelectionInspection {
+  /** Exact resource generation whose selector rows were copied. */
+  readonly resourceGeneration?: number;
   readonly candidateCount: number;
   readonly batchCount: number;
   readonly indirectDrawCount: number;
@@ -369,6 +409,24 @@ export interface GpuDrivenLodSelectionInspection {
   }[];
   readonly geometryWork: number;
   readonly rootGeometryWork: number;
+  /** Actual visible rows copied from the submitted GPU selector. */
+  readonly actualMembers: readonly {
+    readonly batchId: number;
+    readonly primitiveIndex: number;
+    readonly generation: number;
+    readonly drawItemIndex: number;
+    readonly instanceOrdinal: number;
+  }[];
+  /** Surface subset projected by the material producer after readback. */
+  readonly surfaceActualMemberIds?: readonly string[];
+  /** Decoded indexed/non-indexed command words for the exact Surface copy. */
+  readonly surfaceIndirectParameters?: readonly SurfaceGpuIndirectParameters[];
+  /** Fail-closed readback reason when the copied command range is unusable. */
+  readonly surfaceIndirectReadbackError?: SurfaceGpuIndirectReadbackError;
+  /** Exact Surface recording whose selector bytes were copied. */
+  readonly surfaceReadback?: SurfaceGpuReadbackSnapshot;
+  /** Public receipt identity captured when the telemetry copy was encoded. */
+  readonly submit?: GpuDrivenLodSubmitIdentity;
 }
 
 function nextCapacity(required: number): number {
@@ -429,8 +487,12 @@ export class GpuDrivenView {
   private bindGroupCreates = 0;
   private bufferRebuilds = 0;
   private resourceGeneration = 0;
+  private readonly allocationLedger = new GpuResourceAllocationLedger();
+  private readonly allocationTokens = new WeakMap<Buffer, GpuResourceAllocationToken>();
   /** The last readback copy that was actually encoded and is not consumed. */
   private telemetryPending: LodTelemetryCopy | undefined;
+  /** Receipt identity for the copy pass encoded by the current frame. */
+  private telemetrySubmit: GpuDrivenLodSubmitIdentity | undefined;
   /** Coalesce observers while the readback buffer is map-pending. */
   private lodSelectionReadback:
     | {
@@ -449,6 +511,10 @@ export class GpuDrivenView {
     private readonly labelPrefix: string,
   ) {}
 
+  setTelemetrySubmit(identity: GpuDrivenLodSubmitIdentity | undefined): void {
+    this.telemetrySubmit = identity;
+  }
+
   static create(input: {
     readonly device: RhiDevice;
     readonly shaderModuleFactory: PipelineBuilderShaderModuleFactory;
@@ -706,6 +772,7 @@ export class GpuDrivenView {
       bindGroupCreates: this.bindGroupCreates,
       bufferRebuilds: this.bufferRebuilds,
       resourceGeneration: this.resourceGeneration,
+      resourceAllocation: this.allocationLedger.inspect(),
     };
   }
 
@@ -770,6 +837,13 @@ export class GpuDrivenView {
       let overflow = false;
       let geometryWork = 0;
       let rootGeometryWork = 0;
+      const actualMembers: Array<{
+        readonly batchId: number;
+        readonly primitiveIndex: number;
+        readonly generation: number;
+        readonly drawItemIndex: number;
+        readonly instanceOrdinal: number;
+      }> = [];
       const histogram = new Map<number, number>();
       for (let batchIndex = 0; batchIndex < plan.batches.length; batchIndex += 1) {
         const offset = batchIndex * COUNTER_STRIDE;
@@ -780,6 +854,33 @@ export class GpuDrivenView {
               values.getUint32(offset, true),
               plan.batches[batchIndex]?.visibleCapacity ?? 0,
             );
+        const batch = plan.batches[batchIndex];
+        const admitted =
+          batch?.candidates.filter(
+            (candidate) => (candidate as GpuDrivenAdmissionCandidate).submitAdmission !== false,
+          ) ?? [];
+        for (let visibleIndex = 0; visibleIndex < batchVisible; visibleIndex += 1) {
+          const visibleOffset =
+            this.batchCapacity * COUNTER_STRIDE + ((batch?.visibleBase ?? 0) + visibleIndex) * 16;
+          const projectionIndex = values.getUint32(visibleOffset, true);
+          const primitiveIndex = values.getUint32(visibleOffset + 8, true) - 1;
+          const generation = values.getUint32(visibleOffset + 12, true);
+          const candidate = admitted[projectionIndex];
+          if (
+            batch !== undefined &&
+            candidate !== undefined &&
+            candidate.primitiveIndex === primitiveIndex &&
+            candidate.generation === generation
+          ) {
+            actualMembers.push({
+              batchId: batch.batchId,
+              primitiveIndex,
+              generation,
+              drawItemIndex: candidate.drawItemIndex,
+              instanceOrdinal: candidate.instanceOrdinal,
+            });
+          }
+        }
         visible += batchVisible;
         overflow ||= batchOverflow;
         geometryWork += values.getUint32(offset + GEOMETRY_WORK_COUNTER_OFFSET * 4, true);
@@ -800,7 +901,19 @@ export class GpuDrivenView {
         return undefined;
       }
       const candidateCount = plan.candidateCount;
+      const surfaceReadback = copy.surfaceReadbackSnapshot?.();
+      const surfaceIndirectReadback =
+        surfaceReadback === undefined
+          ? undefined
+          : decodeSurfaceIndirectParameters({
+              bytes: range.value,
+              byteOffset: copy.indirectReadbackOffset,
+              byteLength: this.indirectCapacity * INDIRECT_COMMAND_BYTES,
+              indirectBufferIdentity: copy.indirectBufferIdentity,
+              recording: surfaceReadback,
+            });
       this.lodSelection = Object.freeze({
+        resourceGeneration: copy.resourceGeneration,
         candidateCount,
         batchCount: plan.batches.length,
         // Selector-only batches remain in the plan/readback but the production
@@ -848,6 +961,14 @@ export class GpuDrivenView {
         ),
         geometryWork,
         rootGeometryWork,
+        actualMembers: Object.freeze(actualMembers),
+        ...(surfaceReadback === undefined ? {} : { surfaceReadback }),
+        ...(surfaceIndirectReadback === undefined
+          ? {}
+          : surfaceIndirectReadback.ok
+            ? { surfaceIndirectParameters: surfaceIndirectReadback.value }
+            : { surfaceIndirectReadbackError: surfaceIndirectReadback.error }),
+        ...(copy.submit === undefined ? {} : { submit: copy.submit }),
       });
       this.telemetryPending = undefined;
       return this.lodSelection;
@@ -860,6 +981,7 @@ export class GpuDrivenView {
     builder: RenderGraphBuilder<FrameCtx>,
     labelPrefix = 'gpu-driven',
     includeCompute = true,
+    surfaceSubmissionObservation?: () => SurfaceSubmissionCandidate | undefined,
   ): Result<GpuDrivenViewGraphResources, RenderGraphError> {
     const buffers = this.buffers;
     const bindGroup = this.bindGroup;
@@ -941,14 +1063,16 @@ export class GpuDrivenView {
     const lodReadback = importBuffer(
       `${labelPrefix}.lod-selection-readback`,
       buffers.lodReadback,
-      this.batchCapacity * COUNTER_STRIDE,
+      this.batchCapacity * COUNTER_STRIDE +
+        this.visibleBufferCapacity * 16 +
+        this.indirectCapacity * INDIRECT_COMMAND_BYTES,
       GPU_BUFFER_USAGE_MAP_READ | GPU_BUFFER_USAGE_COPY_DST,
     );
     if (!lodReadback.ok) return lodReadback;
     const visible = importBuffer(
       `${labelPrefix}.visible`,
       buffers.visible,
-      this.visibleBufferCapacity * 8,
+      this.visibleBufferCapacity * 16,
       GPU_BUFFER_USAGE_STORAGE | GPU_BUFFER_USAGE_COPY_SRC,
     );
     if (!visible.ok) return visible;
@@ -1014,9 +1138,14 @@ export class GpuDrivenView {
     });
     if (!finalize.ok) return finalize;
     const graphResourceGeneration = this.resourceGeneration;
+    const indirectReadbackOffset =
+      this.batchCapacity * COUNTER_STRIDE + this.visibleBufferCapacity * 16;
+    const indirectBufferIdentity = getOpaqueResourceIdentity(buffers.indirect as object);
     const readback = builder.addCopyPass(`${labelPrefix}.lod-selection-readback`, {
       accesses: [
         { resource: counters.value, usage: 'copy-src' },
+        { resource: visible.value, usage: 'copy-src' },
+        { resource: indirect.value, usage: 'copy-src' },
         { resource: lodReadback.value, usage: 'copy-dst' },
       ],
       encode: ({ encoder, resources }) => {
@@ -1032,6 +1161,20 @@ export class GpuDrivenView {
           resources.buffer(lodReadback.value).unwrap(),
           this.batchCapacity * COUNTER_STRIDE,
         );
+        encoder.copyBufferToBuffer(
+          resources.buffer(visible.value).unwrap(),
+          0,
+          resources.buffer(lodReadback.value).unwrap(),
+          this.batchCapacity * COUNTER_STRIDE,
+          this.visibleBufferCapacity * 16,
+        );
+        encoder.copyBufferToBuffer(
+          resources.buffer(indirect.value).unwrap(),
+          0,
+          resources.buffer(lodReadback.value).unwrap(),
+          indirectReadbackOffset,
+          this.indirectCapacity * INDIRECT_COMMAND_BYTES,
+        );
         // The render graph is cached across camera-only LOD projection
         // changes. The pass closure therefore retains the graph-generation
         // plan while `this.plan` carries the plan uploaded for the frame that
@@ -1044,10 +1187,19 @@ export class GpuDrivenView {
           submittedPlan !== undefined &&
           this.resourceGeneration === graphResourceGeneration
         ) {
+          const submittedObservation = surfaceSubmissionObservation?.();
           this.telemetryPending = {
             buffers,
             plan: submittedPlan,
             resourceGeneration: graphResourceGeneration,
+            indirectBufferIdentity,
+            indirectReadbackOffset,
+            ...(submittedObservation === undefined
+              ? {}
+              : {
+                  surfaceReadbackSnapshot: () => submittedObservation.gpuReadbackSnapshot(),
+                }),
+            ...(this.telemetrySubmit === undefined ? {} : { submit: this.telemetrySubmit }),
           };
         }
       },
@@ -1080,8 +1232,10 @@ export class GpuDrivenView {
     this.sceneMaterial = undefined;
     this.sceneCapacity = 0;
     this.telemetryPending = undefined;
+    this.telemetrySubmit = undefined;
     this.lodSelectionReadback = undefined;
     this.lodSelection = undefined;
+    for (const generation of buffers) this.retireGeneration(generation);
     this.destroyAfterSubmittedWork(buffers);
     void this.pipelineLayout;
   }
@@ -1126,6 +1280,7 @@ export class GpuDrivenView {
     const nextBatch = nextCapacity(batchCapacity);
     const nextIndirect = nextCapacity(indirectCapacity);
     const created: Partial<MutableViewBuffers> = {};
+    const createdTokens: GpuResourceAllocationToken[] = [];
     const allocate = (
       name: keyof ViewBuffers,
       size: number,
@@ -1139,6 +1294,9 @@ export class GpuDrivenView {
       });
       if (!buffer.ok) return buffer;
       created[name] = buffer.value;
+      const token = this.allocationLedger.allocate(size);
+      this.allocationTokens.set(buffer.value, token);
+      createdTokens.push(token);
       return ok(undefined);
     };
     const storage = GPU_BUFFER_USAGE_STORAGE | GPU_BUFFER_USAGE_COPY_SRC;
@@ -1167,7 +1325,7 @@ export class GpuDrivenView {
         storage: false,
       },
       { name: 'counters', size: nextBatch * COUNTER_STRIDE, usage: storage, storage: true },
-      { name: 'visible', size: nextVisible * 8, usage: storage, storage: true },
+      { name: 'visible', size: nextVisible * 16, usage: storage, storage: true },
       {
         name: 'indirect',
         size: nextIndirect * 20,
@@ -1176,7 +1334,7 @@ export class GpuDrivenView {
       },
       {
         name: 'lodReadback',
-        size: nextBatch * COUNTER_STRIDE,
+        size: nextBatch * COUNTER_STRIDE + nextVisible * 16 + nextIndirect * INDIRECT_COMMAND_BYTES,
         usage: GPU_BUFFER_USAGE_MAP_READ | GPU_BUFFER_USAGE_COPY_DST,
         storage: false,
       },
@@ -1202,10 +1360,14 @@ export class GpuDrivenView {
       const result = allocate(request.name, request.size, request.usage);
       if (!result.ok) {
         for (const buffer of Object.values(created)) this.device.destroyBuffer(buffer);
+        for (const token of createdTokens) this.allocationLedger.rollback(token);
         return result;
       }
     }
-    if (this.buffers !== undefined) this.supersededBuffers.push(this.buffers);
+    if (this.buffers !== undefined) {
+      this.supersededBuffers.push(this.buffers);
+      this.retireGeneration(this.buffers);
+    }
     this.buffers = created as ViewBuffers;
     this.candidateCapacity = nextCandidate;
     this.visibleBufferCapacity = nextVisible;
@@ -1223,10 +1385,19 @@ export class GpuDrivenView {
       for (const buffers of generations) {
         for (const buffer of Object.values(buffers)) {
           this.device.destroyBuffer(buffer);
+          const token = this.allocationTokens.get(buffer);
+          if (token !== undefined) this.allocationLedger.release(token);
         }
       }
     };
     void this.device.queue.onSubmittedWorkDone().then(release, release);
   }
+
+  private retireGeneration(generation: ViewBuffers): void {
+    for (const buffer of Object.values(generation)) {
+      const token = this.allocationTokens.get(buffer);
+      if (token !== undefined) this.allocationLedger.retire(token);
+    }
+  }
 }
 export { decideVisibility } from '../scene/visibility/occlusion-confidence';