@forgeax/engine-render 0.1.20 → 0.1.23

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

@@ -20,17 +20,41 @@ import {
   GPU_BUFFER_USAGE_COPY_DST,
   GPU_BUFFER_USAGE_COPY_SRC,
   GPU_BUFFER_USAGE_INDIRECT,
+  GPU_BUFFER_USAGE_MAP_READ,
   GPU_BUFFER_USAGE_STORAGE,
   GPU_BUFFER_USAGE_UNIFORM,
 } from '../gpu-usage';
 import type { PipelineBuilderShaderModuleFactory } from '../pipeline-builder';
-import type { SubmissionPlan } from './batch-topology';
+import type { GpuDrivenCandidate, SubmissionPlan } from './batch-topology';
 
 const COMPUTE_STAGE = 0x4;
 const WORKGROUP_SIZE = 64;
-const CANDIDATE_STRIDE = 28;
-const BATCH_STRIDE = 28;
+const LOD_ROW_STRIDE = GPU_SCENE_LAYOUTS.lod.stride;
+const LOD_ROW_CAPACITY = 8;
+const CANDIDATE_STRIDE = 48 + LOD_ROW_CAPACITY * LOD_ROW_STRIDE;
+const BATCH_STRIDE = 32;
 const VIEW_BYTES = 112;
