@flighthq/effects-wgpu 0.1.0 → 0.2.1-next.410.a23f189

package/src/wgpuBlurEffect.test.ts

@@ -0,0 +1,19 @@
+import { applyBlurEffectToWgpu, applyGaussianBlurToWgpu, defaultWgpuBlurEffectRunner } from './wgpuBlurEffect';
+
+describe('applyBlurEffectToWgpu', () => {
+  it('is a function', () => {
+    expect(typeof applyBlurEffectToWgpu).toBe('function');
+  });
+});
+
+describe('applyGaussianBlurToWgpu', () => {
+  it('is a function', () => {
+    expect(typeof applyGaussianBlurToWgpu).toBe('function');
+  });
+});
+
+describe('defaultWgpuBlurEffectRunner', () => {
+  it('is a function', () => {
+    expect(typeof defaultWgpuBlurEffectRunner).toBe('function');
+  });
+});

package/src/wgpuColorLutPass.test.ts

@@ -0,0 +1,7 @@
+import { applyColorLutPassToWgpu } from './wgpuColorLutPass';
+
+describe('applyColorLutPassToWgpu', () => {
+  it('is a function', () => {
+    expect(typeof applyColorLutPassToWgpu).toBe('function');
+  });
+});

package/src/wgpuColorMatrixPass.test.ts

@@ -0,0 +1,7 @@
+import { applyColorMatrixPassToWgpu } from './wgpuColorMatrixPass';
+
+describe('applyColorMatrixPassToWgpu', () => {
+  it('is a function', () => {
+    expect(typeof applyColorMatrixPassToWgpu).toBe('function');
+  });
+});

package/src/wgpuConvolutionEffect.test.ts

@@ -0,0 +1,13 @@
+import { applyConvolutionEffectToWgpu, defaultWgpuConvolutionEffectRunner } from './wgpuConvolutionEffect';
+
+describe('applyConvolutionEffectToWgpu', () => {
+  it('is a function', () => {
+    expect(typeof applyConvolutionEffectToWgpu).toBe('function');
+  });
+});
+
+describe('defaultWgpuConvolutionEffectRunner', () => {
+  it('is a function', () => {
+    expect(typeof defaultWgpuConvolutionEffectRunner).toBe('function');
+  });
+});

package/src/wgpuDropShadowEffect.test.ts

