@forgeax/engine-render 0.1.27 → 0.1.29

package/src/__tests__/gpu-driven-indirect-raster-evidence.ts

@@ -1,40 +1,65 @@
-import { deriveVertexLayoutProjection } from '@forgeax/engine-geometry';
-import { mat4, vec3 } from '@forgeax/engine-math';
+import { frustum, mat4, vec3 } from '@forgeax/engine-math';
 import { RenderGraphBuilder } from '@forgeax/engine-render-graph';
 import { createShaderModule, rhi } from '@forgeax/engine-rhi-webgpu';
 import { ok } from '@forgeax/engine-types';
-import type { MeshGpuHandles } from '../device/gpu-residency';
 import { BatchTopology } from '../gpu-driven/batch-topology';
-import { GPU_DRIVEN_RIGID_UNLIT_WGSL, GpuDrivenProduction } from '../gpu-driven/production-raster';
-import { GPU_DRIVEN_VIEW_WGSL } from '../gpu-driven/view-gpu';
-import { GpuBuffer } from '../gpu-resource';
+import { GPU_DRIVEN_VIEW_WGSL, GpuDrivenView } from '../gpu-driven/view-gpu';
 import { GpuScene } from '../gpu-scene';
 import {
   GPU_BUFFER_USAGE_COPY_DST,
   GPU_BUFFER_USAGE_INDEX,
   GPU_BUFFER_USAGE_MAP_READ,
   GPU_BUFFER_USAGE_UNIFORM,
-  GPU_BUFFER_USAGE_VERTEX,
 } from '../gpu-usage';
 import type { CameraSnapshot } from '../render-contract';
 import type { RenderPipelineFrame } from '../render-pipeline';
 import type { MaterialSnapshot, RenderableSnapshot } from '../render-system-extract';
 import { RenderScene } from '../scene/render-scene';
 