+// visible + overflow + one bucket per selected LOD + selected/root index work.
+// The two work counters let inspection report geometry reduction from the
+// actual indirect draw ranges instead of treating submitted-instance count as
+// a proxy for vertex/index work.
+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;
+type GpuDrivenAdmissionCandidate = GpuDrivenCandidate & {
+  readonly submitAdmission?: boolean;
+};
+
+export type GpuLodLane = 'gpu' | 'cpu';
+
+export function selectGpuLodLane(caps: {
+  readonly compute: boolean;
+  readonly storageBuffer: boolean;
+  readonly indirectDrawing: boolean;
+}): GpuLodLane {
+  return caps.compute && caps.storageBuffer && caps.indirectDrawing ? 'gpu' : 'cpu';
+}
 
 export const GPU_DRIVEN_VIEW_WGSL = /* wgsl */ `
 struct PrimitiveRecord {
@@ -51,6 +75,17 @@ struct TransformRecord {
   previousWorld: mat4x4<f32>,
 };
 
+struct LodRecord {
+  generation: u32,
+  level: u32,
+  firstIndex: u32,
+  indexCount: u32,
+  baseVertex: i32,
+  screenCoverage: f32,
+  hysteresis: f32,
+  ready: u32,
+};
+
 struct CandidateRecord {
   primitiveIndex: u32,
   generation: u32,
@@ -59,6 +94,15 @@ struct CandidateRecord {
   batchIndex: u32,
   visibleBase: u32,
   visibleCapacity: u32,
+  // Admission is separate from selector membership: suppressed candidates
+  // still contribute to the all-candidate LOD histogram, but never enter the
+  // compacted visible stream.
+  submitAdmission: u32,
+  projectedHeight: f32,
+  previousLevel: u32,
+  historyValid: u32,
+  lodCount: u32,
+  lodRows: array<LodRecord, 8>,
 };
 
 struct InstanceRecord {
@@ -76,6 +120,7 @@ struct BatchRecord {
   baseVertex: i32,
   indirectIndex: u32,
   indexed: u32,
+  candidateBase: u32,
 };
 
 struct ViewConstants {
@@ -86,6 +131,34 @@ struct ViewConstants {
   pad1: u32,
 };
 
+fn selectLodLevel(
+  projectedHeight: f32,
+  previousLevel: u32,
+  historyValid: bool,
+  rows: array<LodRecord, 8>,
+  levelCount: u32,
+) -> u32 {
+  // Row zero is the implicit root and has no transition threshold. Lower
+  // levels carry the absolute boundary that introduces the preceding row.
+  // This mirrors the CPU selector: height >= rows[1] selects root, height
+  // between rows[2] and rows[1] selects level 1, and so on.
+  var selected = levelCount - 1u;
+  for (var level = 1u; level < levelCount; level += 1u) {
+    if (projectedHeight >= rows[level].screenCoverage) {
+      selected = level - 1u;
+      break;
+    }
+  }
+  if (historyValid && previousLevel < levelCount && selected != previousLevel) {
+    var boundary = rows[previousLevel + 1u].screenCoverage;
+    if (selected < previousLevel) { boundary = rows[previousLevel].screenCoverage; }
+    let band = boundary * rows[previousLevel].hysteresis;
+    if (abs(projectedHeight - boundary) <= band) { selected = previousLevel; }
+  }
+  if (selected >= levelCount || rows[selected].ready == 0u) { return 0u; }
+  return selected;
+}
+
 @group(0) @binding(0) var<storage, read> primitives: array<PrimitiveRecord>;
 @group(0) @binding(1) var<storage, read> instances: array<InstanceRecord>;
 @group(0) @binding(2) var<storage, read> transforms: array<TransformRecord>;
@@ -96,11 +169,18 @@ struct ViewConstants {
 @group(0) @binding(7) var<storage, read_write> visibleIndices: array<vec2<u32>>;
 @group(0) @binding(8) var<storage, read_write> indirectArgs: array<u32>;
 
-fn counterIndex(batchIndex: u32) -> u32 { return batchIndex * 2u; }
-fn overflowIndex(batchIndex: u32) -> u32 { return batchIndex * 2u + 1u; }
+fn counterIndex(batchIndex: u32) -> u32 { return batchIndex * ${COUNTER_WORDS}u; }
+fn overflowIndex(batchIndex: u32) -> u32 { return counterIndex(batchIndex) + 1u; }
+fn lodCounterIndex(batchIndex: u32, level: u32) -> u32 {
+  return counterIndex(batchIndex) + 2u + level;
+}
 
 fn isVisible(primitive: PrimitiveRecord, world: mat4x4<f32>) -> bool {
-  if ((primitive.flags & 7u) != 7u) { return false; }
+  // GPU Scene bounds are optional. A producer that has not published local
+  // bounds still belongs in the GPU lane; keep it conservatively visible
+  // instead of silently dropping a valid draw.
+  if ((primitive.flags & 5u) != 5u) { return false; }
+  if ((primitive.flags & 2u) == 0u) { return true; }
   let localCenter = (primitive.localBoundsMin.xyz + primitive.localBoundsMax.xyz) * 0.5;
   let localExtent = (primitive.localBoundsMax.xyz - primitive.localBoundsMin.xyz) * 0.5;
   let worldCenter = (world * vec4<f32>(localCenter, 1.0)).xyz;
@@ -122,6 +202,11 @@ fn resetView(@builtin(global_invocation_id) id: vec3<u32>) {
   if (batchIndex >= view.batchCount) { return; }
   atomicStore(&counters[counterIndex(batchIndex)], 0u);
   atomicStore(&counters[overflowIndex(batchIndex)], 0u);
+  for (var level = 0u; level < ${LOD_ROW_CAPACITY}u; level += 1u) {
+    atomicStore(&counters[lodCounterIndex(batchIndex, level)], 0u);
+  }
+  atomicStore(&counters[counterIndex(batchIndex) + ${GEOMETRY_WORK_COUNTER_OFFSET}u], 0u);
+  atomicStore(&counters[counterIndex(batchIndex) + ${ROOT_GEOMETRY_WORK_COUNTER_OFFSET}u], 0u);
 }
 
 @compute @workgroup_size(${WORKGROUP_SIZE})
@@ -135,7 +220,28 @@ fn cullView(@builtin(global_invocation_id) id: vec3<u32>) {
   let instanceIndex = primitive.instanceStart + candidate.instanceOrdinal;
   let instance = instances[instanceIndex];
   let world = transforms[primitive.transformIndex].currentWorld * transforms[instance.transformIndex].currentWorld;
+  let selectedLod = selectLodLevel(
+    candidate.projectedHeight,
+    candidate.previousLevel,
+    candidate.historyValid != 0u,
+    candidate.lodRows,
+    candidate.lodCount,
+  );
+  if (candidate.lodRows[selectedLod].ready == 0u) { return; }
+  // Selector counters describe the complete LOD population, including
+  // candidates outside the frustum and candidates suppressed by the CPU
+  // visibility facet. Submission counters below remain compacted draw facts.
+  atomicAdd(&counters[lodCounterIndex(candidate.batchIndex, selectedLod)], 1u);
+  if (candidate.submitAdmission == 0u) { return; }
   if (!isVisible(primitive, world)) { return; }
+  atomicAdd(
+    &counters[counterIndex(candidate.batchIndex) + ${GEOMETRY_WORK_COUNTER_OFFSET}u],
+    candidate.lodRows[selectedLod].indexCount,
+  );
+  atomicAdd(
+    &counters[counterIndex(candidate.batchIndex) + ${ROOT_GEOMETRY_WORK_COUNTER_OFFSET}u],
+    candidate.lodRows[0u].indexCount,
+  );
   let localVisible = atomicAdd(&counters[counterIndex(candidate.batchIndex)], 1u);
   if (localVisible >= candidate.visibleCapacity) {
     atomicStore(&counters[overflowIndex(candidate.batchIndex)], 1u);
@@ -157,10 +263,13 @@ fn finalizeView(@builtin(global_invocation_id) id: vec3<u32>) {
     batch.visibleCapacity,
   );
   let args = batch.indirectIndex * 5u;
-  indirectArgs[args] = batch.count;
+  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);
   indirectArgs[args + 1u] = visibleCount;
-  indirectArgs[args + 2u] = batch.first;
-  indirectArgs[args + 3u] = select(0u, bitcast<u32>(batch.baseVertex), batch.indexed != 0u);
+  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 + 4u] = 0u;
 }
 `;
