@flighthq/effects-canvas 0.1.0

package/src/canvasMotionBlurEffect.test.ts

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

package/src/canvasOutlineEffect.test.ts

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

package/src/canvasPixelateEffect.test.ts

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

package/src/canvasPosterizeEffect.test.ts

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

package/src/canvasRadialBlurEffect.test.ts

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

package/src/canvasRenderEffectPipeline.test.ts

@@ -0,0 +1,66 @@
+import {
+  acquireCanvasRenderTarget,
+  beginCanvasRenderEffectPipeline,
+  createCanvasRenderEffectPipeline,
+  createCanvasRenderTargetPool,
+  destroyCanvasRenderEffectPipeline,
+  endCanvasRenderEffectPipeline,
+  releaseCanvasRenderTarget,
+} from './canvasRenderEffectPipeline';
+
+describe('acquireCanvasRenderTarget', () => {
+  it('is a function', () => {
+    expect(typeof acquireCanvasRenderTarget).toBe('function');
+  });
+});
+
+describe('beginCanvasRenderEffectPipeline', () => {
+  it('is a function', () => {
+    expect(typeof beginCanvasRenderEffectPipeline).toBe('function');
+  });
+});
+
+describe('createCanvasRenderEffectPipeline', () => {
+  it('is a function', () => {
+    expect(typeof createCanvasRenderEffectPipeline).toBe('function');
+  });
+});
+
+describe('createCanvasRenderTargetPool', () => {
+  it('is a function', () => {
+    expect(typeof createCanvasRenderTargetPool).toBe('function');
+  });
+
+  it('returns a pool with empty free and inUse lists', () => {
+    const pool = createCanvasRenderTargetPool();
+    expect(pool.free).toEqual([]);
+    expect(pool.inUse).toEqual([]);
+  });
+});
+
+describe('destroyCanvasRenderEffectPipeline', () => {
+  it('is a function', () => {
+    expect(typeof destroyCanvasRenderEffectPipeline).toBe('function');
+  });
+});
+
+describe('endCanvasRenderEffectPipeline', () => {
+  it('is a function', () => {
+    expect(typeof endCanvasRenderEffectPipeline).toBe('function');
+  });
+});
+
+describe('releaseCanvasRenderTarget', () => {
+  it('is a function', () => {
+    expect(typeof releaseCanvasRenderTarget).toBe('function');
+  });
+
+  it('moves an acquired target back to the free list', () => {
+    const pool = createCanvasRenderTargetPool();
+    const target = acquireCanvasRenderTarget(pool, 16, 16);
+    expect(pool.inUse).toContain(target);
+    releaseCanvasRenderTarget(pool, target);
+    expect(pool.inUse).not.toContain(target);
+    expect(pool.free).toContain(target);
+  });
+});

package/src/canvasRenderEffectRegistration.test.ts