-const EMPTY_RESOURCE_CLASS = JSON.stringify({ textures: [], samplers: [], video: [] });
+/**
+ * This fixture deliberately exercises only the generic GPU view owner. The
+ * production Standard PBR shader is producer-owned and is covered by the
+ * renderer integration tests; this small shader makes indirect command and
+ * raster submission observable without reintroducing a second material or
+ * legacy GPU-driven raster owner.
+ */
+const INDIRECT_RASTER_WGSL = /* wgsl */ `
+@group(0) @binding(0) var<uniform> view: mat4x4<f32>;
 
-function snapshot(entityKey: number, assetHandle: number): RenderableSnapshot {
+struct VertexOutput {
+  @builtin(position) position: vec4<f32>,
+};
+
+@vertex
+fn vs_main(@builtin(vertex_index) index: u32) -> VertexOutput {
+  let positions = array<vec4<f32>, 3>(
+    vec4<f32>(-1.0, -1.0, 0.0, 1.0),
+    vec4<f32>(3.0, -1.0, 0.0, 1.0),
+    vec4<f32>(-1.0, 3.0, 0.0, 1.0),
+  );
+  var output: VertexOutput;
+  output.position = view * positions[index % 3u];
+  return output;
+}
+
+@fragment
+fn fs_main() -> @location(0) vec4<f32> {
+  return vec4<f32>(0.25, 0.5, 0.75, 1.0);
+}
+`;
+
+function snapshot(entityKey: number, kind: 'indexed' | 'non-indexed'): RenderableSnapshot {
   const world = mat4.identity(mat4.create());
   const material = {
     baseColor: new Float32Array([0.25, 0.5, 0.75]),
     metallic: 0,
     roughness: 1,
-    materialShaderId: 'forgeax::default-unlit',
+    materialShaderId: 'fixture::indirect-raster',
   } as MaterialSnapshot;
   return {
-    assetHandle,
+    assetHandle: entityKey,
     transform: { world: new Float32Array(world) },
-    localAabb: new Float32Array([-1, -1, -1.25, 1, 1, -0.75]),
+    localAabb: new Float32Array([-1, -1, -1, 1, 1, 1]),
     material,
     materials: [material],
     materialBindingSources: ['engine-default'],
@@ -42,24 +67,32 @@ function snapshot(entityKey: number, assetHandle: number): RenderableSnapshot {
     entityKey,
     gpuDrivenDraws: [
       {
-        kind: 'indexed',
+        kind,
         first: 0,
         count: 3,
         baseVertex: 0,
         materialSlot: 0,
         topology: 'triangle-list',
-        pipelineClass: 'forgeax::default-unlit|triangle-list|null',
-        materialResourceClass: EMPTY_RESOURCE_CLASS,
+        pipelineClass: 'fixture::indirect-raster|triangle-list|null',
+        materialResourceClass: 'fixture',
       },
     ],
   };
 }
 
+function updateSnapshot(value: RenderableSnapshot) {
+  return {
+    kind: 'update' as const,
+    worldId: value.worldId,
+    entityKey: value.entityKey,
+    snapshot: value,
+  };
+}
+
 function camera(): CameraSnapshot {
   const world = mat4.identity(mat4.create());
-  world[14] = 3;
   return {
-    position: vec3.create(0, 0, 3),
+    position: vec3.create(0, 0, 0),
     world: new Float32Array(world),
     fov: Math.PI / 2,
     aspect: 1,
@@ -82,6 +115,20 @@ function camera(): CameraSnapshot {
   };
 }
 
+function viewPlanes(snapshot: CameraSnapshot): Float32Array {
+  const projection = mat4.perspective(
+    mat4.create(),
+    snapshot.fov,
+    snapshot.aspect,
+    snapshot.near,
+    snapshot.far,
+  );
+  return frustum.fromViewProjection(
+    frustum.create(),
+    mat4.multiply(mat4.create(), projection, mat4.invert(mat4.create(), snapshot.world)),
+  );
+}
+
 export interface GpuDrivenIndirectRasterEvidence {
   readonly pixel: readonly number[];
   readonly passNames: readonly string[];
@@ -104,28 +151,46 @@ export async function runGpuDrivenIndirectRasterEvidence(): Promise<GpuDrivenInd
   ).unwrap();
   const rasterShader = (
     await createShaderModule(device, {
-      code: GPU_DRIVEN_RIGID_UNLIT_WGSL,
-      label: 'gpu-driven-rigid-unlit',
+      code: INDIRECT_RASTER_WGSL,
+      label: 'gpu-driven-indirect-raster-fixture',
     })
   ).unwrap();
+
   const viewLayout = device
     .createBindGroupLayout({
       label: 'gpu-driven-production-view-bgl',
       entries: [...GPU_DRIVEN_PRODUCTION_VIEW_BGL_ENTRIES],
     })
     .unwrap();
+  const rasterPipelineLayout = device
+    .createPipelineLayout({
+      label: 'gpu-driven-indirect-raster-fixture-pl',
+      bindGroupLayouts: [viewLayout],
+    })
+    .unwrap();
+  const rasterPipeline = device
+    .createRenderPipeline({
+      label: 'gpu-driven-indirect-raster-fixture',
+      layout: rasterPipelineLayout,
+      vertex: { module: rasterShader, entryPoint: 'vs_main', buffers: [] },
+      fragment: {
+        module: rasterShader,
+        entryPoint: 'fs_main',
+        targets: [{ format: 'rgba8unorm' }],
+      },
+      primitive: { topology: 'triangle-list' },
+    })
+    .unwrap();
+
   const viewUniform = device
     .createBuffer({
       label: 'gpu-driven-production-view',
-      size: 784,
+      size: 64,
       usage: GPU_BUFFER_USAGE_UNIFORM | GPU_BUFFER_USAGE_COPY_DST,
     })
     .unwrap();
-  const viewPayload = new Float32Array(196);
-  const projectionMatrix = mat4.perspective(mat4.create(), Math.PI / 2, 1, 0.1, 10);
-  const view = mat4.invert(mat4.create(), camera().world);
-  viewPayload.set(mat4.multiply(mat4.create(), projectionMatrix, view));
-  device.queue.writeBuffer(viewUniform, 0, viewPayload).unwrap();
+  const identity = mat4.identity(mat4.create());
+  device.queue.writeBuffer(viewUniform, 0, identity).unwrap();
   const viewBindGroup = device
     .createBindGroup({
       label: 'gpu-driven-production-view-bg',
@@ -137,18 +202,6 @@ export async function runGpuDrivenIndirectRasterEvidence(): Promise<GpuDrivenInd
     })
     .unwrap();
 
-  const vertexBuffer = device
-    .createBuffer({
-      label: 'gpu-driven-production-vertices',
-      size: 144,
-      usage: GPU_BUFFER_USAGE_VERTEX | GPU_BUFFER_USAGE_COPY_DST,
-    })
-    .unwrap();
-  const vertices = new Float32Array(36);
-  vertices.set([-1, -1, -1], 0);
-  vertices.set([3, -1, -1], 12);
-  vertices.set([-1, 3, -1], 24);
-  device.queue.writeBuffer(vertexBuffer, 0, vertices).unwrap();
   const indexBuffer = device
     .createBuffer({
       label: 'gpu-driven-production-indices',
@@ -157,104 +210,34 @@ export async function runGpuDrivenIndirectRasterEvidence(): Promise<GpuDrivenInd
     })
     .unwrap();
   device.queue.writeBuffer(indexBuffer, 0, new Uint16Array([0, 1, 2, 0, 1, 2])).unwrap();
-  const mesh: MeshGpuHandles = {
-    vertexBuffer: new GpuBuffer(device, vertexBuffer),
-    indexBuffer: new GpuBuffer(device, indexBuffer),
-    vboBytes: 144,
-    iboBytes: 12,
-    indexCount: 6,
-    indexFormat: 'uint16',
-    layout: '12F',
-    uvSetCount: 1,
-    layoutProjection: deriveVertexLayoutProjection({
-      position: new Float32Array(9),
-      normal: new Float32Array(9),
-      uv: new Float32Array(6),
-      tangent: new Float32Array(12),
-    }),
-    vertexCount: 3,
-    indexed: true,
-    topology: 'triangle-list',
-    submeshes: [
-      {
-        indexOffset: 0,
-        indexCount: 3,
-        vertexCount: 3,
-        materialSlot: 0,
-        topology: 'triangle-list',
-      },
-      {
-        indexOffset: 3,
-        indexCount: 3,
-        vertexCount: 3,
-        materialSlot: 0,
-        topology: 'triangle-list',
-      },
-    ],
-  };
 
-  const indexed = snapshot(1, 3);
+  const indexed = snapshot(1, 'indexed');
   const indexedDraw = indexed.gpuDrivenDraws?.[0];
-  const nonIndexed = snapshot(2, 4);
+  const nonIndexed = snapshot(2, 'non-indexed');
   const nonIndexedDraw = nonIndexed.gpuDrivenDraws?.[0];
   if (indexedDraw === undefined || nonIndexedDraw === undefined) {
     throw new Error('GPU-driven draw fixture unavailable');
   }
   const renderables = [
-    { ...indexed, gpuDrivenDraws: [indexedDraw, { ...indexedDraw, first: 3 }] },
     {
-      ...nonIndexed,
-      gpuDrivenDraws: [{ ...nonIndexedDraw, kind: 'non-indexed' as const }],
+      ...indexed,
+      gpuDrivenDraws: [indexedDraw, { ...indexedDraw, first: 3 }],
     },
+    { ...nonIndexed, gpuDrivenDraws: [nonIndexedDraw] },
   ];
   const projection = new RenderScene();
-  const delta = projection.apply(
-    renderables.map((renderable) => ({ kind: 'create' as const, snapshot: renderable })),
-  );
+  const delta = projection.apply(renderables.map((renderable) => updateSnapshot(renderable)));
   const availability = GpuScene.create(device, 2).unwrap();
   if (availability.status !== 'available') throw new Error('GPU Scene unavailable');
   availability.scene.sync(delta).unwrap();
   const topology = new BatchTopology();
   topology.rebuild(projection.slotsSnapshot());
-  const production = new GpuDrivenProduction(device, {
-    createShaderModule: ({ label }) => ok(label === 'gpu-driven-view' ? viewShader : rasterShader),
-  });
-  const prepared = production
-    .prepare({
-      scene: {
-        scene: availability.scene,
-        plan: topology.plan(),
-        slots: projection.slotsSnapshot(),
-      },
-      camera: camera(),
-      meshes: new Map([
-        [3, mesh],
-        [
-          4,
-          {
-            ...mesh,
-            indexBuffer: null,
-            iboBytes: 0,
-            indexCount: 0,
-            indexed: false,
-            submeshes: [
-              {
-                indexOffset: 0,
-                indexCount: 0,
-                vertexCount: 3,
-                materialSlot: 0,
-                topology: 'triangle-list',
-              },
-            ],
-          },
-        ],
-      ]),
-      viewBindGroupLayout: viewLayout,
-      meshResidencyEpoch: 1,
-      hdrp: false,
-    })
-    .unwrap();
-  if (prepared === undefined) throw new Error('GPU-driven production lane inactive');
+  const plan = topology.plan();
+  const gpuView = GpuDrivenView.create({
+    device,
+    shaderModuleFactory: { createShaderModule: () => ok(viewShader) },
+  }).unwrap();
+  gpuView.update(plan, availability.scene, viewPlanes(camera())).unwrap();
 
   const readbackBuffer = device
     .createBuffer({
@@ -264,7 +247,7 @@ export async function runGpuDrivenIndirectRasterEvidence(): Promise<GpuDrivenInd
     })
     .unwrap();
   const graph = new RenderGraphBuilder<RenderPipelineFrame>();
-  const gpu = prepared.project(graph, 'rgba8unorm', 1).unwrap();
+  const gpu = gpuView.addPasses(graph).unwrap();
   const output = graph
     .createTexture('gpu-driven-production-output', {
       format: 'rgba8unorm',
@@ -272,13 +255,6 @@ export async function runGpuDrivenIndirectRasterEvidence(): Promise<GpuDrivenInd
     })
     .unwrap();
   const outputView = graph.view(output).unwrap();
-  const depth = graph
-    .createTexture('gpu-driven-production-depth', {
-      format: 'depth24plus-stencil8',
-      size: { width: 1, height: 1 },
-    })
-    .unwrap();
-  const depthView = graph.view(depth).unwrap();
   const readback = graph
     .importBuffer(
       'gpu-driven-production-readback',
@@ -286,22 +262,13 @@ export async function runGpuDrivenIndirectRasterEvidence(): Promise<GpuDrivenInd
       () => readbackBuffer,
     )
     .unwrap();
+
   graph
     .addRasterPass('gpu-driven.opaque-indirect', {
       accesses: [
-        ...gpu.accesses,
+        { resource: gpu.indirect, usage: 'indirect-read' },
         { resource: outputView, usage: 'color-attachment' },
-        { resource: depthView, usage: 'depth-stencil-write' },
       ],
-      depthStencilAttachment: {
-        view: depthView,
-        depthClearValue: 1,
-        depthLoadOp: 'clear',
-        depthStoreOp: 'store',
-        stencilClearValue: 0,
-        stencilLoadOp: 'clear',
-        stencilStoreOp: 'store',
-      },
       colorAttachments: [
         {
           view: outputView,
@@ -310,7 +277,19 @@ export async function runGpuDrivenIndirectRasterEvidence(): Promise<GpuDrivenInd
           storeOp: 'store',
         },
       ],
-      encode: ({ pass, resources }) => gpu.encode(viewBindGroup, pass, resources),
+      encode: ({ pass, resources }) => {
+        pass.setPipeline(rasterPipeline);
+        pass.setBindGroup(0, viewBindGroup, [0, 0]);
+        const indirect = resources.buffer(gpu.indirect).unwrap();
+        pass.setIndexBuffer(indexBuffer, 'uint16');
+        for (const [batchIndex, batch] of plan.batches.entries()) {
+          if (batch.key.drawKind === 'indexed') {
+            pass.drawIndexedIndirect(indirect, batchIndex * 20);
+          } else {
+            pass.drawIndirect(indirect, batchIndex * 20);
+          }
+        }
+      },
     })
     .unwrap();
   graph
@@ -332,9 +311,10 @@ export async function runGpuDrivenIndirectRasterEvidence(): Promise<GpuDrivenInd
       },
     })
     .unwrap();