@@ -0,0 +1,109 @@
+vi.hoisted(() => {
+  vi.resetModules();
+});
+
+vi.mock('@flighthq/render-wgpu', () => {
+  let nextTargetId = 0;
+  return {
+    acquireWgpuRenderTarget: vi.fn((_state, _pool, descriptor) => ({
+      ...descriptor,
+      id: `scratch-${nextTargetId++}`,
+      texture: {},
+    })),
+    releaseWgpuRenderTarget: vi.fn(),
+  };
+});
+
+vi.mock('./wgpuEffectBlitShader', () => ({
+  applyWgpuEffectBlitOffsetPass: vi.fn(),
+  applyWgpuEffectBlitPass: vi.fn(),
+  applyWgpuEffectErasePass: vi.fn(),
+}));
+
+vi.mock('./wgpuEffectBoxBlur', () => ({
+  applyWgpuEffectBoxBlur: vi.fn(),
+}));
+
+vi.mock('./wgpuEffectPass', () => ({
+  clearWgpuEffectTarget: vi.fn(),
+}));
+
+vi.mock('./wgpuEffectTintShader', () => ({
+  applyWgpuEffectTintPass: vi.fn(),
+}));
+
+import { applyDropShadowEffectToWgpu, defaultWgpuDropShadowEffectRunner } from './wgpuDropShadowEffect';
+import { applyWgpuEffectBlitPass, applyWgpuEffectErasePass } from './wgpuEffectBlitShader';
+
+describe('applyDropShadowEffectToWgpu', () => {
+  it('is a function', () => {
+    expect(typeof applyDropShadowEffectToWgpu).toBe('function');
+  });
+
+  it('draws the source by default', () => {
+    const source = createTarget('source');
+    const dest = createTarget('dest');
+
+    applyDropShadowEffectToWgpu(createState(), source, dest, createPool(), { kind: 'DropShadowEffect' });
+
+    expect(applyWgpuEffectBlitPass).toHaveBeenCalledWith(expect.anything(), source, dest);
+    expect(applyWgpuEffectErasePass).not.toHaveBeenCalled();
+  });
+
+  it('hides the source when sourceMode is hide', () => {
+    const source = createTarget('source');
+    const dest = createTarget('dest');
+
+    applyDropShadowEffectToWgpu(createState(), source, dest, createPool(), {
+      kind: 'DropShadowEffect',
+      sourceMode: 'hide',
+    });
+
+    expect(applyWgpuEffectBlitPass).not.toHaveBeenCalledWith(expect.anything(), source, dest);
+    expect(applyWgpuEffectErasePass).not.toHaveBeenCalled();
+  });
+
+  it('erases the source silhouette when sourceMode is knockout', () => {
+    const source = createTarget('source');
+    const dest = createTarget('dest');
+
+    applyDropShadowEffectToWgpu(createState(), source, dest, createPool(), {
+      kind: 'DropShadowEffect',
+      sourceMode: 'knockout',
+    });
+
+    expect(applyWgpuEffectBlitPass).not.toHaveBeenCalledWith(expect.anything(), source, dest);
+    expect(applyWgpuEffectErasePass).toHaveBeenCalledWith(expect.anything(), source, dest);
+  });
+});
+
+describe('defaultWgpuDropShadowEffectRunner', () => {
+  it('is a function', () => {
+    expect(typeof defaultWgpuDropShadowEffectRunner).toBe('function');
+  });
+});
+
+beforeEach(() => {
+  vi.clearAllMocks();
+});
+
+afterAll(() => {
+  vi.doUnmock('@flighthq/render-wgpu');
+  vi.doUnmock('./wgpuEffectBlitShader');
+  vi.doUnmock('./wgpuEffectBoxBlur');
+  vi.doUnmock('./wgpuEffectPass');
+  vi.doUnmock('./wgpuEffectTintShader');
+  vi.resetModules();
+});
+
+function createState(): never {
+  return {} as never;
+}
+
+function createPool(): never {
+  return { free: [] } as never;
+}
+
+function createTarget(id: string): never {
+  return { id, width: 32, height: 16, format: 'rgba8', texture: {} } as never;
+}

package/src/wgpuEffectBlitShader.test.ts

@@ -0,0 +1,23 @@
+import {
+  applyWgpuEffectBlitOffsetPass,
+  applyWgpuEffectBlitPass,
+  applyWgpuEffectErasePass,
+} from './wgpuEffectBlitShader';
+
+describe('applyWgpuEffectBlitOffsetPass', () => {
+  it('is a function', () => {
+    expect(typeof applyWgpuEffectBlitOffsetPass).toBe('function');
+  });
+});
+
+describe('applyWgpuEffectBlitPass', () => {
+  it('is a function', () => {
+    expect(typeof applyWgpuEffectBlitPass).toBe('function');
+  });
+});
+
+describe('applyWgpuEffectErasePass', () => {
+  it('is a function', () => {
+    expect(typeof applyWgpuEffectErasePass).toBe('function');
+  });
+});

package/src/wgpuEffectBoxBlur.test.ts

