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

package/src/glInnerShadowEffect.test.ts

@@ -1,9 +1,117 @@
+vi.hoisted(() => {
+  vi.resetModules();
+});
+
+vi.mock('@flighthq/render-gl', () => {
+  let nextTargetId = 0;
+  return {
+    acquireGlRenderTarget: vi.fn((_state, _pool, descriptor) => ({
+      ...descriptor,
+      id: `scratch-${nextTargetId++}`,
+      texture: {},
+    })),
+    clearGlRenderTarget: vi.fn(),
+    compileGlFullscreenProgram: vi.fn(() => ({ program: {}, vao: {} })),
+    drawGlFullscreenPass: vi.fn(),
+    releaseGlRenderTarget: vi.fn(),
+  };
+});
+
+vi.mock('./glEffectBlitShader', () => ({
+  applyGlEffectBlitOffsetPass: vi.fn(),
+  applyGlEffectBlitPass: vi.fn(),
+}));
+
+vi.mock('./glEffectBoxBlur', () => ({
+  applyGlEffectBoxBlur: vi.fn(),
+}));
+
+vi.mock('./glEffectTintShader', () => ({
+  applyGlEffectInvertTintPass: vi.fn(),
+}));
+
+import { drawGlFullscreenPass } from '@flighthq/render-gl';
+
+import { applyGlEffectBlitPass } from './glEffectBlitShader';
+import { applyGlEffectBoxBlur } from './glEffectBoxBlur';
 import { applyInnerShadowEffectToGl, defaultGlInnerShadowEffectRunner } from './glInnerShadowEffect';
 
 describe('applyInnerShadowEffectToGl', () => {
   it('is a function', () => {
     expect(typeof applyInnerShadowEffectToGl).toBe('function');
   });
+
+  it('composites the source before the clipped shadow by default', () => {
+    const source = createTarget('source');
+    const dest = createTarget('dest');
+
+    applyInnerShadowEffectToGl(createState(), source, dest, createPool(), { kind: 'InnerShadowEffect' });
+
+    expect(applyGlEffectBlitPass).toHaveBeenCalledTimes(2);
+    expect(applyGlEffectBlitPass).toHaveBeenNthCalledWith(1, expect.anything(), source, dest);
+  });
+
+  it('omits the source composite when sourceMode is hide', () => {
+    const source = createTarget('source');
+    const dest = createTarget('dest');
+
+    applyInnerShadowEffectToGl(createState(), source, dest, createPool(), {
+      kind: 'InnerShadowEffect',
+      sourceMode: 'hide',
+    });
+
+    expect(applyGlEffectBlitPass).toHaveBeenCalledTimes(1);
+    expect(applyGlEffectBlitPass).not.toHaveBeenCalledWith(expect.anything(), source, dest);
+    const finalComposite = vi.mocked(applyGlEffectBlitPass).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');
+
+    applyInnerShadowEffectToGl(createState(), source, dest, createPool(), {
+      kind: 'InnerShadowEffect',
+      color: 0,
+      sourceMode: 'hide',
+    });
+
+    expect(applyGlEffectBoxBlur).toHaveBeenCalledWith(
+      expect.anything(),
+      expect.anything(),
+      expect.anything(),
+      expect.anything(),
+      expect.objectContaining({ edgeColor: [0, 0, 0, 1] }),
+    );
+  });
+
+  it('preserves the clipped shadow pass when sourceMode is hide', () => {
+    const source = createTarget('source');
+    const dest = createTarget('dest');
+    const sourceTexture = (source as unknown as { texture: unknown }).texture;
+
+    applyInnerShadowEffectToGl(createState(), source, dest, createPool(), {
+      kind: 'InnerShadowEffect',
+      sourceMode: 'hide',
+    });
+
+    expect(drawGlFullscreenPass).toHaveBeenCalledTimes(1);
+    expect(drawGlFullscreenPass).toHaveBeenNthCalledWith(
+      1,
+      expect.anything(),
+      expect.anything(),
+      [expect.anything(), sourceTexture],
+      expect.anything(),
+      expect.any(Function),
+    );
+
+    const gl = { ONE: 1, ZERO: 0, blendFunc: vi.fn() };
+    const setClipUniforms = vi.mocked(drawGlFullscreenPass).mock.calls[0][4];
+    setClipUniforms(gl as never, {} as never);
+
+    expect(gl.blendFunc).toHaveBeenCalledWith(gl.ONE, gl.ZERO);
+  });
 });
 
 describe('defaultGlInnerShadowEffectRunner', () => {
@@ -11,3 +119,27 @@ describe('defaultGlInnerShadowEffectRunner', () => {
     expect(typeof defaultGlInnerShadowEffectRunner).toBe('function');
   });
 });
