@forgeax/engine-render 0.1.21 → 0.1.24

package/src/extract/gpu-driven.ts

@@ -0,0 +1,108 @@
+import type { MaterialShaderArtifact } from '@forgeax/engine-shader';
+import type { MeshAsset } from '@forgeax/engine-types';
+import {
+  type GpuDrivenDrawRange,
+  type PreparedGpuDrivenDraw,
+  type PrepareGpuDrivenDrawInput,
+  prepareGpuDrivenDraw,
+} from '../gpu-driven/prepared-draw';
+import type { MaterialSnapshot } from '../render-system-extract';
+
+export {
+  GpuDrivenPreparationError,
+  type GpuDrivenPreparationErrorCode,
+  type GpuDrivenPreparationErrorDetail,
+  type GpuDrivenPreparationReason,
+} from '../errors/gpu-driven';
+export {
+  type GpuDrivenDrawRange,
+  type GpuDrivenGeometryReceipt,
+  type GpuDrivenSkinReceipt,
+  type PreparedGpuDrivenDraw,
+  type PrepareGpuDrivenDrawInput,
+  prepareGpuDrivenDraw,
+} from '../gpu-driven/prepared-draw';
+
+export interface GpuDrivenDrawSnapshot {
+  readonly kind: GpuDrivenDrawRange['kind'];
+  readonly first: GpuDrivenDrawRange['first'];
+  readonly count: GpuDrivenDrawRange['count'];
+  readonly baseVertex: GpuDrivenDrawRange['baseVertex'];
+  readonly materialSlot: number;
+  readonly topology: GpuDrivenDrawRange['topology'];
+  readonly pipelineClass: string;
+  readonly materialResourceClass: string;
+  /** Producer-owned prepared ABI facts used by the PBR GPU lane. */
+  readonly prepared?: PreparedGpuDrivenDraw;
+}
+
+/**
+ * Resolves prepared facts once at extract time; record never re-reads assets.
+ * The resolver surfaces UV, reflection, vertex, alpha, resource, and
+ * generation failures as GpuDrivenPreparationError before recording.
+ */
+export function resolvePreparedGpuDrivenDraw(input: PrepareGpuDrivenDrawInput):
+  | { readonly ok: true; readonly value: PreparedGpuDrivenDraw }
+  | {
+      readonly ok: false;
+      readonly error: import('../errors/gpu-driven').GpuDrivenPreparationError;
+    } {
+  return prepareGpuDrivenDraw(input);
+}
+
+/** Keeps the artifact type visible at this owner boundary for contract checks. */
+export type PreparedGpuDrivenArtifact = MaterialShaderArtifact;
+
+/**
+ * Derives the resource identity consumed by the existing GPU-driven batch
+ * owner. The extract stage is the only place that resolves material values;
+ * this helper keeps the batch adapter from re-reading assets later.
+ */
+export function gpuDrivenMaterialResourceClass(material: MaterialSnapshot): string {
+  const textures = [...(material.textureHandles?.entries() ?? [])]
+    .map(([name, handle]) => [name, Number(handle)] as const)
+    .sort(([left], [right]) => left.localeCompare(right));
+  const samplers = [...(material.samplerHandles?.entries() ?? [])]
+    .map(([name, handle]) => [name, Number(handle)] as const)
+    .sort(([left], [right]) => left.localeCompare(right));
+  return JSON.stringify({
+    textures,
+    samplers,
+    video: [...(material.videoTextureFields?.keys() ?? [])].sort(),
+  });
+}
+
+/**
+ * Projects already-resolved mesh facts into the existing GPU-driven draw
+ * snapshot. No World or AssetRegistry access is permitted at this boundary.
+ */
+export function buildGpuDrivenDraws(input: {
+  readonly submeshes: readonly MeshAsset['submeshes'][number][];
+  readonly indexed: boolean;
+  readonly materials: readonly MaterialSnapshot[];
+  readonly fallbackMaterial: MaterialSnapshot;
+  readonly prepare?: (
+    draw: GpuDrivenDrawSnapshot,
+    material: MaterialSnapshot,
+  ) => PreparedGpuDrivenDraw | undefined;
+}): GpuDrivenDrawSnapshot[] {
+  let nonIndexedFirst = 0;
+  return input.submeshes.flatMap((submesh) => {
+    const drawMaterial = input.materials[submesh.materialSlot] ?? input.fallbackMaterial;
+    const first = input.indexed ? submesh.indexOffset : nonIndexedFirst;
+    nonIndexedFirst += submesh.vertexCount;
+    if (drawMaterial.transparent === true) return [];
+    const draw: GpuDrivenDrawSnapshot = {
+      kind: input.indexed ? ('indexed' as const) : ('non-indexed' as const),
+      first,
+      count: input.indexed ? submesh.indexCount : submesh.vertexCount,
+      baseVertex: 0,
+      materialSlot: submesh.materialSlot,
+      topology: submesh.topology,
+      pipelineClass: `${drawMaterial.materialShaderId ?? 'forgeax::default-unlit'}|${submesh.topology}|${JSON.stringify(drawMaterial.renderState ?? null)}`,
+      materialResourceClass: gpuDrivenMaterialResourceClass(drawMaterial),
+    };
+    const prepared = input.prepare?.(draw, drawMaterial);
+    return [prepared === undefined ? draw : { ...draw, prepared }];
+  });
+}

