@forgeax/engine-render 0.1.28 → 0.1.30

package/src/gpu-driven/batch-topology.ts

@@ -1,4 +1,5 @@
 import type { PrimitiveTopology } from '@forgeax/engine-types';
+import { gpuDrivenSourceDrawItemIndex } from '../extract/gpu-driven';
 import type { BatchTopologyInspection } from '../inspection-types';
 import type { CameraSnapshot } from '../render-contract';
 import type { RenderSceneApplyResult, RenderSceneSlot } from '../scene/render-scene-types';
@@ -8,6 +9,9 @@ import type { PreparedGpuDrivenDraw } from './prepared-draw';
 
 export type { BatchTopologyInspection } from '../inspection-types';
 
+/** High bit in the compact candidate material lane marks a skin palette row. */
+export const GPU_DRIVEN_SKIN_FLAG = 0x80000000;
+
 export interface GpuDrivenBatchKey {
   readonly assetHandle: number;
   readonly drawKind: 'indexed' | 'non-indexed';
@@ -31,6 +35,7 @@ export interface GpuDrivenCandidate {
   readonly generation: number;
   readonly drawItemIndex: number;
   readonly instanceOrdinal: number;
+  readonly prepared?: PreparedGpuDrivenDraw;
   /** Absolute coverage rows uploaded to the GPU selector; root is implicit. */
   readonly lodCoverages?: readonly number[];
   readonly lodHysteresis?: number;
@@ -40,7 +45,6 @@ export interface GpuDrivenCandidate {
     readonly count: number;
     readonly baseVertex: number;
   }[];
-  readonly prepared?: PreparedGpuDrivenDraw;
 }
 
 export interface GpuDrivenBatch {
@@ -55,6 +59,8 @@ export interface GpuDrivenBatch {
 
 export interface SubmissionPlan {
   readonly revision: number;
+  /** Payload-only updates keep topology revision stable but still invalidate the plan snapshot. */
+  readonly payloadRevision: number;
   readonly batches: readonly GpuDrivenBatch[];
   readonly candidateCount: number;
   readonly visibleCapacity: number;
@@ -86,6 +92,88 @@ export function compactGpuLodCandidates(
   );
 }
 
+export interface SubmissionCandidateMembershipEntry {
+  readonly batchId: number;
+  readonly candidate: GpuDrivenCandidate;
+}
+
+/**
+ * Immutable reverse membership for one submission topology.
+ *
+ * Shadow views query the same candidate domain as the main view. Keeping the
+ * primitive-to-batch join beside the immutable plan makes that lookup once per
+ * topology instead of rescanning every batch for every view.
+ */
+export interface SubmissionCandidateMembership {
+  readonly source: SubmissionPlan;
+  readonly byPrimitiveIndex: ReadonlyMap<number, readonly SubmissionCandidateMembershipEntry[]>;
+}
+
+const submissionCandidateMembershipCache = new WeakMap<
+  SubmissionPlan,
+  SubmissionCandidateMembership
+>();
+
+export function buildSubmissionCandidateMembership(
+  source: SubmissionPlan,
+): SubmissionCandidateMembership {
+  const cached = submissionCandidateMembershipCache.get(source);
+  if (cached !== undefined) return cached;
+
+  const mutable = new Map<number, SubmissionCandidateMembershipEntry[]>();
+  for (const batch of source.batches) {
+    for (const candidate of batch.candidates) {
+      const entries = mutable.get(candidate.primitiveIndex) ?? [];
+      entries.push({ batchId: batch.batchId, candidate });
+      mutable.set(candidate.primitiveIndex, entries);
+    }
+  }
+  const byPrimitiveIndex = new Map<number, readonly SubmissionCandidateMembershipEntry[]>();
+  for (const [primitiveIndex, entries] of mutable) {
+    byPrimitiveIndex.set(primitiveIndex, Object.freeze(entries));
+  }
+  const membership: SubmissionCandidateMembership = {
+    source,
+    byPrimitiveIndex,
+  };
+  submissionCandidateMembershipCache.set(source, membership);
+  return membership;
+}
+
+/**
+ * Re-project one source topology for a view without changing batch identity.
+ * The returned plan only changes candidate windows and keeps batch ids,
+ * generations, draw ranges, and indirect offsets from the source plan.
+ */
+export function buildBatchAlignedSubmission(
+  source: SubmissionPlan,
+  candidatesByBatch: ReadonlyMap<number, readonly GpuDrivenCandidate[]>,
+): SubmissionPlan {
+  let visibleBase = 0;
+  const batches: GpuDrivenBatch[] = [];
+  for (const sourceBatch of source.batches) {
+    const candidates = candidatesByBatch.get(sourceBatch.batchId) ?? [];
+    if (candidates.length === 0) continue;
+    visibleBase = alignInstanceBase(visibleBase);
+    batches.push(
+      Object.freeze({
+        ...sourceBatch,
+        candidates: Object.freeze([...candidates]),
+        visibleBase,
+        visibleCapacity: candidates.length,
+      }),
+    );
+    visibleBase += candidates.length;
+  }
+  return Object.freeze({
+    revision: source.revision,
+    payloadRevision: source.payloadRevision,
+    batches: Object.freeze(batches),
+    candidateCount: batches.reduce((total, batch) => total + batch.candidates.length, 0),
+    visibleCapacity: visibleBase,
+  });
+}
+
 interface MutableBatch {
   readonly batchId: number;
   readonly generation: number;
@@ -93,7 +181,57 @@ interface MutableBatch {
   readonly candidates: Map<string, GpuDrivenCandidate>;
 }
 
-function eligibleKeys(slot: RenderSceneSlot): readonly GpuDrivenBatchKey[] {
+interface EligibleGpuDrivenDraw {
+  readonly sourceDrawIndex: number;
+  readonly key: GpuDrivenBatchKey;
+  readonly prepared?: PreparedGpuDrivenDraw;
+  readonly projectedHeight?: number;
+  readonly lodCoverages?: readonly number[];
+  readonly lodHysteresis?: number;
+  readonly lodRanges?: readonly {
+    readonly first: number;
+    readonly count: number;
+    readonly baseVertex: number;
+  }[];
+  /** Candidate data that does not change batch compatibility. */
+  readonly payloadRevision: string;
+}
+
+interface MembershipDraw {
+  readonly sourceDrawIndex: number;
+  readonly key: GpuDrivenBatchKey;
+  readonly batchText: string;
+  readonly candidateKeyPrefix: string;
+  readonly payloadRevision: string;
+}
+
+interface MembershipProjection {
+  readonly instanceCount: number;
+  readonly hasLod: boolean;
+  readonly draws: readonly MembershipDraw[];
+}
+
+function hasActiveAlphaMask(
+  material: RenderSceneSlot['snapshot']['material'],
+  prepared: PreparedGpuDrivenDraw,
+): boolean {
+  const { cutoff, source } = prepared.alphaMask;
+  if (cutoff.length === 0 || source.length === 0) return false;
+  // Standard's shared receipt describes the alpha-clip interface; the actual
+  // mode is selected by its authored cutoff. Custom producers own coverage in
+  // their receipt, so a declared clip remains masked without guessing a field.
+  if (
+    prepared.identity.material === 'forgeax::default-standard-pbr' ||
+    prepared.identity.material === 'forgeax::pbr-skin' ||
+    prepared.identity.material === 'forgeax::default-standard-pbr-skin'
+  ) {
+    const value = material.paramSnapshot?.[cutoff];
+    return typeof value === 'number' && value > 0;
+  }
+  return true;
+}
+
+function eligibleDraws(slot: RenderSceneSlot): readonly EligibleGpuDrivenDraw[] {
   const snapshot = slot.snapshot;
   const draws = snapshot.gpuDrivenDraws;
   if (
@@ -101,29 +239,53 @@ function eligibleKeys(slot: RenderSceneSlot): readonly GpuDrivenBatchKey[] {
     draws.length === 0 ||
     snapshot.instances?.instanceCount === 0 ||
     snapshot.localAabb === undefined ||
-    snapshot.skin !== undefined ||
     snapshot.morph !== undefined ||
     snapshot.spriteInstances !== undefined
   ) {
     return [];
   }
-  return draws.flatMap((draw) => {
+  const result: EligibleGpuDrivenDraw[] = [];
+  for (let compactIndex = 0; compactIndex < draws.length; compactIndex += 1) {
+    const draw = draws[compactIndex];
+    if (draw === undefined) continue;
+    const drawItemIndex = gpuDrivenSourceDrawItemIndex(draw, compactIndex);
     const prepared = draw.prepared;
     const material = snapshot.materials[draw.materialSlot] ?? snapshot.material;
     if (prepared !== undefined) {
-      const isStandardPbr =
-        (material.materialShaderId === 'forgeax::default-standard-pbr' &&
-          prepared.identity.material === 'forgeax::default-standard-pbr') ||
-        (material.materialShaderId === 'forgeax::default-standard-pbr-skin' &&
-          prepared.identity.material === 'forgeax::default-standard-pbr-skin');
+      // Prepared producer identity is the admission proof; the material
+      // identifier is only a consistency check, never a built-in allow-list.
+      const materialIdentityMatches =
+        material.materialShaderId === undefined ||
+        prepared.identity.material === material.materialShaderId;
       const isAlphaBlend =
         material.transparent === true || material.renderState?.blend !== undefined;
-      if (!isStandardPbr || isAlphaBlend || prepared.identity.deformation !== 'rigid') return [];
-      const preparedIdentity = `${prepared.identity.material}|${prepared.identity.geometry}|${prepared.identity.deformation}`;
-      const admission =
-        typeof material.paramSnapshot?.alphaCutoff === 'number' ? 'alpha-mask' : 'opaque';
-      return [
-        {
+      const cpuOnlyMaterialResources =
+        (material.textureSources?.size ?? 0) > 0 || (material.videoTextureFields?.size ?? 0) > 0;
+      const skinReady =
+        prepared.identity.deformation !== 'skin' ||
+        (snapshot.skin?.storageOrUniform === 'storage' &&
+          snapshot.skin.customDataStart >= 0 &&
+          Number.isInteger(snapshot.skin.customDataStart) &&
+          hasFiniteOrderedBounds(snapshot.skin.bounds) &&
+          prepared.skinPaletteAddress !== undefined);
+      if (
+        !materialIdentityMatches ||
+        isAlphaBlend ||
+        cpuOnlyMaterialResources ||
+        (prepared.identity.deformation !== 'rigid' && prepared.identity.deformation !== 'skin') ||
+        !skinReady
+      )
+        continue;
+      const preparedIdentity = [
+        prepared.identity.material,
+        prepared.identity.geometry,
+        prepared.identity.deformation,
+        ...(prepared.receiptIdentity === undefined ? [] : [prepared.receiptIdentity]),
+      ].join('|');
+      const admission = hasActiveAlphaMask(material, prepared) ? 'alpha-mask' : 'opaque';
+      result.push({
+        sourceDrawIndex: drawItemIndex,
+        key: {
           assetHandle: snapshot.assetHandle,
           drawKind: draw.kind,
           first: prepared.first,
@@ -137,10 +299,14 @@ function eligibleKeys(slot: RenderSceneSlot): readonly GpuDrivenBatchKey[] {
           resourceIdentity: draw.materialResourceClass,
           admission,
         },
-      ];
+        prepared,
+        ...candidatePayload(draw, snapshot),
+      });
+      continue;
     }
-    return [
-      {
+    result.push({
+      sourceDrawIndex: drawItemIndex,
+      key: {
         assetHandle: snapshot.assetHandle,
         drawKind: draw.kind,
         first: draw.first,
@@ -151,8 +317,66 @@ function eligibleKeys(slot: RenderSceneSlot): readonly GpuDrivenBatchKey[] {
         pipelineClass: draw.pipelineClass,
         materialResourceClass: draw.materialResourceClass,
       },
-    ];
+      ...candidatePayload(draw, snapshot),
+    });
+  }
+  return result;
+}
+
+function candidatePayload(
+  draw: NonNullable<RenderSceneSlot['snapshot']['gpuDrivenDraws']>[number],
+  snapshot: RenderSceneSlot['snapshot'],
+): Pick<
+  EligibleGpuDrivenDraw,
+  'lodCoverages' | 'lodHysteresis' | 'lodRanges' | 'payloadRevision' | 'projectedHeight'
+> {
+  const lodCoverages =
+    snapshot.lods === undefined
+      ? undefined
+      : [1, ...snapshot.lods.map((lod) => lod.screenCoverage)];
+  const lodRanges = draw.lodRanges as EligibleGpuDrivenDraw['lodRanges'];
+  const lodHysteresis = snapshot.lodHysteresis;
+  const payloadRevision = JSON.stringify({
+    projectedHeight: draw.projectedHeight,
+    lodCoverages,
+    lodHysteresis,
+    lodRanges,
+    prepared: draw.prepared,
   });
+  return {
+    ...(draw.projectedHeight === undefined ? {} : { projectedHeight: draw.projectedHeight }),
+    ...(lodCoverages === undefined ? {} : { lodCoverages }),
+    ...(lodHysteresis === undefined ? {} : { lodHysteresis }),
+    ...(lodRanges === undefined ? {} : { lodRanges }),
+    payloadRevision,
+  };
+}
+
+function hasFiniteOrderedBounds(bounds: Float32Array | undefined): boolean {
+  if (bounds === undefined || bounds.length < 6) return false;
+  const minX = bounds[0];
+  const minY = bounds[1];
+  const minZ = bounds[2];
+  const maxX = bounds[3];
+  const maxY = bounds[4];
+  const maxZ = bounds[5];
+  return (
+    minX !== undefined &&
+    minY !== undefined &&
+    minZ !== undefined &&
+    maxX !== undefined &&
+    maxY !== undefined &&
+    maxZ !== undefined &&
+    Number.isFinite(minX) &&
+    Number.isFinite(minY) &&
+    Number.isFinite(minZ) &&
+    Number.isFinite(maxX) &&
+    Number.isFinite(maxY) &&
+    Number.isFinite(maxZ) &&
+    minX <= maxX &&
+    minY <= maxY &&
+    minZ <= maxZ
+  );
 }
 
 function keyText(key: GpuDrivenBatchKey): string {
@@ -160,11 +384,9 @@ function keyText(key: GpuDrivenBatchKey): string {
 }
 
 /**
- * A GPU indirect draw has one index/vertex range for the whole batch.  LOD
+ * A GPU indirect draw has one index/vertex range for the whole batch. LOD
  * selection is per candidate, so sharing a batch between LOD candidates would
- * let `finalizeView` pick the first candidate's range for every visible
- * instance. Keep LOD candidates in single-candidate batches; ordinary meshes
- * retain the existing compatibility batching path.
+ * let the first candidate's range serve every visible instance.
  */
 function candidateBatchText(
   key: GpuDrivenBatchKey,
@@ -178,19 +400,32 @@ function candidateBatchText(
     : keyText(key);
 }
 
-function membershipTexts(slot: RenderSceneSlot): readonly string[] {
-  const keys = eligibleKeys(slot);
+function drawBatchText(
+  key: GpuDrivenBatchKey,
+  primitiveIndex: number,
+  drawItemIndex: number,
+  hasLod: boolean,
+): string {
+  return hasLod ? `${keyText(key)}|lod:${primitiveIndex}:${drawItemIndex}` : keyText(key);
+}
+
+function membershipProjection(
+  slot: RenderSceneSlot,
+  draws = eligibleDraws(slot),
+): MembershipProjection {
   const instanceCount = slot.snapshot.instances?.instanceCount ?? 1;
   const hasLod = (slot.snapshot.lods?.length ?? 0) > 0;
-  const texts: string[] = [];
-  for (let drawItemIndex = 0; drawItemIndex < keys.length; drawItemIndex += 1) {
-    const key = keys[drawItemIndex];
-    if (key === undefined) continue;
-    for (let instanceOrdinal = 0; instanceOrdinal < instanceCount; instanceOrdinal += 1) {
-      texts.push(candidateBatchText(key, slot.slot, drawItemIndex, instanceOrdinal, hasLod));
-    }
-  }
-  return texts;
+  return {
+    instanceCount,
+    hasLod,
+    draws: draws.map((draw) => ({
+      sourceDrawIndex: draw.sourceDrawIndex,
+      key: draw.key,
+      batchText: drawBatchText(draw.key, slot.slot, draw.sourceDrawIndex, hasLod),
+      candidateKeyPrefix: `${slot.slot}:${draw.sourceDrawIndex}:`,
+      payloadRevision: draw.payloadRevision,
+    })),
+  };
 }
 
 function alignInstanceBase(value: number): number {
@@ -209,10 +444,6 @@ export function projectedHeightForCandidate(slot: RenderSceneSlot, camera: Camer
   const halfY = Math.abs((aabb[4] ?? 0) - (aabb[1] ?? 0)) * 0.5;
   const halfZ = Math.abs((aabb[5] ?? 0) - (aabb[2] ?? 0)) * 0.5;
   const world = slot.snapshot.transform.world;
-  // Transform the local AABB's half extents through the absolute value of the
-  // world 3x3. This is the conservative world-space sphere bound for every
-  // rotation and signed/non-uniform scale, and keeps CPU projection aligned
-  // with the world transform uploaded to the GPU selector.
   const worldHalfX =
     Math.abs(world[0] ?? 0) * halfX +
     Math.abs(world[4] ?? 0) * halfY +
@@ -241,16 +472,19 @@ export function projectedHeightForCandidate(slot: RenderSceneSlot, camera: Camer
 /** Stable compatibility grouping; per-view visibility never mutates this owner. */
 export class BatchTopology {
   private readonly batches = new Map<string, MutableBatch>();
-  private readonly membershipByPrimitive = new Map<
-    number,
-    readonly { readonly batchText: string; readonly candidateKey: string }[]
-  >();
+  private readonly membershipByPrimitive = new Map<number, MembershipProjection>();
   private readonly ineligiblePrimitives = new Set<number>();
   private readonly generationByBatchId: number[] = [];
   private readonly freeBatchIds: number[] = [];
   private revision = 0;
+  private payloadRevision = 0;
   private rebuilds = 0;
   private patches = 0;
+  private payloadPatches = 0;
+  private membershipChecks = 0;
+  private membershipAllocations = 0;
+  private candidateAdds = 0;
+  private candidateRemoves = 0;
   private cachedPlan: SubmissionPlan | undefined;
 
   rebuild(slots: readonly RenderSceneSlot[]): void {
@@ -261,37 +495,125 @@ export class BatchTopology {
     this.freeBatchIds.length = 0;
     for (const slot of slots) this.add(slot);
     this.revision += 1;
+    this.payloadRevision += 1;
     this.rebuilds += 1;
     this.cachedPlan = undefined;
   }
 
   apply(delta: RenderSceneApplyResult): boolean {
     let changed = false;
-    for (const removed of delta.removedSlots) changed = this.remove(removed.slot) || changed;
+    let topologyChanged = false;
+    for (const removed of delta.removedSlots) {
+      const removedChanged = this.remove(removed.slot);
+      changed = removedChanged || changed;
+      topologyChanged = removedChanged || topologyChanged;
+    }
     for (const slot of delta.recreatedSlots) {
-      changed = this.remove(slot.slot) || changed;
-      changed = this.add(slot) || changed;
+      const removedChanged = this.remove(slot.slot);
+      const addedChanged = this.add(slot);
+      changed = removedChanged || addedChanged || changed;
+      topologyChanged = removedChanged || addedChanged || topologyChanged;
     }
-    // Most updated slots are transform-only. A full renderable update can
-    // still carry a changed material/geometry/draw topology, so compare the
-    // stable batch memberships and patch only when that key actually changed.
-    // This keeps moving entities on the zero-work transform lane while making
-    // same-entity resource edits visible to the GPU-driven owner.
-    for (const slot of delta.updatedSlots) {
-      const previous = this.membershipByPrimitive.get(slot.slot) ?? [];
-      const next = membershipTexts(slot);
-      if (
-        previous.length === next.length &&
-        previous.every((membership, index) => membership.batchText === next[index])
-      ) {
+    // Membership depends on source descriptors and instance cardinality.
+    // Root matrices feed visibility without changing this dependency.
+    const contentUpdatedSlots = delta.contentUpdatedSlots;
+    const instanceUpdatedSlots = delta.instanceUpdatedSlots;
+    const membershipUpdates = new Map<number, { slot: RenderSceneSlot; content: boolean }>();
+    for (const slot of contentUpdatedSlots) {
+      membershipUpdates.set(slot.slot, { slot, content: true });
+    }
+    // Instance cardinality is a membership input, including in mixed updates.
+    for (const slot of instanceUpdatedSlots) {
+      if (!membershipUpdates.has(slot.slot)) {
+        membershipUpdates.set(slot.slot, { slot, content: false });
+      }
+    }
+    for (const update of membershipUpdates.values()) {
+      const { slot, content } = update;
+      const eligible = eligibleDraws(slot);
+      const next = membershipProjection(slot, eligible);
+      // The projection is one descriptor per eligible source draw; candidate
+      // identities are derived from the stable ordinal and are not stored as
+      // N per-instance comparison records.
+      this.membershipAllocations += next.draws.length;
+      const previous = this.membershipByPrimitive.get(slot.slot);
+      this.membershipChecks += 1;
+      const topologyStable =
+        previous !== undefined &&
+        previous.instanceCount === next.instanceCount &&
+        previous.hasLod === next.hasLod &&
+        previous.draws.length === next.draws.length &&
+        previous.draws.every((membership, index) => {
+          const candidate = next.draws[index];
+          return (
+            candidate !== undefined &&
+            membership.sourceDrawIndex === candidate.sourceDrawIndex &&
+            membership.batchText === candidate.batchText
+          );
+        });
+      if (!topologyStable) {
+        const removedChanged = this.remove(slot.slot);
+        const addedChanged = this.add(slot);
+        changed = removedChanged || addedChanged || changed;
+        topologyChanged = removedChanged || addedChanged || topologyChanged;
+        continue;
+      }
+      if (!content) {
+        this.membershipByPrimitive.set(slot.slot, next);
         continue;
       }
-      changed = this.remove(slot.slot) || changed;
-      changed = this.add(slot) || changed;
+      let payloadChanged = false;
+      let topologyFallback = false;
+      for (let index = 0; index < next.draws.length; index += 1) {
+        const oldMembership = previous.draws[index];
+        const newMembership = next.draws[index];
+        const draw = eligible[index];
+        if (oldMembership === undefined || newMembership === undefined || draw === undefined) {
+          continue;
+        }
+        if (oldMembership.payloadRevision === newMembership.payloadRevision) continue;
+        for (let instanceOrdinal = 0; instanceOrdinal < next.instanceCount; instanceOrdinal += 1) {
+          const batchText = candidateBatchText(
+            draw.key,
+            slot.slot,
+            draw.sourceDrawIndex,
+            instanceOrdinal,
+            next.hasLod,
+          );
+          const batch = this.batches.get(batchText);
+          const candidateKey = `${newMembership.candidateKeyPrefix}${instanceOrdinal}`;
+          if (batch === undefined || !batch.candidates.has(candidateKey)) {
+            const removedChanged = this.remove(slot.slot);
+            const addedChanged = this.add(slot);
+            changed = removedChanged || addedChanged || changed;
+            topologyChanged = removedChanged || addedChanged || topologyChanged;
+            topologyFallback = true;
+            break;
+          }
+          batch.candidates.set(
+            candidateKey,
+            this.candidateFromEligible(slot, instanceOrdinal, draw),
+          );
+        }
+        if (topologyFallback) break;
+        payloadChanged = true;
+      }
+      this.membershipByPrimitive.set(slot.slot, next);
+      if (payloadChanged) {
+        changed = true;
+        this.payloadRevision += 1;
+        this.payloadPatches += 1;
+        this.cachedPlan = undefined;
+      }
+    }
+    for (const slot of delta.createdSlots) {
+      const addedChanged = this.add(slot);
+      changed = addedChanged || changed;
+      topologyChanged = addedChanged || topologyChanged;
     }
-    for (const slot of delta.createdSlots) changed = this.add(slot) || changed;
-    if (changed) {
+    if (topologyChanged) {
       this.revision += 1;
+      this.payloadRevision += 1;
       this.patches += 1;
       this.cachedPlan = undefined;
     }
@@ -324,6 +646,7 @@ export class BatchTopology {
     });
     this.cachedPlan = Object.freeze({
       revision: this.revision,
+      payloadRevision: this.payloadRevision,
       batches: Object.freeze(batches),
       candidateCount: batches.reduce((total, batch) => total + batch.candidates.length, 0),
       visibleCapacity: visibleBase,
@@ -341,24 +664,34 @@ export class BatchTopology {
       rebuilds: this.rebuilds,
       patches: this.patches,
       ineligible: this.ineligiblePrimitives.size,
+      payloadPatches: this.payloadPatches,
+      membershipChecks: this.membershipChecks,
+      membershipAllocations: this.membershipAllocations,
+      candidateAdds: this.candidateAdds,
+      candidateRemoves: this.candidateRemoves,
     };
   }
 
   private add(slot: RenderSceneSlot): boolean {
-    const keys = eligibleKeys(slot);
-    if (keys.length === 0) {
+    const draws = eligibleDraws(slot);
+    if (draws.length === 0) {
       this.ineligiblePrimitives.add(slot.slot);
       return false;
     }
     this.ineligiblePrimitives.delete(slot.slot);
-    const memberships: Array<{ batchText: string; candidateKey: string }> = [];
-    const instanceCount = slot.snapshot.instances?.instanceCount ?? 1;
-    const hasLod = (slot.snapshot.lods?.length ?? 0) > 0;
-    for (let drawItemIndex = 0; drawItemIndex < keys.length; drawItemIndex += 1) {
-      const key = keys[drawItemIndex];
-      if (key === undefined) continue;
+    const memberships = membershipProjection(slot, draws);
+    const instanceCount = memberships.instanceCount;
+    const hasLod = memberships.hasLod;
+    this.membershipAllocations += memberships.draws.length;
+    for (const draw of draws) {
       for (let instanceOrdinal = 0; instanceOrdinal < instanceCount; instanceOrdinal += 1) {
-        const text = candidateBatchText(key, slot.slot, drawItemIndex, instanceOrdinal, hasLod);
+        const text = candidateBatchText(
+          draw.key,
+          slot.slot,
+          draw.sourceDrawIndex,
+          instanceOrdinal,
+          hasLod,
+        );
         let batch = this.batches.get(text);
         if (batch === undefined) {
           const reused = this.freeBatchIds.pop();
@@ -366,39 +699,12 @@ export class BatchTopology {
           const generation =
             reused === undefined ? 0 : (this.generationByBatchId[batchId] ?? -1) + 1;
           this.generationByBatchId[batchId] = generation;
-          batch = { batchId, generation, key, candidates: new Map() };
+          batch = { batchId, generation, key: draw.key, candidates: new Map() };
           this.batches.set(text, batch);
         }
-        const candidateKey = `${slot.slot}:${drawItemIndex}:${instanceOrdinal}`;
-        const draw = slot.snapshot.gpuDrivenDraws?.[drawItemIndex];
-        const prepared = draw?.prepared;
-        batch.candidates.set(candidateKey, {
-          primitiveIndex: slot.slot,
-          generation: slot.generation,
-          drawItemIndex,
-          instanceOrdinal,
-          ...(draw?.projectedHeight === undefined ? {} : { projectedHeight: draw.projectedHeight }),
-          ...(slot.snapshot.lods === undefined
-            ? {}
-            : {
-                lodCoverages: [1, ...slot.snapshot.lods.map((lod) => lod.screenCoverage)],
-                ...(slot.snapshot.gpuDrivenDraws?.[drawItemIndex]?.lodRanges === undefined
-                  ? {}
-                  : {
-                      lodRanges: slot.snapshot.gpuDrivenDraws[drawItemIndex]
-                        ?.lodRanges as readonly {
-                        readonly first: number;
-                        readonly count: number;
-                        readonly baseVertex: number;
-                      }[],
-                    }),
-                ...(slot.snapshot.lodHysteresis === undefined
-                  ? {}
-                  : { lodHysteresis: slot.snapshot.lodHysteresis }),
-              }),
-          ...(prepared === undefined ? {} : { prepared }),
-        });
-        memberships.push({ batchText: text, candidateKey });
+        const candidateKey = `${slot.slot}:${draw.sourceDrawIndex}:${instanceOrdinal}`;
+        batch.candidates.set(candidateKey, this.candidateFromEligible(slot, instanceOrdinal, draw));
+        this.candidateAdds += 1;
       }
     }
     this.membershipByPrimitive.set(slot.slot, memberships);
@@ -410,15 +716,53 @@ export class BatchTopology {
     const memberships = this.membershipByPrimitive.get(primitiveIndex);
     this.membershipByPrimitive.delete(primitiveIndex);
     if (memberships === undefined) return false;
-    for (const membership of memberships) {
-      const batch = this.batches.get(membership.batchText);
-      if (batch === undefined) continue;
-      batch.candidates.delete(membership.candidateKey);
-      if (batch.candidates.size === 0) {
-        this.batches.delete(membership.batchText);
-        this.freeBatchIds.push(batch.batchId);
+    for (const membership of memberships.draws) {
+      const batchTexts = new Set<string>();
+      for (
+        let instanceOrdinal = 0;
+        instanceOrdinal < memberships.instanceCount;
+        instanceOrdinal += 1
+      ) {
+        const batchText = candidateBatchText(
+          membership.key,
+          primitiveIndex,
+          membership.sourceDrawIndex,
+          instanceOrdinal,
+          memberships.hasLod,
+        );
+        batchTexts.add(batchText);
+        const batch = this.batches.get(batchText);
+        if (batch === undefined) continue;
+        const candidateKey = `${membership.candidateKeyPrefix}${instanceOrdinal}`;
+        if (!batch.candidates.delete(candidateKey)) continue;
+        this.candidateRemoves += 1;
+      }
+      for (const batchText of batchTexts) {
+        const batch = this.batches.get(batchText);
+        if (batch !== undefined && batch.candidates.size === 0) {
+          this.batches.delete(batchText);
+          this.freeBatchIds.push(batch.batchId);
+        }
       }
     }
     return true;
   }
+
+  private candidateFromEligible(
+    slot: RenderSceneSlot,
+    instanceOrdinal: number,
+    draw: EligibleGpuDrivenDraw,
+  ): GpuDrivenCandidate {
+    return {
+      primitiveIndex: slot.slot,
+      generation: slot.generation,
+      drawItemIndex: draw.sourceDrawIndex,
+      instanceOrdinal,
+      ...(draw.projectedHeight === undefined ? {} : { projectedHeight: draw.projectedHeight }),
+      ...(draw.lodCoverages === undefined ? {} : { lodCoverages: draw.lodCoverages }),
+      ...(draw.lodRanges === undefined ? {} : { lodRanges: draw.lodRanges }),
+      ...(draw.lodHysteresis === undefined ? {} : { lodHysteresis: draw.lodHysteresis }),
+      ...(draw.prepared === undefined ? {} : { prepared: draw.prepared }),
+    };
+  }
 }