@forgeax/engine-render 0.1.20 → 0.1.23

package/src/__tests__/gpu-driven-production.integration.test.ts

@@ -1,20 +1,28 @@
 import { HANDLE_CUBE } from '@forgeax/engine-assets-runtime';
 import { World } from '@forgeax/engine-ecs';
 import { deriveVertexLayoutProjection } from '@forgeax/engine-geometry';
+import { vec3 } from '@forgeax/engine-math';
 import { RenderGraphBuilder } from '@forgeax/engine-render-graph';
+import type { BindGroup } from '@forgeax/engine-rhi';
 import { type RhiNullDevice, rhi } from '@forgeax/engine-rhi-null';
 import { Transform } from '@forgeax/engine-scene';
 import {
+  createStandardPbrArtifactReceipt,
   DEFAULT_STANDARD_PBR_PARAM_SCHEMA,
   DEFAULT_UNLIT_PARAM_SCHEMA,
 } from '@forgeax/engine-shader';
 import { ok } from '@forgeax/engine-types';
 import { describe, expect, it } from 'vitest';
 import { createRenderer as constructRenderer } from '../assembly/factory';
-import { Camera, MeshFilter, MeshRenderer } from '../components';
+import { Camera, MeshFilter, MeshRenderer, PointLight } from '../components';
 import type { MeshGpuHandles } from '../device/gpu-residency';
 import { BatchTopology } from '../gpu-driven/batch-topology';
