@forgeax/engine-render 0.1.4 → 0.1.7

package/src/gpu-driven/production-raster.ts

@@ -13,59 +13,32 @@ import type {
   Result,
   RhiDevice,
   ShaderModule,
+  TextureFormat,
 } from '@forgeax/engine-rhi';
 import { err, ok, RhiError } from '@forgeax/engine-rhi';
-import { type MaterialRenderState, RenderQueue } from '@forgeax/engine-types';
+import type { MaterialRenderState } from '@forgeax/engine-types';
+import type { MeshGpuHandles } from '../device/gpu-residency';
 import { GPU_SCENE_WGSL } from '../gpu-scene-schema';
 import {
   GPU_BUFFER_USAGE_COPY_DST,
   GPU_BUFFER_USAGE_INDEX,
-  GPU_BUFFER_USAGE_UNIFORM,
   GPU_BUFFER_USAGE_VERTEX,
 } from '../gpu-usage';
-import type { PersistentGpuDrivenState } from '../persistent-render-scene';
+import type { GpuDrivenProductionInspection } from '../inspection-types';
 import type { PipelineBuilderShaderModuleFactory } from '../pipeline-builder';
-import { type RasterItemKey, rasterItemKey } from '../record';
-import type {
-  RenderPipelineFrame,
-  RenderPipelineGpuDrivenProjection,
-  RenderPipelineGpuDrivenShadowProjection,
-} from '../render-pipeline';
-import type { MeshGpuHandles } from '../render-system';
-import {
-  buildRenderVisibilityViewDescriptors,
-  type CameraSnapshot,
-  type ExtractedFrame,
-  type RenderableSnapshot,
-} from '../render-system-extract';
-import {
-  buildBatchAlignedSubmission,
-  buildSubmissionCandidateMembership,
-  type GpuDrivenBatch,
-  type GpuDrivenCandidate,
-  type SubmissionCandidateMembership,
-  type SubmissionPlan,
-} from './batch-topology';
-import {
-  type CpuMultiViewVisibilityResult,
-  type CpuVisibilityCandidate,
-  executeCpuMultiViewVisibility,
-  GpuDrivenView,
-} from './view-gpu';
+import { worldEntityKey } from '../record/frame-snapshot';
+import { geometryRenderStateForTopology } from '../record/main-pass-material';
+import type { CameraSnapshot } from '../render-contract';
+import type { RenderPipelineFrame, RenderPipelineGpuDrivenProjection } from '../render-pipeline';
+import type { RenderableSnapshot } from '../render-system-extract';
+import type { PersistentGpuDrivenState } from '../scene/render-scene';
+import type { GpuDrivenBatch, SubmissionPlan } from './batch-topology';
+import { GpuDrivenView } from './view-gpu';
 
 const VERTEX_STAGE = 0x1;
 const FRAGMENT_STAGE = 0x2;
 const EMPTY_RESOURCE_CLASS = JSON.stringify({ textures: [], samplers: [], video: [] });
 
-function supportsRigidGpuDrivenProjection(mesh: MeshGpuHandles): boolean {
-  const attributes = mesh.layoutProjection.attributes;
-  const required = ['position', 'normal', 'uv', 'tangent'] as const;
-  return (
-    attributes.length === required.length &&
-    attributes.every((attribute, index) => attribute.key === required[index])
-  );
-}
-
 export const GPU_DRIVEN_RIGID_UNLIT_WGSL = /* wgsl */ `
 ${GPU_SCENE_WGSL}
 
@@ -110,45 +83,6 @@ fn fs_main(input: VertexOutput) -> @location(0) vec4<f32> {
 }
 `;
 
-/**
- * Depth-only shadow raster companion for the shared GPU Scene visibility
- * buffers. It deliberately has no material-dependent fragment stage: alpha
- * test and custom ShadowCaster variants stay on the CPU contract until their
- * own batch shader is available. Opaque casters use the same primitive,
- * instance, transform and compact-visible tables as the main view.
- */
-export const GPU_DRIVEN_SHADOW_WGSL = /* wgsl */ `
-${GPU_SCENE_WGSL}
-
-struct ShadowBatch {
-  lightViewProj: mat4x4<f32>,
-  visibleBase: u32,
-  pad0: u32,
-  pad1: u32,
-  pad2: u32,
-};
-
-@group(2) @binding(0) var<storage, read> primitives: array<GpuScenePrimitive>;
-@group(2) @binding(1) var<storage, read> instances: array<GpuSceneInstance>;
-@group(2) @binding(2) var<storage, read> transforms: array<GpuSceneTransform>;
-@group(2) @binding(3) var<storage, read> visibleItems: array<vec2<u32>>;
-@group(2) @binding(4) var<uniform> shadowBatch: ShadowBatch;
-
-struct VertexInput {
-  @location(0) position: vec3<f32>,
-};
-
-@vertex
-fn vs_main(input: VertexInput, @builtin(instance_index) instanceIndex: u32) -> @builtin(position) vec4<f32> {
-  let visible = visibleItems[shadowBatch.visibleBase + instanceIndex];
-  let sceneInstance = instances[visible.x];
-  let primitive = primitives[sceneInstance.primitiveIndex];
-  let world = transforms[primitive.transformIndex].currentWorld *
-    transforms[sceneInstance.transformIndex].currentWorld;
-  return shadowBatch.lightViewProj * world * vec4<f32>(input.position, 1.0);
-}
-`;
-
 interface PreparedBatch {
   readonly batch: GpuDrivenBatch;
   readonly mesh: MeshGpuHandles;
@@ -199,85 +133,19 @@ function activeFrustum(camera: CameraSnapshot): Float32Array {
   );
 }
 