+
   const compiled = graph.compile({ device, surfaceSize: { width: 1, height: 1 } }).unwrap();
   const encoder = device.createCommandEncoder({ label: 'gpu-driven-production-frame' }).unwrap();
-  compiled.execute({ viewBindGroup, encoder } as unknown as RenderPipelineFrame).unwrap();
+  compiled.execute({ encoder } as unknown as RenderPipelineFrame).unwrap();
   device.queue.submit([encoder.finish().unwrap()]).unwrap();
   await device.queue.onSubmittedWorkDone();
   const mapped = (await readbackBuffer.mapAsync(GPU_BUFFER_USAGE_MAP_READ)).unwrap();
@@ -343,9 +323,9 @@ export async function runGpuDrivenIndirectRasterEvidence(): Promise<GpuDrivenInd
   const passNames = compiled.inspect().passes.map((pass) => pass.name);
 
   (await compiled.retire()).unwrap();
-  production.dispose();
+  gpuView.dispose();
   availability.scene.dispose();
-  for (const buffer of [vertexBuffer, indexBuffer, viewUniform, readbackBuffer]) {
+  for (const buffer of [indexBuffer, viewUniform, readbackBuffer]) {
     device.destroyBuffer(buffer);
   }
   return { pixel, passNames };

package/src/__tests__/gpu-driven-indirect-raster.browser.test.ts

@@ -6,7 +6,16 @@ const browserReady = typeof navigator !== 'undefined' && navigator.gpu !== undef
 describe.skipIf(!browserReady)('GPU-driven indirect raster Browser WebGPU', () => {
   it('consumes indexed, non-indexed, and multi-submesh indirect args without CPU readback', async () => {
     const evidence = await runGpuDrivenIndirectRasterEvidence();
+    expect(evidence.passNames).toEqual(
+      expect.arrayContaining([
+        'gpu-driven.view-reset',
+        'gpu-driven.frustum-compact',
+        'gpu-driven.finalize-indirect',
+        'gpu-driven.lod-selection-readback',
+        'gpu-driven.opaque-indirect',
+        'gpu-driven.raster-readback',
+      ]),
+    );
     expect(evidence.pixel).toEqual([64, 128, 191, 255]);
-    expect(evidence.passNames).toContain('gpu-driven.opaque-indirect');
   });
 });

package/src/__tests__/gpu-driven-lod-cache.unit.test.ts

@@ -0,0 +1,264 @@
+import { deriveVertexLayoutProjection } from '@forgeax/engine-geometry';
+import { vec3 } from '@forgeax/engine-math';
+import { type RhiNullDevice, rhi } from '@forgeax/engine-rhi-null';
+import { ok } from '@forgeax/engine-types';
+import { describe, expect, it } from 'vitest';
+import type { MeshGpuHandles } from '../device/gpu-residency';
+import { BatchTopology } from '../gpu-driven/batch-topology';
+import { GpuDrivenProduction } from '../gpu-driven/production-raster';
+import { GpuBuffer } from '../gpu-resource';
+import { GpuScene } from '../gpu-scene';
+import {
+  GPU_BUFFER_USAGE_COPY_DST,
+  GPU_BUFFER_USAGE_INDEX,
+  GPU_BUFFER_USAGE_VERTEX,
+} from '../gpu-usage';
+import { makeZeroCameraFallbackSnapshot } from '../record/frame-snapshot';
+import type { MaterialSnapshot, RenderableSnapshot } from '../render-system-extract';
+import { RenderScene } from '../scene/render-scene';
+import { preparedPbrSnapshot, standardPbrInputs } from './gpu-driven-production-fixture';
+
+const EMPTY_RESOURCE_CLASS = JSON.stringify({ textures: [], samplers: [], video: [] });
+const LOD_MESH_GUID = '00000000-0000-7000-8000-000000000001' as never;
+
+function identityWorld(z = 0): Float32Array {
+  const world = new Float32Array(16);
+  world[0] = 1;
+  world[5] = 1;
+  world[10] = 1;
+  world[14] = z;
+  world[15] = 1;
+  return world;
+}
+
+function snapshot(entityKey: number, withLod: boolean): RenderableSnapshot {
+  const material = {
+    baseColor: new Float32Array([1, 1, 1]),
+    metallic: 0,
+    roughness: 1,
+    materialShaderId: 'forgeax::default-unlit',
+  } as MaterialSnapshot;
+  const source: RenderableSnapshot = {
+    assetHandle: 3,
+    transform: { world: identityWorld() },
+    // A radius large enough to cross the 0.5 screen-coverage threshold at z=5.
+    localAabb: new Float32Array([-1, -1, -1, 1, 1, 1]),
+    material,
+    materials: [material],
+    materialBindingSources: ['engine-default'],
+    worldId: 0,
+    entityKey,
+    gpuDrivenDraws: [
+      {
+        kind: 'indexed',
+        first: 0,
+        count: 3,
+        baseVertex: 0,
+        materialSlot: 0,
+        topology: 'triangle-list',
+        pipelineClass: 'forgeax::default-unlit|triangle-list|null',
+        materialResourceClass: EMPTY_RESOURCE_CLASS,
+      },
+    ],
+  };
+  const prepared = preparedPbrSnapshot(source);
+  if (!withLod) return prepared;
+  const draw = prepared.gpuDrivenDraws?.[0];
+  if (draw === undefined) throw new Error('LOD fixture draw is missing');
+  return {
+    ...prepared,
+    lods: [{ mesh: LOD_MESH_GUID, screenCoverage: 0.5 }],
+    gpuDrivenDraws: [{ ...draw, lodRanges: [{ first: 3, count: 1, baseVertex: 0 }] }],
+  };
+}
+
+function updateSnapshot(value: RenderableSnapshot) {
+  return {
+    kind: 'update' as const,
+    worldId: value.worldId,
+    entityKey: value.entityKey,
+    snapshot: value,
+  };
+}
+
+function updateWorld(entityKey: number, z: number) {
+  return {
+    kind: 'update' as const,
+    worldId: 0,
+    entityKey,
+    world: identityWorld(z),
+  };
+}
+
+function mesh(device: RhiNullDevice, withLod: boolean): MeshGpuHandles {
+  const vertex = device
+    .createBuffer({ size: 144, usage: GPU_BUFFER_USAGE_VERTEX | GPU_BUFFER_USAGE_COPY_DST })
+    .unwrap();
+  const index = device
+    .createBuffer({ size: 8, usage: GPU_BUFFER_USAGE_INDEX | GPU_BUFFER_USAGE_COPY_DST })
+    .unwrap();
+  return {
+    vertexBuffer: new GpuBuffer(device, vertex),
+    indexBuffer: new GpuBuffer(device, index),
+    vboBytes: 144,
+    iboBytes: 8,
+    indexCount: 3,
+    indexFormat: 'uint16',
+    layoutProjection: deriveVertexLayoutProjection({
+      position: new Float32Array(9),
+      normal: new Float32Array(9),
+      uv: new Float32Array(6),
+      tangent: new Float32Array(12),
+    }),
+    uvSetCount: 1,
+    vertexCount: 3,
+    indexed: true,
+    topology: 'triangle-list',
+    submeshes: [
+      {
+        indexOffset: 0,
+        indexCount: 3,
+        vertexCount: 3,
+        materialSlot: 0,
+        topology: 'triangle-list',
+      },
+    ],
+    ...(withLod
+      ? {
+          lodRanges: [
+            [{ first: 0, count: 3, baseVertex: 0 }],
+            [{ first: 3, count: 1, baseVertex: 0 }],
+          ],
+        }
+      : {}),
+  };
+}
+
+async function fixture(withLod: boolean) {
+  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 pbrInputs = standardPbrInputs(device, shader, viewLayout);
+  const projection = new RenderScene();
+  const firstSnapshot = snapshot(1, withLod);
+  const secondSnapshot = snapshot(2, withLod);
+  const delta = projection.apply([updateSnapshot(firstSnapshot), updateSnapshot(secondSnapshot)]);
+  const availability = GpuScene.create(device, 2).unwrap();
+  if (availability.status !== 'available') throw new Error('GPU Scene unavailable');
+  availability.scene.sync(delta).unwrap();
+  const topology = new BatchTopology();
+  topology.rebuild(projection.slotsSnapshot());
+  const production = new GpuDrivenProduction(device, {
+    createShaderModule: () => ok(shader),
+  });
+  const gpuMesh = mesh(device, withLod);
+  return {
+    device,
+    viewLayout,
+    pbrInputs,
+    projection,
+    availability,
+    topology,
+    production,
+    gpuMesh,
+  };
+}
+
+describe('GPU-driven filtered-plan cache', () => {
+  it('rebuilds LOD grouping after a root matrix-only scene update', async () => {
+    const fixtureValue = await fixture(true);
+    const { availability, production, projection, topology, gpuMesh, viewLayout, pbrInputs } =
+      fixtureValue;
+    const slots = projection.slotsSnapshot();
+    const camera = { ...makeZeroCameraFallbackSnapshot(), position: vec3.create(0, 0, 5) };
+    const scene = { scene: availability.scene, plan: topology.plan(), slots };
+    const meshes = new Map(slots.map((slot) => [slot.slot, gpuMesh] as const));
+
+    const first = production
+      .prepare({
+        ...pbrInputs,
+        scene,
+        camera,
+        meshBySlot: meshes,
+        viewBindGroupLayout: viewLayout,
+        meshResidencyEpoch: 1,
+        hdrp: false,
+      })
+      .unwrap();
+    expect(first).toBeDefined();
+    expect(production.inspect()).toMatchObject({
+      filteredPlanBuilds: 1,
+      batchCount: 1,
+      indirectDrawCount: 1,
+    });
+
+    const movedDelta = projection.apply([updateWorld(2, 50)]);
+    expect(movedDelta.updated).toBe(1);
+    expect(movedDelta.contentUpdatedSlots).toHaveLength(0);
+    expect(movedDelta.instanceUpdatedSlots).toHaveLength(0);
+    expect(projection.slotsSnapshot()).toBe(slots);
+    availability.scene.sync(movedDelta).unwrap();
+
+    const moved = production
+      .prepare({
+        ...pbrInputs,
+        scene,
+        camera,
+        meshBySlot: meshes,
+        viewBindGroupLayout: viewLayout,
+        meshResidencyEpoch: 1,
+        hdrp: false,
+      })
+      .unwrap();
+    expect(moved).toBeDefined();
+    expect(production.inspect()).toMatchObject({
+      filteredPlanBuilds: 1,
+      batchCount: 2,
+      indirectDrawCount: 2,
+    });
+
+    production.dispose();
+    availability.scene.dispose();
+  });
+
+  it('reuses an unchanged no-LOD source after a root matrix-only update', async () => {
+    const fixtureValue = await fixture(false);
+    const { availability, production, projection, topology, gpuMesh, viewLayout, pbrInputs } =
+      fixtureValue;
+    const slots = projection.slotsSnapshot();
+    const camera = { ...makeZeroCameraFallbackSnapshot(), position: vec3.create(0, 0, 5) };
+    const scene = { scene: availability.scene, plan: topology.plan(), slots };
+    const meshes = new Map(slots.map((slot) => [slot.slot, gpuMesh] as const));
+    const prepare = () =>
+      production
+        .prepare({
+          ...pbrInputs,
+          scene,
+          camera,
+          meshBySlot: meshes,
+          viewBindGroupLayout: viewLayout,
+          meshResidencyEpoch: 1,
+          hdrp: false,
+        })
+        .unwrap();
+
+    expect(prepare()).toBeDefined();
+    expect(production.inspect().filteredPlanBuilds).toBe(1);
+    const movedDelta = projection.apply([updateWorld(2, 50)]);
+    availability.scene.sync(movedDelta).unwrap();
+    expect(prepare()).toBeDefined();
+    expect(production.inspect()).toMatchObject({
+      filteredPlanBuilds: 0,
+      batchCount: 1,
+      indirectDrawCount: 1,
+    });
+
+    production.dispose();
+    availability.scene.dispose();
+  });
+});