@forgeax/engine-render 0.1.4 → 0.1.6

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

@@ -3,6 +3,7 @@ import { 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';
@@ -15,14 +16,10 @@ import {
   GPU_BUFFER_USAGE_UNIFORM,
   GPU_BUFFER_USAGE_VERTEX,
 } from '../gpu-usage';
+import type { CameraSnapshot } from '../render-contract';
 import type { RenderPipelineFrame } from '../render-pipeline';
-import { RenderSceneProjection } from '../render-scene-projection';
-import type { MeshGpuHandles } from '../render-system';
-import type {
-  CameraSnapshot,
-  MaterialSnapshot,
-  RenderableSnapshot,
-} from '../render-system-extract';
+import type { MaterialSnapshot, RenderableSnapshot } from '../render-system-extract';
+import { RenderScene } from '../scene/render-scene';
 
 const EMPTY_RESOURCE_CLASS = JSON.stringify({ textures: [], samplers: [], video: [] });
 
@@ -45,9 +42,6 @@ function snapshot(entityKey: number, assetHandle: number): RenderableSnapshot {
     entityKey,
     gpuDrivenDraws: [
       {
-        submeshIndex: 0,
-        passIndex: 0,
-        queue: 2000,
         kind: 'indexed',
         first: 0,
         count: 3,
@@ -65,8 +59,6 @@ function camera(): CameraSnapshot {
   const world = mat4.identity(mat4.create());
   world[14] = 3;
   return {
-    worldId: 0,
-    entityKey: 0,
     position: vec3.create(0, 0, 3),
     world: new Float32Array(world),
     fov: Math.PI / 2,
@@ -82,7 +74,6 @@ function camera(): CameraSnapshot {
     exposure: 1,
     whitePoint: 4,
     antialias: 'none',
-    historyVersion: 0,
     bloom: 'off',
     bloomThreshold: 1,
     bloomIntensity: 1,
@@ -161,6 +152,8 @@ export async function runGpuDrivenIndirectRasterEvidence(): Promise<GpuDrivenInd
     iboBytes: 12,
     indexCount: 6,
     indexFormat: 'uint16',
+    layout: '12F',
+    uvSetCount: 1,
     layoutProjection: deriveVertexLayoutProjection({
       position: new Float32Array(9),
       normal: new Float32Array(9),
@@ -202,13 +195,13 @@ export async function runGpuDrivenIndirectRasterEvidence(): Promise<GpuDrivenInd
       gpuDrivenDraws: [{ ...nonIndexedDraw, kind: 'non-indexed' as const }],
     },
   ];
-  const projection = new RenderSceneProjection();
+  const projection = new RenderScene();
   const delta = projection.apply(
     renderables.map((renderable) => ({ kind: 'create' as const, snapshot: renderable })),
   );
   const availability = GpuScene.create(device, 2).unwrap();
   if (availability.status !== 'available') throw new Error('GPU Scene unavailable');
-  availability.scene.sync(projection, delta).unwrap();
+  availability.scene.sync(delta).unwrap();
   const topology = new BatchTopology();
   topology.rebuild(projection.slotsSnapshot());
   const production = new GpuDrivenProduction(device, {
@@ -329,7 +322,7 @@ 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 RenderPipelineFrame).unwrap();
+  compiled.execute({ viewBindGroup, 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();

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

@@ -1,13 +1,14 @@
+import { HANDLE_CUBE } from '@forgeax/engine-assets-runtime';
 import { World } from '@forgeax/engine-ecs';
-import { createPrimitiveMesh, deriveVertexLayoutProjection } from '@forgeax/engine-geometry';
-import { createProfiler } from '@forgeax/engine-profiler';
+import { deriveVertexLayoutProjection } from '@forgeax/engine-geometry';
 import { RenderGraphBuilder } from '@forgeax/engine-render-graph';
 import { type RhiNullDevice, rhi } from '@forgeax/engine-rhi-null';
 import { Transform } from '@forgeax/engine-scene';
 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 { constructRenderer } from '../construct-renderer';
+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';
@@ -18,20 +19,10 @@ import {
   GPU_BUFFER_USAGE_UNIFORM,
   GPU_BUFFER_USAGE_VERTEX,
 } from '../gpu-usage';
-import { Materials } from '../materials';
-import { makeZeroCameraFallbackSnapshot } from '../record';
-import {
-  buildRenderCandidateDomain,
-  type RenderCandidateDomain,
-} from '../render-dispatch-membership';
+import { makeZeroCameraFallbackSnapshot } from '../record/frame-snapshot';
 import type { RenderPipelineFrame } from '../render-pipeline';
-import { RenderSceneProjection } from '../render-scene-projection';
-import type { MeshGpuHandles } from '../render-system';
-import type {
-  ExtractedFrame,
-  MaterialSnapshot,
-  RenderableSnapshot,
-} from '../render-system-extract';
+import type { MaterialSnapshot, RenderableSnapshot } from '../render-system-extract';
+import { RenderScene } from '../scene/render-scene';
 
 const EMPTY_RESOURCE_CLASS = JSON.stringify({ textures: [], samplers: [], video: [] });
 
@@ -58,9 +49,6 @@ function snapshot(entityKey: number, assetHandle: number): RenderableSnapshot {
     entityKey,
     gpuDrivenDraws: [
       {
-        submeshIndex: 0,
-        passIndex: 0,
-        queue: 2000,
         kind: 'indexed',
         first: 0,
         count: 3,
@@ -96,12 +84,14 @@ function mesh(device: RhiNullDevice, indexed = true): MeshGpuHandles {
     iboBytes: indexed ? 8 : 0,
     indexCount: indexed ? 3 : 0,
     indexFormat: 'uint16',
+    layout: '12F',
     layoutProjection: deriveVertexLayoutProjection({
       position: new Float32Array(9),
       normal: new Float32Array(9),
       uv: new Float32Array(6),
       tangent: new Float32Array(12),
     }),
+    uvSetCount: 1,
     vertexCount: 3,
     indexed,
     topology: 'triangle-list',
@@ -117,104 +107,7 @@ function mesh(device: RhiNullDevice, indexed = true): MeshGpuHandles {
   };
 }
 
-function candidateDomainFrame(domain: RenderCandidateDomain): ExtractedFrame {
-  return {
-    cameras: [],
-    lights: {
-      directional: undefined,
-      directionalCount: 0,
-      point: [],
-      spot: [],
-      lightViewProj: undefined,
-      splitPlanes: undefined,
-      cascadeCount: undefined,
-      cascadeBlend: undefined,
-      shadowMapSize: undefined,
-      depthBias: undefined,
-      normalBias: undefined,
-      pcfKernelSize: undefined,
-      pointShadow: [],
-      directionalCsmConfig: undefined,
-      directionalCsmDirection: undefined,
-    },
-    renderables: [...domain.renderables],
-    dispatch: [...domain.dispatch],
-    candidateRenderables: domain.renderables,
-    candidateDispatch: domain.dispatch,
-    candidateDispatchMembership: domain.membership,
-    candidateDomain: domain,
-    environment: { kind: 'none', worldId: 0, skylightCount: 0, skyboxCount: 0 },
-    frustumStats: { culled: 0, total: 0 },
-    visibilityStats: { explicitlyHidden: 0 },
-    postProcessParams: new Map(),
-    visibilitySnapshots: [],
-    featureVisibilitySnapshots: [],
-    hiddenEntityReports: [],
-  };
-}
-
 describe('GPU-driven production projection', () => {
-  it('joins compact candidate ownership by identity after projection removal', 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 first = { ...snapshot(1, 3), candidateIndex: 0 };
-    const second = { ...snapshot(2, 3), candidateIndex: 1 };
-    const third = { ...snapshot(3, 3), candidateIndex: 2 };
-    const projection = new RenderSceneProjection();
-    const initialDelta = projection.apply([
-      { kind: 'create', snapshot: first },
-      { kind: 'create', snapshot: second },
-      { kind: 'create', snapshot: third },
-    ]);
-    const availability = GpuScene.create(device, 3).unwrap();
-    expect(availability.status).toBe('available');
-    if (availability.status !== 'available') return;
-    availability.scene.sync(projection, initialDelta).unwrap();
-    const topology = new BatchTopology();
-    topology.rebuild(projection.slotsSnapshot());
-
-    const firstRecord = projection.record(0, first.entityKey);
-    expect(firstRecord).toBeDefined();
-    const removalDelta = projection.apply([
-      {
-        kind: 'remove',
-        worldId: 0,
-        entityKey: first.entityKey,
-        ...(firstRecord === undefined ? {} : { expectedGeneration: firstRecord.generation }),
-      },
-    ]);
-    topology.apply(removalDelta);
-    availability.scene.sync(projection, removalDelta).unwrap();
-
-    const staleProjectionSnapshots = projection.materialize();
-    expect(staleProjectionSnapshots.map((candidate) => candidate.candidateIndex)).toEqual([1, 2]);
-    const compactCandidates = staleProjectionSnapshots.map((candidate, candidateIndex) => ({
-      ...candidate,
-      candidateIndex,
-    }));
-    const domain = buildRenderCandidateDomain(compactCandidates, []);
-    const production = new GpuDrivenProduction(device, {
-      createShaderModule: () => ok(shader),
-    });
-    const visibility = production.prepareCpuVisibility({
-      scene: {
-        scene: availability.scene,
-        plan: topology.plan(),
-        slots: projection.slotsSnapshot(),
-        projection,
-      },
-      frame: candidateDomainFrame(domain),
-      camera: undefined,
-    });
-    const main = visibility?.views.find((view) => view.viewId === 'main');
-    expect(main?.stableIds).toEqual([1, 2]);
-    expect(main?.compactVisible.map((item) => item.candidateIndex)).toEqual([0, 1]);
-
-    production.dispose();
-    availability.scene.dispose();
-  });
-
   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;
@@ -247,14 +140,7 @@ describe('GPU-driven production projection', () => {
       renderState: { cullMode: 'none' as const, depthCompare: 'less-equal' as const },
     };
     const renderables = [
-      {
-        ...first,
-        gpuDrivenDraws: [
-          firstDraw,
-          { ...firstDraw, first: 3 },
-          { ...firstDraw, submeshIndex: 1, queue: 4000, first: 6 },
-        ],
-      },
+      { ...first, gpuDrivenDraws: [firstDraw, { ...firstDraw, first: 3 }] },
       {
         ...second,
         material: preparedMaterial,
@@ -269,25 +155,20 @@ describe('GPU-driven production projection', () => {
         ],
       },
     ];
-    const projection = new RenderSceneProjection();
+    const projection = new RenderScene();
     const delta = projection.apply(
       renderables.map((renderable) => ({ kind: 'create' as const, snapshot: renderable })),
     );
     const availability = GpuScene.create(device, 2).unwrap();
     expect(availability.status).toBe('available');
     if (availability.status !== 'available') return;
-    availability.scene.sync(projection, delta).unwrap();
+    availability.scene.sync(delta).unwrap();
     const topology = new BatchTopology();
     topology.rebuild(projection.slotsSnapshot());
     expect(topology.plan()).toMatchObject({
-      candidateCount: 4,
-      visibleCapacity: 193,
-      batches: [
-        { visibleBase: 0 },
-        { visibleBase: 64 },
-        { visibleBase: 128 },
-        { visibleBase: 192 },
-      ],
+      candidateCount: 3,
+      visibleCapacity: 129,
+      batches: [{ visibleBase: 0 }, { visibleBase: 64 }, { visibleBase: 128 }],
     });
     const production = new GpuDrivenProduction(device, {
       createShaderModule: () => ok(shader),
@@ -312,7 +193,7 @@ describe('GPU-driven production projection', () => {
       .unwrap();
     expect(prepared).toBeDefined();
     if (prepared === undefined) return;
-    expect([...prepared.ownedItemKeys]).toEqual(['0:1:0:0', '0:2:0:0']);
+    expect([...prepared.entityKeys]).toEqual([1, 2]);
     expect(production.inspect()).toMatchObject({
       gpuOwnedSnapshotsMaterialized: 2,
       filteredPlanBuilds: 1,
@@ -375,7 +256,7 @@ describe('GPU-driven production projection', () => {
       dependencies: ['gpu-driven.frustum-compact', 'gpu-driven.finalize-indirect'],
     });
     const encoder = device.createCommandEncoder({ label: 'gpu-driven-production' }).unwrap();
-    compiled.execute({ viewBindGroup, encoder } as RenderPipelineFrame).unwrap();
+    compiled.execute({ viewBindGroup, encoder } as unknown as RenderPipelineFrame).unwrap();
     encoder.finish().unwrap();
     expect(device.framePassNames).toEqual([
       'gpu-driven.view-reset',
@@ -389,7 +270,7 @@ describe('GPU-driven production projection', () => {
     const replacement = GpuScene.create(device, 2).unwrap();
     expect(replacement.status).toBe('available');
     if (replacement.status !== 'available') return;
-    replacement.scene.sync(projection, delta).unwrap();
+    replacement.scene.sync(delta).unwrap();
     const replacementPrepared = production
       .prepare({
         scene: {
@@ -411,7 +292,7 @@ describe('GPU-driven production projection', () => {
     availability.scene.dispose();
   });
 
-  it('keeps an overlay material on the CPU while Geometry stays GPU-driven', async () => {
+  it('activates inside the renderer-owned URP graph and removes the CPU forward draw', async () => {
     const manifest = `data:application/json,${encodeURIComponent(
       JSON.stringify({
         schemaVersion: '1.0.0',
@@ -429,16 +310,10 @@ describe('GPU-driven production projection', () => {
       addEventListener: () => undefined,
       removeEventListener: () => undefined,
     } as unknown as HTMLCanvasElement;
-    const profiler = createProfiler();
-    const renderer = await constructRenderer(
-      canvas,
-      { profiler, rhi },
-      { shaderManifestUrl: manifest },
-    );
-    expect((await renderer.ready).ok).toBe(true);
+    const renderer = await constructRenderer(canvas, { rhi }, { shaderManifestUrl: manifest });
+    expect((await renderer.initialization).ok).toBe(true);
     const world = new World();
-    const cubeHandle = world.internSharedRef('MeshAsset', createPrimitiveMesh('cube').unwrap());
-    expect(renderer.attachWorld(world).ok).toBe(true);
+    expect(renderer.attach(world).ok).toBe(true);
     world
       .spawn(
         { component: Transform, data: { pos: [0, 0, 5] } },
@@ -448,25 +323,10 @@ describe('GPU-driven production projection', () => {
     world
       .spawn(
         { component: Transform, data: {} },
-        { component: MeshFilter, data: { assetHandle: cubeHandle } },
+        { component: MeshFilter, data: { assetHandle: HANDLE_CUBE } },
         { component: MeshRenderer, data: {} },
       )
       .unwrap();
-    const overlayMaterial = world.allocSharedRef(
-      'MaterialAsset',
-      Materials.unlit([1, 0, 0, 1], {
-        castShadow: false,
-        queue: 4000,
-        renderState: { depthCompare: 'always', depthWriteEnabled: false },
-      }),
-    );
-    world
-      .spawn(
-        { component: Transform, data: {} },
-        { component: MeshFilter, data: { assetHandle: cubeHandle } },
-        { component: MeshRenderer, data: { materials: [overlayMaterial] } },
-      )
-      .unwrap();
 
     for (let frame = 0; frame < 4; frame += 1) {
       world.update(1 / 60).unwrap();
@@ -475,19 +335,8 @@ describe('GPU-driven production projection', () => {
     }
     const device = renderer.device as RhiNullDevice;
     device.totalDrawCount = 0;
-    const captureResult = profiler.startCapture({
-      frameLimit: 1,
-      eventLimit: 128,
-      detail: 'passes',
-    });
-    expect(captureResult.ok).toBe(true);
-    if (!captureResult.ok) throw new Error(captureResult.error.code);
     world.update(1 / 60).unwrap();
     expect(renderer.draw([world], { cameraOwner: 0, resourceOwner: 0 }).ok).toBe(true);
-    const artifactResult = captureResult.value.finish();
-    expect(artifactResult.ok).toBe(true);
-    if (!artifactResult.ok) throw new Error(artifactResult.error.code);
-    const artifact = artifactResult.value;
     expect(renderer.perFramePassNames).toEqual(
       expect.arrayContaining([
         'gpu-driven.view-reset',
@@ -497,19 +346,10 @@ describe('GPU-driven production projection', () => {
       ]),
     );
     expect(device.totalDrawCount).toBe(2);
-    expect(artifact.records).not.toEqual(
-      expect.arrayContaining([
-        expect.objectContaining({
-          kind: 'phase',
-          source: 'render',
-          phase: 'record/graph-execute/forward/geometry-loop',
-        }),
-      ]),
-    );
     expect(renderer.renderScene).toMatchObject({
       worldEntitiesScanned: 0,
-      projectionRecords: 2,
-      topology: { batchCount: 2, candidateCount: 2 },
+      projectionRecords: 1,
+      topology: { batchCount: 1, candidateCount: 1 },
       gpu: { status: 'resident' },
       gpuDriven: {
         gpuOwnedSnapshotsMaterialized: 0,
@@ -519,7 +359,7 @@ describe('GPU-driven production projection', () => {
         batchBindGroupCreates: 0,
         viewBindGroupCreates: 0,
         validatedGpuOwnedRows: 0,
-        cpuFallbackDrawItems: 1,
+        cpuFallbackDrawItems: 0,
       },
     });
     renderer.dispose();
@@ -544,15 +384,11 @@ describe('GPU-driven production projection', () => {
       removeEventListener: () => undefined,
     } as unknown as HTMLCanvasElement;
     const renderer = await constructRenderer(canvas, { rhi }, { shaderManifestUrl: manifest });
-    expect((await renderer.ready).ok).toBe(true);
+    expect((await renderer.initialization).ok).toBe(true);
     const cameraWorld = new World();
     const sceneWorld = new World();
-    const cubeHandle = sceneWorld.internSharedRef(
-      'MeshAsset',
-      createPrimitiveMesh('cube').unwrap(),
-    );
-    expect(renderer.attachWorld(cameraWorld).ok).toBe(true);
-    expect(renderer.attachWorld(sceneWorld).ok).toBe(true);
+    expect(renderer.attach(cameraWorld).ok).toBe(true);
+    expect(renderer.attach(sceneWorld).ok).toBe(true);
     cameraWorld
       .spawn(
         { component: Transform, data: { pos: [0, 0, 5] } },
@@ -562,7 +398,7 @@ describe('GPU-driven production projection', () => {
     const rendered = sceneWorld
       .spawn(
         { component: Transform, data: {} },
-        { component: MeshFilter, data: { assetHandle: cubeHandle } },
+        { component: MeshFilter, data: { assetHandle: HANDLE_CUBE } },
         { component: MeshRenderer, data: {} },
       )
       .unwrap();
@@ -582,25 +418,16 @@ describe('GPU-driven production projection', () => {
       gpu: { status: 'resident' },
       gpuDriven: { cpuFallbackDrawItems: 0, validatedGpuOwnedRows: 0 },
     });
-    const sceneWorldId = renderer.meshMaterialBindings[0]?.worldId;
-    expect(sceneWorldId).toBeDefined();
-
-    cameraWorld.update(1 / 60).unwrap();
-    sceneWorld.update(1 / 60).unwrap();
-    expect(renderer.draw([sceneWorld, cameraWorld], { cameraOwner: 1, resourceOwner: 1 }).ok).toBe(
-      true,
-    );
-    expect(renderer.meshMaterialBindings[0]?.worldId).toBe(sceneWorldId);
 
     sceneWorld.set(rendered, Transform, { pos: [1, 0, 0] }).unwrap();
     cameraWorld.update(1 / 60).unwrap();
     sceneWorld.update(1 / 60).unwrap();
-    expect(renderer.draw([sceneWorld, cameraWorld], { cameraOwner: 1, resourceOwner: 1 }).ok).toBe(
+    expect(renderer.draw([cameraWorld, sceneWorld], { cameraOwner: 0, resourceOwner: 0 }).ok).toBe(
       true,
     );
     expect(renderer.renderScene).toMatchObject({
       worldEntitiesScanned: 0,
-      fullRebuilds: 2,
+      fullRebuilds: 1,
       transformUpdates: 1,
       projectionRecords: 1,
     });

package/src/__tests__/gpu-driven-scaling.unit.test.ts

@@ -1,8 +1,8 @@
 import { mat4 } from '@forgeax/engine-math';
 import { beforeAll, describe, expect, it } from 'vitest';
 import { BatchTopology } from '../gpu-driven/batch-topology';
-import { RenderSceneProjection } from '../render-scene-projection';
 import type { MaterialSnapshot, RenderableSnapshot } from '../render-system-extract';
+import { RenderScene } from '../scene/render-scene';
 
 const ENTITY_COUNT = 100_000;
 const material = {
@@ -24,9 +24,6 @@ function snapshot(entityKey: number): RenderableSnapshot {
     entityKey,
     gpuDrivenDraws: [
       {
-        submeshIndex: 0,
-        passIndex: 0,
-        queue: 2000,
         kind: 'indexed',
         first: 0,
         count: 36,
@@ -41,17 +38,17 @@ function snapshot(entityKey: number): RenderableSnapshot {
 }
 
 describe('GPU-driven scaling contract', () => {
-  let projection: RenderSceneProjection;
+  let projection: RenderScene;
   let topology: BatchTopology;
   let materialized: readonly RenderableSnapshot[];
   let stablePlan: ReturnType<BatchTopology['plan']>;
   let stableMaterializationReused = false;
   let stablePlanReused = false;
-  let delta: ReturnType<RenderSceneProjection['apply']>;
+  let delta: ReturnType<RenderScene['apply']>;
   let topologyChanged = true;
 
   beforeAll(() => {
-    projection = new RenderSceneProjection();
+    projection = new RenderScene();
     projection.reset(Array.from({ length: ENTITY_COUNT }, (_, index) => snapshot(index)));
     materialized = projection.materialize();
     topology = new BatchTopology();

package/src/__tests__/gpu-driven-view-gpu-evidence.ts

@@ -1,14 +1,14 @@
 import { frustum, mat4 } from '@forgeax/engine-math';
-import { RenderGraphBuilder } from '@forgeax/engine-render-graph';
+import { type CompiledRenderGraph, RenderGraphBuilder } from '@forgeax/engine-render-graph';
 import type { RhiCommandEncoder } from '@forgeax/engine-rhi';
-import { rhi } from '@forgeax/engine-rhi-webgpu';
+import { _internal_getRawDevice, rhi } from '@forgeax/engine-rhi-webgpu';
 import { ok } from '@forgeax/engine-types';
 import { BatchTopology } from '../gpu-driven/batch-topology';
 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_MAP_READ } from '../gpu-usage';
-import { RenderSceneProjection } from '../render-scene-projection';
 import type { MaterialSnapshot, RenderableSnapshot } from '../render-system-extract';
+import { RenderScene } from '../scene/render-scene';
 
 const GPU_MAP_MODE_READ = 0x0001;
 
@@ -31,9 +31,6 @@ function snapshot(entityKey: number, x: number): RenderableSnapshot {
     entityKey,
     gpuDrivenDraws: [
       {
-        submeshIndex: 0,
-        passIndex: 0,
-        queue: 2000,
         kind: 'indexed',
         first: 3,
         count: 36,
@@ -58,6 +55,88 @@ export interface GpuDrivenViewGpuEvidence {
   readonly persistentTranslationX: number;
 }
 
+export interface GpuDrivenViewLifecycleEvidence {
+  readonly frames: number;
+  readonly bufferRebuilds: number;
+  readonly candidateCapacity: number;
+}
+
+export async function runGpuDrivenViewLifecycleEvidence(): Promise<GpuDrivenViewLifecycleEvidence> {
+  const adapter = (await rhi.requestAdapter()).unwrap();
+  const device = (await adapter.requestDevice()).unwrap();
+  const rawDevice = _internal_getRawDevice(device);
+  if (rawDevice === undefined) throw new Error('GPU-driven lifecycle raw device unavailable');
+  rawDevice.pushErrorScope('validation');
+  const shader = (
+    await rhi.createShaderModule(device, {
+      code: GPU_DRIVEN_VIEW_WGSL,
+      label: 'gpu-driven-view-lifecycle',
+    })
+  ).unwrap();
+  const projection = new RenderScene();
+  const sceneAvailability = GpuScene.create(device, 8).unwrap();
+  if (sceneAvailability.status !== 'available') throw new Error('GPU Scene unavailable');
+  const topology = new BatchTopology();
+  const view = GpuDrivenView.create({
+    device,
+    shaderModuleFactory: { createShaderModule: () => ok(shader) },
+  }).unwrap();
+  const planes = frustum.fromViewProjection(frustum.create(), mat4.identity(mat4.create()));
+  const retirements: Array<Promise<unknown>> = [];
+  let activeCount = 0;
+  let previous: CompiledRenderGraph<{ readonly encoder: RhiCommandEncoder }> | undefined;
+  const frames = 300;
+
+  for (let frame = 0; frame < frames; frame += 1) {
+    const targetCount = frame < 4 ? 2 ** frame : frame % 2 === 0 ? 1 : 8;
+    const operations: Array<
+      | { readonly kind: 'create'; readonly snapshot: RenderableSnapshot }
+      | { readonly kind: 'remove'; readonly worldId: number; readonly entityKey: number }
+    > = [];
+    while (activeCount < targetCount) {
+      activeCount += 1;
+      operations.push({ kind: 'create', snapshot: snapshot(activeCount, activeCount * 0.05) });
+    }
+    while (activeCount > targetCount) {
+      operations.push({ kind: 'remove', worldId: 0, entityKey: activeCount });
+      activeCount -= 1;
+    }
+    const delta = projection.apply(operations);
+    sceneAvailability.scene.sync(delta).unwrap();
+    topology.apply(delta);
+    view.update(topology.plan(), sceneAvailability.scene, planes).unwrap();
+
+    const graph = new RenderGraphBuilder<{ readonly encoder: RhiCommandEncoder }>();
+    view.addPasses(graph).unwrap();
+    const compiled = graph.compile({ device, surfaceSize: { width: 1, height: 1 } }).unwrap();
+    if (previous !== undefined) retirements.push(previous.retire());
+    view._commitResourceReplacement();
+    const encoder = device
+      .createCommandEncoder({ label: `gpu-driven-lifecycle-${frame}` })
+      .unwrap();
+    compiled.execute({ encoder }).unwrap();
+    device.queue.submit([encoder.finish().unwrap()]).unwrap();
+    previous = compiled;
+  }
+
+  await device.queue.onSubmittedWorkDone();
+  if (previous !== undefined) retirements.push(previous.retire());
+  await Promise.all(retirements);
+  const validationError = await rawDevice.popErrorScope();
+  if (validationError !== null) {
+    throw new Error(`GPU-driven lifecycle validation failed: ${validationError.message}`);
+  }
+  const inspection = view.inspect();
+  view.dispose();
+  sceneAvailability.scene.dispose();
+  await device.queue.onSubmittedWorkDone();
+  return {
+    frames,
+    bufferRebuilds: inspection.bufferRebuilds,
+    candidateCapacity: inspection.candidateCapacity,
+  };
+}
+
 export async function runGpuDrivenViewGpuEvidence(): Promise<GpuDrivenViewGpuEvidence> {
   const adapter = (await rhi.requestAdapter()).unwrap();
   const device = (await adapter.requestDevice()).unwrap();
@@ -67,7 +146,7 @@ export async function runGpuDrivenViewGpuEvidence(): Promise<GpuDrivenViewGpuEvi
       label: 'gpu-driven-view-evidence',
     })
   ).unwrap();
-  const projection = new RenderSceneProjection();
+  const projection = new RenderScene();
   const visibleInstance = mat4.identity(mat4.create());
   const culledInstance = mat4.identity(mat4.create());
   culledInstance[12] = 10;
@@ -89,7 +168,7 @@ export async function runGpuDrivenViewGpuEvidence(): Promise<GpuDrivenViewGpuEvi
   ]);
   const sceneAvailability = GpuScene.create(device, 2).unwrap();
   if (sceneAvailability.status !== 'available') throw new Error('GPU Scene unavailable');
-  sceneAvailability.scene.sync(projection, delta).unwrap();
+  sceneAvailability.scene.sync(delta).unwrap();
   const topology = new BatchTopology();
   topology.rebuild(projection.slotsSnapshot());
   const view = GpuDrivenView.create({