@@ -0,0 +1,162 @@
+import type { CanvasRenderState } from '@flighthq/types';
+
+import {
+  registerAllCanvasRenderEffects,
+  registerBlurCanvasRenderEffects,
+  registerColorGradeCanvasRenderEffects,
+  registerScreenSpaceCanvasRenderEffects,
+  registerStylizeCanvasRenderEffects,
+} from './canvasRenderEffectRegistration';
+import { hasCanvasRenderEffectRunner } from './canvasRenderEffectRegistry';
+
+describe('registerAllCanvasRenderEffects', () => {
+  it('is a function', () => {
+    expect(typeof registerAllCanvasRenderEffects).toBe('function');
+  });
+  it('registers bloom effect', () => {
+    const fakeState = {} as CanvasRenderState;
+    registerAllCanvasRenderEffects(fakeState);
+    expect(hasCanvasRenderEffectRunner(fakeState, 'BloomEffect')).toBe(true);
+  });
+  it('registers color-grade effects', () => {
+    const fakeState = {} as CanvasRenderState;
+    registerAllCanvasRenderEffects(fakeState);
+    expect(hasCanvasRenderEffectRunner(fakeState, 'BrightnessContrastEffect')).toBe(true);
+    expect(hasCanvasRenderEffectRunner(fakeState, 'GrayscaleEffect')).toBe(true);
+  });
+  it('registers stylize effects', () => {
+    const fakeState = {} as CanvasRenderState;
+    registerAllCanvasRenderEffects(fakeState);
+    expect(hasCanvasRenderEffectRunner(fakeState, 'VignetteEffect')).toBe(true);
+    expect(hasCanvasRenderEffectRunner(fakeState, 'FilmGrainEffect')).toBe(true);
+    expect(hasCanvasRenderEffectRunner(fakeState, 'ChromaticAberrationEffect')).toBe(true);
+  });
+  it('does not register passthrough effects (BokehDepthOfFieldEffect)', () => {
+    const fakeState = {} as CanvasRenderState;
+    registerAllCanvasRenderEffects(fakeState);
+    expect(hasCanvasRenderEffectRunner(fakeState, 'BokehDepthOfFieldEffect')).toBe(false);
+  });
+  it('does not register passthrough effects (FxaaEffect)', () => {
+    const fakeState = {} as CanvasRenderState;
+    registerAllCanvasRenderEffects(fakeState);
+    expect(hasCanvasRenderEffectRunner(fakeState, 'FxaaEffect')).toBe(false);
+  });
+  it('does not register passthrough effects (LookupTableGradeEffect)', () => {
+    const fakeState = {} as CanvasRenderState;
+    registerAllCanvasRenderEffects(fakeState);
+    expect(hasCanvasRenderEffectRunner(fakeState, 'LookupTableGradeEffect')).toBe(false);
+  });
+});
+
+describe('registerBlurCanvasRenderEffects', () => {
+  it('is a function', () => {
+    expect(typeof registerBlurCanvasRenderEffects).toBe('function');
+  });
+  it('registers blur-family effects', () => {
+    const fakeState = {} as CanvasRenderState;
+    registerBlurCanvasRenderEffects(fakeState);
+    expect(hasCanvasRenderEffectRunner(fakeState, 'BloomEffect')).toBe(true);
+    expect(hasCanvasRenderEffectRunner(fakeState, 'DirectionalBlurEffect')).toBe(true);
+    expect(hasCanvasRenderEffectRunner(fakeState, 'RadialBlurEffect')).toBe(true);
+    expect(hasCanvasRenderEffectRunner(fakeState, 'TiltShiftEffect')).toBe(true);
+  });
+  it('does not register color-grade effects', () => {
+    const fakeState = {} as CanvasRenderState;
+    registerBlurCanvasRenderEffects(fakeState);
+    expect(hasCanvasRenderEffectRunner(fakeState, 'GrayscaleEffect')).toBe(false);
+  });
+});
+
+describe('registerColorGradeCanvasRenderEffects', () => {
+  it('is a function', () => {
+    expect(typeof registerColorGradeCanvasRenderEffects).toBe('function');
+  });
+  it('registers color-grade effects', () => {
+    const fakeState = {} as CanvasRenderState;
+    registerColorGradeCanvasRenderEffects(fakeState);
+    expect(hasCanvasRenderEffectRunner(fakeState, 'BrightnessContrastEffect')).toBe(true);
+    expect(hasCanvasRenderEffectRunner(fakeState, 'GrayscaleEffect')).toBe(true);
+  });
+  it('covers every non-passthrough color-grade kind', () => {
+    const fakeState = {} as CanvasRenderState;
+    registerColorGradeCanvasRenderEffects(fakeState);
+    const colorGradeKinds = [
+      'BrightnessContrastEffect',
+      'ChannelMixerEffect',
+      'ColorGradeEffect',
+      'DitherEffect',
+      'ExposureEffect',
+      'GrayscaleEffect',
+      'HueSaturationEffect',
+      'InvertEffect',
+      'LiftGammaGainEffect',
+      'PosterizeEffect',
+      'SepiaEffect',
+      'ToneMapEffect',
+      'WhiteBalanceEffect',
+    ];
+    for (const kind of colorGradeKinds) {
+      expect(hasCanvasRenderEffectRunner(fakeState, kind)).toBe(true);
+    }
+  });
+});
+
+describe('registerScreenSpaceCanvasRenderEffects', () => {
+  it('is a function', () => {
+    expect(typeof registerScreenSpaceCanvasRenderEffects).toBe('function');
+  });
+  it('is a no-op on Canvas 2D (all screen-space effects are passthrough)', () => {
+    // This just verifies it does not throw and that no runner is registered for
+    // any of the screen-space passthrough kinds.
+    const fakeState = {} as CanvasRenderState;
+    registerScreenSpaceCanvasRenderEffects(fakeState);
+    expect(hasCanvasRenderEffectRunner(fakeState, 'FxaaEffect')).toBe(false);
+    expect(hasCanvasRenderEffectRunner(fakeState, 'SmaaEffect')).toBe(false);
+    expect(hasCanvasRenderEffectRunner(fakeState, 'TaaEffect')).toBe(false);
+  });
+});
+
+describe('registerStylizeCanvasRenderEffects', () => {
+  it('is a function', () => {
+    expect(typeof registerStylizeCanvasRenderEffects).toBe('function');
+  });
+  it('registers stylize effects', () => {
+    const fakeState = {} as CanvasRenderState;
+    registerStylizeCanvasRenderEffects(fakeState);
+    expect(hasCanvasRenderEffectRunner(fakeState, 'VignetteEffect')).toBe(true);
+    expect(hasCanvasRenderEffectRunner(fakeState, 'FilmGrainEffect')).toBe(true);
+    expect(hasCanvasRenderEffectRunner(fakeState, 'GlitchEffect')).toBe(true);
+  });
+  it('covers every stylize kind', () => {
+    const fakeState = {} as CanvasRenderState;
+    registerStylizeCanvasRenderEffects(fakeState);
+    const stylizeKinds = [
+      'ChromaticAberrationEffect',
+      'CrtEffect',
+      'DisplacementEffect',
+      'FilmGrainEffect',
+      'GlitchEffect',
+      'GodRaysEffect',
+      'HalftoneEffect',
+      'KuwaharaEffect',
+      'LensDirtEffect',
+      'LensDistortionEffect',
+      'LensFlareEffect',
+      'OutlineEffect',
+      'PixelateEffect',
+      'ScanlinesEffect',
+      'ScreenSpaceFogEffect',
+      'SharpenEffect',
+      'SketchEffect',
+      'VignetteEffect',
+    ];
+    for (const kind of stylizeKinds) {
+      expect(hasCanvasRenderEffectRunner(fakeState, kind)).toBe(true);
+    }
+  });
+  it('does not register blur effects', () => {
+    const fakeState = {} as CanvasRenderState;
+    registerStylizeCanvasRenderEffects(fakeState);
+    expect(hasCanvasRenderEffectRunner(fakeState, 'BloomEffect')).toBe(false);
+  });
+});