+
+beforeEach(() => {
+  vi.clearAllMocks();
+});
+
+afterAll(() => {
+  vi.doUnmock('@flighthq/render-gl');
+  vi.doUnmock('./glEffectBlitShader');
+  vi.doUnmock('./glEffectBoxBlur');
+  vi.doUnmock('./glEffectTintShader');
+  vi.resetModules();
+});
+
+function createState(): never {
+  return { gl: {} } 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/glOuterGlowEffect.test.ts

@@ -1,9 +1,76 @@
+vi.hoisted(() => {
+  vi.resetModules();
+});
+
+vi.mock('@flighthq/render-gl', () => {
+  let nextTargetId = 0;
+  return {
+    acquireGlRenderTarget: vi.fn((_state, _pool, descriptor) => ({
+      ...descriptor,
+      id: `scratch-${nextTargetId++}`,
+      texture: {},
+    })),
+    clearGlRenderTarget: vi.fn(),
+    releaseGlRenderTarget: vi.fn(),
+  };
+});
+
+vi.mock('./glEffectBlitShader', () => ({
+  applyGlEffectBlitPass: vi.fn(),
+  applyGlEffectErasePass: vi.fn(),
+}));
+
+vi.mock('./glEffectBoxBlur', () => ({
+  applyGlEffectBoxBlur: vi.fn(),
+}));
+
+vi.mock('./glEffectTintShader', () => ({
+  applyGlEffectTintPass: vi.fn(),
+}));
+
+import { applyGlEffectBlitPass, applyGlEffectErasePass } from './glEffectBlitShader';
 import { applyOuterGlowEffectToGl, defaultGlOuterGlowEffectRunner } from './glOuterGlowEffect';
 
 describe('applyOuterGlowEffectToGl', () => {
   it('is a function', () => {
     expect(typeof applyOuterGlowEffectToGl).toBe('function');
   });
+
+  it('draws the source by default', () => {
+    const source = createTarget('source');
+    const dest = createTarget('dest');
+
+    applyOuterGlowEffectToGl(createState(), source, dest, createPool(), { kind: 'OuterGlowEffect' });
+
+    expect(applyGlEffectBlitPass).toHaveBeenCalledWith(expect.anything(), source, dest);
+    expect(applyGlEffectErasePass).not.toHaveBeenCalled();
+  });
+
+  it('hides the source when sourceMode is hide', () => {
+    const source = createTarget('source');
+    const dest = createTarget('dest');
+
+    applyOuterGlowEffectToGl(createState(), source, dest, createPool(), {
+      kind: 'OuterGlowEffect',
+      sourceMode: 'hide',
+    });
+
+    expect(applyGlEffectBlitPass).not.toHaveBeenCalledWith(expect.anything(), source, dest);
+    expect(applyGlEffectErasePass).not.toHaveBeenCalled();
+  });
+
+  it('erases the source silhouette when sourceMode is knockout', () => {
+    const source = createTarget('source');
+    const dest = createTarget('dest');
+
+    applyOuterGlowEffectToGl(createState(), source, dest, createPool(), {
+      kind: 'OuterGlowEffect',
+      sourceMode: 'knockout',
+    });
+
+    expect(applyGlEffectBlitPass).not.toHaveBeenCalledWith(expect.anything(), source, dest);
+    expect(applyGlEffectErasePass).toHaveBeenCalledWith(expect.anything(), source, dest);
+  });
 });
 
 describe('defaultGlOuterGlowEffectRunner', () => {
@@ -11,3 +78,27 @@ describe('defaultGlOuterGlowEffectRunner', () => {
     expect(typeof defaultGlOuterGlowEffectRunner).toBe('function');
   });
 });
+
+beforeEach(() => {
+  vi.clearAllMocks();
+});
+
+afterAll(() => {
+  vi.doUnmock('@flighthq/render-gl');
+  vi.doUnmock('./glEffectBlitShader');
+  vi.doUnmock('./glEffectBoxBlur');
+  vi.doUnmock('./glEffectTintShader');
+  vi.resetModules();
+});
+
+function createState(): never {
+  return { gl: {} } 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/glRenderEffectRegistrar.test.ts

@@ -127,11 +127,12 @@ describe('registerCompositeGlRenderEffects', () => {
     expect(typeof registerCompositeGlRenderEffects).toBe('function');
   });
 
-  it('registers the seven former-filter composite effect runners', () => {
+  it('registers the composite effect runners including the advanced-blend recipe', () => {
     const state = {} as never;
     registerCompositeGlRenderEffects(state);
     for (const kind of [
       'BevelEffect',
+      'BlendEffect',
       'DropShadowEffect',
       'GradientBevelEffect',
       'GradientGlowEffect',