-import { GpuDrivenProduction } from '../gpu-driven/production-raster';
+import {
+  adaptStandardPbrFrameResources,
+  GpuDrivenProduction,
+  projectStandardPbrScene,
+} from '../gpu-driven/production-raster';
+import { GPU_DRIVEN_VIEW_WGSL } from '../gpu-driven/view-gpu';
 import { GpuBuffer } from '../gpu-resource';
 import { GpuScene } from '../gpu-scene';
 import {
@@ -23,12 +31,19 @@ import {
   GPU_BUFFER_USAGE_UNIFORM,
   GPU_BUFFER_USAGE_VERTEX,
 } from '../gpu-usage';
-import { makeZeroCameraFallbackSnapshot } from '../record/frame-snapshot';
+import { makeZeroCameraFallbackSnapshot, worldEntityKey } from '../record/frame-snapshot';
 import type { RenderPipelineFrame } from '../render-pipeline';
 import type { MaterialSnapshot, RenderableSnapshot } from '../render-system-extract';
 import { RenderScene } from '../scene/render-scene';
 
+const STANDARD_PBR_RECEIPT = createStandardPbrArtifactReceipt();
+
 const EMPTY_RESOURCE_CLASS = JSON.stringify({ textures: [], samplers: [], video: [] });
+const OUTPUT_TRANSFORM_WGSL =
+  '@vertex fn vs_main(@builtin(vertex_index) i: u32) -> @builtin(position) vec4<f32> { ' +
+  'var p = array<vec2<f32>, 3>(vec2<f32>(-1.0, -1.0), vec2<f32>(3.0, -1.0), vec2<f32>(-1.0, 3.0)); ' +
+  'return vec4<f32>(p[i], 0.0, 1.0); } ' +
+  '@fragment fn fs_main() -> @location(0) vec4<f32> { return vec4<f32>(0.0); }';
 
 const STANDARD_PBR_URP_VARIANT_KEY =
   'CLUSTER_FORWARD_AVAILABLE=false+STORAGE_BUFFER_AVAILABLE=true+TRANSMISSION_AVAILABLE=false+VERTEX_COLOR_AVAILABLE=false';
@@ -38,7 +53,7 @@ const STANDARD_PBR_TRANSMISSION_VARIANT_KEY =
 function manifestDataUrl(): string {
   const pbrWgsl = '/* pbr stub - calls f_schlick( */';
   const unlitWgsl = '/* unlit stub */';
-  const tonemapWgsl = '/* tonemap stub - struct TonemapParams { exposure: f32 }; */';
+  const tonemapWgsl = OUTPUT_TRANSFORM_WGSL;
   const standardPbrVariant = (transmissionAvailable: boolean, definesKey: string) => ({
     definesKey,
     defines: {
@@ -121,7 +136,7 @@ function snapshot(entityKey: number, assetHandle: number): RenderableSnapshot {
   };
 }
 
-function mesh(device: RhiNullDevice, indexed = true): MeshGpuHandles {
+function mesh(device: RhiNullDevice, indexed = true, withLod = false): MeshGpuHandles {
   const vertex = device
     .createBuffer({
       size: 144,
@@ -163,10 +178,401 @@ function mesh(device: RhiNullDevice, indexed = true): MeshGpuHandles {
         topology: 'triangle-list',
       },
     ],
+    ...(withLod
+      ? {
+          lodRanges: [
+            [{ first: 0, count: 3, baseVertex: 0 }],
+            [{ first: 3, count: 1, baseVertex: 0 }],
+          ],
+        }
+      : {}),
   };
 }
 
 describe('GPU-driven production projection', () => {
+  it('retains suppressed LOD candidates for selector accounting while admitting only active draws', async () => {
+    const adapter = (await rhi.requestAdapter()).unwrap();
+    const device = (await adapter.requestDevice()).unwrap() as RhiNullDevice;
+    const shader = (await rhi.createShaderModule(device, { code: 'synthetic' })).unwrap();
+    const viewLayout = device
+      .createBindGroupLayout({
+        entries: [{ binding: 0, visibility: 0x1, buffer: { type: 'uniform' } }],
+      })
+      .unwrap();
+    const projection = new RenderScene();
+    const lodMeshGuid = '00000000-0000-7000-8000-000000000001' as never;
+    const makeLodSnapshot = (entityKey: number): RenderableSnapshot => {
+      const base = snapshot(entityKey, 3);
+      const draw = base.gpuDrivenDraws?.[0];
+      if (draw === undefined) throw new Error('LOD test snapshot has no draw');
+      return {
+        ...base,
+        lods: [{ mesh: lodMeshGuid, screenCoverage: 0.5 }],
+        gpuDrivenDraws: [{ ...draw, lodRanges: [{ first: 3, count: 1, baseVertex: 0 }] }],
+      };
+    };
+    const delta = projection.apply([
+      { kind: 'create', snapshot: makeLodSnapshot(1) },
+      { kind: 'create', snapshot: makeLodSnapshot(2) },
+    ]);
+    const availability = GpuScene.create(device, 2).unwrap();
+    expect(availability.status).toBe('available');
+    if (availability.status !== 'available') return;
+    availability.scene.sync(delta).unwrap();
+    const topology = new BatchTopology();
+    topology.rebuild(projection.slotsSnapshot());
+    const production = new GpuDrivenProduction(device, {
+      createShaderModule: () => ok(shader),
+    });
+    const prepared = production
+      .prepare({
+        scene: {
+          scene: availability.scene,
+          plan: topology.plan(),
+          slots: projection.slotsSnapshot(),
+        },
+        camera: makeZeroCameraFallbackSnapshot(),
+        meshes: new Map([[3, mesh(device, true, true)]]),
+        viewBindGroupLayout: viewLayout,
+        meshResidencyEpoch: 1,
+        hdrp: false,
+        activeEntityKeys: new Set([worldEntityKey(0, 1)]),
+        activeEntityRevision: 1,
+      })
+      .unwrap();
+    expect(prepared?.entityKeys).toEqual(new Set([worldEntityKey(0, 1)]));
+    // Both candidates are uploaded to the selector (2 * 304 bytes), while
+    // only the active entity is admitted into the compacted draw stream.
+    expect(production.inspect()).toMatchObject({
+      candidateUploadBytes: 2 * 304,
+      batchCount: 1,
+      indirectDrawCount: 1,
+    });
+    if (prepared === undefined) return;
+    const projected = prepared
+      .project(new RenderGraphBuilder<RenderPipelineFrame>(), 'rgba8unorm', 1)
+      .unwrap();
+    expect(projected.accesses.length).toBeGreaterThan(0);
+    expect(production.inspect()).toMatchObject({
+      batchBindGroupCreates: 1,
+      indirectDrawCount: 1,
+    });
+    expect(production.inspect().indirectDrawCount).toBeGreaterThan(0);
+    expect(production.inspect().indirectDrawCount).toBeLessThanOrEqual(
+      production.inspect().batchCount,
+    );
+
+    const suppressed = production
+      .prepare({
+        scene: {
+          scene: availability.scene,
+          plan: topology.plan(),
+          slots: projection.slotsSnapshot(),
+        },
+        camera: makeZeroCameraFallbackSnapshot(),
+        meshes: new Map([[3, mesh(device, true, true)]]),
+        viewBindGroupLayout: viewLayout,
+        meshResidencyEpoch: 1,
+        hdrp: false,
+        activeEntityKeys: new Set(),
+        activeEntityRevision: 2,
+      })
+      .unwrap();
+    expect(suppressed?.topologySignature).not.toBe(prepared.topologySignature);
+    expect(production.inspect()).toMatchObject({
+      batchCount: 1,
+      indirectDrawCount: 0,
+    });
+
+    const restored = production
+      .prepare({
+        scene: {
+          scene: availability.scene,
+          plan: topology.plan(),
+          slots: projection.slotsSnapshot(),
+        },
+        camera: makeZeroCameraFallbackSnapshot(),
+        meshes: new Map([[3, mesh(device, true, true)]]),
+        viewBindGroupLayout: viewLayout,
+        meshResidencyEpoch: 1,
+        hdrp: false,
+        activeEntityKeys: new Set([worldEntityKey(0, 1)]),
+        activeEntityRevision: 3,
+      })
+      .unwrap();
+    expect(restored?.topologySignature).not.toBe(suppressed?.topologySignature);
+    expect(production.inspect()).toMatchObject({
+      batchCount: 1,
+      indirectDrawCount: 1,
+    });
+    expect(GPU_DRIVEN_VIEW_WGSL.indexOf('atomicAdd(&counters[lodCounterIndex')).toBeLessThan(
+      GPU_DRIVEN_VIEW_WGSL.indexOf('if (candidate.submitAdmission == 0u)'),
+    );
+    expect(GPU_DRIVEN_VIEW_WGSL.indexOf('if (candidate.submitAdmission == 0u)')).toBeLessThan(
+      GPU_DRIVEN_VIEW_WGSL.indexOf('atomicAdd(&counters[counterIndex(candidate.batchIndex)], 1u)'),
+    );
+    production.dispose();
+    availability.scene.dispose();
+  });
+
+  it('keeps a suppressed-only batch in selector telemetry without raster resources', async () => {
+    const adapter = (await rhi.requestAdapter()).unwrap();
+    const device = (await adapter.requestDevice()).unwrap() as RhiNullDevice;
+    const shader = (await rhi.createShaderModule(device, { code: 'synthetic' })).unwrap();
+    const viewLayout = device
+      .createBindGroupLayout({
+        entries: [{ binding: 0, visibility: 0x1, buffer: { type: 'uniform' } }],
+      })
+      .unwrap();
+    const projection = new RenderScene();
+    const candidate = snapshot(1, 3);
+    const delta = projection.apply([{ kind: 'create', snapshot: candidate }]);
+    const availability = GpuScene.create(device, 1).unwrap();
+    expect(availability.status).toBe('available');
+    if (availability.status !== 'available') return;
+    availability.scene.sync(delta).unwrap();
+    const topology = new BatchTopology();
+    topology.rebuild(projection.slotsSnapshot());
+    const production = new GpuDrivenProduction(device, {
+      createShaderModule: () => ok(shader),
+    });
+    const prepared = production
+      .prepare({
+        scene: {
+          scene: availability.scene,
+          plan: topology.plan(),
+          slots: projection.slotsSnapshot(),
+        },
+        camera: makeZeroCameraFallbackSnapshot(),
+        meshes: new Map([[3, mesh(device)]]),
+        viewBindGroupLayout: viewLayout,
+        meshResidencyEpoch: 1,
+        hdrp: false,
+        activeEntityKeys: new Set(),
+        activeEntityRevision: 1,
+      })
+      .unwrap();
+    expect(prepared).toBeDefined();
+    expect(production.requiresSceneRows()).toBe(true);
+    expect(production.inspect()).toMatchObject({
+      batchCount: 1,
+      indirectDrawCount: 0,
+      batchBindGroupCreates: 0,
+    });
+    if (prepared === undefined) return;
+    prepared.project(new RenderGraphBuilder<RenderPipelineFrame>(), 'rgba8unorm', 1).unwrap();
+    expect(production.inspect()).toMatchObject({
+      batchCount: 1,
+      indirectDrawCount: 0,
+      batchBindGroupCreates: 0,
+    });
+    production.dispose();
+    availability.scene.dispose();
+  });
+
+  it('keeps GPU batches World-homogeneous for same-submit counter attribution', async () => {
+    const adapter = (await rhi.requestAdapter()).unwrap();
+    const device = (await adapter.requestDevice()).unwrap() as RhiNullDevice;
+    const shader = (await rhi.createShaderModule(device, { code: 'synthetic' })).unwrap();
+    const viewLayout = device
+      .createBindGroupLayout({
+        entries: [{ binding: 0, visibility: 0x1, buffer: { type: 'uniform' } }],
+      })
+      .unwrap();
+    const projection = new RenderScene();
+    const first = snapshot(1, 3);
+    const second = { ...snapshot(2, 3), worldId: 1 };
+    const delta = projection.apply([
+      { kind: 'create', snapshot: first },
+      { kind: 'create', snapshot: second },
+    ]);
+    const availability = GpuScene.create(device, 2).unwrap();
+    expect(availability.status).toBe('available');
+    if (availability.status !== 'available') return;
+    availability.scene.sync(delta).unwrap();
+    const topology = new BatchTopology();
+    topology.rebuild(projection.slotsSnapshot());
+    const production = new GpuDrivenProduction(device, {
+      createShaderModule: () => ok(shader),
+    });
+    const prepared = production
+      .prepare({
+        scene: {
+          scene: availability.scene,
+          plan: topology.plan(),
+          slots: projection.slotsSnapshot(),
+        },
+        camera: makeZeroCameraFallbackSnapshot(),
+        meshes: new Map([[3, mesh(device)]]),
+        viewBindGroupLayout: viewLayout,
+        meshResidencyEpoch: 1,
+        hdrp: false,
+      })
+      .unwrap();
+    expect(prepared).toBeDefined();
+    expect(production.inspect()).toMatchObject({ batchCount: 2, indirectDrawCount: 2 });
+    production.dispose();
+    availability.scene.dispose();
+  });
+
+  it('uses renderer-local World keys for CPU validation telemetry', async () => {
+    const adapter = (await rhi.requestAdapter()).unwrap();
+    const device = (await adapter.requestDevice()).unwrap() as RhiNullDevice;
+    const shader = (await rhi.createShaderModule(device, { code: 'synthetic' })).unwrap();
+    const production = new GpuDrivenProduction(device, {
+      createShaderModule: () => ok(shader),
+    });
+    const gpuLodRow = {
+      ...snapshot(7, 3),
+      worldId: 1,
+      lods: [{ mesh: '00000000-0000-7000-8000-000000000001' as never, screenCoverage: 0.5 }],
+    };
+    const plainFallbackRow = { ...snapshot(2, 3), worldId: 0 };
+    const gpuOwned = new Set([worldEntityKey(101, gpuLodRow.entityKey)]);
+    const worldKeys = [202, 101];
+
+    // A GPU-owned row is removed from validation before this telemetry hook;
+    // the remaining plain row must still be counted as the one CPU fallback.
+    production.recordCpuValidation([{ source: plainFallbackRow }], gpuOwned, worldKeys);
+    expect(production.inspect()).toMatchObject({
+      cpuFallbackDrawItems: 1,
+      validatedGpuOwnedRows: 0,
+    });
+
+    // Prove the same renderer-local namespace recognizes the GPU row when a
+    // diagnostic caller supplies it directly, even though its extracted
+    // RenderableSnapshot still carries the reordered array index.
+    production.recordCpuValidation([{ source: gpuLodRow }], gpuOwned, worldKeys);
+    expect(production.inspect()).toMatchObject({
+      cpuFallbackDrawItems: 1,
+      validatedGpuOwnedRows: 1,
+    });
+    production.dispose();
+  });
+
+  it('coalesces LOD candidates that share the selected geometry range', async () => {
+    const adapter = (await rhi.requestAdapter()).unwrap();
+    const device = (await adapter.requestDevice()).unwrap() as RhiNullDevice;
+    const shader = (await rhi.createShaderModule(device, { code: 'synthetic' })).unwrap();
+    const viewLayout = device
+      .createBindGroupLayout({
+        entries: [{ binding: 0, visibility: 0x1, buffer: { type: 'uniform' } }],
+      })
+      .unwrap();
+    const projection = new RenderScene();
+    const lodMeshGuid = '00000000-0000-7000-8000-000000000001' as never;
+    const makeLodSnapshot = (entityKey: number): RenderableSnapshot => {
+      const base = snapshot(entityKey, 3);
+      const draw = base.gpuDrivenDraws?.[0];
+      if (draw === undefined) throw new Error('LOD test snapshot has no draw');
+      return {
+        ...base,
+        lods: [{ mesh: lodMeshGuid, screenCoverage: 0.5 }],
+        gpuDrivenDraws: [{ ...draw, lodRanges: [{ first: 3, count: 1, baseVertex: 0 }] }],
+      };
+    };
+    const delta = projection.apply([
+      { kind: 'create', snapshot: makeLodSnapshot(1) },
+      { kind: 'create', snapshot: makeLodSnapshot(2) },
+    ]);
+    const availability = GpuScene.create(device, 2).unwrap();
+    expect(availability.status).toBe('available');
+    if (availability.status !== 'available') return;
+    availability.scene.sync(delta).unwrap();
+    const topology = new BatchTopology();
+    topology.rebuild(projection.slotsSnapshot());
+    const production = new GpuDrivenProduction(device, {
+      createShaderModule: () => ok(shader),
+    });
+    const prepared = production
+      .prepare({
+        scene: {
+          scene: availability.scene,
+          plan: topology.plan(),
+          slots: projection.slotsSnapshot(),
+        },
+        camera: { ...makeZeroCameraFallbackSnapshot(), position: vec3.create(0, 0, 5) },
+        meshes: new Map([[3, mesh(device, true, true)]]),
+        viewBindGroupLayout: viewLayout,
+        meshResidencyEpoch: 1,
+        hdrp: false,
+      })
+      .unwrap();
+    expect(prepared).toBeDefined();
+    expect(production.inspect()).toMatchObject({
+      batchCount: 1,
+      indirectDrawCount: 1,
+      candidateUploadBytes: 2 * 304,
+    });
+    production.dispose();
+    availability.scene.dispose();
+  });
+
+  it('projects scene rows from the receipt-selected scene-index entry', () => {
+    const result = projectStandardPbrScene({
+      artifact: {
+        material: 'forgeax::default-standard-pbr',
+        pass: 'forward',
+        wgsl: 'standard-pbr',
+        layoutIdentity: STANDARD_PBR_RECEIPT.reflection.layoutIdentity,
+        bindings: [],
+        deps: [],
+        vertexInputs: STANDARD_PBR_RECEIPT.vertexInputs.map((input) => ({ ...input })),
+        receipt: STANDARD_PBR_RECEIPT,
+      },
+      candidates: [
+        {
+          primitiveIndex: 3,
+          world: Float32Array.from([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 2, 3, 4, 1]),
+        },
+      ],
+    });
+    expect(result.ok).toBe(true);
+    if (!result.ok) return;
+    expect(result.value.entryPoint).toBe('vs_scene_index');
+    expect(result.value.rows[0]).toBe(1);
+    expect(result.value.rows[12]).toBe(2);
+    expect(result.value.rows[13]).toBe(3);
+    expect(result.value.rows[14]).toBe(4);
+  });
+
+  it('adapts the four existing Standard PBR groups from one receipt', () => {
+    const groups = {
+      view: { id: 'view' },
+      material: { id: 'material' },
+      mesh: { id: 'mesh' },
+      instances: { id: 'instances' },
+    } as unknown as {
+      readonly view: BindGroup;
+      readonly material: BindGroup;
+      readonly mesh: BindGroup;
+      readonly instances: BindGroup;
+    };
+    const result = adaptStandardPbrFrameResources({
+      artifact: {
+        material: 'forgeax::default-standard-pbr',
+        pass: 'forward',
+        wgsl: 'standard-pbr',
+        layoutIdentity: STANDARD_PBR_RECEIPT.reflection.layoutIdentity,
+        bindings: [],
+        deps: [],
+        vertexInputs: STANDARD_PBR_RECEIPT.vertexInputs.map((input) => ({ ...input })),
+        receipt: STANDARD_PBR_RECEIPT,
+      },
+      ...groups,
+    });
+    expect(result.ok).toBe(true);
+    if (!result.ok) return;
+    expect(result.value.entryPoint).toBe('vs_scene_index');
+    expect(result.value.bindGroups).toEqual([
+      groups.view,
+      groups.material,
+      groups.mesh,
+      groups.instances,
+    ]);
+    expect(result.value.resourceSlots).toEqual(STANDARD_PBR_RECEIPT.resourceSlots);
+  });
+
   it('projects aligned multi-batch compute work into one indirect raster pass', async () => {
     const adapter = (await rhi.requestAdapter()).unwrap();
     const device = (await adapter.requestDevice()).unwrap() as RhiNullDevice;
@@ -189,7 +595,7 @@ describe('GPU-driven production projection', () => {
     const firstDraw = first.gpuDrivenDraws?.[0];
     expect(firstDraw).toBeDefined();
     if (firstDraw === undefined) return;
-    const second = snapshot(2, 4);
+    const second = { ...snapshot(2, 4), worldId: 1 };
     const secondDraw = second.gpuDrivenDraws?.[0];
     expect(secondDraw).toBeDefined();
     if (secondDraw === undefined) return;
@@ -252,12 +658,12 @@ describe('GPU-driven production projection', () => {
       .unwrap();
     expect(prepared).toBeDefined();
     if (prepared === undefined) return;
-    expect([...prepared.entityKeys]).toEqual([1, 2]);
+    expect([...prepared.entityKeys]).toEqual([worldEntityKey(0, 1), worldEntityKey(1, 2)]);
     expect(production.inspect()).toMatchObject({
       gpuOwnedSnapshotsMaterialized: 2,
       filteredPlanBuilds: 1,
-      candidateUploadBytes: 84,
-      batchUploadBytes: 84,
+      candidateUploadBytes: 912,
+      batchUploadBytes: 96,
       viewBindGroupCreates: 1,
     });
 
@@ -284,10 +690,40 @@ describe('GPU-driven production projection', () => {
       viewConstantsUploadBytes: 112,
       viewBindGroupCreates: 0,
       batchBindGroupCreates: 0,
+      indirectDrawCount: 3,
     });
 
+    // The scene topology is unchanged, but projectedHeight is camera-owned
+    // input to the GPU LOD selector. A moved camera must rebuild the filtered
+    // candidate plan instead of reusing the previous view's heights.
+    const movedCamera = {
+      ...makeZeroCameraFallbackSnapshot(),
+      position: vec3.create(0, 0, 6),
+    };
+    const moved = production
+      .prepare({
+        scene: {
+          scene: availability.scene,
+          plan: topology.plan(),
+          slots: projection.slotsSnapshot(),
+        },
+        camera: movedCamera,
+        meshes,
+        viewBindGroupLayout: viewLayout,
+        meshResidencyEpoch: 1,
+        hdrp: false,
+      })
+      .unwrap();
+    expect(moved).toBeDefined();
+    expect(production.inspect()).toMatchObject({
+      filteredPlanBuilds: 1,
+      candidateUploadBytes: 912,
+      batchUploadBytes: 96,
+    });
+    if (moved === undefined) return;
+
     const graph = new RenderGraphBuilder<RenderPipelineFrame>();
-    const gpu = prepared.project(graph, 'rgba8unorm', 1).unwrap();
+    const gpu = moved.project(graph, 'rgba8unorm', 1).unwrap();
     const color = graph
       .createTexture('gpu-driven-production-color', {
         format: 'rgba8unorm',
@@ -325,6 +761,54 @@ describe('GPU-driven production projection', () => {
     ]);
     expect(device.totalDispatchCount).toBe(3);
     expect(device.totalDrawCount).toBe(3);
+    expect(production.inspect().indirectDrawCount).toBe(3);
+    expect(production.inspect().indirectDrawCount).toBeLessThanOrEqual(
+      production.inspect().batchCount,
+    );
+
+    // The facet projection is the same admission set consumed by the GPU
+    // candidate upload. A suppressed entity must disappear from the indirect
+    // plan without making the remaining entity fall back to CPU validation.
+    const activeOnly = production
+      .prepare({
+        scene: {
+          scene: availability.scene,
+          plan: topology.plan(),
+          slots: projection.slotsSnapshot(),
+        },
+        camera: movedCamera,
+        meshes,
+        viewBindGroupLayout: viewLayout,
+        meshResidencyEpoch: 1,
+        hdrp: false,
+        activeEntityKeys: new Set([worldEntityKey(0, 1)]),
+        activeEntityRevision: 1,
+      })
+      .unwrap();
+    expect(activeOnly?.entityKeys).toEqual(new Set([1]));
+    expect(activeOnly?.ownsAllRenderables).toBe(true);
+
+    const changedActive = production
+      .prepare({
+        scene: {
+          scene: availability.scene,
+          plan: topology.plan(),
+          slots: projection.slotsSnapshot(),
+        },
+        camera: movedCamera,
+        meshes,
+        viewBindGroupLayout: viewLayout,
+        meshResidencyEpoch: 1,
+        hdrp: false,
+        activeEntityKeys: new Set([worldEntityKey(1, 2)]),
+        activeEntityRevision: 2,
+      })
+      .unwrap();
+    expect(changedActive?.entityKeys).toEqual(new Set([worldEntityKey(1, 2)]));
+    // Production inspection counters are per-prepare-frame facts. The changed
+    // revision must trigger exactly one rebuild for this frame, not accumulate
+    // the prior frame's count.
+    expect(production.inspect().filteredPlanBuilds).toBe(1);
 
     const replacement = GpuScene.create(device, 2).unwrap();
     expect(replacement.status).toBe('available');
@@ -351,7 +835,76 @@ describe('GPU-driven production projection', () => {
     availability.scene.dispose();
   });
 
-  it('activates inside the renderer-owned URP graph and removes the CPU forward draw', async () => {
+  it('keeps an ineligible production topology empty while the camera moves', async () => {
+    const adapter = (await rhi.requestAdapter()).unwrap();
+    const device = (await adapter.requestDevice()).unwrap() as RhiNullDevice;
+    const shader = (await rhi.createShaderModule(device, { code: 'synthetic' })).unwrap();
+    const viewLayout = device
+      .createBindGroupLayout({
+        entries: [{ binding: 0, visibility: 0x1, buffer: { type: 'uniform' } }],
+      })
+      .unwrap();
+    const base = snapshot(1, 3);
+    const material = {
+      ...base.material,
+      materialShaderId: 'forgeax::default-standard-pbr',
+    };
+    const projection = new RenderScene();
+    const delta = projection.apply([
+      { kind: 'create', snapshot: { ...base, material, materials: [material] } },
+    ]);
+    const availability = GpuScene.create(device, 1).unwrap();
+    expect(availability.status).toBe('available');
+    if (availability.status !== 'available') return;
+    availability.scene.sync(delta).unwrap();
+    const topology = new BatchTopology();
+    topology.rebuild(projection.slotsSnapshot());
+    const production = new GpuDrivenProduction(device, {
+      createShaderModule: () => ok(shader),
+    });
+    const input = {
+      scene: {
+        scene: availability.scene,
+        plan: topology.plan(),
+        slots: projection.slotsSnapshot(),
+      },
+      meshes: new Map([[3, mesh(device)]]),
+      viewBindGroupLayout: viewLayout,
+      hdrp: false,
+    } as const;
+
+    expect(
+      production
+        .prepare({
+          ...input,
+          camera: makeZeroCameraFallbackSnapshot(),
+          meshResidencyEpoch: 1,
+        })
+        .unwrap(),
+    ).toBeUndefined();
+    expect(production.requiresSceneRows()).toBe(false);
+    expect(production.inspect().filteredPlanBuilds).toBe(1);
+    expect(
+      production
+        .prepare({
+          ...input,
+          camera: { ...makeZeroCameraFallbackSnapshot(), position: vec3.create(0, 0, 6) },
+          meshResidencyEpoch: 2,
+        })
+        .unwrap(),
+    ).toBeUndefined();
+    expect(production.requiresSceneRows()).toBe(false);
+    expect(production.inspect()).toMatchObject({
+      filteredPlanBuilds: 0,
+      gpuOwnedSnapshotsMaterialized: 0,
+      gpuOwnedEntityCount: 0,
+    });
+
+    production.dispose();
+    availability.scene.dispose();
+  });
+
+  it('activates inside the renderer-owned clustered Standard graph and removes the CPU draw', async () => {
     const canvas = {
       width: 1,
       height: 1,
@@ -380,6 +933,12 @@ describe('GPU-driven production projection', () => {
         { component: MeshRenderer, data: {} },
       )
       .unwrap();
+    world
+      .spawn(
+        { component: Transform, data: { pos: [0, 0, 1] } },
+        { component: PointLight, data: {} },
+      )
+      .unwrap();
 
     for (let frame = 0; frame < 4; frame += 1) {
       world.update(1 / 60).unwrap();
@@ -391,18 +950,21 @@ describe('GPU-driven production projection', () => {
     world.update(1 / 60).unwrap();
     expect(renderer.draw([world], { cameraOwner: 0, resourceOwner: 0 }).ok).toBe(true);
     expect(renderer.perFramePassNames).toEqual(
-      expect.arrayContaining([
-        'gpu-driven.view-reset',
-        'gpu-driven.frustum-compact',
-        'gpu-driven.finalize-indirect',
-        'main',
-      ]),
+      expect.arrayContaining(['cluster-membership-producer', 'main', 'output-transform']),
     );
     expect(renderer.perFramePassNames).toContain('output-transform');
     // Storage-buffer LDR frames keep the scene linear until the one output
     // transform writes the encoded surface; the GPU-driven indirect raster
     // draw and that fullscreen pass are the only draws in this topology.
+    // A plain mesh has no LOD relation, so it stays on the CPU visibility
+    // path for occlusion while GPU-driven raster + output-transform remain
+    // the only draws in this graph.
     expect(device.totalDrawCount).toBe(2);
+    expect(renderer.inspect().lodOcclusion).toMatchObject({
+      fallback: { active: false },
+      degradation: { active: false },
+      pagePressure: { used: 0, capacity: 3 * 4096 },
+    });
     expect(renderer.renderScene).toMatchObject({
       worldEntitiesScanned: 0,
       fullRebuilds: 1,