@@ -0,0 +1,75 @@
+const mockState = vi.hoisted(() => ({
+  uniformSnapshots: [] as number[][],
+}));
+
+vi.hoisted(() => {
+  vi.resetModules();
+});
+
+vi.mock('./wgpuEffectPass', () => ({
+  createWgpuEffectPipeline: vi.fn(() => ({ blendMode: 'replace', pipeline: {} })),
+  drawWgpuEffectPass: vi.fn((_state, _source, _dest, _pipeline, setUniforms) => {
+    const f32 = new Float32Array(16);
+    const i32 = new Int32Array(f32.buffer);
+    setUniforms(f32, i32);
+    mockState.uniformSnapshots.push(Array.from(f32));
+  }),
+}));
+
+import { applyWgpuEffectBoxBlur } from './wgpuEffectBoxBlur';
+import { createWgpuEffectPipeline, drawWgpuEffectPass } from './wgpuEffectPass';
+
+describe('applyWgpuEffectBoxBlur', () => {
+  it('is a function', () => {
+    expect(typeof applyWgpuEffectBoxBlur).toBe('function');
+  });
+
+  it('binds the exterior edge color when one is provided', () => {
+    applyWgpuEffectBoxBlur(createState(), createTarget('source'), createTarget('dest'), createTarget('temp'), {
+      blurX: 4,
+      blurY: 0,
+      edgeColor: [0.1, 0.2, 0.3, 0.4],
+      passes: 1,
+    });
+
+    expect(createWgpuEffectPipeline).toHaveBeenCalledWith(expect.anything(), expect.any(String), 'replace');
+    expect(mockState.uniformSnapshots[0]![4]).toBeCloseTo(0.1);
+    expect(mockState.uniformSnapshots[0]![5]).toBeCloseTo(0.2);
+    expect(mockState.uniformSnapshots[0]![6]).toBeCloseTo(0.3);
+    expect(mockState.uniformSnapshots[0]![7]).toBeCloseTo(0.4);
+    expect(mockState.uniformSnapshots[0]![9]).toBe(1);
+  });
+
+  it('uses the replacement blur pipeline for zero-radius copies', () => {
+    const dest = createTarget('dest');
+
+    applyWgpuEffectBoxBlur(createState(), createTarget('source'), dest, createTarget('temp'), {
+      blurX: 0,
+      blurY: 0,
+      passes: 1,
+    });
+
+    expect(drawWgpuEffectPass).toHaveBeenCalledTimes(1);
+    expect(vi.mocked(drawWgpuEffectPass).mock.calls[0]![2]).toBe(dest);
+    expect(mockState.uniformSnapshots[0]![8]).toBe(0);
+    expect(mockState.uniformSnapshots[0]![9]).toBe(0);
+  });
+});
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  mockState.uniformSnapshots.length = 0;
+});
+
+afterAll(() => {
+  vi.doUnmock('./wgpuEffectPass');
+  vi.resetModules();
+});
+
+function createState(): never {
+  return {} as never;
+}
+
+function createTarget(id: string): never {
+  return { id, width: 32, height: 16, format: 'rgba8', texture: {}, view: {} } as never;
+}

package/src/wgpuEffectGradientRamp.test.ts

@@ -0,0 +1,7 @@
+import { getWgpuEffectGradientRampTexture } from './wgpuEffectGradientRamp';
+
+describe('getWgpuEffectGradientRampTexture', () => {
+  it('is a function', () => {
+    expect(typeof getWgpuEffectGradientRampTexture).toBe('function');
+  });
+});

package/src/wgpuEffectPass.test.ts

