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

package/src/wgpuInnerGlowEffect.test.ts

@@ -1,9 +1,108 @@
+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', () => {
@@ -11,3 +110,28 @@ describe('defaultWgpuInnerGlowEffectRunner', () => {
     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

@@ -1,9 +1,108 @@
+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', () => {
@@ -11,3 +110,28 @@ describe('defaultWgpuInnerShadowEffectRunner', () => {
     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;
+}

package/src/wgpuOuterGlowEffect.test.ts

@@ -1,9 +1,79 @@
+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(),
+  applyWgpuEffectErasePass: vi.fn(),
+}));
+
+vi.mock('./wgpuEffectBoxBlur', () => ({
+  applyWgpuEffectBoxBlur: vi.fn(),
+}));
+
+vi.mock('./wgpuEffectPass', () => ({
+  clearWgpuEffectTarget: vi.fn(),
+}));
+
+vi.mock('./wgpuEffectTintShader', () => ({
+  applyWgpuEffectTintPass: vi.fn(),
+}));
+
+import { applyWgpuEffectBlitPass, applyWgpuEffectErasePass } from './wgpuEffectBlitShader';
 import { applyOuterGlowEffectToWgpu, defaultWgpuOuterGlowEffectRunner } from './wgpuOuterGlowEffect';
 
 describe('applyOuterGlowEffectToWgpu', () => {
   it('is a function', () => {
     expect(typeof applyOuterGlowEffectToWgpu).toBe('function');
   });
+
+  it('draws the source by default', () => {
+    const source = createTarget('source');
+    const dest = createTarget('dest');
+
+    applyOuterGlowEffectToWgpu(createState(), source, dest, createPool(), { kind: 'OuterGlowEffect' });
+
+    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');
+
+    applyOuterGlowEffectToWgpu(createState(), source, dest, createPool(), {
+      kind: 'OuterGlowEffect',
+      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');
+
+    applyOuterGlowEffectToWgpu(createState(), source, dest, createPool(), {
+      kind: 'OuterGlowEffect',
+      sourceMode: 'knockout',
+    });
+
+    expect(applyWgpuEffectBlitPass).not.toHaveBeenCalledWith(expect.anything(), source, dest);
+    expect(applyWgpuEffectErasePass).toHaveBeenCalledWith(expect.anything(), source, dest);
+  });
 });
 
 describe('defaultWgpuOuterGlowEffectRunner', () => {
@@ -11,3 +81,28 @@ describe('defaultWgpuOuterGlowEffectRunner', () => {
     expect(typeof defaultWgpuOuterGlowEffectRunner).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;
+}