package/src/extract/visibility.ts

@@ -1,5 +1,4 @@
 import type { EntityHandle, World } from '@forgeax/engine-ecs';
-import { createWorldProjection } from '@forgeax/engine-ecs/projection';
 import {
   projectHierarchy,
   type SceneHierarchyDiagnostic,
@@ -38,14 +37,6 @@ interface ResolutionState {
   readonly source: VisibilitySource;
 }
 
-interface VisibilityCacheEntry {
-  readonly changes: ReturnType<typeof createWorldProjection>;
-  readonly hierarchy: SceneHierarchySnapshot;
-  readonly snapshot: VisibilitySnapshot;
-}
-
-const VISIBILITY_CACHE = new WeakMap<World, VisibilityCacheEntry>();
-
 /**
  * Resolve author intent against the scene-owned valid parent projection.
  * Diagnostics are preserved for callers to repair hierarchy input before retry.
@@ -54,19 +45,6 @@ export function resolveVisibility(
   world: World,
   hierarchy: SceneHierarchySnapshot = projectHierarchy(world),
 ): VisibilitySnapshot {
-  const cached = VISIBILITY_CACHE.get(world);
-  const changes = cached?.changes ?? createWorldProjection(world, { components: [Visibility] });
-  if (cached !== undefined) {
-    const evidence = changes.poll();
-    if (
-      evidence.status === 'delta' &&
-      evidence.changes.length === 0 &&
-      cached.hierarchy === hierarchy
-    ) {
-      return cached.snapshot;
-    }
-  }
-
   // Visibility is an opt-in component. Query only the owning archetypes
   // instead of walking every Entity row with an optional column; the latter
   // made a World with no visibility intents pay a full-scene scan on each
@@ -158,6 +136,5 @@ export function resolveVisibility(
       return resolveEntity?.(entity)?.effective ?? 'visible';
     },
   };
-  VISIBILITY_CACHE.set(world, { changes, hierarchy, snapshot });
   return snapshot;
 }

package/src/features/host.ts

@@ -1,6 +1,7 @@
 import type { EntityHandle } from '@forgeax/engine-ecs';
 import type { RhiCaps, TextureFormat } from '@forgeax/engine-rhi';
 import { err, ok, type Result } from '@forgeax/engine-types';
+import type { DeviceScope, LifecycleResourceSpec } from '../device/device-scope';
 import {
   type RenderError,
   RenderFeatureCapabilityMissingError,
@@ -175,6 +176,7 @@ export interface RenderFeatureHost {
     batches: readonly RenderFeaturePreparedResourceBatch[],
   ): Result<void, RenderError>;
   recover(input: RenderFeatureRecoverInput): Result<void, RenderError>;
+  createRecoveryRoot(scope: DeviceScope): LifecycleResourceSpec<unknown>;
   diagnostics(): readonly RenderFeatureDiagnostics[];
   /** Subscribe to lifecycle projection changes; unchanged active frames are silent. */
   subscribeDiagnostics(listener: () => void): () => void;
@@ -915,6 +917,20 @@ class FeatureHostImpl implements RenderFeatureHost {
     return this.slots.map((slot) => slot.feature);
   }
 
+  createRecoveryRoot(scope: DeviceScope): LifecycleResourceSpec<unknown> {
+    return {
+      kind: 'feature',
+      create: () => {
+        if (!scope.isAlive()) throw new Error('Feature candidate scope is not active.');
+        // The root carries the detached host owner itself. A scalar marker is
+        // not evidence that feature planning/preparation actually ran; the
+        // candidate graph and host own the prepared resources.
+        return this;
+      },
+      cleanup: () => undefined,
+    };
+  }
+
   private publishDiagnosticsChanged(): void {
     for (const listener of this.diagnosticsListeners) {
       try {

package/src/features/prepared-gpu-work.ts

@@ -11,6 +11,7 @@ import type {
   ShaderModule,
 } from '@forgeax/engine-rhi';
 import { type BindGroupLayoutDescriptor, err, ok, type Result } from '@forgeax/engine-types';
+import type { DeviceScope, LifecycleResourceSpec } from '../device/device-scope';
 import { type RenderError, RenderFeaturePreparationFailedError } from '../errors/render';
 import type { PipelineBuilderShaderModuleFactory } from '../pipeline-builder';
 import type { RenderFeatureShaderModuleMode } from './types';
@@ -910,6 +911,8 @@ function createRenderFeatureGpuWorkSession(input: {
  * retains the per-feature prepared GPU state and recreates it after recovery.
  */
 export interface RenderFeatureGpuWorkOwner {
+  /** Candidate root carries this detached GPU-work owner itself. */
+  createRecoveryRoot(scope: DeviceScope): LifecycleResourceSpec<unknown>;
   beginFeature(
     featureIdentity: string,
     generation: number,
@@ -935,9 +938,21 @@ export function createRenderFeatureGpuWorkOwner(input: {
       session: RenderFeatureGpuPrepareSession;
     }
   >();
-
-  return {
+  let disposed = false;
+
+  const owner: RenderFeatureGpuWorkOwner = {
+    createRecoveryRoot: (scope) => ({
+      kind: 'feature',
+      create: () => {
+        if (!scope.isAlive()) throw new Error('Feature GPU candidate scope is not active.');
+        return owner;
+      },
+      cleanup: () => undefined,
+    }),
     beginFeature: (featureIdentity, generation, requestedShaderModuleMode = 'validated') => {
+      if (disposed) {
+        throw new Error('Render feature GPU work owner is disposed.');
+      }
       const shaderModuleMode = requestedShaderModuleMode;
       const existing = sessions.get(featureIdentity);
       if (existing?.generation === generation && existing.shaderModuleMode === shaderModuleMode) {
@@ -962,6 +977,8 @@ export function createRenderFeatureGpuWorkOwner(input: {
     resolveBuffer: (featureIdentity, reference) =>
       sessions.get(featureIdentity)?.session.resolveBuffer(reference),
     dispose: () => {
+      if (disposed) return ok(undefined);
+      disposed = true;
       let first: RenderError | undefined;
       for (const { session } of sessions.values()) {
         const disposed = session.dispose();
@@ -971,4 +988,5 @@ export function createRenderFeatureGpuWorkOwner(input: {
       return first === undefined ? ok(undefined) : err(first);
     },
   };
+  return owner;
 }

package/src/features/prepared-graphics-store.ts

@@ -1,5 +1,6 @@
 import type { TextureFormat } from '@forgeax/engine-rhi';
 import { err, ok, type Result } from '@forgeax/engine-types';
+import type { DeviceScope, LifecycleResourceSpec } from '../device/device-scope';
 import { type RenderError, RenderFeaturePreparationFailedError } from '../errors/render';
 import type {
   PreparedKind,
@@ -81,6 +82,7 @@ export interface PreparedGraphicsStore {
   beginFrame(featureIdentity: string, generation: number): PreparedGraphicsTransaction;
   snapshot(featureIdentity: string): PreparedGraphicsStoreSnapshot;
   invalidate(featureIdentity: string, generation: number): void;
+  createRecoveryRoot(scope: DeviceScope): LifecycleResourceSpec<unknown>;
 }
 
 interface Slot {
@@ -418,6 +420,21 @@ class PreparedGraphicsStoreImpl implements PreparedGraphicsStore {
     }
   }
 
+  createRecoveryRoot(scope: DeviceScope): LifecycleResourceSpec<unknown> {
+    return {
+      kind: 'buffer',
+      create: () => {
+        if (!scope.isAlive()) throw new Error('Prepared graphics candidate scope is not active.');
+        const itemCount = [...this.slots.values()].reduce(
+          (count, slot) => count + slot.items.size,
+          0,
+        );
+        return Object.freeze({ generation: scope.generation, itemCount });
+      },
+      cleanup: () => undefined,
+    };
+  }
+
   registerReference(reference: object, item: PreparedGraphicsItem): void {
     this.references.set(reference, item);
   }

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

@@ -1,6 +1,10 @@
 import type { PrimitiveTopology } from '@forgeax/engine-types';
 import type { BatchTopologyInspection } from '../inspection-types';
+import type { CameraSnapshot } from '../render-contract';
 import type { RenderSceneApplyResult, RenderSceneSlot } from '../scene/render-scene-types';
+import { type GpuLodRow, selectGpuLod } from '../scene/visibility/gpu-lod';
+import { projectedHeight as measureProjectedHeight } from '../scene/visibility/lod-selector';
+import type { PreparedGpuDrivenDraw } from './prepared-draw';
 
 export type { BatchTopologyInspection } from '../inspection-types';
 
@@ -14,6 +18,12 @@ export interface GpuDrivenBatchKey {
   readonly topology: PrimitiveTopology;
   readonly pipelineClass: string;
   readonly materialResourceClass: string;
+  /** Stable producer-owned identity; topology never derives this from a shader name. */
+  readonly preparedIdentity?: string;
+  /** Resource identity projected by the prepared material contract. */
+  readonly resourceIdentity?: string;
+  /** Closed admission lane for the prepared Standard PBR draw. */
+  readonly admission?: 'opaque' | 'alpha-mask';
 }
 
 export interface GpuDrivenCandidate {
@@ -21,6 +31,16 @@ export interface GpuDrivenCandidate {
   readonly generation: number;
   readonly drawItemIndex: number;
   readonly instanceOrdinal: number;
+  /** Absolute coverage rows uploaded to the GPU selector; root is implicit. */
+  readonly lodCoverages?: readonly number[];
+  readonly lodHysteresis?: number;
+  readonly projectedHeight?: number;
+  readonly lodRanges?: readonly {
+    readonly first: number;
+    readonly count: number;
+    readonly baseVertex: number;
+  }[];
+  readonly prepared?: PreparedGpuDrivenDraw;
 }
 
 export interface GpuDrivenBatch {
@@ -40,6 +60,32 @@ export interface SubmissionPlan {
   readonly visibleCapacity: number;
 }
 
+export interface GpuLodCandidateInput {
+  readonly candidate: GpuDrivenCandidate;
+  readonly rows: readonly GpuLodRow[];
+  readonly projectedHeight: number;
+  readonly previousLevel: number;
+  readonly historyValid: boolean;
+}
+
+export interface GpuLodCompactCandidate {
+  readonly candidate: GpuDrivenCandidate;
+  readonly level: number;
+  readonly confidence: number;
+}
+
+/** Selects one level per stable topology candidate without mutating membership. */
+export function compactGpuLodCandidates(
+  inputs: readonly GpuLodCandidateInput[],
+): readonly GpuLodCompactCandidate[] {
+  return Object.freeze(
+    inputs.map((input) => {
+      const selection = selectGpuLod(input.rows, input);
+      return Object.freeze({ candidate: input.candidate, ...selection });
+    }),
+  );
+}
+
 interface MutableBatch {
   readonly batchId: number;
   readonly generation: number;
@@ -56,27 +102,97 @@ function eligibleKeys(slot: RenderSceneSlot): readonly GpuDrivenBatchKey[] {
     snapshot.instances?.instanceCount === 0 ||
     snapshot.localAabb === undefined ||
     snapshot.skin !== undefined ||
+    snapshot.morph !== undefined ||
     snapshot.spriteInstances !== undefined
   ) {
     return [];
   }
-  return draws.map((draw) => ({
-    assetHandle: snapshot.assetHandle,
-    drawKind: draw.kind,
-    first: draw.first,
-    count: draw.count,
-    baseVertex: draw.baseVertex,
-    materialSlot: draw.materialSlot,
-    topology: draw.topology,
-    pipelineClass: draw.pipelineClass,
-    materialResourceClass: draw.materialResourceClass,
-  }));
+  return draws.flatMap((draw) => {
+    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');
+      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 [
+        {
+          assetHandle: snapshot.assetHandle,
+          drawKind: draw.kind,
+          first: prepared.first,
+          count: prepared.count,
+          baseVertex: prepared.baseVertex,
+          materialSlot: draw.materialSlot,
+          topology: prepared.topology,
+          pipelineClass: preparedIdentity,
+          materialResourceClass: draw.materialResourceClass,
+          preparedIdentity,
+          resourceIdentity: draw.materialResourceClass,
+          admission,
+        },
+      ];
+    }
+    return [
+      {
+        assetHandle: snapshot.assetHandle,
+        drawKind: draw.kind,
+        first: draw.first,
+        count: draw.count,
+        baseVertex: draw.baseVertex,
+        materialSlot: draw.materialSlot,
+        topology: draw.topology,
+        pipelineClass: draw.pipelineClass,
+        materialResourceClass: draw.materialResourceClass,
+      },
+    ];
+  });
 }
 
 function keyText(key: GpuDrivenBatchKey): string {
   return JSON.stringify(key);
 }
 
+/**
+ * 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.
+ */
+function candidateBatchText(
+  key: GpuDrivenBatchKey,
+  primitiveIndex: number,
+  drawItemIndex: number,
+  instanceOrdinal: number,
+  hasLod: boolean,
+): string {
+  return hasLod
+    ? `${keyText(key)}|lod:${primitiveIndex}:${drawItemIndex}:${instanceOrdinal}`
+    : keyText(key);
+}
+
+function membershipTexts(slot: RenderSceneSlot): readonly string[] {
+  const keys = eligibleKeys(slot);
+  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;
+}
+
 function alignInstanceBase(value: number): number {
   // Raster binds each batch's visible-index and compact-transform segment at
   // a static storage-buffer offset. WebGPU requires those offsets to satisfy
@@ -86,6 +202,42 @@ function alignInstanceBase(value: number): number {
   return Math.ceil(value / 64) * 64;
 }
 
+export function projectedHeightForCandidate(slot: RenderSceneSlot, camera: CameraSnapshot): number {
+  const aabb = slot.snapshot.localAabb;
+  if (aabb === undefined || aabb.length < 6) return Number.NaN;
+  const halfX = Math.abs((aabb[3] ?? 0) - (aabb[0] ?? 0)) * 0.5;
+  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 +
+    Math.abs(world[8] ?? 0) * halfZ;
+  const worldHalfY =
+    Math.abs(world[1] ?? 0) * halfX +
+    Math.abs(world[5] ?? 0) * halfY +
+    Math.abs(world[9] ?? 0) * halfZ;
+  const worldHalfZ =
+    Math.abs(world[2] ?? 0) * halfX +
+    Math.abs(world[6] ?? 0) * halfY +
+    Math.abs(world[10] ?? 0) * halfZ;
+  const radius = Math.hypot(worldHalfX, worldHalfY, worldHalfZ);
+  const dx = (world[12] ?? 0) - (camera.position[0] ?? 0);
+  const dy = (world[13] ?? 0) - (camera.position[1] ?? 0);
+  const dz = (world[14] ?? 0) - (camera.position[2] ?? 0);
+  return measureProjectedHeight({
+    radius,
+    depth: Math.hypot(dx, dy, dz),
+    projection: camera.projection,
+    fov: camera.fov,
+    orthoHeight: Math.abs(camera.orthoTop - camera.orthoBottom),
+  });
+}
+
 /** Stable compatibility grouping; per-view visibility never mutates this owner. */
 export class BatchTopology {
   private readonly batches = new Map<string, MutableBatch>();
@@ -120,15 +272,17 @@ export class BatchTopology {
       changed = this.remove(slot.slot) || changed;
       changed = this.add(slot) || changed;
     }
+    // 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 instanceCount = slot.snapshot.instances?.instanceCount ?? 1;
-      const nextTexts = eligibleKeys(slot).flatMap((key) =>
-        Array.from({ length: instanceCount }, () => keyText(key)),
-      );
-      const current = this.membershipByPrimitive.get(slot.slot) ?? [];
+      const previous = this.membershipByPrimitive.get(slot.slot) ?? [];
+      const next = membershipTexts(slot);
       if (
-        current.length === nextTexts.length &&
-        current.every((membership, index) => membership.batchText === nextTexts[index])
+        previous.length === next.length &&
+        previous.every((membership, index) => membership.batchText === next[index])
       ) {
         continue;
       }
@@ -199,26 +353,50 @@ export class BatchTopology {
     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 text = keyText(key);
-      let batch = this.batches.get(text);
-      if (batch === undefined) {
-        const reused = this.freeBatchIds.pop();
-        const batchId = reused ?? this.generationByBatchId.length;
-        const generation = reused === undefined ? 0 : (this.generationByBatchId[batchId] ?? -1) + 1;
-        this.generationByBatchId[batchId] = generation;
-        batch = { batchId, generation, key, candidates: new Map() };
-        this.batches.set(text, batch);
-      }
       for (let instanceOrdinal = 0; instanceOrdinal < instanceCount; instanceOrdinal += 1) {
+        const text = candidateBatchText(key, slot.slot, drawItemIndex, instanceOrdinal, hasLod);
+        let batch = this.batches.get(text);
+        if (batch === undefined) {
+          const reused = this.freeBatchIds.pop();
+          const batchId = reused ?? this.generationByBatchId.length;
+          const generation =
+            reused === undefined ? 0 : (this.generationByBatchId[batchId] ?? -1) + 1;
+          this.generationByBatchId[batchId] = generation;
+          batch = { batchId, generation, 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 });
       }