package/src/canvasRenderEffectRegistry.test.ts

@@ -0,0 +1,41 @@
+import type { CanvasRenderEffectRunner, CanvasRenderState } from '@flighthq/types';
+
+import {
+  getCanvasRenderEffectRunner,
+  hasCanvasRenderEffectRunner,
+  registerCanvasRenderEffect,
+} from './canvasRenderEffectRegistry';
+
+describe('getCanvasRenderEffectRunner', () => {
+  it('is a function', () => {
+    expect(typeof getCanvasRenderEffectRunner).toBe('function');
+  });
+});
+
+describe('hasCanvasRenderEffectRunner', () => {
+  it('is a function', () => {
+    expect(typeof hasCanvasRenderEffectRunner).toBe('function');
+  });
+  it('returns false when state has no registered runners', () => {
+    const fakeState = {} as CanvasRenderState;
+    expect(hasCanvasRenderEffectRunner(fakeState, 'NotRegisteredEffect')).toBe(false);
+  });
+  it('returns true after registering a runner for the given kind', () => {
+    const fakeState = {} as CanvasRenderState;
+    const fakeRunner = (() => {}) as unknown as CanvasRenderEffectRunner;
+    registerCanvasRenderEffect(fakeState, 'HasTestEffect', fakeRunner);
+    expect(hasCanvasRenderEffectRunner(fakeState, 'HasTestEffect')).toBe(true);
+  });
+  it('returns false for a different kind on the same state', () => {
+    const fakeState = {} as CanvasRenderState;
+    const fakeRunner = (() => {}) as unknown as CanvasRenderEffectRunner;
+    registerCanvasRenderEffect(fakeState, 'OnlyThisEffect', fakeRunner);
+    expect(hasCanvasRenderEffectRunner(fakeState, 'OtherEffect')).toBe(false);
+  });
+});
+
+describe('registerCanvasRenderEffect', () => {
+  it('is a function', () => {
+    expect(typeof registerCanvasRenderEffect).toBe('function');
+  });
+});

package/src/canvasScanlinesEffect.test.ts

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

package/src/canvasScreenSpaceFogEffect.test.ts

@@ -0,0 +1,16 @@
+import {
+  applyScreenSpaceFogEffectToCanvas,
+  defaultCanvasScreenSpaceFogEffectRunner,
+} from './canvasScreenSpaceFogEffect';
+
+describe('applyScreenSpaceFogEffectToCanvas', () => {
+  it('is a function', () => {
+    expect(typeof applyScreenSpaceFogEffectToCanvas).toBe('function');
+  });
+});
+
+describe('defaultCanvasScreenSpaceFogEffectRunner', () => {
+  it('is a function', () => {
+    expect(typeof defaultCanvasScreenSpaceFogEffectRunner).toBe('function');
+  });
+});

package/src/canvasSepiaEffect.test.ts

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

package/src/canvasSharpenEffect.test.ts

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

package/src/canvasSketchEffect.test.ts

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

package/src/canvasSmaaEffect.test.ts

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

package/src/canvasSsaoEffect.test.ts

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

package/src/canvasSsrEffect.test.ts

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

package/src/canvasTaaEffect.test.ts

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

package/src/canvasTiltShiftEffect.test.ts

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

package/src/canvasToneMapEffect.test.ts

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

package/src/canvasVignetteEffect.test.ts

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

package/src/canvasWhiteBalanceEffect.test.ts

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