@@ -0,0 +1,51 @@
+import {
+  clearWgpuEffectTarget,
+  createWgpuDualSourceEffectPipeline,
+  createWgpuEffectPipeline,
+  drawWgpuDualSourceEffectPass,
+  drawWgpuEffectPass,
+  EFFECT_VERTEX_WGSL,
+  getWgpuEffectPassState,
+} from './wgpuEffectPass';
+
+describe('clearWgpuEffectTarget', () => {
+  it('is a function', () => {
+    expect(typeof clearWgpuEffectTarget).toBe('function');
+  });
+});
+
+describe('createWgpuDualSourceEffectPipeline', () => {
+  it('is a function', () => {
+    expect(typeof createWgpuDualSourceEffectPipeline).toBe('function');
+  });
+});
+
+describe('createWgpuEffectPipeline', () => {
+  it('is a function', () => {
+    expect(typeof createWgpuEffectPipeline).toBe('function');
+  });
+});
+
+describe('drawWgpuDualSourceEffectPass', () => {
+  it('is a function', () => {
+    expect(typeof drawWgpuDualSourceEffectPass).toBe('function');
+  });
+});
+
+describe('drawWgpuEffectPass', () => {
+  it('is a function', () => {
+    expect(typeof drawWgpuEffectPass).toBe('function');
+  });
+});
+
+describe('EFFECT_VERTEX_WGSL', () => {
+  it('is a WGSL string', () => {
+    expect(typeof EFFECT_VERTEX_WGSL).toBe('string');
+  });
+});
+
+describe('getWgpuEffectPassState', () => {
+  it('is a function', () => {
+    expect(typeof getWgpuEffectPassState).toBe('function');
+  });
+});

package/src/wgpuEffectTintShader.test.ts

@@ -0,0 +1,66 @@
+vi.hoisted(() => {
+  vi.resetModules();
+});
+
+vi.mock('./wgpuEffectPass', () => ({
+  createWgpuDualSourceEffectPipeline: vi.fn(() => ({ blendMode: 'replace', pipeline: {} })),
+  createWgpuEffectPipeline: vi.fn(() => ({ blendMode: 'replace', pipeline: {} })),
+  drawWgpuDualSourceEffectPass: vi.fn(),
+  drawWgpuEffectPass: vi.fn(),
+}));
+
+import { createWgpuDualSourceEffectPipeline, createWgpuEffectPipeline } from './wgpuEffectPass';
+import {
+  applyWgpuEffectInnerClipPass,
+  applyWgpuEffectInvertTintPass,
+  applyWgpuEffectTintPass,
+} from './wgpuEffectTintShader';
+
+describe('applyWgpuEffectInnerClipPass', () => {
+  it('is a function', () => {
+    expect(typeof applyWgpuEffectInnerClipPass).toBe('function');
+  });
+
+  it('uses replacement blending', () => {
+    applyWgpuEffectInnerClipPass(createState(), createTarget(), createTarget(), createTarget());
+
+    expect(createWgpuDualSourceEffectPipeline).toHaveBeenCalledWith(expect.anything(), expect.any(String), 'replace');
+  });
+});
+
+describe('applyWgpuEffectInvertTintPass', () => {
+  it('is a function', () => {
+    expect(typeof applyWgpuEffectInvertTintPass).toBe('function');
+  });
+
+  it('uses replacement blending', () => {
+    applyWgpuEffectInvertTintPass(createState(), createTarget(), createTarget(), 0xff00cc, 0.5, 2);
+
+    expect(createWgpuEffectPipeline).toHaveBeenCalledWith(expect.anything(), expect.any(String), 'replace');
+  });
+});
+
+describe('applyWgpuEffectTintPass', () => {
+  it('is a function', () => {
+    expect(typeof applyWgpuEffectTintPass).toBe('function');
+  });
+
+  it('uses replacement blending', () => {
+    applyWgpuEffectTintPass(createState(), createTarget(), createTarget(), 0xff00cc, 0.5, 2);
+
+    expect(createWgpuEffectPipeline).toHaveBeenCalledWith(expect.anything(), expect.any(String), 'replace');
+  });
+});
+
+afterAll(() => {
+  vi.doUnmock('./wgpuEffectPass');
+  vi.resetModules();
+});
+
+function createState(): never {
+  return {} as never;
+}
+
+function createTarget(): never {
+  return {} as never;
+}

package/src/wgpuGradientBevelEffect.test.ts