@@ -172,6 +281,7 @@ interface ViewBuffers {
   readonly counters: Buffer;
   readonly visible: Buffer;
   readonly indirect: Buffer;
+  readonly lodReadback: Buffer;
 }
 
 type MutableViewBuffers = { -readonly [Name in keyof ViewBuffers]: ViewBuffers[Name] };
@@ -192,6 +302,8 @@ export interface GpuDrivenViewInspection {
   readonly batchCount: number;
   readonly visibleCapacity: number;
   readonly candidateCapacity: number;
+  /** Allocated visible-index capacity; distinct from logical candidates. */
+  readonly visibleBufferCapacity: number;
   readonly batchCapacity: number;
   readonly indirectCapacity: number;
   readonly updateCount: number;
@@ -204,10 +316,69 @@ export interface GpuDrivenViewInspection {
   readonly resourceGeneration: number;
 }
 
+export interface GpuDrivenViewBufferCapacities {
+  readonly candidate: number;
+  readonly visible: number;
+  readonly batch: number;
+  readonly indirect: number;
+}
+
+export interface GpuDrivenLodSelectionInspection {
+  readonly candidateCount: number;
+  readonly batchCount: number;
+  readonly indirectDrawCount: number;
+  readonly visible: number;
+  readonly occluded: number;
+  readonly lodHistogram: readonly { readonly level: number; readonly count: number }[];
+  readonly batches: readonly {
+    readonly batchId: number;
+    readonly candidateCount: number;
+    readonly visible: number;
+    readonly occluded: number;
+    readonly lodHistogram: readonly { readonly level: number; readonly count: number }[];
+  }[];
+  readonly worldSelections?: readonly {
+    readonly worldKey: number;
+    readonly primitiveSlot: number;
+    readonly slotGeneration: number;
+    readonly candidateCount: number;
+    readonly visible: number;
+    readonly occluded: number;
+    readonly lodHistogram: readonly { readonly level: number; readonly count: number }[];
+  }[];
+  readonly geometryWork: number;
+  readonly rootGeometryWork: number;
+}
+
 function nextCapacity(required: number): number {
   return 2 ** Math.ceil(Math.log2(Math.max(1, required)));
 }
 
+/** Selector batches with no admitted candidates never produce a raster draw. */
+function admittedRasterBatchCount(plan: SubmissionPlan): number {
+  return plan.batches.reduce((count, batch) => count + (batch.visibleCapacity > 0 ? 1 : 0), 0);
+}
+
+/**
+ * Derive each GPU-driven allocation from its own logical capacity domain.
+ * Candidate records are dense; visible indices use the sparse, 64-entry
+ * aligned ranges assigned by BatchTopology. Keeping these values separate is
+ * what makes a large LOD candidate set bounded instead of multiplying the
+ * candidate record and inline LOD-row buffers by the visible address space.
+ */
+export function deriveGpuDrivenViewBufferCapacities(
+  plan: Pick<SubmissionPlan, 'candidateCount' | 'visibleCapacity' | 'batches'>,
+): GpuDrivenViewBufferCapacities {
+  return Object.freeze({
+    candidate: nextCapacity(plan.candidateCount),
+    visible: nextCapacity(plan.visibleCapacity),
+    batch: nextCapacity(plan.batches.length),
+    indirect: nextCapacity(
+      plan.batches.reduce((maximum, batch) => Math.max(maximum, batch.batchId + 1), 0),
+    ),
+  });
+}
+
 function bufferBinding(buffer: Buffer): {
   readonly kind: 'buffer';
   readonly value: { buffer: Buffer };
@@ -220,6 +391,7 @@ export class GpuDrivenView {
   private supersededBuffers: ViewBuffers[] = [];
   private bindGroup: BindGroup | undefined;
   private candidateCapacity = 0;
+  private visibleBufferCapacity = 0;
   private batchCapacity = 0;
   private indirectCapacity = 0;
   private plan: SubmissionPlan | undefined;
@@ -236,6 +408,8 @@ export class GpuDrivenView {
   private bindGroupCreates = 0;
   private bufferRebuilds = 0;
   private resourceGeneration = 0;
+  private telemetryPending = false;
+  private lodSelection: GpuDrivenLodSelectionInspection | undefined;
 
   private constructor(
     private readonly device: RhiDevice,
@@ -314,22 +488,34 @@ export class GpuDrivenView {
     this.batchUploadBytes = 0;
     this.viewConstantsUploadBytes = 0;
     this.bindGroupCreates = 0;
+    // The readback copy is part of the accepted graph and therefore executes
+    // every submitted frame, not only when that graph is (re)compiled.  Keep
+    // the observation latch armed across per-frame view updates; clearing it
+    // here would make a cached graph silently discard all later LOD samples.
+    this.telemetryPending = true;
+    this.lodSelection = undefined;
     const topologyChanged = this.plan !== plan;
     let buffersRebuilt = false;
     if (topologyChanged || this.buffers === undefined) {
-      const requiredCandidates = Math.max(1, plan.candidateCount, plan.visibleCapacity);
-      const requiredBatches = Math.max(1, plan.batches.length);
-      const requiredIndirect = Math.max(
-        1,
-        plan.batches.reduce((maximum, batch) => Math.max(maximum, batch.batchId + 1), 0),
-      );
+      // Candidate records and compacted visible indices are different
+      // capacity domains.  LOD singleton batches align each visible segment
+      // to 64 entries, so plan.visibleCapacity can be much larger than the
+      // number of logical candidates.  Never let that sparse address space
+      // inflate candidate/LOD-row storage allocations.
+      const capacities = deriveGpuDrivenViewBufferCapacities(plan);
       if (
         this.buffers === undefined ||
-        requiredCandidates > this.candidateCapacity ||
-        requiredBatches > this.batchCapacity ||
-        requiredIndirect > this.indirectCapacity
+        capacities.candidate > this.candidateCapacity ||
+        capacities.visible > this.visibleBufferCapacity ||
+        capacities.batch > this.batchCapacity ||
+        capacities.indirect > this.indirectCapacity
       ) {
-        const rebuilt = this.rebuildBuffers(requiredCandidates, requiredBatches, requiredIndirect);
+        const rebuilt = this.rebuildBuffers(
+          capacities.candidate,
+          capacities.visible,
+          capacities.batch,
+          capacities.indirect,
+        );
         if (!rebuilt.ok) return rebuilt;
         buffersRebuilt = true;
       }
@@ -353,7 +539,9 @@ export class GpuDrivenView {
         batches.setInt32(batchOffset + 16, batch.key.baseVertex, true);
         batches.setUint32(batchOffset + 20, batch.batchId, true);
         batches.setUint32(batchOffset + 24, batch.key.drawKind === 'indexed' ? 1 : 0, true);
+        batches.setUint32(batchOffset + 28, candidateIndex, true);
         for (const candidate of batch.candidates) {
+          const admissionCandidate = candidate as GpuDrivenAdmissionCandidate;
           const candidateOffset = candidateIndex * CANDIDATE_STRIDE;
           candidates.setUint32(candidateOffset, candidate.primitiveIndex, true);
           candidates.setUint32(candidateOffset + 4, candidate.generation, true);
@@ -362,6 +550,40 @@ export class GpuDrivenView {
           candidates.setUint32(candidateOffset + 16, batchIndex, true);
           candidates.setUint32(candidateOffset + 20, batch.visibleBase, true);
           candidates.setUint32(candidateOffset + 24, batch.visibleCapacity, true);
+          const coverages = candidate.lodCoverages ?? [1];
+          const ranges = [
+            { first: batch.key.first, count: batch.key.count, baseVertex: batch.key.baseVertex },
+            ...(candidate.lodRanges ?? []),
+          ];
+          const lodCount = Math.min(LOD_ROW_CAPACITY, Math.max(1, coverages.length, ranges.length));
+          candidates.setUint32(
+            candidateOffset + 28,
+            admissionCandidate.submitAdmission === false ? 0 : 1,
+            true,
+          );
+          candidates.setFloat32(
+            candidateOffset + 32,
+            candidate.projectedHeight ?? Number.NaN,
+            true,
+          );
+          candidates.setUint32(candidateOffset + 36, 0, true);
+          candidates.setUint32(candidateOffset + 40, 0, true);
+          candidates.setUint32(candidateOffset + 44, lodCount, true);
+          for (let level = 0; level < lodCount; level += 1) {
+            const rowOffset = candidateOffset + 48 + level * LOD_ROW_STRIDE;
+            candidates.setUint32(rowOffset, candidate.generation, true);
+            candidates.setUint32(rowOffset + 4, level, true);
+            candidates.setUint32(rowOffset + 8, ranges[level]?.first ?? batch.key.first, true);
+            candidates.setUint32(rowOffset + 12, ranges[level]?.count ?? batch.key.count, true);
+            candidates.setInt32(
+              rowOffset + 16,
+              ranges[level]?.baseVertex ?? batch.key.baseVertex,
+              true,
+            );
+            candidates.setFloat32(rowOffset + 20, coverages[level] ?? 0, true);
+            candidates.setFloat32(rowOffset + 24, candidate.lodHysteresis ?? 0.08, true);
+            candidates.setUint32(rowOffset + 28, 1, true);
+          }
           candidateIndex += 1;
         }
       }
@@ -434,6 +656,7 @@ export class GpuDrivenView {
       batchCount: this.plan?.batches.length ?? 0,
       visibleCapacity: this.plan?.visibleCapacity ?? 0,
       candidateCapacity: this.candidateCapacity,
+      visibleBufferCapacity: this.visibleBufferCapacity,
       batchCapacity: this.batchCapacity,
       indirectCapacity: this.indirectCapacity,
       updateCount: this.updateCount,
@@ -463,6 +686,88 @@ export class GpuDrivenView {
     return 4;
   }
 
+  /** Read selected levels written by the GPU cull pass for the last submit. */
+  async readLodSelection(): Promise<GpuDrivenLodSelectionInspection | undefined> {
+    const buffers = this.buffers;
+    const plan = this.plan;
+    if (buffers === undefined || plan === undefined || !this.telemetryPending) {
+      return this.lodSelection;
+    }
+    this.telemetryPending = false;
+    const mapped = await buffers.lodReadback.mapAsync(GPU_BUFFER_USAGE_MAP_READ);
+    if (!mapped.ok) return undefined;
+    const range = mapped.value.getMappedRange();
+    if (!range.ok) {
+      mapped.value.unmap();
+      return undefined;
+    }
+    try {
+      const values = new DataView(range.value);
+      let visible = 0;
+      let geometryWork = 0;
+      let rootGeometryWork = 0;
+      const histogram = new Map<number, number>();
+      for (let batchIndex = 0; batchIndex < plan.batches.length; batchIndex += 1) {
+        const offset = batchIndex * COUNTER_STRIDE;
+        visible += values.getUint32(offset, true);
+        geometryWork += values.getUint32(offset + GEOMETRY_WORK_COUNTER_OFFSET * 4, true);
+        rootGeometryWork += values.getUint32(offset + ROOT_GEOMETRY_WORK_COUNTER_OFFSET * 4, true);
+        for (let level = 0; level < LOD_ROW_CAPACITY; level += 1) {
+          const count = values.getUint32(offset + (2 + level) * 4, true);
+          if (count > 0) histogram.set(level, (histogram.get(level) ?? 0) + count);
+        }
+      }
+      const candidateCount = plan.candidateCount;
+      this.lodSelection = Object.freeze({
+        candidateCount,
+        batchCount: plan.batches.length,
+        // Selector-only batches remain in the plan/readback but the production
+        // raster skips them. Report the actual nonzero-admission command count
+        // so a benchmark cannot mistake selector batches for raster draws.
+        indirectDrawCount: admittedRasterBatchCount(plan),
+        visible,
+        // A LOD histogram counts candidates that reached the selector, while
+        // `visible` is the actual compacted submission count. Occlusion is the
+        // difference between those candidate/visibility totals; using the
+        // histogram here would mislabel a visible candidate dropped only by an
+        // indirect-capacity overflow as occluded.
+        occluded: Math.max(0, candidateCount - visible),
+        lodHistogram: Object.freeze(
+          [...histogram.entries()]
+            .sort(([left], [right]) => left - right)
+            .map(([level, count]) => Object.freeze({ level, count })),
+        ),
+        batches: Object.freeze(
+          plan.batches.map((batch, batchIndex) => {
+            const offset = batchIndex * COUNTER_STRIDE;
+            const batchHistogram = new Map<number, number>();
+            for (let level = 0; level < LOD_ROW_CAPACITY; level += 1) {
+              const count = values.getUint32(offset + (2 + level) * 4, true);
+              if (count > 0) batchHistogram.set(level, count);
+            }
+            const batchVisible = values.getUint32(offset, true);
+            return Object.freeze({
+              batchId: batch.batchId,
+              candidateCount: batch.candidates.length,
+              visible: batchVisible,
+              occluded: Math.max(0, batch.candidates.length - batchVisible),
+              lodHistogram: Object.freeze(
+                [...batchHistogram.entries()]
+                  .sort(([left], [right]) => left - right)
+                  .map(([level, count]) => Object.freeze({ level, count })),
+              ),
+            });
+          }),
+        ),
+        geometryWork,
+        rootGeometryWork,
+      });
+      return this.lodSelection;
+    } finally {
+      mapped.value.unmap();
+    }
+  }
+
   addPasses<FrameCtx extends RenderGraphFrame>(
     builder: RenderGraphBuilder<FrameCtx>,
   ): Result<GpuDrivenViewGraphResources, RenderGraphError> {
@@ -538,14 +843,21 @@ export class GpuDrivenView {
     const counters = importBuffer(
       'gpu-driven.counters',
       buffers.counters,
-      this.batchCapacity * 8,
+      this.batchCapacity * COUNTER_STRIDE,
       GPU_BUFFER_USAGE_STORAGE | GPU_BUFFER_USAGE_COPY_SRC,
     );
     if (!counters.ok) return counters;
+    const lodReadback = importBuffer(
+      'gpu-driven.lod-selection-readback',
+      buffers.lodReadback,
+      this.batchCapacity * COUNTER_STRIDE,
+      GPU_BUFFER_USAGE_MAP_READ | GPU_BUFFER_USAGE_COPY_DST,
+    );
+    if (!lodReadback.ok) return lodReadback;
     const visible = importBuffer(
       'gpu-driven.visible',
       buffers.visible,
-      this.candidateCapacity * 8,
+      this.visibleBufferCapacity * 8,
       GPU_BUFFER_USAGE_STORAGE | GPU_BUFFER_USAGE_COPY_SRC,
     );
     if (!visible.ok) return visible;
@@ -599,6 +911,21 @@ export class GpuDrivenView {
       },
     });
     if (!finalize.ok) return finalize;
+    const readback = builder.addCopyPass('gpu-driven.lod-selection-readback', {
+      accesses: [
+        { resource: counters.value, usage: 'copy-src' },
+        { resource: lodReadback.value, usage: 'copy-dst' },
+      ],
+      encode: ({ encoder, resources }) => {
+        encoder.copyBufferToBuffer(
+          resources.buffer(counters.value).unwrap(),
+          resources.buffer(lodReadback.value).unwrap(),
+          this.batchCapacity * COUNTER_STRIDE,
+        );
+      },
+    });
+    if (!readback.ok) return readback;
+    this.telemetryPending = true;
     return ok({
       visible: visible.value,
       primitive: primitive.value,
@@ -619,6 +946,7 @@ export class GpuDrivenView {
     this.buffers = undefined;
     this.bindGroup = undefined;
     this.plan = undefined;
+    this.visibleBufferCapacity = 0;
     this.scenePrimitive = undefined;
     this.sceneInstance = undefined;
     this.sceneTransform = undefined;
@@ -643,10 +971,12 @@ export class GpuDrivenView {
 
   private rebuildBuffers(
     candidateCapacity: number,
+    visibleCapacity: number,
     batchCapacity: number,
     indirectCapacity: number,
   ): Result<void, RhiError> {
     const nextCandidate = nextCapacity(candidateCapacity);
+    const nextVisible = nextCapacity(visibleCapacity);
     const nextBatch = nextCapacity(batchCapacity);
     const nextIndirect = nextCapacity(indirectCapacity);
     const created: Partial<MutableViewBuffers> = {};
@@ -666,14 +996,64 @@ export class GpuDrivenView {
       return ok(undefined);
     };
     const storage = GPU_BUFFER_USAGE_STORAGE | GPU_BUFFER_USAGE_COPY_SRC;
-    for (const result of [
-      allocate('candidates', nextCandidate * CANDIDATE_STRIDE, storage | GPU_BUFFER_USAGE_COPY_DST),
-      allocate('batches', nextBatch * BATCH_STRIDE, storage | GPU_BUFFER_USAGE_COPY_DST),
-      allocate('view', VIEW_BYTES, GPU_BUFFER_USAGE_UNIFORM | GPU_BUFFER_USAGE_COPY_DST),
-      allocate('counters', nextBatch * 8, storage),
-      allocate('visible', nextCandidate * 8, storage),
-      allocate('indirect', nextIndirect * 20, storage | GPU_BUFFER_USAGE_INDIRECT),
-    ]) {
+    const requests: readonly {
+      readonly name: keyof ViewBuffers;
+      readonly size: number;
+      readonly usage: number;
+      readonly storage: boolean;
+    }[] = [
+      {
+        name: 'candidates',
+        size: nextCandidate * CANDIDATE_STRIDE,
+        usage: storage | GPU_BUFFER_USAGE_COPY_DST,
+        storage: true,
+      },
+      {
+        name: 'batches',
+        size: nextBatch * BATCH_STRIDE,
+        usage: storage | GPU_BUFFER_USAGE_COPY_DST,
+        storage: true,
+      },
+      {
+        name: 'view',
+        size: VIEW_BYTES,
+        usage: GPU_BUFFER_USAGE_UNIFORM | GPU_BUFFER_USAGE_COPY_DST,
+        storage: false,
+      },
+      { name: 'counters', size: nextBatch * COUNTER_STRIDE, usage: storage, storage: true },
+      { name: 'visible', size: nextVisible * 8, usage: storage, storage: true },
+      {
+        name: 'indirect',
+        size: nextIndirect * 20,
+        usage: storage | GPU_BUFFER_USAGE_INDIRECT,
+        storage: true,
+      },
+      {
+        name: 'lodReadback',
+        size: nextBatch * COUNTER_STRIDE,
+        usage: GPU_BUFFER_USAGE_MAP_READ | GPU_BUFFER_USAGE_COPY_DST,
+        storage: false,
+      },
+    ];
+    const maxBufferSize = Number(this.device.limits.maxBufferSize);
+    const maxStorageBufferBindingSize = Number(this.device.limits.maxStorageBufferBindingSize);
+    for (const request of requests) {
+      const limit = request.storage ? maxStorageBufferBindingSize : maxBufferSize;
+      if (!Number.isFinite(limit) || limit <= 0 || request.size <= limit) continue;
+      return err(
+        new RhiError({
+          code: 'limit-exceeded',
+          expected: `GPU-driven ${request.name} buffer (${request.size} B) fits within ${request.storage ? 'device.limits.maxStorageBufferBindingSize' : 'device.limits.maxBufferSize'} (${limit} B)`,
+          hint: 'reduce the visible/candidate workload or split the GPU-driven buffer plan before retrying',
+          detail: {
+            maxStorageBufferBindingSize: limit,
+            requestedBytes: request.size,
+          },
+        }),
+      );
+    }
+    for (const request of requests) {
+      const result = allocate(request.name, request.size, request.usage);
       if (!result.ok) {
         for (const buffer of Object.values(created)) this.device.destroyBuffer(buffer);
         return result;
@@ -682,6 +1062,7 @@ export class GpuDrivenView {
     if (this.buffers !== undefined) this.supersededBuffers.push(this.buffers);
     this.buffers = created as ViewBuffers;
     this.candidateCapacity = nextCandidate;
+    this.visibleBufferCapacity = nextVisible;
     this.batchCapacity = nextBatch;
     this.indirectCapacity = nextIndirect;
     this.bufferRebuilds += 1;
@@ -701,3 +1082,4 @@ export class GpuDrivenView {
     void this.device.queue.onSubmittedWorkDone().then(release, release);
   }
 }
+export { decideVisibility } from '../scene/visibility/occlusion-confidence';

package/src/gpu-scene-schema.ts

@@ -63,6 +63,19 @@ export function gpuSceneWgsl(layout: GpuSceneTableLayout): string {
 }
 
 export const GPU_SCENE_SCHEMAS = Object.freeze({
+  lod: {
+    name: 'GpuSceneLod',
+    fields: [
+      { name: 'generation', type: 'u32' },
+      { name: 'level', type: 'u32' },
+      { name: 'firstIndex', type: 'u32' },
+      { name: 'indexCount', type: 'u32' },
+      { name: 'baseVertex', type: 'i32' },
+      { name: 'screenCoverage', type: 'f32' },
+      { name: 'hysteresis', type: 'f32' },
+      { name: 'ready', type: 'u32' },
+    ],
+  },
   primitive: {
     name: 'GpuScenePrimitive',
     fields: [