@forgeax/engine-render 0.1.29 → 0.1.31

package/src/__tests__/dynamic-geometry.unit.test.ts

@@ -1,3 +1,4 @@
+import { createMeshBuilder } from '@forgeax/engine-geometry';
 import type { MeshAsset } from '@forgeax/engine-types';
 import { describe, expect, it } from 'vitest';
 import { createDynamicGeometryLifecycle } from '../dynamic-geometry';
@@ -15,6 +16,41 @@ const mesh = (): MeshAsset => ({
 });
 
 describe('standard dynamic geometry lifecycle', () => {
+  it('accepts a MeshBuilder interleaved color buffer with four vertices', () => {
+    const source = createMeshBuilder({
+      attributes: {
+        position: new Float32Array([0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0]),
+        color: new Float32Array(16).fill(1),
+      },
+      indices: new Uint16Array([0, 1, 2, 0, 2, 3]),
+    })
+      .build()
+      .unwrap();
+    expect(source.vertices.length % 3).not.toBe(0);
+    const lifecycle = createDynamicGeometryLifecycle();
+    expect(lifecycle.prepare({ world: {}, mesh: source, revision: 1 }, 1).ok).toBe(true);
+  });
+
+  it('validates referenced material slots rather than requiring one slot per submesh', () => {
+    const source = mesh();
+    const shared = { ...source, submeshes: [...source.submeshes, ...source.submeshes] };
+    const lifecycle = createDynamicGeometryLifecycle();
+    expect(lifecycle.prepare({ world: {}, mesh: shared, revision: 1 }, 1).ok).toBe(true);
+    expect(
+      lifecycle.prepare(
+        {
+          world: {},
+          mesh: {
+            ...source,
+            submeshes: source.submeshes.map((submesh) => ({ ...submesh, materialSlot: 2 })),
+          },
+          revision: 1,
+        },
+        1,
+      ).ok,
+    ).toBe(false);
+  });
+
   it('copies a MeshAsset and publishes only after a matching frame generation', () => {
     const lifecycle = createDynamicGeometryLifecycle();
     const world = {};

package/src/__tests__/dynamic-resolution-plugin.integration.test.ts

@@ -0,0 +1,81 @@
+import { createWorldContext, World } from '@forgeax/engine-ecs';
+import { scenePlugin, Transform } from '@forgeax/engine-scene';
+import { describe, expect, it } from 'vitest';
+import { extractCameraSnapshots } from '../extract/camera';
+import { ANTIALIAS_NONE, ANTIALIAS_TAA, Camera, DynamicResolution, MotionBlur } from '../index';
+import { renderComponentsPlugin } from '../plugin';
+import { extractFrames } from '../render-system-extract';
+
+describe('DynamicResolution render component registration', () => {
+  it('uses the existing render plugin for add, remove, and extraction retries', async () => {
+    const world = new World();
+    const context = await createWorldContext(world, [renderComponentsPlugin(), scenePlugin()]);
+    const entries = [...world.components.entries()].map(([name]) => name);
+    expect(entries).toContain('DynamicResolution');
+
+    const entity = world
+      .spawn(
+        { component: Transform, data: {} },
+        { component: Camera, data: { antialias: ANTIALIAS_TAA } },
+        { component: DynamicResolution, data: { minScale: 0.5, maxScale: 0.5 } },
+      )
+      .unwrap();
+    world.update(1 / 60).unwrap();
+    expect(extractCameraSnapshots(world)[0]?.dynamicResolution).toMatchObject({
+      minScale: 0.5,
+      maxScale: 0.5,
+    });
+    expect(extractCameraSnapshots(world)[0]?.dynamicResolution?.targetGpuMs).toBeCloseTo(16.67);
+
+    world.removeComponent(entity, DynamicResolution).unwrap();
+    expect(extractCameraSnapshots(world)[0]?.dynamicResolution).toBeUndefined();
+    expect(extractFrames([world], 0).cameras[0]?.dynamicResolution).toBeUndefined();
+    world
+      .addComponent(entity, {
+        component: DynamicResolution,
+        data: { minScale: 0.75, maxScale: 0.75 },
+      })
+      .unwrap();
+    expect(extractCameraSnapshots(world)[0]?.dynamicResolution).toMatchObject({
+      minScale: 0.75,
+      maxScale: 0.75,
+    });
+    expect(extractCameraSnapshots(world)[0]?.dynamicResolution?.targetGpuMs).toBeCloseTo(16.67);
+
+    const nonTaa = world.set(entity, Camera, { antialias: ANTIALIAS_NONE });
+    expect(nonTaa.ok).toBe(true);
+    expect(() => extractCameraSnapshots(world)).toThrowError(
+      expect.objectContaining({ code: 'dynamic-resolution-requires-taa' }),
+    );
+
+    await context.fiber.dispose();
+  });
+
+  it('registers MotionBlur for the shared camera extraction query', async () => {
+    const world = new World();
+    const context = await createWorldContext(world, [renderComponentsPlugin(), scenePlugin()]);
+    expect([...world.components.entries()].map(([name]) => name)).toContain('MotionBlur');
+
+    world
+      .spawn(
+        { component: Transform, data: {} },
+        { component: Camera, data: { antialias: ANTIALIAS_TAA } },
+        { component: MotionBlur, data: { shutterAngle: 120, maxRadiusPixels: 12, sampleCount: 6 } },
+      )
+      .unwrap();
+    world.update(1 / 60).unwrap();
+
+    expect(extractCameraSnapshots(world)[0]?.motionBlur).toEqual({
+      shutterAngle: 120,
+      maxRadiusPixels: 12,
+      sampleCount: 6,
+    });
+    expect(extractFrames([world], 0).cameras[0]?.motionBlur).toEqual({
+      shutterAngle: 120,
+      maxRadiusPixels: 12,
+      sampleCount: 6,
+    });
+
+    await context.fiber.dispose();
+  });
+});

package/src/__tests__/factory-contract.integration.test.ts

@@ -18,7 +18,15 @@ import { err, ok } from '@forgeax/engine-types';
 import { describe, expect, it, vi } from 'vitest';
 import type { RhiBackendPack } from '../assembly/backend-contract';
 import { createRenderer as constructRenderer } from '../assembly/factory';
-import { DirectionalLight, MeshFilter, MeshRenderer, PointLight, SpotLight } from '../components';
+import {
+  DirectionalLight,
+  DynamicResolution,
+  MeshFilter,
+  MeshRenderer,
+  MotionBlur,
+  PointLight,
+  SpotLight,
+} from '../components';
 import {
   ANTIALIAS_NONE,
   ANTIALIAS_TAA,
@@ -931,6 +939,161 @@ describe('factory contract', () => {
     expect((await renderer.dispose()).ok).toBe(true);
   });
 
+  it('rebuilds the TAA graph when DynamicResolution is removed', async () => {
+    const renderer = await constructRenderer(
+      { width: 64, height: 64, getContext: () => null },
+      { rhi },
+      { shaderManifestUrl: renderLifecycleManifestUrl() },
+    );
+    expect((await renderer.initialization).ok).toBe(true);
+    const world = new World();
+    const attached = renderer.attach(world);
+    expect(attached.ok).toBe(true);
+    if (!attached.ok) return;
+    registerPropagateTransforms(world);
+    const camera = world
+      .spawn(
+        { component: Transform, data: { pos: [0, 0, 4] } },
+        {
+          component: LocalCamera,
+          data: { fov: 1, aspect: 1, near: 0.1, far: 100, antialias: ANTIALIAS_TAA },
+        },
+        {
+          component: DynamicResolution,
+          data: { targetGpuMs: 16.67, minScale: 0.5, maxScale: 0.5 },
+        },
+      )
+      .unwrap();
+    const frameInput = () => ({
+      leases: [attached.value],
+      camera: { lease: attached.value },
+      environment: { lease: attached.value },
+    });
+    expect(world.update().ok).toBe(true);
+    expect(renderer.draw(frameInput()).ok).toBe(true);
+    const dynamicInspection = renderer.inspect();
+    expect(dynamicInspection.perFramePassNames).toContain('standard-scene-coverage');
+    expect(dynamicInspection.temporalTarget).toMatchObject({
+      descriptor: { width: 32, height: 32 },
+    });
+    const dynamicGeneration = dynamicInspection.recoveryEvidence.graph.generation;
+
+    expect(world.removeComponent(camera, DynamicResolution).ok).toBe(true);
+    expect(world.update().ok).toBe(true);
+    expect(renderer.draw(frameInput()).ok).toBe(true);
+    const surfaceInspection = renderer.inspect();
+    expect(surfaceInspection.perFramePassNames).not.toContain('standard-scene-coverage');
+    expect(surfaceInspection.temporalTarget).toMatchObject({
+      descriptor: { width: 64, height: 64 },
+    });
+    expect(surfaceInspection.recoveryEvidence.graph.generation).toBeGreaterThan(dynamicGeneration);
+    await renderer.dispose();
+  });
+
+  it('restores the surface graph after toggling DynamicResolution on and off', async () => {
+    const renderer = await constructRenderer(
+      { width: 64, height: 64, getContext: () => null },
+      { rhi },
+      { shaderManifestUrl: renderLifecycleManifestUrl() },
+    );
+    expect((await renderer.initialization).ok).toBe(true);
+    const world = new World();
+    const attached = renderer.attach(world);
+    expect(attached.ok).toBe(true);
+    if (!attached.ok) return;
+    registerPropagateTransforms(world);
+    const camera = world
+      .spawn(
+        { component: Transform, data: { pos: [0, 0, 4] } },
+        {
+          component: LocalCamera,
+          data: { fov: 1, aspect: 1, near: 0.1, far: 100, antialias: ANTIALIAS_TAA },
+        },
+      )
+      .unwrap();
+    const frameInput = () => ({
+      leases: [attached.value],
+      camera: { lease: attached.value },
+      environment: { lease: attached.value },
+    });
+    expect(world.update().ok).toBe(true);
+    expect(renderer.draw(frameInput()).ok).toBe(true);
+    expect(renderer.inspect().perFramePassNames).not.toContain('standard-scene-coverage');
+
+    expect(
+      world.addComponent(camera, {
+        component: DynamicResolution,
+        data: { targetGpuMs: 16.67, minScale: 0.5, maxScale: 0.5 },
+      }).ok,
+    ).toBe(true);
+    expect(world.update().ok).toBe(true);
+    expect(renderer.draw(frameInput()).ok).toBe(true);
+    const dynamic = renderer.inspect();
+    expect(dynamic.perFramePassNames).toContain('standard-scene-coverage');
+    expect(dynamic.temporalTarget).toMatchObject({ descriptor: { width: 32, height: 32 } });
+
+    expect(world.removeComponent(camera, DynamicResolution).ok).toBe(true);
+    expect(world.update().ok).toBe(true);
+    expect(renderer.draw(frameInput()).ok).toBe(true);
+    const surface = renderer.inspect();
+    expect(surface.perFramePassNames).not.toContain('standard-scene-coverage');
+    expect(surface.temporalTarget).toMatchObject({ descriptor: { width: 64, height: 64 } });
+    await renderer.dispose();
+  });
+
+  it('rebuilds the TAA graph when MotionBlur is added', async () => {
+    const renderer = await constructRenderer(
+      { width: 64, height: 64, getContext: () => null },
+      { rhi },
+      { shaderManifestUrl: renderLifecycleManifestUrl() },
+    );
+    expect((await renderer.initialization).ok).toBe(true);
+    const errors: unknown[] = [];
+    renderer.onError((error) => errors.push(error));
+    const world = new World();
+    const attached = renderer.attach(world);
+    expect(attached.ok).toBe(true);
+    if (!attached.ok) return;
+    registerPropagateTransforms(world);
+    const camera = world
+      .spawn(
+        { component: Transform, data: { pos: [0, 0, 4] } },
+        {
+          component: LocalCamera,
+          data: { fov: 1, aspect: 1, near: 0.1, far: 100, antialias: ANTIALIAS_TAA },
+        },
+      )
+      .unwrap();
+    const frameInput = () => ({
+      leases: [attached.value],
+      camera: { lease: attached.value },
+      environment: { lease: attached.value },
+    });
+    expect(world.update().ok).toBe(true);
+    expect(renderer.draw(frameInput()).ok).toBe(true);
+    expect(renderer.inspect().perFramePassNames).not.toContain('motion-blur');
+
+    expect(
+      world.addComponent(camera, {
+        component: MotionBlur,
+        data: { shutterAngle: 180, maxRadiusPixels: 8, sampleCount: 4 },
+      }).ok,
+    ).toBe(true);
+    expect(world.update().ok).toBe(true);
+    const motionDraw = renderer.draw(frameInput());
+    if (!motionDraw.ok) {
+      throw new Error(JSON.stringify({ error: motionDraw.error, events: errors }));
+    }
+    const inspection = renderer.inspect();
+    expect(inspection.perFramePassNames).toContain('motion-blur');
+    expect(inspection.motionBlur).toMatchObject({
+      enabled: true,
+      status: 'active',
+      temporalDemand: 'scene-data-temporal-v1',
+    });
+    await renderer.dispose();
+  });
+
   it('retires factory-owned TAA textures and params on an off submit', async () => {
     const created = new Map<object, string>();
     const destroyed = new Set<object>();

package/src/__tests__/frame-observation.contract.test.ts

@@ -124,4 +124,25 @@ describe('render current-frame observation producer contract', () => {
       }),
     ).toEqual({ ok: true });
   });
+  it('validates every half-float encoding in both word lanes and an unaligned tail', () => {
+    const storage = new Uint8Array(8);
+    const bytes = storage.subarray(1, 7);
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    for (let bits = 0; bits <= 0xffff; bits += 1) {
+      for (const offset of [0, 2, 4]) {
+        bytes.fill(0);
+        view.setUint16(offset, bits, true);
+        const result = validateGraphTargetCaptureReadback({
+          bytes,
+          expectedByteLength: bytes.byteLength,
+          allowZero: true,
+        });
+        const finite = (bits & 0x7c00) !== 0x7c00;
+        if (result.ok !== finite)
+          throw new Error(`half ${bits.toString(16)} at byte ${offset} misclassified`);
+        if (!result.ok && result.code !== 'capture-readback-non-finite')
+          throw new Error(`half ${bits.toString(16)} returned ${result.code}`);
+      }
+    }
+  });
 });

package/src/__tests__/gpu-driven-baseline.characterization.test.ts

@@ -40,7 +40,7 @@ describe('GPU-driven baseline characterization', () => {
   it('requires the prepared Standard PBR production owner', () => {
     expect(productionRaster).not.toContain('GPU_DRIVEN_STANDARD_PBR_WGSL');
     expect(productionRaster).not.toContain('class GpuDrivenPbrRaster');
-    expect(productionRaster).toContain('StandardPbrRasterAdapter');
+    expect(productionRaster).toContain('MaterialAbiRasterAdapter');
     expect(productionRaster).toContain('preparedPbrCandidateEligible');
     expect(productionRaster).toContain('deriveVertexBufferLayoutFromProjection');
     expect(productionRaster).toContain('vertexLayout.arrayStride');

package/src/__tests__/gpu-driven-batch-topology-pbr.unit.test.ts

@@ -64,6 +64,7 @@ function prepared(overrides: Partial<PreparedGpuDrivenDraw> = {}): PreparedGpuDr
   return {
     identity: { material: 'forgeax::default-standard-pbr', geometry: 'cube', deformation: 'rigid' },
     receiptGeneration: receipt.generation,
+    receiptIdentity: receipt.receiptIdentity,
     directEntry: receipt.directEntry,
     sceneIndexEntry: receipt.sceneIndexEntry,
     materialRow: receipt.materialRow,
@@ -218,11 +219,29 @@ describe('PBR prepared GPU-driven batch topology', () => {
     expect(plan.candidateCount).toBe(2);
     expect(plan.batches).toHaveLength(2);
     expect(plan.batches[0]?.key).toMatchObject({
-      preparedIdentity: 'forgeax::default-standard-pbr|cube|rigid',
+      preparedIdentity: 'forgeax::default-standard-pbr|cube|rigid|standard-pbr/material-row-v3',
       resourceIdentity: resourceClass,
     });
   });
 
+  it('keeps colored and uncolored ABI variants in separate prepared batches', () => {
+    const coloredReceipt = createStandardPbrArtifactReceipt(false, true);
+    const colored = prepared({
+      receiptIdentity: coloredReceipt.receiptIdentity,
+      vertexInputs: coloredReceipt.vertexInputs,
+    });
+    const topology = topologyFor(snapshot(1, prepared()), snapshot(2, colored));
+
+    expect(topology.plan().candidateCount).toBe(2);
+    expect(topology.plan().batches).toHaveLength(2);
+    expect(new Set(topology.plan().batches.map((batch) => batch.key.preparedIdentity))).toEqual(
+      new Set([
+        'forgeax::default-standard-pbr|cube|rigid|standard-pbr/material-row-v3',
+        'forgeax::default-standard-pbr|cube|rigid|standard-pbr/material-row-v3/vertex-color',
+      ]),
+    );
+  });
+
   it('keeps numeric edits in place and patches only resource identity changes', () => {
     const projection = new RenderScene();
     projection.apply([updateSnapshot(snapshot(1, prepared()))]);

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

@@ -187,7 +187,6 @@ describe('GPU-driven filtered-plan cache', () => {
         meshBySlot: meshes,
         viewBindGroupLayout: viewLayout,
         meshResidencyEpoch: 1,
-        hdrp: false,
       })
       .unwrap();
     expect(first).toBeDefined();
@@ -212,7 +211,6 @@ describe('GPU-driven filtered-plan cache', () => {
         meshBySlot: meshes,
         viewBindGroupLayout: viewLayout,
         meshResidencyEpoch: 1,
-        hdrp: false,
       })
       .unwrap();
     expect(moved).toBeDefined();
@@ -243,7 +241,6 @@ describe('GPU-driven filtered-plan cache', () => {
           meshBySlot: meshes,
           viewBindGroupLayout: viewLayout,
           meshResidencyEpoch: 1,
-          hdrp: false,
         })
         .unwrap();
 

package/src/__tests__/gpu-driven-mesh-world-identity.unit.test.ts

@@ -267,7 +267,6 @@ describe('GPU-driven mesh world identity', () => {
         meshBySlot: meshes,
         viewBindGroupLayout: fixture.viewLayout,
         meshResidencyEpoch: 1,
-        hdrp: false,
       })
       .unwrap();
     expect(prepared).toBeDefined();
@@ -310,7 +309,6 @@ describe('GPU-driven mesh world identity', () => {
         ]),
         viewBindGroupLayout: fixture.viewLayout,
         meshResidencyEpoch: 1,
-        hdrp: false,
       })
       .unwrap();
     expect(firstPrepared).toBeDefined();
@@ -337,7 +335,6 @@ describe('GPU-driven mesh world identity', () => {
         ]),
         viewBindGroupLayout: fixture.viewLayout,
         meshResidencyEpoch: 1,
-        hdrp: false,
       })
       .unwrap();
     expect(secondPrepared).toBeDefined();

package/src/__tests__/gpu-driven-pbr.dawn.test.ts

@@ -33,6 +33,7 @@ import {
   buildPbrPipelineLayouts,
 } from '../pbr-pipeline';
 import { makeZeroCameraFallbackSnapshot, worldEntityKey } from '../record/frame-snapshot';
+import { MATERIAL_PER_ENTITY_STRIDE } from '../record/render-context';
 import {
   type GpuDrivenShadowBatch,
   type GpuDrivenShadowSubmission,
@@ -86,7 +87,8 @@ const SHADOW_CASTER_GPU_ALPHA_VARIANT = SHADOW_CASTER_PRODUCER?.variants.find(
     defines.SKINNING_DISABLED === true &&
     defines.GPU_DRIVEN_SCENE_INDEX_AVAILABLE === true &&
     defines.GPU_DRIVEN_SCENE_INDEX_EXPLICIT === false &&
-    defines.ALPHA_MASK === true,
+    defines.ALPHA_MASK === true &&
+    defines.VERTEX_COLOR_AVAILABLE === false,
 );
 
 // The local/native evidence window remains 300 frames. CI already sets the
@@ -490,13 +492,13 @@ describe('GPU-driven production PBR Dawn regression', () => {
     device.queue.writeBuffer(spotCascadeUniform, 16, shadowLightMatrix).unwrap();
     const opaqueMaterialBuffer = device
       .createBuffer({
-        size: 512,
+        size: MATERIAL_PER_ENTITY_STRIDE,
         usage: GPU_BUFFER_USAGE_UNIFORM | GPU_BUFFER_USAGE_COPY_DST,
       })
       .unwrap();
     const discardedMaterialBuffer = device
       .createBuffer({
-        size: 512,
+        size: MATERIAL_PER_ENTITY_STRIDE,
         usage: GPU_BUFFER_USAGE_UNIFORM | GPU_BUFFER_USAGE_COPY_DST,
       })
       .unwrap();
@@ -636,6 +638,7 @@ describe('GPU-driven production PBR Dawn regression', () => {
       { binding: 15, resource: { kind: 'textureView' as const, value: materialCubeView } },
       { binding: 16, resource: { kind: 'sampler' as const, value: baseColorSampler } },
       { binding: 17, resource: { kind: 'textureView' as const, value: materialCubeView } },
+      { binding: 47, resource: { kind: 'textureView' as const, value: materialCubeView } },
       { binding: 18, resource: { kind: 'sampler' as const, value: baseColorSampler } },
       { binding: 19, resource: { kind: 'textureView' as const, value: baseColorView } },
       { binding: 20, resource: { kind: 'sampler' as const, value: baseColorSampler } },
@@ -729,7 +732,7 @@ describe('GPU-driven production PBR Dawn regression', () => {
       meshBySlot: new Map(projection.map((slot) => [slot.slot, gpuMesh])),
       viewBindGroupLayout: viewLayout,
       meshResidencyEpoch: 1,
-      hdrp: false,
+
       standardPbrArtifact: artifact,
       standardPbrPipelineState: {
         pbrPipelineLayout: pipelineLayout,
@@ -756,7 +759,9 @@ describe('GPU-driven production PBR Dawn regression', () => {
     expect(prepared.value.shadowDrawKeys).toEqual(new Set([shadowKey]));
     expect(prepared.value.standardPbrFrameResources.instancesBindGroup).toBeDefined();
     expect(prepared.value.standardPbrFrameResources.sceneMaterialBuffer).toBe(scene.materialBuffer);
-    expect(prepared.value.standardPbrFrameResources.materialStride).toBe(512);
+    expect(prepared.value.standardPbrFrameResources.materialStride).toBe(
+      MATERIAL_PER_ENTITY_STRIDE,
+    );
     expect(artifact.receipt.alphaMask).toEqual({ cutoff: 'alphaCutoff', source: 'baseColor.a' });
 
     const shadowVertexLayout = deriveVertexBufferLayoutFromProjection(gpuMesh.layoutProjection, {
@@ -885,7 +890,7 @@ describe('GPU-driven production PBR Dawn regression', () => {
           meshBindGroup: projection.meshBindGroup,
           visibleBindGroup: projection.visibleBindGroup,
           deformation: projection.deformation,
-          alphaMaskMaterialGroup: opaqueMaterialBindGroup,
+          materialGroup: opaqueMaterialBindGroup,
           vertexBuffer: projection.mesh.vertexBuffer.handle,
           ...(indexBuffer === null
             ? {}

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

@@ -281,7 +281,7 @@ describe('GPU-driven production projection', () => {
         ]),
         viewBindGroupLayout: viewLayout,
         meshResidencyEpoch: 1,
-        hdrp: false,
+
         activeEntityKeys: new Set([worldEntityKey(0, 1)]),
         activeEntityRevision: 1,
       })
@@ -327,7 +327,7 @@ describe('GPU-driven production projection', () => {
         ]),
         viewBindGroupLayout: viewLayout,
         meshResidencyEpoch: 1,
-        hdrp: false,
+
         activeEntityKeys: new Set([worldEntityKey(0, 1)]),
         activeEntityRevision: 1,
       })
@@ -351,7 +351,7 @@ describe('GPU-driven production projection', () => {
         ]),
         viewBindGroupLayout: viewLayout,
         meshResidencyEpoch: 1,
-        hdrp: false,
+
         activeEntityKeys: new Set(),
         activeEntityRevision: 2,
       })
@@ -377,7 +377,7 @@ describe('GPU-driven production projection', () => {
         ]),
         viewBindGroupLayout: viewLayout,
         meshResidencyEpoch: 1,
-        hdrp: false,
+
         activeEntityKeys: new Set([worldEntityKey(0, 1)]),
         activeEntityRevision: 3,
       })
@@ -433,7 +433,7 @@ describe('GPU-driven production projection', () => {
         meshBySlot: new Map([[0, mesh(device)]]),
         viewBindGroupLayout: viewLayout,
         meshResidencyEpoch: 1,
-        hdrp: false,
+
         activeEntityKeys: new Set(),
         activeEntityRevision: 1,
       })
@@ -491,7 +491,6 @@ describe('GPU-driven production projection', () => {
         ]),
         viewBindGroupLayout: viewLayout,
         meshResidencyEpoch: 1,
-        hdrp: false,
       })
       .unwrap();
     expect(prepared).toBeDefined();
@@ -586,7 +585,6 @@ describe('GPU-driven production projection', () => {
         ]),
         viewBindGroupLayout: viewLayout,
         meshResidencyEpoch: 1,
-        hdrp: false,
       })
       .unwrap();
     expect(prepared).toBeDefined();
@@ -744,7 +742,6 @@ describe('GPU-driven production projection', () => {
         meshBySlot: meshes,
         viewBindGroupLayout: viewLayout,
         meshResidencyEpoch: 1,
-        hdrp: false,
       })
       .unwrap();
     expect(prepared).toBeDefined();
@@ -776,7 +773,6 @@ describe('GPU-driven production projection', () => {
         meshBySlot: meshes,
         viewBindGroupLayout: viewLayout,
         meshResidencyEpoch: 1,
-        hdrp: false,
       })
       .unwrap();
     expect(stable?.topologySignature).toBe(prepared.topologySignature);
@@ -809,7 +805,6 @@ describe('GPU-driven production projection', () => {
         meshBySlot: meshes,
         viewBindGroupLayout: viewLayout,
         meshResidencyEpoch: 1,
-        hdrp: false,
       })
       .unwrap();
     expect(moved).toBeDefined();
@@ -892,7 +887,7 @@ describe('GPU-driven production projection', () => {
         meshBySlot: meshes,
         viewBindGroupLayout: viewLayout,
         meshResidencyEpoch: 1,
-        hdrp: false,
+
         activeEntityKeys: new Set([worldEntityKey(0, 1)]),
         activeEntityRevision: 1,
       })
@@ -912,7 +907,7 @@ describe('GPU-driven production projection', () => {
         meshBySlot: meshes,
         viewBindGroupLayout: viewLayout,
         meshResidencyEpoch: 1,
-        hdrp: false,
+
         activeEntityKeys: new Set([worldEntityKey(1, 2)]),
         activeEntityRevision: 2,
       })
@@ -939,7 +934,6 @@ describe('GPU-driven production projection', () => {
         meshBySlot: meshes,
         viewBindGroupLayout: viewLayout,
         meshResidencyEpoch: 1,
-        hdrp: false,
       })
       .unwrap();
     expect(replacementPrepared?.topologySignature).not.toBe(prepared.topologySignature);
@@ -982,7 +976,6 @@ describe('GPU-driven production projection', () => {
       },
       meshBySlot: new Map([[0, mesh(device)]]),
       viewBindGroupLayout: viewLayout,
-      hdrp: false,
     } as const;
 
     expect(
@@ -1353,7 +1346,7 @@ describe('GPU-driven production projection', () => {
       meshBySlot: new Map([[0, mesh(device)]]),
       viewBindGroupLayout: viewLayout,
       meshResidencyEpoch: 1,
-      hdrp: false,
+
       standardPbrArtifact: artifact,
       standardPbrPipelineState: {
         pbrPipelineLayout,
@@ -1461,7 +1454,7 @@ describe('GPU-driven production projection', () => {
     const gpuKey = gpuDrivenShadowDrawKey(entity, -1, 0, 0);
     const residualKey = gpuDrivenShadowDrawKey(entity, 22, 1, 0);
     const allShadowKeys = new Set([gpuKey, residualKey]);
-    const prepareFrame = (hdrp: boolean) =>
+    const prepareFrame = () =>
       production
         .prepare({
           scene: {
@@ -1473,7 +1466,6 @@ describe('GPU-driven production projection', () => {
           meshBySlot: new Map([[0, mesh(device)]]),
           viewBindGroupLayout: viewLayout,
           meshResidencyEpoch: 1,
-          hdrp,
           standardPbrArtifact: artifact,
           standardPbrPipelineState: {
             pbrPipelineLayout,
@@ -1487,7 +1479,7 @@ describe('GPU-driven production projection', () => {
           shadowCasterDrawKeys: allShadowKeys,
         })
         .unwrap();
-    const prepared = prepareFrame(false);
+    const prepared = prepareFrame();
     expect(prepared).toBeDefined();
     if (prepared === undefined) return;
     const claimed = new Set(prepared.shadowDrawKeys ?? []);
@@ -1521,11 +1513,7 @@ describe('GPU-driven production projection', () => {
     );
     const submission = prepared.shadowViewPool?.submission(identity);
     expect(submission?.plan.candidateCount).toBe(1);
-    expect(prepareFrame(true)).toBeUndefined();
-    expect(production.inspect().channels.filter((channel) => channel.viewPass !== 'main')).toEqual(
-      [],
-    );
-    const resumed = prepareFrame(false);
+    const resumed = prepareFrame();
     expect(
       resumed?.updateShadowViews?.([
         { identity, planes: new Float32Array(24), cacheToken: 'mixed-candidates' },
@@ -1684,7 +1672,7 @@ describe('GPU-driven production projection', () => {
         meshBySlot: new Map([[0, multiMesh]]),
         viewBindGroupLayout: viewLayout,
         meshResidencyEpoch: 1,
-        hdrp: false,
+
         standardPbrArtifact: artifact,
         standardPbrPipelineState: {
           pbrPipelineLayout,
@@ -1906,7 +1894,7 @@ describe('GPU-driven production projection', () => {
         instanceBuffers: new Map(),
         meshBindGroupCache: new Map(),
         instancesBgPerEntity: new Map(),
-        singletonMaterialCache: new Map(),
+        shadowMaterialBindGroups: new WeakMap(),
         materialBgShared: new Map(),
       },
       materialBgAssemblyCache: new Map(),