@@ -0,0 +1,13 @@
+import { applyGradientBevelEffectToWgpu, defaultWgpuGradientBevelEffectRunner } from './wgpuGradientBevelEffect';
+
+describe('applyGradientBevelEffectToWgpu', () => {
+  it('is a function', () => {
+    expect(typeof applyGradientBevelEffectToWgpu).toBe('function');
+  });
+});
+
+describe('defaultWgpuGradientBevelEffectRunner', () => {
+  it('is a function', () => {
+    expect(typeof defaultWgpuGradientBevelEffectRunner).toBe('function');
+  });
+});

package/src/wgpuGradientGlowEffect.test.ts

@@ -0,0 +1,13 @@
+import { applyGradientGlowEffectToWgpu, defaultWgpuGradientGlowEffectRunner } from './wgpuGradientGlowEffect';
+
+describe('applyGradientGlowEffectToWgpu', () => {
+  it('is a function', () => {
+    expect(typeof applyGradientGlowEffectToWgpu).toBe('function');
+  });
+});
+
+describe('defaultWgpuGradientGlowEffectRunner', () => {
+  it('is a function', () => {
+    expect(typeof defaultWgpuGradientGlowEffectRunner).toBe('function');
+  });
+});

package/src/wgpuInnerGlowEffect.test.ts

@@ -0,0 +1,137 @@
+vi.hoisted(() => {
+  vi.resetModules();
+});
+
+vi.mock('@flighthq/render-wgpu', () => {
+  let nextTargetId = 0;
+  return {
+    acquireWgpuRenderTarget: vi.fn((_state, _pool, descriptor) => ({
+      ...descriptor,
+      id: `scratch-${nextTargetId++}`,
+      texture: {},
+    })),
+    releaseWgpuRenderTarget: vi.fn(),
+  };
+});
+
+vi.mock('./wgpuEffectBlitShader', () => ({
+  applyWgpuEffectBlitPass: vi.fn(),
+}));
+
+vi.mock('./wgpuEffectBoxBlur', () => ({
+  applyWgpuEffectBoxBlur: vi.fn(),
+}));
+
+vi.mock('./wgpuEffectPass', () => ({
+  clearWgpuEffectTarget: vi.fn(),
+}));
+
+vi.mock('./wgpuEffectTintShader', () => ({
+  applyWgpuEffectInnerClipPass: vi.fn(),
+  applyWgpuEffectInvertTintPass: vi.fn(),
+}));
+
+import { applyWgpuEffectBlitPass } from './wgpuEffectBlitShader';
+import { applyWgpuEffectBoxBlur } from './wgpuEffectBoxBlur';
+import { applyWgpuEffectInnerClipPass } from './wgpuEffectTintShader';
+import { applyInnerGlowEffectToWgpu, defaultWgpuInnerGlowEffectRunner } from './wgpuInnerGlowEffect';
+
+describe('applyInnerGlowEffectToWgpu', () => {
+  it('is a function', () => {
+    expect(typeof applyInnerGlowEffectToWgpu).toBe('function');
+  });
+
+  it('composites the source before the clipped glow by default', () => {
+    const source = createTarget('source');
+    const dest = createTarget('dest');
+
+    applyInnerGlowEffectToWgpu(createState(), source, dest, createPool(), { kind: 'InnerGlowEffect' });
+
+    expect(applyWgpuEffectBlitPass).toHaveBeenCalledTimes(2);
+    expect(applyWgpuEffectBlitPass).toHaveBeenNthCalledWith(1, expect.anything(), source, dest);
+  });
+
+  it('omits the source composite when sourceMode is hide', () => {
+    const source = createTarget('source');
+    const dest = createTarget('dest');
+
+    applyInnerGlowEffectToWgpu(createState(), source, dest, createPool(), {
+      kind: 'InnerGlowEffect',
+      sourceMode: 'hide',
+    });
+
+    expect(applyWgpuEffectBlitPass).toHaveBeenCalledTimes(1);
+    expect(applyWgpuEffectBlitPass).not.toHaveBeenCalledWith(expect.anything(), source, dest);
+    const finalComposite = vi.mocked(applyWgpuEffectBlitPass).mock.calls[0];
+    expect(finalComposite[1]).not.toBe(source);
+    expect(finalComposite[2]).toBe(dest);
+  });
+
+  it('uses an inverted exterior edge color for hidden-source blur', () => {
+    const source = createTarget('source');
+    const dest = createTarget('dest');
+
+    applyInnerGlowEffectToWgpu(createState(), source, dest, createPool(), {
+      kind: 'InnerGlowEffect',
+      color: 0xff0000,
+      sourceMode: 'hide',
+      strength: 2,
+    });
+
+    expect(applyWgpuEffectBoxBlur).toHaveBeenCalledWith(
+      expect.anything(),
+      expect.anything(),
+      expect.anything(),
+      expect.anything(),
+      expect.objectContaining({ edgeColor: [1, 0, 0, 1] }),
+    );
+  });
+
+  it('clips the hidden-source glow against the source alpha', () => {
+    const source = createTarget('source');
+    const dest = createTarget('dest');
+
+    applyInnerGlowEffectToWgpu(createState(), source, dest, createPool(), {
+      kind: 'InnerGlowEffect',
+      sourceMode: 'hide',
+    });
+
+    expect(applyWgpuEffectInnerClipPass).toHaveBeenCalledWith(
+      expect.anything(),
+      expect.anything(),
+      source,
+      expect.anything(),
+    );
+  });
+});
+
+describe('defaultWgpuInnerGlowEffectRunner', () => {
+  it('is a function', () => {
+    expect(typeof defaultWgpuInnerGlowEffectRunner).toBe('function');
+  });
+});
+
+beforeEach(() => {
+  vi.clearAllMocks();
+});
+
+afterAll(() => {
+  vi.doUnmock('@flighthq/render-wgpu');
+  vi.doUnmock('./wgpuEffectBlitShader');
+  vi.doUnmock('./wgpuEffectBoxBlur');
+  vi.doUnmock('./wgpuEffectPass');
+  vi.doUnmock('./wgpuEffectTintShader');
+  vi.resetModules();
+});
+
+function createState(): never {
+  return {} as never;
+}
+
+function createPool(): never {
+  return { free: [] } as never;
+}
+
+function createTarget(id: string): never {
+  return { id, width: 32, height: 16, format: 'rgba8', texture: {} } as never;
+}

