@flighthq/effects-wgpu 0.5.1-next.1069.554a2ac → 0.5.1-next.1201.9b49dee

package/src/wgpuLensDirtEffect.test.ts

@@ -15,7 +15,7 @@ let nextTargetId = 0;
 beforeEach(() => {
   nextTargetId = 0;
 
-  vi.spyOn(renderWgpuContractModule, 'acquireWgpuRenderTarget').mockImplementation(((
+  vi.spyOn(renderWgpuContractModule, 'acquireWgpuTextureRenderTarget').mockImplementation(((
     _state: never,
     _pool: never,
     descriptor: never,
@@ -24,7 +24,7 @@ beforeEach(() => {
     id: `scratch-${nextTargetId++}`,
     texture: {},
   })) as never);
-  vi.spyOn(renderWgpuContractModule, 'releaseWgpuRenderTarget').mockImplementation((() => {}) as never);
+  vi.spyOn(renderWgpuContractModule, 'releaseWgpuTextureRenderTarget').mockImplementation((() => {}) as never);
   vi.spyOn(wgpuBlurEffectModule, 'applyGaussianBlurToWgpu').mockImplementation((() => {}) as never);
   vi.spyOn(wgpuEffectPassModule, 'createWgpuDualSourceEffectPipeline').mockReturnValue({ pipeline: {} } as never);
   vi.spyOn(wgpuEffectPassModule, 'drawWgpuDualSourceEffectPass').mockImplementation((() => {}) as never);
@@ -59,9 +59,9 @@ describe('applyLensDirtEffectToWgpu', () => {
       }),
     );
 
-    expect(renderWgpuContractModule.acquireWgpuRenderTarget).toHaveBeenCalledTimes(3);
+    expect(renderWgpuContractModule.acquireWgpuTextureRenderTarget).toHaveBeenCalledTimes(3);
     const [bright, blurred, temp] = vi
-      .mocked(renderWgpuContractModule.acquireWgpuRenderTarget)
+      .mocked(renderWgpuContractModule.acquireWgpuTextureRenderTarget)
       .mock.results.map((result) => result.value!);
     expect(wgpuEffectProgramCacheModule.getWgpuEffectPipeline).toHaveBeenCalledWith(
       state,
@@ -93,9 +93,9 @@ describe('applyLensDirtEffectToWgpu', () => {
       expect.anything(),
       expect.any(Function),
     );
-    expect(renderWgpuContractModule.releaseWgpuRenderTarget).toHaveBeenNthCalledWith(1, pool, bright);
-    expect(renderWgpuContractModule.releaseWgpuRenderTarget).toHaveBeenNthCalledWith(2, pool, blurred);
-    expect(renderWgpuContractModule.releaseWgpuRenderTarget).toHaveBeenNthCalledWith(3, pool, temp);
+    expect(renderWgpuContractModule.releaseWgpuTextureRenderTarget).toHaveBeenNthCalledWith(1, pool, bright);
+    expect(renderWgpuContractModule.releaseWgpuTextureRenderTarget).toHaveBeenNthCalledWith(2, pool, blurred);
+    expect(renderWgpuContractModule.releaseWgpuTextureRenderTarget).toHaveBeenNthCalledWith(3, pool, temp);
 
     const brightUniforms = new Float32Array(4);
     vi.mocked(wgpuEffectPassModule.drawWgpuEffectPass).mock.calls[0]![4](

package/src/wgpuLogicalEffectResolution.test.ts

@@ -13,7 +13,8 @@ import {
   createSsaoEffect,
   createTiltShiftEffect,
 } from '@flighthq/effects/contract';
-import type { WgpuRenderState, WgpuRenderTarget } from '@flighthq/types/contract';
+import type { WgpuRenderState, WgpuTextureRenderTarget } from '@flighthq/types/contract';
+import { EntityRuntimeKey } from '@flighthq/types/contract';
 
 import * as wgpuEffectPassModule from './wgpuEffectPass';
 import * as wgpuEffectProgramCacheModule from './wgpuEffectProgramCache';
@@ -72,12 +73,16 @@ import { applyTiltShiftEffectToWgpu } from './wgpuTiltShiftEffect';
 
 type ApplyEffect = (
   state: WgpuRenderState,
-  source: Readonly<WgpuRenderTarget>,
-  dest: Readonly<WgpuRenderTarget>,
+  source: Readonly<WgpuTextureRenderTarget>,
+  dest: Readonly<WgpuTextureRenderTarget>,
 ) => void;
 
-const state = { surface: { height: 600, width: 800 } } as unknown as WgpuRenderState;
-const nativeTarget = { height: 600, sampleCount: 1, view: {}, width: 800 } as unknown as WgpuRenderTarget;
+// The logical extent an effect measures its descriptor distances against is the open pass's viewport, so
+// the stand-in state carries a runtime with that viewport rather than a surface.
+const state = {
+  [EntityRuntimeKey]: { passStack: [{ viewport: { height: 600, width: 800 } }] },
+} as unknown as WgpuRenderState;
+const nativeTarget = { height: 600, sampleCount: 1, view: {}, width: 800 } as unknown as WgpuTextureRenderTarget;
 // Pool scratch targets preserve supersampled dimensions but have sampleCount 1; this is the discriminator
 // that prevents a tempting sampleCount-derived implementation from silently returning the wrong scale.
 const supersampledScratchTarget = {
@@ -85,7 +90,7 @@ const supersampledScratchTarget = {
   sampleCount: 1,
   view: {},
   width: 1600,
-} as unknown as WgpuRenderTarget;
+} as unknown as WgpuTextureRenderTarget;
 
 const logicalEffects: ReadonlyArray<{
   readonly apply: ApplyEffect;
@@ -175,7 +180,7 @@ const physicalEffects: ReadonlyArray<{ readonly apply: ApplyEffect; readonly nam
   },
 ];
 
-function uploadedBy(apply: ApplyEffect, target: WgpuRenderTarget): readonly number[] {
+function uploadedBy(apply: ApplyEffect, target: WgpuTextureRenderTarget): readonly number[] {
   recorded.uniforms.length = 0;
   apply(state, target, target);
   return recorded.uniforms[0]!;

package/src/wgpuOuterGlowEffect.test.ts

@@ -16,7 +16,7 @@ let nextTargetId = 0;
 beforeEach(() => {
   nextTargetId = 0;
 
-  vi.spyOn(renderWgpuContractModule, 'acquireWgpuRenderTarget').mockImplementation(((
+  vi.spyOn(renderWgpuContractModule, 'acquireWgpuTextureRenderTarget').mockImplementation(((
     _state: never,
     _pool: never,
     descriptor: never,
@@ -25,7 +25,7 @@ beforeEach(() => {
     id: `scratch-${nextTargetId++}`,
     texture: {},
   })) as never);
-  vi.spyOn(renderWgpuContractModule, 'releaseWgpuRenderTarget').mockImplementation((() => {}) as never);
+  vi.spyOn(renderWgpuContractModule, 'releaseWgpuTextureRenderTarget').mockImplementation((() => {}) as never);
   vi.spyOn(wgpuEffectBlitShaderModule, 'applyWgpuEffectBlitPass').mockImplementation((() => {}) as never);
   vi.spyOn(wgpuEffectBlitShaderModule, 'applyWgpuEffectErasePass').mockImplementation((() => {}) as never);
   vi.spyOn(wgpuEffectBoxBlurModule, 'applyWgpuEffectBoxBlur').mockImplementation((() => {}) as never);

package/src/wgpuRadialBlurEffect.test.ts

@@ -1,6 +1,6 @@
 import { createRadialBlurEffect } from '@flighthq/effects/contract';
 import { createWgpuRenderStateForTest, installWgpuMock } from '@flighthq/render-wgpu/contract';
-import type { RadialBlurEffect, WgpuRenderState, WgpuRenderTarget } from '@flighthq/types/contract';
+import type { RadialBlurEffect, WgpuRenderState, WgpuTextureRenderTarget } from '@flighthq/types/contract';
 
 import * as wgpuEffectPassModule from './wgpuEffectPass';
 import * as wgpuEffectProgramCacheModule from './wgpuEffectProgramCache';
@@ -53,7 +53,7 @@ beforeAll(() => installWgpuMock());
 function apply(effect: Readonly<Partial<RadialBlurEffect>> = {}): readonly number[] {
   recorded.pipelines.length = 0;
   recorded.uniforms.length = 0;
-  const target = { height: 64, view: {}, width: 64 } as unknown as WgpuRenderTarget;
+  const target = { height: 64, view: {}, width: 64 } as unknown as WgpuTextureRenderTarget;
   applyRadialBlurEffectToWgpu({} as unknown as WgpuRenderState, target, target, createRadialBlurEffect(effect));
   return recorded.uniforms[0]!;
 }
@@ -119,7 +119,7 @@ describe('applyRadialBlurEffectToWgpu', () => {
 describe('defaultWgpuRadialBlurEffectRunner', () => {
   it('routes the runner context through to the pass', () => {
     recorded.uniforms.length = 0;
-    const target = { height: 8, view: {}, width: 8 } as unknown as WgpuRenderTarget;
+    const target = { height: 8, view: {}, width: 8 } as unknown as WgpuTextureRenderTarget;
 
     defaultWgpuRadialBlurEffectRunner(
       { dest: target, pool: {}, source: target, state: {} } as never,

package/src/wgpuRenderEffectPipeline.test.ts

@@ -1,6 +1,11 @@
 import { createColorLutCache } from '@flighthq/adjustments/contract';
 import { allocateEntity, finishEntity } from '@flighthq/entity/contract';
-import { beginWgpuFrame, createWgpuRenderStateForTest, installWgpuMock } from '@flighthq/render-wgpu/contract';
+import {
+  beginWgpuScreenRenderPassForTest,
+  createWgpuRenderStateForTest,
+  endWgpuRenderPass,
+  installWgpuMock,
+} from '@flighthq/render-wgpu/contract';
 import type { RenderEffect } from '@flighthq/types/contract';
 import { EntityRuntimeKey } from '@flighthq/types/contract';
 
@@ -22,71 +27,83 @@ describe('beginWgpuRenderEffectPipeline', () => {
     const state = await createWgpuRenderStateForTest();
     const pipeline = createWgpuRenderEffectPipeline(state);
 
-    beginWgpuFrame(state);
-    beginWgpuRenderEffectPipeline(state, pipeline);
+    const screenPass = beginWgpuScreenRenderPassForTest(state);
+    endWgpuRenderEffectPipeline(beginWgpuRenderEffectPipeline(screenPass, pipeline), pipeline, []);
     const first = pipeline.sceneTarget;
-    endWgpuRenderEffectPipeline(state, pipeline, []);
-
-    beginWgpuFrame(state);
-    beginWgpuRenderEffectPipeline(state, pipeline);
+    endWgpuRenderEffectPipeline(beginWgpuRenderEffectPipeline(screenPass, pipeline), pipeline, []);
 
     expect(first).not.toBeNull();
     // The retained-target contract: begin resizes rather than reallocating, so a per-frame pipeline
     // does not churn GPU memory. A new object here would be a leak the pool cannot see.
     expect(pipeline.sceneTarget).toBe(first);
-    endWgpuRenderEffectPipeline(state, pipeline, []);
+    endWgpuRenderPass(screenPass);
   });
 
   it('stamps the requested color space onto the scene target before the pass opens', async () => {
     const state = await createWgpuRenderStateForTest();
     const pipeline = createWgpuRenderEffectPipeline(state);
 
-    beginWgpuFrame(state);
-    beginWgpuRenderEffectPipeline(state, pipeline, 'linear');
+    const screenPass = beginWgpuScreenRenderPassForTest(state);
+    const scenePass = beginWgpuRenderEffectPipeline(screenPass, pipeline, undefined, 'linear');
 
     expect(pipeline.sceneTarget?.colorSpace).toBe('linear');
-    endWgpuRenderEffectPipeline(state, pipeline, []);
+    endWgpuRenderEffectPipeline(scenePass, pipeline, []);
+    endWgpuRenderPass(screenPass);
   });
 
-  it('packs the background quadruple into one 0xRRGGBBAA clear color', async () => {
+  // ★ THE CLEAR IS AN ARGUMENT, NOT A STATE PROPERTY. The scene target used to be cleared to
+  // state.backgroundColorRgba, which meant "what the frame is cleared to" was a value the render state
+  // carried around and every caller shared. It is per-pass data and now arrives as one.
+  it('clears the scene target to the colour it is given', async () => {
     const state = await createWgpuRenderStateForTest();
     const pipeline = createWgpuRenderEffectPipeline(state);
-    // Quarter/half/three-quarter channels, chosen so a wrong byte order cannot coincide with the
-    // right one — the ground truth is arithmetic here, not a value read back out of the source.
-    state.backgroundColorRgba.splice(0, state.backgroundColorRgba.length, 0x40 / 255, 0x80 / 255, 0xc0 / 255, 1);
+    const screenPass = beginWgpuScreenRenderPassForTest(state);
+    const { getWgpuRenderStateRuntime } = await import('@flighthq/render-wgpu/contract');
+    const beginRenderPass = vi.spyOn(getWgpuRenderStateRuntime(state).commandEncoder!, 'beginRenderPass');
 
-    beginWgpuFrame(state);
-    beginWgpuRenderEffectPipeline(state, pipeline);
+    const scenePass = beginWgpuRenderEffectPipeline(screenPass, pipeline, {
+      color: [0x40 / 255, 0x80 / 255, 0xc0 / 255, 1],
+      depth: 1.0,
+    });
 
-    expect(pipeline.sceneTarget?.clearColors).toEqual([0x4080c0ff]);
-    endWgpuRenderEffectPipeline(state, pipeline, []);
+    const attachment = Array.from(beginRenderPass.mock.calls.at(-1)![0].colorAttachments)[0]!;
+    const clearValue = attachment.clearValue as GPUColorDict;
+    expect(clearValue.r).toBeCloseTo(0x40 / 255);
+    expect(clearValue.g).toBeCloseTo(0x80 / 255);
+    expect(clearValue.b).toBeCloseTo(0xc0 / 255);
+    expect(clearValue.a).toBe(1);
+    endWgpuRenderEffectPipeline(scenePass, pipeline, []);
+    endWgpuRenderPass(screenPass);
   });
 
-  it('leaves the clear list empty when the background is not a full quadruple', async () => {
+  it('clears to transparent black when the caller names no colour', async () => {
     const state = await createWgpuRenderStateForTest();
     const pipeline = createWgpuRenderEffectPipeline(state);
-    state.backgroundColorRgba.splice(0, state.backgroundColorRgba.length, 0.5, 0.5, 0.5);
+    const screenPass = beginWgpuScreenRenderPassForTest(state);
+    const { getWgpuRenderStateRuntime } = await import('@flighthq/render-wgpu/contract');
+    const beginRenderPass = vi.spyOn(getWgpuRenderStateRuntime(state).commandEncoder!, 'beginRenderPass');
 
-    beginWgpuFrame(state);
-    beginWgpuRenderEffectPipeline(state, pipeline);
+    const scenePass = beginWgpuRenderEffectPipeline(screenPass, pipeline);
 
-    // Empty means "no background to composite" — a different frame than a transparent clear, and the
-    // reason the target falls back to the render state's own background instead.
-    expect(pipeline.sceneTarget?.clearColors).toEqual([]);
-    endWgpuRenderEffectPipeline(state, pipeline, []);
+    const attachment = Array.from(beginRenderPass.mock.calls.at(-1)![0].colorAttachments)[0]!;
+    const clearValue = attachment.clearValue as GPUColorDict;
+    expect([clearValue.r, clearValue.g, clearValue.b, clearValue.a]).toEqual([0, 0, 0, 0]);
+    endWgpuRenderEffectPipeline(scenePass, pipeline, []);
+    endWgpuRenderPass(screenPass);
   });
 
   it('realizes a four-sample scene target at twice the canvas extent', async () => {
     const state = await createWgpuRenderStateForTest();
     const pipeline = createWgpuRenderEffectPipeline(state, { sampleCount: 4 });
 
-    beginWgpuFrame(state);
-    beginWgpuRenderEffectPipeline(state, pipeline);
+    const screenPass = beginWgpuScreenRenderPassForTest(state);
+    const scenePass = beginWgpuRenderEffectPipeline(screenPass, pipeline);
 
-    expect(pipeline.sceneTarget?.width).toBe(state.surface.width * 2);
-    expect(pipeline.sceneTarget?.height).toBe(state.surface.height * 2);
+    expect(pipeline.sceneTarget?.width).toBe(screenPass.viewport.width * 2);
+    expect(pipeline.sceneTarget?.height).toBe(screenPass.viewport.height * 2);
     expect(pipeline.sceneTarget?.sampleCount).toBe(4);
-    endWgpuRenderEffectPipeline(state, pipeline, []);
+    endWgpuRenderEffectPipeline(scenePass, pipeline, []);
+    endWgpuRenderPass(screenPass);
   });
 });
 
@@ -155,9 +172,9 @@ describe('destroyWgpuRenderEffectPipeline', () => {
   it('releases the scene target and clears the LUT caches', async () => {
     const state = await createWgpuRenderStateForTest();
     const pipeline = createWgpuRenderEffectPipeline(state);
-    beginWgpuFrame(state);
-    beginWgpuRenderEffectPipeline(state, pipeline);
-    endWgpuRenderEffectPipeline(state, pipeline, []);
+    const screenPass = beginWgpuScreenRenderPassForTest(state);
+    endWgpuRenderEffectPipeline(beginWgpuRenderEffectPipeline(screenPass, pipeline), pipeline, []);
+    endWgpuRenderPass(screenPass);
     expect(pipeline.sceneTarget).not.toBeNull();
 
     destroyWgpuRenderEffectPipeline(state, pipeline);
@@ -179,9 +196,9 @@ describe('destroyWgpuRenderEffectPipeline', () => {
   it('is idempotent — a second destroy neither throws nor resurrects state', async () => {
     const state = await createWgpuRenderStateForTest();
     const pipeline = createWgpuRenderEffectPipeline(state);
-    beginWgpuFrame(state);
-    beginWgpuRenderEffectPipeline(state, pipeline);
-    endWgpuRenderEffectPipeline(state, pipeline, []);
+    const screenPass = beginWgpuScreenRenderPassForTest(state);
+    endWgpuRenderEffectPipeline(beginWgpuRenderEffectPipeline(screenPass, pipeline), pipeline, []);
+    endWgpuRenderPass(screenPass);
 
     destroyWgpuRenderEffectPipeline(state, pipeline);
     expect(() => destroyWgpuRenderEffectPipeline(state, pipeline)).not.toThrow();
@@ -196,8 +213,10 @@ describe('endWgpuRenderEffectPipeline', () => {
     const pool = pipeline.pool;
 
     // The early return is the only thing standing between an unbegun pipeline and endWgpuRenderPass
-    // popping a pass that was never pushed, so it is asserted rather than assumed.
-    expect(() => endWgpuRenderEffectPipeline(state, pipeline, [])).not.toThrow();
+    // closing a pass the pipeline never opened, so it is asserted rather than assumed.
+    const screenPass = beginWgpuScreenRenderPassForTest(state);
+    expect(() => endWgpuRenderEffectPipeline(screenPass, pipeline, [])).not.toThrow();
+    endWgpuRenderPass(screenPass);
     expect(pipeline.sceneTarget).toBeNull();
     expect(pipeline.pool).toBe(pool);
   });
@@ -206,9 +225,9 @@ describe('endWgpuRenderEffectPipeline', () => {
     const state = await createWgpuRenderStateForTest();
     const pipeline = createWgpuRenderEffectPipeline(state);
 
-    beginWgpuFrame(state);
-    beginWgpuRenderEffectPipeline(state, pipeline);
-    endWgpuRenderEffectPipeline(state, pipeline, []);
+    const screenPass = beginWgpuScreenRenderPassForTest(state);
+    endWgpuRenderEffectPipeline(beginWgpuRenderEffectPipeline(screenPass, pipeline), pipeline, []);
+    endWgpuRenderPass(screenPass);
 
     // Every acquire must be matched by a release before end returns; a pool holding entries after an
     // empty chain would mean the ping-pong leaked a target on the no-op path.
@@ -226,9 +245,9 @@ describe('endWgpuRenderEffectPipeline', () => {
       })() as RenderEffect,
     ];
 
-    beginWgpuFrame(state);
-    beginWgpuRenderEffectPipeline(state, pipeline);
-    endWgpuRenderEffectPipeline(state, pipeline, chain);
+    const screenPass = beginWgpuScreenRenderPassForTest(state);
+    endWgpuRenderEffectPipeline(beginWgpuRenderEffectPipeline(screenPass, pipeline), pipeline, chain);
+    endWgpuRenderPass(screenPass);
 
     // An unregistered kind is skipped, so the chain does no work — but the bracketing still has to
     // balance. This is the acquire/release invariant measured at its cheapest observable point.
@@ -256,18 +275,18 @@ describe('setWgpuRenderEffectPipelineSkipGuard', () => {
     ];
 
     setWgpuRenderEffectPipelineSkipGuard(state, (_state, kind) => dropped.push(kind));
-    beginWgpuFrame(state);
-    beginWgpuRenderEffectPipeline(state, pipeline);
-    endWgpuRenderEffectPipeline(state, pipeline, chain);
+    const guarded = beginWgpuScreenRenderPassForTest(state);
+    endWgpuRenderEffectPipeline(beginWgpuRenderEffectPipeline(guarded, pipeline), pipeline, chain);
+    endWgpuRenderPass(guarded);
 
     expect(dropped).toEqual(['test.wgpu-pipeline-skip-seam']);
 
     // Clearing must restore the original silence exactly: the seam is the ONLY path by which a dropped
     // effect is observable, so a stale guard would be the difference between a diagnostic and a leak.
     setWgpuRenderEffectPipelineSkipGuard(state, null);
-    beginWgpuFrame(state);
-    beginWgpuRenderEffectPipeline(state, pipeline);
-    endWgpuRenderEffectPipeline(state, pipeline, chain);
+    const silent = beginWgpuScreenRenderPassForTest(state);
+    endWgpuRenderEffectPipeline(beginWgpuRenderEffectPipeline(silent, pipeline), pipeline, chain);
+    endWgpuRenderPass(silent);
 
     expect(dropped).toEqual(['test.wgpu-pipeline-skip-seam']);
   });