-export type GpuDrivenRasterEligibilityReason =
-  | 'missing-local-bounds-capability-lane'
-  | 'skinned-capability-lane'
-  | 'sprite-capability-lane'
-  | 'not-geometry-queue'
-  | 'unsafe-ordering'
-  | 'pbr-capability-lane'
-  | 'alpha-test-capability-lane'
-  | 'resource-bindings-capability-lane'
-  | 'transparent';
-
-export interface GpuDrivenRasterEligibility {
-  readonly eligible: boolean;
-  readonly reason: GpuDrivenRasterEligibilityReason | undefined;
-}
-
-/**
- * The current shader remains a deliberately narrow capability lane. Semantic
- * batch keys still retain PBR/alpha/resource/double-sided identity so those
- * objects can share the CPU/shadow contract without being misreported as
- * rigid-unlit GPU-owned raster work.
- */
-export function gpuDrivenRasterEligibility(
-  snapshot: RenderableSnapshot,
-  batch: GpuDrivenBatch,
-): GpuDrivenRasterEligibility {
+function productionEligible(snapshot: RenderableSnapshot, batch: GpuDrivenBatch): boolean {
   const material = snapshot.materials[batch.key.materialSlot] ?? snapshot.material;
   const shader = material.materialShaderId ?? 'forgeax::default-unlit';
-  if (snapshot.localAabb === undefined) {
-    return { eligible: false, reason: 'missing-local-bounds-capability-lane' };
-  }
-  if (snapshot.skin !== undefined) return { eligible: false, reason: 'skinned-capability-lane' };
-  if (snapshot.spriteInstances !== undefined) {
-    return { eligible: false, reason: 'sprite-capability-lane' };
-  }
-  if (batch.key.queue !== RenderQueue.Geometry) {
-    return { eligible: false, reason: 'not-geometry-queue' };
-  }
-  if (!orderSafe(material.renderState)) return { eligible: false, reason: 'unsafe-ordering' };
-  if (batch.key.pbr || shader !== 'forgeax::default-unlit') {
-    return { eligible: false, reason: 'pbr-capability-lane' };
-  }
-  if (batch.key.alphaTest) return { eligible: false, reason: 'alpha-test-capability-lane' };
-  if (
-    batch.key.materialResourceClass !== EMPTY_RESOURCE_CLASS ||
-    material.baseColorTexture !== undefined
-  ) {
-    return { eligible: false, reason: 'resource-bindings-capability-lane' };
-  }
-  if (material.transparent === true) return { eligible: false, reason: 'transparent' };
-  return { eligible: true, reason: undefined };
-}
-
-function productionEligible(snapshot: RenderableSnapshot, batch: GpuDrivenBatch): boolean {
-  return gpuDrivenRasterEligibility(snapshot, batch).eligible;
-}
-
-function sameNumberArray(left: readonly number[], right: readonly number[]): boolean {
-  if (left.length !== right.length) return false;
-  for (let index = 0; index < left.length; index += 1) {
-    if (left[index] !== right[index]) return false;
-  }
-  return true;
-}
-
-function orderSafe(renderState: MaterialRenderState | undefined): boolean {
-  if (renderState === undefined) return true;
   return (
-    renderState.blend === undefined &&
-    renderState.depthWriteEnabled !== false &&
-    renderState.depthCompare !== 'always' &&
-    renderState.stencil === undefined &&
-    renderState.stencilReadMask === undefined &&
-    renderState.stencilWriteMask === undefined
+    shader === 'forgeax::default-unlit' &&
+    batch.key.materialResourceClass === EMPTY_RESOURCE_CLASS &&
+    material.baseColorTexture === undefined &&
+    material.transparent !== true
   );
 }
 
 function meshSupportsBatch(mesh: MeshGpuHandles, batch: GpuDrivenBatch): boolean {
-  if (!supportsRigidGpuDrivenProjection(mesh)) return false;
+  if (mesh.layoutProjection.arrayStride !== 48) return false;
   return batch.key.drawKind === 'indexed'
     ? mesh.indexed && mesh.indexBuffer !== null
     : !mesh.indexed;
@@ -289,159 +157,72 @@ function filteredPlan(
   meshes: ReadonlyMap<number, MeshGpuHandles>,
 ): {
   readonly plan: SubmissionPlan;
-  readonly shadowPlan: SubmissionPlan;
   readonly batches: readonly PreparedBatch[];
-  readonly itemKeys: ReadonlySet<RasterItemKey>;
-  readonly forwardItemKeys: ReadonlySet<RasterItemKey>;
+  readonly entityKeys: ReadonlySet<number>;
 } {
   const slotByPrimitive = new Map(slots.map((slot) => [slot.slot, slot] as const));
-  const itemKeys = new Set<RasterItemKey>();
-  const forwardItemKeys = new Set<RasterItemKey>();
-  let hasEarlierQueue = false;
+  const entityKeys = new Set<number>();
+  const eligiblePrimitives = new Set<number>();
   for (const slot of slots) {
-    for (const draw of slot.snapshot.gpuDrivenDraws ?? []) {
-      const key = rasterItemKey(
-        slot.snapshot.worldId,
-        slot.snapshot.entityKey,
-        draw.submeshIndex,
-        draw.passIndex,
-      );
-      if (draw.queue === RenderQueue.Geometry) forwardItemKeys.add(key);
-      if (draw.queue < RenderQueue.Geometry) hasEarlierQueue = true;
+    const mesh = meshes.get(slot.snapshot.assetHandle);
+    const participating = source.batches.filter((batch) =>
+      batch.candidates.some((candidate) => candidate.primitiveIndex === slot.slot),
+    );
+    if (
+      mesh !== undefined &&
+      participating.length === (slot.snapshot.gpuDrivenDraws?.length ?? 0) &&
+      participating.every(
+        (batch) => productionEligible(slot.snapshot, batch) && meshSupportsBatch(mesh, batch),
+      )
+    ) {
+      eligiblePrimitives.add(slot.slot);
+      entityKeys.add(worldEntityKey(slot.snapshot.worldId, slot.snapshot.entityKey));
     }
   }
-  const candidatesByBatch = new Map<number, readonly GpuDrivenCandidate[]>();
-  const shadowCandidatesByBatch = new Map<number, readonly GpuDrivenCandidate[]>();
-  const meshByBatch = new Map<number, MeshGpuHandles>();
-  const renderStateByBatch = new Map<number, MaterialRenderState | undefined>();
+  const batches: PreparedBatch[] = [];
+  let visibleBase = 0;
+  const filteredBatches: GpuDrivenBatch[] = [];
   for (const batch of source.batches) {
-    const shadowCandidates = batch.candidates.filter(
-      (candidate) => slotByPrimitive.has(candidate.primitiveIndex) && batch.key.shadowCaster,
-    );
-    if (shadowCandidates.length > 0) {
-      shadowCandidatesByBatch.set(batch.batchId, Object.freeze(shadowCandidates));
-    }
     const candidates = batch.candidates.filter((candidate) => {
       const slot = slotByPrimitive.get(candidate.primitiveIndex);
-      if (slot === undefined || !productionEligible(slot.snapshot, batch)) return false;
+      if (slot === undefined || !eligiblePrimitives.has(slot.slot)) return false;
       const mesh = meshes.get(slot.snapshot.assetHandle);
-      if (mesh === undefined || !meshSupportsBatch(mesh, batch)) return false;
-      const draw = slot.snapshot.gpuDrivenDraws?.[candidate.drawItemIndex];
-      if (draw === undefined) return false;
-      itemKeys.add(
-        rasterItemKey(
-          slot.snapshot.worldId,
-          slot.snapshot.entityKey,
-          draw.submeshIndex,
-          draw.passIndex,
-        ),
-      );
-      return true;
+      return mesh !== undefined && meshSupportsBatch(mesh, batch);
     });
     if (candidates.length === 0) continue;
+    visibleBase = Math.ceil(visibleBase / 64) * 64;
+    const filtered: GpuDrivenBatch = Object.freeze({
+      ...batch,
+      candidates: Object.freeze(candidates),
+      visibleBase,
+      visibleCapacity: candidates.length,
+    });
+    visibleBase += candidates.length;
     const first = slotByPrimitive.get(candidates[0]?.primitiveIndex ?? -1);
     const mesh = first === undefined ? undefined : meshes.get(first.snapshot.assetHandle);
     if (mesh === undefined || first === undefined) continue;
-    candidatesByBatch.set(batch.batchId, Object.freeze(candidates));
-    meshByBatch.set(batch.batchId, mesh);
+    filteredBatches.push(filtered);
     const material = first.snapshot.materials[batch.key.materialSlot] ?? first.snapshot.material;
-    renderStateByBatch.set(batch.batchId, material.renderState);
-  }
-  const sourceShadowPlan = buildBatchAlignedSubmission(source, shadowCandidatesByBatch);
-  // The typed graph encodes the GPU Geometry lane before CPU recording in the
-  // same raster pass. If an earlier queue or an ineligible Geometry item is
-  // present, publishing only a subset would change stable queue order. Fail
-  // closed for the whole GPU lane and let the CPU path own every item.
-  if (hasEarlierQueue || itemKeys.size !== forwardItemKeys.size) {
-    return {
-      plan: Object.freeze({
-        revision: source.revision,
-        batches: Object.freeze([]),
-        candidateCount: 0,
-        visibleCapacity: 0,
-      }),
-      shadowPlan: sourceShadowPlan,
-      batches: Object.freeze([]),
-      itemKeys: new Set<RasterItemKey>(),
-      forwardItemKeys,
-    };
-  }
-  const plan = buildBatchAlignedSubmission(source, candidatesByBatch);
-  const batches: PreparedBatch[] = [];
-  for (const batch of plan.batches) {
-    const mesh = meshByBatch.get(batch.batchId);
-    if (mesh === undefined) continue;
     batches.push({
-      batch,
+      batch: filtered,
       mesh,
-      renderState: renderStateByBatch.get(batch.batchId),
+      renderState: geometryRenderStateForTopology(batch.key.topology, material.renderState),
     });
   }
   return {
-    plan,
-    // Shadow topology is intentionally derived from the unfiltered source
-    // plan. The rigid-unlit forward capability lane must not remove PBR,
-    // alpha-test, or double-sided casters from the ShadowCaster pool.
-    shadowPlan: sourceShadowPlan,
+    plan: Object.freeze({
+      revision: source.revision,
+      batches: Object.freeze(filteredBatches),
+      candidateCount: filteredBatches.reduce((total, batch) => total + batch.candidates.length, 0),
+      visibleCapacity: visibleBase,
+    }),
     batches: Object.freeze(batches),
-    itemKeys,
-    forwardItemKeys,
+    entityKeys,
   };
 }
 
-function filterShadowSubmissionBySlots(
-  source: SubmissionPlan,
-  shadowCasterSlotIndices: ReadonlySet<number> | undefined,
-): SubmissionPlan {
-  if (shadowCasterSlotIndices === undefined) return source;
-  const candidatesByBatch = new Map<number, readonly GpuDrivenCandidate[]>();
-  for (const batch of source.batches) {
-    const candidates = batch.candidates.filter((candidate) =>
-      shadowCasterSlotIndices.has(candidate.primitiveIndex),
-    );
-    if (candidates.length > 0) {
-      candidatesByBatch.set(batch.batchId, Object.freeze(candidates));
-    }
-  }
-  return buildBatchAlignedSubmission(source, candidatesByBatch);
-}
-
 type FilteredProductionPlan = ReturnType<typeof filteredPlan>;
 
-export interface GpuDrivenProductionInspection {
-  readonly gpuOwnedSnapshotsMaterialized: number;
-  readonly filteredPlanBuilds: number;
-  readonly gpuOwnedItemCount: number;
-  readonly candidateUploadBytes: number;
-  readonly batchUploadBytes: number;
-  readonly viewConstantsUploadBytes: number;
-  readonly batchBindGroupCreates: number;
-  readonly viewBindGroupCreates: number;
-  readonly topologyRevision: number | undefined;
-  readonly validatedGpuOwnedRows: number;
-  readonly cpuFallbackDrawItems: number;
-  readonly cpuVisibility: CpuMultiViewVisibilityResult | undefined;
-  readonly shadowBatchCount: number;
-  readonly shadowCandidateCount: number;
-  readonly shadowDrawCount: number;
-  readonly faults: readonly GpuDrivenVisibilityFault[];
-}
-
-export type GpuDrivenVisibilityFaultCode =
-  | 'visibility-overflow'
-  | 'gpu-capability-unavailable'
-  | 'gpu-scene-fact-unavailable'
-  | 'device-recovery-required'
-  | 'gpu-resource-failed';
-
-export interface GpuDrivenVisibilityFault {
-  readonly code: GpuDrivenVisibilityFaultCode;
-  readonly viewId: string;
-  readonly revision: number;
-  readonly fallback: 'cpu-batch-contract' | 'scene-rebuild';
-  readonly detail: string;
-}
-
 class GpuDrivenRigidRaster {
   private readonly pipelines = new Map<string, RenderPipeline>();
 
@@ -492,7 +273,7 @@ class GpuDrivenRigidRaster {
   }
 
   pipeline(
-    format: string,
+    format: TextureFormat,
     sampleCount: 1 | 4,
     vertexStride: number,
     topology: GpuDrivenBatch['key']['topology'],
@@ -504,9 +285,9 @@ class GpuDrivenRigidRaster {
     if (cached !== undefined) return ok(cached);
     const created = this.device.createRenderPipeline({
       label: `gpu-driven-rigid-unlit.${key}`,
-      layout: this.pipelineLayout as unknown as GPUPipelineLayout,
+      layout: this.pipelineLayout,
       vertex: {
-        module: this.module as unknown as GPUShaderModule,
+        module: this.module,
         entryPoint: 'vs_main',
         buffers: [
           {
@@ -517,17 +298,17 @@ class GpuDrivenRigidRaster {
         ],
       },
       fragment: {
-        module: this.module as unknown as GPUShaderModule,
+        module: this.module,
         entryPoint: 'fs_main',
         targets: [
           {
-            format: format as GPUTextureFormat,
+            format,
             ...(renderState?.blend === undefined ? {} : { blend: renderState.blend }),
           },
         ],
       },
       primitive: {
-        topology: topology as GPUPrimitiveTopology,
+        topology,
         cullMode: renderState?.cullMode ?? 'back',
         frontFace: renderState?.frontFace ?? 'ccw',
         ...(stripIndexFormat === undefined ? {} : { stripIndexFormat }),
@@ -594,292 +375,22 @@ class GpuDrivenRigidRaster {
   }
 }
 
-interface PreparedShadowBatch {
-  readonly batch: GpuDrivenBatch;
-  readonly mesh: MeshGpuHandles;
-  readonly pipeline: RenderPipeline;
-  readonly uniformOffset: number;
-}
-
-interface PreparedShadowView {
-  readonly cascadeIndex: number;
-  readonly view: GpuDrivenView;
-  readonly plan: SubmissionPlan;
-  readonly batches: readonly PreparedShadowBatch[];
-  readonly bindGroup: BindGroup;
-  readonly graphLabel: string;
-  readonly graphResources?: import('./view-gpu').GpuDrivenViewGraphResources;
-}
-
-class GpuDrivenShadowRaster {
-  private readonly pipelines = new Map<string, RenderPipeline>();
-  private readonly uniformBuffers = new Set<import('@forgeax/engine-rhi').Buffer>();
-  private readonly uniformByCascade = new Map<number, import('@forgeax/engine-rhi').Buffer>();
-  private readonly uniformCapacities = new Map<number, number>();
-
-  private constructor(
-    private readonly device: RhiDevice,
-    private readonly layout: BindGroupLayout,
-    private readonly pipelineLayout: import('@forgeax/engine-rhi').PipelineLayout,
-    private readonly module: ShaderModule,
-  ) {}
-
-  static create(input: {
-    readonly device: RhiDevice;
-    readonly shaderModuleFactory: PipelineBuilderShaderModuleFactory;
-    readonly viewBindGroupLayout: BindGroupLayout;
-    readonly materialBindGroupLayout: BindGroupLayout;
-  }): Result<GpuDrivenShadowRaster, RhiError> {
-    const layout = input.device.createBindGroupLayout({
-      label: 'gpu-driven-shadow-raster-bgl',
-      entries: [
-        { binding: 0, visibility: VERTEX_STAGE, buffer: { type: 'read-only-storage' } },
-        { binding: 1, visibility: VERTEX_STAGE, buffer: { type: 'read-only-storage' } },
-        { binding: 2, visibility: VERTEX_STAGE, buffer: { type: 'read-only-storage' } },
-        { binding: 3, visibility: VERTEX_STAGE, buffer: { type: 'read-only-storage' } },
-        {
-          binding: 4,
-          visibility: VERTEX_STAGE,
-          buffer: { type: 'uniform', hasDynamicOffset: true },
-        },
-      ],
-    });
-    if (!layout.ok) return layout;
-    const pipelineLayout = input.device.createPipelineLayout({
-      label: 'gpu-driven-shadow-raster-pl',
-      bindGroupLayouts: [input.viewBindGroupLayout, input.materialBindGroupLayout, layout.value],
-    });
-    if (!pipelineLayout.ok) return pipelineLayout;
-    const module = input.shaderModuleFactory.createShaderModule({
-      label: 'gpu-driven-shadow-raster',
-      code: GPU_DRIVEN_SHADOW_WGSL,
-    });
-    if (!module.ok) return module;
-    return ok(
-      new GpuDrivenShadowRaster(input.device, layout.value, pipelineLayout.value, module.value),
-    );
-  }
-
-  prepareView(input: {
-    readonly cascadeIndex: number;
-    readonly scene: PersistentGpuDrivenState['scene'];
-    readonly view: GpuDrivenView;
-    readonly plan: SubmissionPlan;
-    readonly lightViewProj: Float32Array;
-    readonly meshes: ReadonlyMap<number, MeshGpuHandles>;
-    readonly graphLabel: string;
-  }): Result<PreparedShadowView | undefined, RhiError> {
-    const eligibleBatches: Array<{
-      readonly batch: GpuDrivenBatch;
-      readonly mesh: MeshGpuHandles;
-    }> = [];
-    for (const batch of input.plan.batches) {
-      // The GPU shadow shader is the opaque rigid capability lane. Alpha-test,
-      // custom material shadow shaders, non-rigid geometry and line/point
-      // topology remain on the same batch-aligned CPU fallback contract.
-      if (batch.key.alphaTest) continue;
-      if (batch.key.topology !== 'triangle-list' && batch.key.topology !== 'triangle-strip') {
-        continue;
-      }
-      const mesh = input.meshes.get(batch.key.assetHandle);
-      if (mesh === undefined || !supportsRigidGpuDrivenProjection(mesh)) continue;
-      if (batch.key.drawKind === 'indexed' && (!mesh.indexed || mesh.indexBuffer === null)) {
-        continue;
-      }
-      if (batch.key.drawKind === 'non-indexed' && mesh.indexed) continue;
-      eligibleBatches.push({ batch, mesh });
-    }
-    if (eligibleBatches.length === 0 || input.view.visibleBuffer === undefined)
-      return ok(undefined);
-
-    const requiredBytes = Math.max(256, eligibleBatches.length * 256);
-    let uniformBuffer = this.uniformByCascade.get(input.cascadeIndex);
-    const currentCapacity = this.uniformCapacities.get(input.cascadeIndex) ?? 0;
-    if (uniformBuffer === undefined || currentCapacity < requiredBytes) {
-      const created = this.device.createBuffer({
-        label: `gpu-driven-shadow-cascade-${input.cascadeIndex}-uniforms`,
-        size: requiredBytes,
-        usage: GPU_BUFFER_USAGE_UNIFORM | GPU_BUFFER_USAGE_COPY_DST,
-        mappedAtCreation: false,
-      });
-      if (!created.ok) return created;
-      uniformBuffer = created.value;
-      this.uniformBuffers.add(uniformBuffer);
-      this.uniformByCascade.set(input.cascadeIndex, uniformBuffer);
-      this.uniformCapacities.set(input.cascadeIndex, requiredBytes);
-    }
-    const payload = new Uint8Array(requiredBytes);
-    for (let index = 0; index < eligibleBatches.length; index += 1) {
-      const item = eligibleBatches[index];
-      if (item === undefined) continue;
-      const offset = index * 256;
-      new Float32Array(payload.buffer, offset, 16).set(input.lightViewProj.subarray(0, 16));
-      new DataView(payload.buffer).setUint32(offset + 64, item.batch.visibleBase, true);
-    }
-    const write = this.device.queue.writeBuffer(uniformBuffer, 0, payload);
-    if (!write.ok) return write;
-    const visible = input.view.visibleBuffer;
-    const binding = this.device.createBindGroup({
-      label: `gpu-driven-shadow-cascade-${input.cascadeIndex}-bg`,
-      layout: this.layout,
-      entries: [
-        { binding: 0, resource: bufferBinding(input.scene.primitiveBuffer) },
-        { binding: 1, resource: bufferBinding(input.scene.instanceBuffer) },
-        { binding: 2, resource: bufferBinding(input.scene.transformBuffer) },
-        { binding: 3, resource: bufferBinding(visible) },
-        {
-          binding: 4,
-          resource: {
-            kind: 'buffer',
-            value: { buffer: uniformBuffer, offset: 0, size: 80 },
-          },
-        },
-      ],
-    });
-    if (!binding.ok) return binding;
-    const batches: PreparedShadowBatch[] = [];
-    for (let index = 0; index < eligibleBatches.length; index += 1) {
-      const item = eligibleBatches[index];
-      if (item === undefined) continue;
-      const pipeline = this.pipeline(item.mesh, item.batch);
-      if (!pipeline.ok) return pipeline;
-      batches.push({
-        batch: item.batch,
-        mesh: item.mesh,
-        pipeline: pipeline.value,
-        uniformOffset: index * 256,
-      });
-    }
-    return ok({
-      cascadeIndex: input.cascadeIndex,
-      view: input.view,
-      plan: input.plan,
-      batches: Object.freeze(batches),
-      bindGroup: binding.value,
-      graphLabel: input.graphLabel,
-    });
-  }
-
-  encode(
-    prepared: PreparedShadowView,
-    resources: GraphResourceResolver,
-    graphResources: import('./view-gpu').GpuDrivenViewGraphResources,
-    pass: import('@forgeax/engine-rhi').RhiRenderPassEncoder,
-  ): void {
-    const indirect = resources.buffer(graphResources.indirect);
-    if (!indirect.ok) throw indirect.error;
-    let currentPipeline: RenderPipeline | undefined;
-    let currentVertex: import('@forgeax/engine-rhi').Buffer | undefined;
-    let currentIndex: import('@forgeax/engine-rhi').Buffer | undefined;
-    for (const batch of prepared.batches) {
-      if (currentPipeline !== batch.pipeline) {
-        pass.setPipeline(batch.pipeline);
-        currentPipeline = batch.pipeline;
-      }
-      pass.setBindGroup(2, prepared.bindGroup, [batch.uniformOffset]);
-      if (currentVertex !== batch.mesh.vertexBuffer.handle) {
-        pass.setVertexBuffer(0, batch.mesh.vertexBuffer.handle);
-        currentVertex = batch.mesh.vertexBuffer.handle;
-      }
-      if (batch.mesh.indexBuffer !== null && batch.mesh.indexed) {
-        if (currentIndex !== batch.mesh.indexBuffer.handle) {
-          pass.setIndexBuffer(batch.mesh.indexBuffer.handle, batch.mesh.indexFormat);
-          currentIndex = batch.mesh.indexBuffer.handle;
-        }
-        pass.drawIndexedIndirect(indirect.value, batch.batch.indirectOffset);
-      } else {
-        pass.drawIndirect(indirect.value, batch.batch.indirectOffset);
-      }
-    }
-  }
-
-  dispose(): void {
-    for (const buffer of this.uniformBuffers) this.device.destroyBuffer(buffer);
-    this.uniformBuffers.clear();
-    this.uniformByCascade.clear();
-    this.uniformCapacities.clear();
-    this.pipelines.clear();
-  }
-
-  private pipeline(mesh: MeshGpuHandles, batch: GpuDrivenBatch): Result<RenderPipeline, RhiError> {
-    const stripIndexFormat =
-      batch.key.drawKind === 'indexed' && batch.key.topology === 'triangle-strip'
-        ? mesh.indexFormat
-        : undefined;
-    const key = `${batch.key.topology}|${stripIndexFormat ?? ''}|${batch.key.doubleSided ? 'none' : 'back'}`;
-    const cached = this.pipelines.get(key);
-    if (cached !== undefined) return ok(cached);
-    const created = this.device.createRenderPipeline({
-      label: `gpu-driven-shadow-${key}`,
-      layout: this.pipelineLayout as unknown as GPUPipelineLayout,
-      vertex: {
-        module: this.module as unknown as GPUShaderModule,
-        entryPoint: 'vs_main',
-        buffers: [
-          {
-            arrayStride: 48,
-            stepMode: 'vertex',
-            attributes: [{ shaderLocation: 0, offset: 0, format: 'float32x3' }],
-          },
-        ],
-      },
-      primitive: {
-        topology: batch.key.topology as GPUPrimitiveTopology,
-        cullMode: batch.key.doubleSided ? 'none' : 'back',
-        frontFace: 'ccw',
-        ...(stripIndexFormat === undefined ? {} : { stripIndexFormat }),
-      },
-      depthStencil: {
-        format: 'depth32float',
-        depthWriteEnabled: true,
-        depthCompare: 'less',
-      },
-    });
-    if (!created.ok) return created;
-    this.pipelines.set(key, created.value);
-    return created;
-  }
-}
-
 export interface PreparedGpuDrivenFrame {
   readonly topologySignature: string;
-  readonly ownedItemKeys: ReadonlySet<RasterItemKey>;
-  readonly ownsAllForwardItems: boolean;
-  /** Batch-aligned ShadowCaster candidates from the same topology revision. */
-  readonly shadowSubmission: SubmissionPlan;
+  readonly entityKeys: ReadonlySet<number>;
+  readonly ownsAllRenderables: boolean;
+  /** @internal Commits a replacement generation only after graph promotion. */
+  readonly _commitResourceReplacement: () => void;
   project(
     graph: RenderGraphBuilder<RenderPipelineFrame>,
-    format: string,
+    format: TextureFormat,
     sampleCount: 1 | 4,
   ): Result<RenderPipelineGpuDrivenProjection, RenderGraphError | RhiError>;
 }
 
-/**
- * Per-view production submission. The batch-aligned plan owns candidate
- * membership; candidateIndexByStableId is a one-way adapter for the existing
- * direct RHI draw encoder and must not be used to generate another view list.
- */
-export interface MultiViewProductionSubmission {
-  readonly source: 'multi-view-indirect';
-  readonly viewId: string;
-  readonly kind: 'main' | 'cascade';
-  readonly cascadeIndex: number | undefined;
-  readonly volumeRevision: number | undefined;
-  readonly spatialIndexRevision: number | undefined;
-  readonly overflow: boolean;
-  readonly plan: SubmissionPlan;
-  readonly candidateIndexByStableId: ReadonlyMap<number, number>;
-  /** Immutable candidate membership adapter shared by CPU shadow fallback and observation. */
-  readonly candidateIndices: ReadonlySet<number>;
-  readonly faults: readonly GpuDrivenVisibilityFault[];
-}
-
 export class GpuDrivenProduction {
   private view: GpuDrivenView | undefined;
   private raster: GpuDrivenRigidRaster | undefined;
-  private shadowRaster: GpuDrivenShadowRaster | undefined;
-  private readonly shadowViews = new Map<number, GpuDrivenView>();
-  private preparedShadowViews: readonly PreparedShadowView[] = [];
   private readonly sceneIdentities = new WeakMap<object, number>();
   private nextSceneIdentity = 1;
   private filteredCache:
@@ -891,32 +402,10 @@ export class GpuDrivenProduction {
     | undefined;
   private gpuOwnedSnapshotsMaterialized = 0;
   private filteredPlanBuilds = 0;
-  private gpuOwnedItemCount = 0;
+  private gpuOwnedEntityCount = 0;
   private batchBindGroupCreates = 0;
   private validatedGpuOwnedRows = 0;
   private cpuFallbackDrawItems = 0;
-  private cpuVisibility: CpuMultiViewVisibilityResult | undefined;
-  /** Candidate-domain ShadowCaster membership projected onto persistent slots. */
-  private shadowCasterSlotIndices: ReadonlySet<number> | undefined;
-  private visibilityViews: readonly import('../render-system-extract').RenderVisibilityViewDescriptor[] =
-    [];
-  private shadowSubmission: SubmissionPlan | undefined;
-  private readonly shadowPlanCache = new Map<
-    string,
-    {
-      readonly source: SubmissionPlan;
-      readonly stableIds: readonly number[];
-      readonly generations: readonly number[];
-      readonly plan: SubmissionPlan;
-    }
-  >();
-  /**
-   * Reverse index for the immutable shadow topology. Cascade views provide
-   * stable slot ids, so rebuilding a view plan should walk the selected view
-   * domain instead of filtering every source candidate for every cascade.
-   */
-  private shadowCandidateMembership: SubmissionCandidateMembership | undefined;
-  private faults: readonly GpuDrivenVisibilityFault[] = [];
   private signatureCache:
     | {
         readonly filtered: FilteredProductionPlan;
@@ -932,146 +421,11 @@ export class GpuDrivenProduction {
     private readonly shaderModuleFactory: PipelineBuilderShaderModuleFactory,
   ) {}
 
-  prepareCpuVisibility(input: {
-    readonly scene: PersistentGpuDrivenState | undefined;
-    readonly frame: ExtractedFrame;
-    readonly camera: CameraSnapshot | undefined;
-  }): CpuMultiViewVisibilityResult | undefined {
-    this.faults = [];
-    if (input.scene === undefined) {
-      this.cpuVisibility = undefined;
-      this.visibilityViews = [];
-      this.shadowCasterSlotIndices = undefined;
-      this.shadowPlanCache.clear();
-      this.shadowCandidateMembership = undefined;
-      return undefined;
-    }
-    const descriptors = buildRenderVisibilityViewDescriptors({
-      camera: input.camera,
-      directionalCsm: input.frame.lights.directionalCsm,
-      spatialIndexRevision: input.scene.scene.inspect().spatialIndex?.revision,
-    });
-    const batchBySlot = new Map<
-      number,
-      { readonly batchId: number; readonly instanceOrdinal: number }
-    >();
-    const capacityByBatch = new Map<number, number>();
-    for (const batch of input.scene.plan.batches) {
-      capacityByBatch.set(batch.batchId, batch.visibleCapacity);
-      for (const candidate of batch.candidates) {
-        if (!batchBySlot.has(candidate.primitiveIndex)) {
-          batchBySlot.set(candidate.primitiveIndex, {
-            batchId: batch.batchId,
-            instanceOrdinal: candidate.instanceOrdinal,
-          });
-        }
-      }
-    }
-    const candidateDomain = input.frame.candidateDomain;
-    const needsCandidateIdentityFallback =
-      candidateDomain !== undefined ||
-      input.scene.slots.some((slot) => slot.snapshot.candidateIndex === undefined);
-    let candidateIndexByIdentity: ReadonlyMap<string, number> = new Map<string, number>();
-    if (needsCandidateIdentityFallback) {
-      if (candidateDomain !== undefined) {
-        // The persistent candidate domain is the only owner that remains
-        // correct after projection removals compact the candidate array. A
-        // projection slot may still carry the old snapshot candidateIndex;
-        // never let that stale producer hint override the domain join.
-        candidateIndexByIdentity = candidateDomain.indexByIdentity;
-      } else {
-        const fallback = new Map<string, number>();
-        for (let index = 0; index < (input.frame.candidateRenderables?.length ?? 0); index += 1) {
-          const candidate = input.frame.candidateRenderables?.[index];
-          if (candidate !== undefined) {
-            fallback.set(`${candidate.worldId}:${candidate.entityKey}`, index);
-          }
-        }
-        candidateIndexByIdentity = fallback;
-      }
-    }
-    const candidatesBySlot = new Map<number, CpuVisibilityCandidate>();
-    const shadowCasterCandidateIndices =
-      input.frame.candidateDomain?.membership.shadowCasterCandidateIndices ??
-      input.frame.candidateDispatchMembership?.shadowCasterCandidateIndices;
-    const shadowCasterSlotIndices =
-      shadowCasterCandidateIndices === undefined ? undefined : new Set<number>();
-    for (const slot of input.scene.slots) {
-      const batch = batchBySlot.get(slot.slot);
-      const worldAabb =
-        slot.fact.bounds.status === 'present' ? slot.fact.bounds.worldAabb : undefined;
-      const candidateIndex =
-        candidateDomain === undefined
-          ? (slot.snapshot.candidateIndex ??
-            candidateIndexByIdentity.get(`${slot.worldId}:${slot.entityKey}`))
-          : candidateIndexByIdentity.get(`${slot.worldId}:${slot.entityKey}`);
-      const dispatchShadowCaster =
-        shadowCasterCandidateIndices === undefined ||
-        candidateIndex === undefined ||
-        shadowCasterCandidateIndices.has(candidateIndex);
-      if (
-        dispatchShadowCaster &&
-        slot.fact.casterEligibility !== 'ineligible' &&
-        shadowCasterSlotIndices !== undefined
-      ) {
-        shadowCasterSlotIndices.add(slot.slot);
-      }
-      candidatesBySlot.set(slot.slot, {
-        stableId: slot.slot,
-        generation: slot.generation,
-        candidateIndex,
-        worldAabb,
-        // Unknown authoring facts remain conservative. Only an explicit
-        // ineligible fact may remove a candidate from a shadow view.
-        casterEligible: slot.fact.casterEligibility !== 'ineligible' && dispatchShadowCaster,
-        batchId: batch?.batchId,
-        instanceOrdinal: batch?.instanceOrdinal,
-      });
-    }
-    this.shadowCasterSlotIndices =
-      shadowCasterSlotIndices === undefined
-        ? undefined
-        : (Object.freeze(shadowCasterSlotIndices) as ReadonlySet<number>);
-    const candidatesByView = new Map<string, readonly CpuVisibilityCandidate[]>();
-    const candidateUnion = new Map<number, CpuVisibilityCandidate>();
-    for (const view of descriptors) {
-      const hits =
-        view.broadphaseWorldAabb === undefined || input.scene.projection === undefined
-          ? input.scene.slots
-          : input.scene.projection.querySpatialIndex(view.broadphaseWorldAabb).hits;
-      const domain: CpuVisibilityCandidate[] = [];
-      for (const hit of hits) {
-        const candidate = candidatesBySlot.get(hit.slot);
-        if (candidate === undefined) continue;
-        domain.push(candidate);
-        candidateUnion.set(candidate.stableId, candidate);
-      }
-      candidatesByView.set(view.viewId, Object.freeze(domain));
-    }
-    const candidates = [...candidateUnion.values()];
-    // Main visibility is independent from the GPU batch domain. Keep its
-    // compact array large enough for non-GPU renderables in the broadphase
-    // domain, otherwise a valid CPU-only object would be reported as an
-    // artificial visibility overflow.
-    const capacity = Math.max(1, input.scene.plan.visibleCapacity, candidates.length);
-    const capacityByView = new Map(descriptors.map((view) => [view.viewId, capacity] as const));
-    this.visibilityViews = descriptors;
-    this.cpuVisibility = executeCpuMultiViewVisibility({
-      views: descriptors,
-      candidates,
-      candidatesByView,
-      capacityByView,
-      capacityByBatch,
-    });
-    return this.cpuVisibility;
-  }
-
   prepare(input: {
     readonly scene: PersistentGpuDrivenState | undefined;
     readonly camera: CameraSnapshot;
     readonly meshes: ReadonlyMap<number, MeshGpuHandles>;
     readonly viewBindGroupLayout: BindGroupLayout;
-    readonly materialBindGroupLayout?: BindGroupLayout;
     readonly meshResidencyEpoch: number;
     readonly hdrp: boolean;
   }): Result<PreparedGpuDrivenFrame | undefined, RhiError> {
@@ -1080,11 +434,14 @@ export class GpuDrivenProduction {
     this.batchBindGroupCreates = 0;
     this.validatedGpuOwnedRows = 0;
     this.cpuFallbackDrawItems = 0;
-    this.shadowSubmission = undefined;
-    this.shadowCandidateMembership = undefined;
-    this.preparedShadowViews = [];
-    if (input.scene === undefined) {
-      this.gpuOwnedItemCount = 0;
+    if (
+      input.hdrp ||
+      input.scene === undefined ||
+      !this.device.caps.compute ||
+      !this.device.caps.storageBuffer ||
+      !this.device.caps.indirectDrawing
+    ) {
+      this.gpuOwnedEntityCount = 0;
       return ok(undefined);
     }
     const scene = input.scene;
@@ -1103,41 +460,14 @@ export class GpuDrivenProduction {
       this.gpuOwnedSnapshotsMaterialized = scene.slots.length;
       this.filteredPlanBuilds = 1;
     }
-    this.gpuOwnedItemCount = filtered.itemKeys.size;
-    const shadowSubmission = filterShadowSubmissionBySlots(
-      filtered.shadowPlan,
-      this.shadowCasterSlotIndices,
-    );
-    this.shadowSubmission = shadowSubmission;
-    if (
-      input.hdrp ||
-      !this.device.caps.compute ||
-      !this.device.caps.storageBuffer ||
-      !this.device.caps.indirectDrawing ||
-      (filtered.batches.length === 0 && shadowSubmission.batches.length === 0)
-    ) {
-      if (shadowSubmission.candidateCount > 0) {
-        this.addFault({
-          code: 'gpu-capability-unavailable',
-          viewId: 'all',
-          revision: shadowSubmission.revision,
-          fallback: 'cpu-batch-contract',
-          detail: input.hdrp
-            ? 'HDRP production raster does not expose the rigid shadow capability lane'
-            : 'compute, storage-buffer, indirect-drawing, or forward batch capability is unavailable',
-        });
-      }
-      return ok(undefined);
-    }
+    this.gpuOwnedEntityCount = filtered.entityKeys.size;
+    if (filtered.batches.length === 0) return ok(undefined);
     if (this.view === undefined) {
       const created = GpuDrivenView.create({
         device: this.device,
         shaderModuleFactory: this.shaderModuleFactory,
       });
-      if (!created.ok) {
-        this.addRhiFault(created.error, 'all', filtered.plan.revision);
-        return created;
-      }
+      if (!created.ok) return created;
       this.view = created.value;
     }
     if (this.raster === undefined) {
@@ -1146,35 +476,11 @@ export class GpuDrivenProduction {
         shaderModuleFactory: this.shaderModuleFactory,
         viewBindGroupLayout: input.viewBindGroupLayout,
       });
-      if (!created.ok) {
-        this.addRhiFault(created.error, 'all', filtered.plan.revision);
-        return created;
-      }
+      if (!created.ok) return created;
       this.raster = created.value;
     }
-    if (this.shadowRaster === undefined && input.materialBindGroupLayout !== undefined) {
-      const created = GpuDrivenShadowRaster.create({
-        device: this.device,
-        shaderModuleFactory: this.shaderModuleFactory,
-        viewBindGroupLayout: input.viewBindGroupLayout,
-        materialBindGroupLayout: input.materialBindGroupLayout,
-      });
-      if (!created.ok) {
-        this.addRhiFault(created.error, 'all', shadowSubmission.revision);
-      } else {
-        this.shadowRaster = created.value;
-      }
-    }
     const updated = this.view.update(filtered.plan, scene.scene, activeFrustum(input.camera));
-    if (!updated.ok) {
-      this.addRhiFault(updated.error, 'main', filtered.plan.revision);
-      return updated;
-    }
-    const shadowPrepared = this.prepareShadowViews(scene, shadowSubmission, input.meshes);
-    if (!shadowPrepared.ok) {
-      this.addRhiFault(shadowPrepared.error, 'all', shadowSubmission.revision);
-      return shadowPrepared;
-    }
+    if (!updated.ok) return updated;
     const view = this.view;
     const raster = this.raster;
     const sceneIdentity = this.sceneIdentity(scene.scene);
@@ -1204,7 +510,7 @@ export class GpuDrivenProduction {
           mesh.vboBytes,
           mesh.iboBytes,
           mesh.indexFormat,
-          mesh.layoutProjection.digest,
+          mesh.uvSetCount,
         ]),
         capacities: [
           viewInspection.candidateCapacity,
@@ -1222,11 +528,9 @@ export class GpuDrivenProduction {
     }
     return ok({
       topologySignature: signature,
-      ownedItemKeys: filtered.itemKeys,
-      ownsAllForwardItems:
-        filtered.forwardItemKeys.size > 0 &&
-        [...filtered.forwardItemKeys].every((key) => filtered.itemKeys.has(key)),
-      shadowSubmission,
+      entityKeys: filtered.entityKeys,
+      ownsAllRenderables: filtered.entityKeys.size === scene.slots.length,
+      _commitResourceReplacement: () => view._commitResourceReplacement(),
       project: (graph, format, sampleCount) => {
         const outputs = view.addPasses(graph);
         if (!outputs.ok) return outputs;
@@ -1279,7 +583,7 @@ export class GpuDrivenProduction {
           const pipeline = raster.pipeline(
             format,
             sampleCount,
-            prepared.mesh.layoutProjection.arrayStride,
+            48 + (prepared.mesh.uvSetCount - 1) * 8,
             prepared.batch.key.topology,
             prepared.batch.key.drawKind === 'indexed' &&
               (prepared.batch.key.topology === 'line-strip' ||
@@ -1299,70 +603,15 @@ export class GpuDrivenProduction {
             bindings: bindings.value,
           });
         }
-        const shadow: RenderPipelineGpuDrivenShadowProjection[] = [];
-        const shadowRaster = this.shadowRaster;
-        if (shadowRaster !== undefined) {
-          for (const prepared of this.preparedShadowViews) {
-            const shadowOutputs = prepared.view.addPasses(graph, prepared.graphLabel);
-            if (!shadowOutputs.ok) return shadowOutputs;
-            const shadowAccesses: GraphAccess[] = [
-              { resource: shadowOutputs.value.primitive, usage: 'storage-read' },
-              { resource: shadowOutputs.value.instance, usage: 'storage-read' },
-              { resource: shadowOutputs.value.transform, usage: 'storage-read' },
-              { resource: shadowOutputs.value.visible, usage: 'storage-read' },
-              { resource: shadowOutputs.value.indirect, usage: 'indirect-read' },
-            ];
-            const meshBuffers = new Map<
-              number,
-              { readonly vertex: GraphBuffer; readonly index?: GraphBuffer }
-            >();
-            for (const batch of prepared.batches) {
-              let buffers = meshBuffers.get(batch.batch.key.assetHandle);
-              if (buffers === undefined) {
-                const vertex = graph.importBuffer(
-                  `${prepared.graphLabel}.mesh.${batch.batch.key.assetHandle}.vertex`,
-                  {
-                    size: batch.mesh.vboBytes,
-                    usage: GPU_BUFFER_USAGE_VERTEX | GPU_BUFFER_USAGE_COPY_DST,
-                  },
-                  () => batch.mesh.vertexBuffer.handle,
-                );
-                if (!vertex.ok) return vertex;
-                let index: GraphBuffer | undefined;
-                if (batch.mesh.indexBuffer !== null) {
-                  const imported = graph.importBuffer(
-                    `${prepared.graphLabel}.mesh.${batch.batch.key.assetHandle}.index`,
-                    {
-                      size: batch.mesh.iboBytes,
-                      usage: GPU_BUFFER_USAGE_INDEX | GPU_BUFFER_USAGE_COPY_DST,
-                    },
-                    () => batch.mesh.indexBuffer?.handle as import('@forgeax/engine-rhi').Buffer,
-                  );
-                  if (!imported.ok) return imported;
-                  index = imported.value;
-                }
-                buffers = { vertex: vertex.value, ...(index === undefined ? {} : { index }) };
-                meshBuffers.set(batch.batch.key.assetHandle, buffers);
-                shadowAccesses.push({ resource: buffers.vertex, usage: 'vertex-read' });
-                if (buffers.index !== undefined) {
-                  shadowAccesses.push({ resource: buffers.index, usage: 'index-read' });
-                }
-              }
-            }
-            shadow.push({
-              cascadeIndex: prepared.cascadeIndex,
-              accesses: Object.freeze(shadowAccesses),
-              batchCount: prepared.batches.length,
-              encode: (pass, resources) =>
-                shadowRaster.encode(prepared, resources, shadowOutputs.value, pass),
-            });
-          }
-        }
         return ok({
           accesses,
-          shadow: Object.freeze(shadow),
           encode: (viewBindGroup, pass, resources: GraphResourceResolver) => {
-            pass.setBindGroup(0, viewBindGroup);
+            // pbr-view-bgl carries the vertex-only Points/Lines UBO at binding
+            // 10 as a dynamic uniform buffer.  The production view group is
+            // shared by the GPU-driven raster pipeline, so even rigid draws
+            // must provide the binding-10 offset (zero selects the frame
+            // default slot).
+            pass.setBindGroup(0, viewBindGroup, [0]);
             let currentPipeline: RenderPipeline | undefined;
             let currentVertex: GraphBuffer | undefined;
             let currentIndex: GraphBuffer | undefined;
@@ -1398,238 +647,12 @@ export class GpuDrivenProduction {
     });
   }
 
-  /**
-   * Intersect the four-view visibility result with the shared ShadowCaster
-   * topology. This is the only production candidate-to-submission join; CPU
-   * fallback devices consume the same immutable plans as indirect-capable
-   * devices.
-   */
-  multiViewSubmissions(): readonly MultiViewProductionSubmission[] {
-    if (this.cpuVisibility === undefined || this.shadowSubmission === undefined) {
-      return [];
-    }
-    const shadowSubmission = this.shadowSubmission;
-    return Object.freeze(
-      this.cpuVisibility.views.map((view) => {
-        const candidateIndexByStableId = new Map<number, number>();
-        for (const candidate of view.compactVisible) {
-          if (candidate.candidateIndex !== undefined) {
-            candidateIndexByStableId.set(candidate.stableId, candidate.candidateIndex);
-          }
-        }
-        const plan = this.shadowSubmissionForView(shadowSubmission, view);
-        const candidateIndices = new Set<number>();
-        for (const batch of plan.batches) {
-          for (const candidate of batch.candidates) {
-            const candidateIndex = candidateIndexByStableId.get(candidate.primitiveIndex);
-            if (candidateIndex !== undefined) candidateIndices.add(candidateIndex);
-          }
-        }
-        return Object.freeze({
-          source: 'multi-view-indirect' as const,
-          viewId: view.viewId,
-          kind: view.kind,
-          cascadeIndex: view.cascadeIndex,
-          volumeRevision: view.volumeRevision,
-          spatialIndexRevision: view.spatialIndexRevision,
-          overflow: view.overflow,
-          plan,
-          candidateIndexByStableId,
-          candidateIndices,
-          faults: Object.freeze(
-            this.faults.filter((fault) => fault.viewId === 'all' || fault.viewId === view.viewId),
-          ),
-        });
-      }),
-    );
-  }
-
-  private prepareShadowViews(
-    scene: PersistentGpuDrivenState,
-    shadowSource: SubmissionPlan,
-    meshes: ReadonlyMap<number, MeshGpuHandles>,
-  ): Result<void, RhiError> {
-    this.preparedShadowViews = [];
-    if (this.shadowRaster === undefined || this.cpuVisibility === undefined) return ok(undefined);
-    const slotByPrimitive = new Map(scene.slots.map((slot) => [slot.slot, slot] as const));
-    const descriptorByView = new Map(
-      this.visibilityViews.map((view) => [view.viewId, view] as const),
-    );
-    const prepared: PreparedShadowView[] = [];
-    for (const viewResult of this.cpuVisibility.views) {
-      if (viewResult.kind !== 'cascade' || viewResult.cascadeIndex === undefined) continue;
-      const descriptor = descriptorByView.get(viewResult.viewId);
-      if (
-        descriptor === undefined ||
-        descriptor.lightViewProj === undefined ||
-        descriptor.planes.length < 24 ||
-        viewResult.overflow
-      ) {
-        if (viewResult.overflow) {
-          this.addFault({
-            code: 'visibility-overflow',
-            viewId: viewResult.viewId,
-            revision: shadowSource.revision,
-            fallback: 'cpu-batch-contract',
-            detail:
-              'compact visibility capacity was exceeded; the complete CPU batch contract remains authoritative',
-          });
-        } else if (descriptor === undefined || descriptor.lightViewProj === undefined) {
-          this.addFault({
-            code: 'gpu-resource-failed',
-            viewId: viewResult.viewId,
-            revision: shadowSource.revision,
-            fallback: 'cpu-batch-contract',
-            detail: 'cascade volume did not publish a canonical raster matrix',
-          });
-        }
-        continue;
-      }
-      const plan = this.shadowSubmissionForView(shadowSource, viewResult);
-      if (plan.batches.length === 0) continue;
-      let gpuSafe = true;
-      for (const batch of plan.batches) {
-        const mesh = meshes.get(batch.key.assetHandle);
-        if (
-          batch.key.alphaTest ||
-          (batch.key.materialClass !== 'forgeax::default-unlit' &&
-            batch.key.materialClass !== 'forgeax::default-standard-pbr') ||
-          mesh === undefined ||
-          !supportsRigidGpuDrivenProjection(mesh) ||
-          (batch.key.topology !== 'triangle-list' && batch.key.topology !== 'triangle-strip') ||
-          (batch.key.drawKind === 'indexed' && (!mesh.indexed || mesh.indexBuffer === null)) ||
-          (batch.key.drawKind === 'non-indexed' && mesh.indexed)
-        ) {
-          gpuSafe = false;
-          break;
-        }
-        for (const candidate of batch.candidates) {
-          const slot = slotByPrimitive.get(candidate.primitiveIndex);
-          if (
-            slot === undefined ||
-            slot.fact.bounds.status !== 'present' ||
-            slot.snapshot.gpuDrivenDraws === undefined
-          ) {
-            gpuSafe = false;
-            break;
-          }
-        }
-        if (!gpuSafe) break;
-      }
-      if (!gpuSafe) {
-        this.addFault({
-          code: 'gpu-scene-fact-unavailable',
-          viewId: viewResult.viewId,
-          revision: shadowSource.revision,
-          fallback: 'cpu-batch-contract',
-          detail:
-            'one or more casters lack bounded GPU Scene facts required by the exact shadow cull',
-        });
-        continue;
-      }
-      let view = this.shadowViews.get(viewResult.cascadeIndex);
-      if (view === undefined) {
-        const created = GpuDrivenView.create({
-          device: this.device,
-          shaderModuleFactory: this.shaderModuleFactory,
-        });
-        if (!created.ok) {
-          this.addRhiFault(created.error, viewResult.viewId, shadowSource.revision);
-          continue;
-        }
-        view = created.value;
-        this.shadowViews.set(viewResult.cascadeIndex, view);
-      }
-      const updated = view.update(plan, scene.scene, descriptor.planes);
-      if (!updated.ok) {
-        this.addRhiFault(updated.error, viewResult.viewId, shadowSource.revision);
-        continue;
-      }
-      const shadowView = this.shadowRaster.prepareView({
-        cascadeIndex: viewResult.cascadeIndex,
-        scene: scene.scene,
-        view,
-        plan,
-        lightViewProj: descriptor.lightViewProj,
-        meshes,
-        graphLabel: `gpu-driven.shadow.cascade-${viewResult.cascadeIndex}`,
-      });
-      if (!shadowView.ok) {
-        this.addRhiFault(shadowView.error, viewResult.viewId, shadowSource.revision);
-        continue;
-      }
-      if (shadowView.value !== undefined) prepared.push(shadowView.value);
-    }
-    this.preparedShadowViews = Object.freeze(prepared);
-    return ok(undefined);
-  }
-
-  private shadowSubmissionForView(
-    shadowSubmission: SubmissionPlan,
-    view: CpuMultiViewVisibilityResult['views'][number],
-  ): SubmissionPlan {
-    const cached = this.shadowPlanCache.get(view.viewId);
-    const stableIds = view.compactVisible.map((candidate) => candidate.stableId);
-    const generations = view.compactVisible.map((candidate) => candidate.generation);
-    if (
-      cached !== undefined &&
-      cached.source === shadowSubmission &&
-      sameNumberArray(cached.stableIds, stableIds) &&
-      sameNumberArray(cached.generations, generations)
-    ) {
-      return cached.plan;
-    }
-    let reverse = this.shadowCandidateMembership;
-    if (reverse?.source !== shadowSubmission) {
-      reverse = buildSubmissionCandidateMembership(shadowSubmission);
-      this.shadowCandidateMembership = reverse;
-    }
-    const candidatesByBatch = new Map<number, GpuDrivenCandidate[]>();
-    // compactVisible is stable-id ordered because the CPU visibility owner
-    // sorts its candidate domain once. Appending each slot's source-order
-    // candidates therefore preserves the old deterministic order while
-    // changing the join from O(all shadow candidates per cascade) to
-    // O(selected candidates).
-    for (const visible of view.compactVisible) {
-      const entries = reverse.byPrimitiveIndex.get(visible.stableId);
-      if (entries === undefined) continue;
-      for (const entry of entries) {
-        if (entry.candidate.generation !== visible.generation) continue;
-        const candidates = candidatesByBatch.get(entry.batchId) ?? [];
-        candidates.push(entry.candidate);
-        candidatesByBatch.set(entry.batchId, candidates);
-      }
-    }
-    const frozenCandidatesByBatch = new Map<number, readonly GpuDrivenCandidate[]>();
-    for (const [batchId, candidates] of candidatesByBatch) {
-      frozenCandidatesByBatch.set(batchId, Object.freeze(candidates));
-    }
-    const plan = buildBatchAlignedSubmission(shadowSubmission, frozenCandidatesByBatch);
-    this.shadowPlanCache.set(view.viewId, {
-      source: shadowSubmission,
-      stableIds: Object.freeze(stableIds),
-      generations: Object.freeze(generations),
-      plan,
-    });
-    return plan;
-  }
-
   dispose(): void {
     this.view?.dispose();
-    for (const view of this.shadowViews.values()) view.dispose();
-    this.shadowViews.clear();
-    this.shadowRaster?.dispose();
     this.view = undefined;
     this.raster = undefined;
-    this.shadowRaster = undefined;
-    this.preparedShadowViews = [];
     this.filteredCache = undefined;
     this.signatureCache = undefined;
-    this.cpuVisibility = undefined;
-    this.shadowCasterSlotIndices = undefined;
-    this.shadowSubmission = undefined;
-    this.shadowPlanCache.clear();
-    this.shadowCandidateMembership = undefined;
   }
 
   inspect(): GpuDrivenProductionInspection {
@@ -1637,7 +660,7 @@ export class GpuDrivenProduction {
     return {
       gpuOwnedSnapshotsMaterialized: this.gpuOwnedSnapshotsMaterialized,
       filteredPlanBuilds: this.filteredPlanBuilds,
-      gpuOwnedItemCount: this.gpuOwnedItemCount,
+      gpuOwnedEntityCount: this.gpuOwnedEntityCount,
       candidateUploadBytes: view?.candidateUploadBytes ?? 0,
       batchUploadBytes: view?.batchUploadBytes ?? 0,
       viewConstantsUploadBytes: view?.viewConstantsUploadBytes ?? 0,
@@ -1646,37 +669,19 @@ export class GpuDrivenProduction {
       topologyRevision: view?.topologyRevision,
       validatedGpuOwnedRows: this.validatedGpuOwnedRows,
       cpuFallbackDrawItems: this.cpuFallbackDrawItems,
-      cpuVisibility: this.cpuVisibility,
-      shadowBatchCount: this.shadowSubmission?.batches.length ?? 0,
-      shadowCandidateCount: this.shadowSubmission?.candidateCount ?? 0,
-      shadowDrawCount: this.preparedShadowViews.reduce(
-        (total, prepared) => total + prepared.batches.length,
-        0,
-      ),
-      faults: this.faults,
     };
   }
 
   recordCpuValidation(
     validated: readonly { readonly source: RenderableSnapshot }[],
-    gpuOwned: ReadonlySet<RasterItemKey>,
+    gpuOwned: ReadonlySet<number>,
   ): void {
-    let cpuFallbackItems = 0;
+    this.cpuFallbackDrawItems = validated.length;
+    let gpuOwnedRows = 0;
     for (const row of validated) {
-      for (const draw of row.source.gpuDrivenDraws ?? []) {
-        const key = rasterItemKey(
-          row.source.worldId,
-          row.source.entityKey,
-          draw.submeshIndex,
-          draw.passIndex,
-        );
-        if (!gpuOwned.has(key)) cpuFallbackItems += 1;
-      }
+      if (gpuOwned.has(worldEntityKey(row.source.worldId, row.source.entityKey))) gpuOwnedRows += 1;
     }
-    this.cpuFallbackDrawItems = cpuFallbackItems;
-    // Validation remains a renderable/mesh-residency phase. Ownership is
-    // published only for item keys, so no validated row is GPU-owned.
-    this.validatedGpuOwnedRows = 0;
+    this.validatedGpuOwnedRows = gpuOwnedRows;
   }
 
   private sceneIdentity(scene: object): number {
@@ -1687,19 +692,4 @@ export class GpuDrivenProduction {
     this.sceneIdentities.set(scene, identity);
     return identity;
   }
-
-  private addFault(fault: GpuDrivenVisibilityFault): void {
-    this.faults = Object.freeze([...this.faults, Object.freeze(fault)]);
-  }
-
-  private addRhiFault(error: RhiError, viewId: string, revision: number): void {
-    const requiresRecovery = error.code === 'device-lost' || error.code === 'oom';
-    this.addFault({
-      code: requiresRecovery ? 'device-recovery-required' : 'gpu-resource-failed',
-      viewId,
-      revision,
-      fallback: requiresRecovery ? 'scene-rebuild' : 'cpu-batch-contract',
-      detail: `${error.code}: ${error.message}`,
-    });
-  }
 }