package/src/wgpuInnerShadowEffect.test.ts

@@ -0,0 +1,137 @@
+vi.hoisted(() => {
+  vi.resetModules();
+});
+
+vi.mock('@flighthq/render-wgpu', () => {
+  let nextTargetId = 0;
+  return {
+    acquireWgpuRenderTarget: vi.fn((_state, _pool, descriptor) => ({
+      ...descriptor,
+      id: `scratch-${nextTargetId++}`,
+      texture: {},
+    })),
+    releaseWgpuRenderTarget: vi.fn(),
+  };
+});
+
+vi.mock('./wgpuEffectBlitShader', () => ({
+  applyWgpuEffectBlitOffsetPass: vi.fn(),
+  applyWgpuEffectBlitPass: vi.fn(),
+}));
+
+vi.mock('./wgpuEffectBoxBlur', () => ({
+  applyWgpuEffectBoxBlur: vi.fn(),
+}));
+
+vi.mock('./wgpuEffectPass', () => ({
+  clearWgpuEffectTarget: vi.fn(),
+}));
+
+vi.mock('./wgpuEffectTintShader', () => ({
+  applyWgpuEffectInnerClipPass: vi.fn(),
+  applyWgpuEffectInvertTintPass: vi.fn(),
+}));
+
+import { applyWgpuEffectBlitPass } from './wgpuEffectBlitShader';
+import { applyWgpuEffectBoxBlur } from './wgpuEffectBoxBlur';
+import { applyWgpuEffectInnerClipPass } from './wgpuEffectTintShader';
+import { applyInnerShadowEffectToWgpu, defaultWgpuInnerShadowEffectRunner } from './wgpuInnerShadowEffect';
+
+describe('applyInnerShadowEffectToWgpu', () => {
+  it('is a function', () => {
+    expect(typeof applyInnerShadowEffectToWgpu).toBe('function');
+  });
+
+  it('composites the source before the clipped shadow by default', () => {
+    const source = createTarget('source');
+    const dest = createTarget('dest');
+
+    applyInnerShadowEffectToWgpu(createState(), source, dest, createPool(), { kind: 'InnerShadowEffect' });
+
+    expect(applyWgpuEffectBlitPass).toHaveBeenCalledTimes(2);
+    expect(applyWgpuEffectBlitPass).toHaveBeenNthCalledWith(1, expect.anything(), source, dest);
+  });
+
+  it('omits the source composite when sourceMode is hide', () => {
+    const source = createTarget('source');
+    const dest = createTarget('dest');
+
+    applyInnerShadowEffectToWgpu(createState(), source, dest, createPool(), {
+      kind: 'InnerShadowEffect',
+      sourceMode: 'hide',
+    });
+
+    expect(applyWgpuEffectBlitPass).toHaveBeenCalledTimes(1);
+    expect(applyWgpuEffectBlitPass).not.toHaveBeenCalledWith(expect.anything(), source, dest);
+    const finalComposite = vi.mocked(applyWgpuEffectBlitPass).mock.calls[0];
+    expect(finalComposite[1]).not.toBe(source);
+    expect(finalComposite[2]).toBe(dest);
+  });
+
+  it('uses an inverted exterior edge color for hidden-source blur', () => {
+    const source = createTarget('source');
+    const dest = createTarget('dest');
+
+    applyInnerShadowEffectToWgpu(createState(), source, dest, createPool(), {
+      kind: 'InnerShadowEffect',
+      color: 0,
+      sourceMode: 'hide',
+    });
+
+    expect(applyWgpuEffectBoxBlur).toHaveBeenCalledWith(
+      expect.anything(),
+      expect.anything(),
+      expect.anything(),
+      expect.anything(),
+      expect.objectContaining({ edgeColor: [0, 0, 0, 1] }),
+    );
+  });
+
+  it('clips the hidden-source shadow against the source alpha', () => {
+    const source = createTarget('source');
+    const dest = createTarget('dest');
+
+    applyInnerShadowEffectToWgpu(createState(), source, dest, createPool(), {
+      kind: 'InnerShadowEffect',
+      sourceMode: 'hide',
+    });
+
+    expect(applyWgpuEffectInnerClipPass).toHaveBeenCalledWith(
+      expect.anything(),
+      expect.anything(),
+      source,
+      expect.anything(),
+    );
+  });
+});
+
+describe('defaultWgpuInnerShadowEffectRunner', () => {
+  it('is a function', () => {
+    expect(typeof defaultWgpuInnerShadowEffectRunner).toBe('function');
+  });
+});
+
+beforeEach(() => {
+  vi.clearAllMocks();
+});
+
+afterAll(() => {
+  vi.doUnmock('@flighthq/render-wgpu');
+  vi.doUnmock('./wgpuEffectBlitShader');
+  vi.doUnmock('./wgpuEffectBoxBlur');
+  vi.doUnmock('./wgpuEffectPass');
+  vi.doUnmock('./wgpuEffectTintShader');
+  vi.resetModules();
+});
+
+function createState(): never {
+  return {} as never;
+}
+
+function createPool(): never {
+  return { free: [] } as never;
+}
+
+function createTarget(id: string): never {
+  return { id, width: 32, height: 16, format: 'rgba8', texture: {} } as never;
+}