@flighthq/effects-wgpu 0.1.0

package/src/wgpuLensDistortionEffect.test.ts

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

package/src/wgpuLensFlareEffect.test.ts

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

package/src/wgpuLiftGammaGainEffect.test.ts

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

package/src/wgpuLookupTableGradeEffect.test.ts

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

package/src/wgpuMotionBlurEffect.test.ts

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

package/src/wgpuOutlineEffect.test.ts

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

package/src/wgpuPixelateEffect.test.ts

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

package/src/wgpuPosterizeEffect.test.ts

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

package/src/wgpuRadialBlurEffect.test.ts

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

package/src/wgpuRenderEffectPipeline.test.ts

@@ -0,0 +1,45 @@
+import {
+  beginWgpuRenderEffectPipeline,
+  createWgpuRenderEffectPipeline,
+  destroyWgpuRenderEffectPipeline,
+  endWgpuRenderEffectPipeline,
+  setWgpuRenderEffectVelocityTexture,
+} from './wgpuRenderEffectPipeline';
+
+describe('beginWgpuRenderEffectPipeline', () => {
+  it('is a function', () => {
+    expect(typeof beginWgpuRenderEffectPipeline).toBe('function');
+  });
+});
+
+describe('createWgpuRenderEffectPipeline', () => {
+  it('is a function', () => {
+    expect(typeof createWgpuRenderEffectPipeline).toBe('function');
+  });
+});
+
+describe('destroyWgpuRenderEffectPipeline', () => {
+  it('is a function', () => {
+    expect(typeof destroyWgpuRenderEffectPipeline).toBe('function');
+  });
+});
+
+describe('endWgpuRenderEffectPipeline', () => {
+  it('is a function', () => {
+    expect(typeof endWgpuRenderEffectPipeline).toBe('function');
+  });
+});
+
+describe('setWgpuRenderEffectVelocityTexture', () => {
+  it('sets the velocity texture on the pipeline', () => {
+    const pipeline = {
+      options: {},
+      sceneTarget: null,
+      pool: { free: [] },
+      velocityTexture: null,
+    };
+    const texture = {} as GPUTexture;
+    setWgpuRenderEffectVelocityTexture(pipeline, texture);
+    expect(pipeline.velocityTexture).toBe(texture);
+  });
+});

package/src/wgpuRenderEffectRegistrants.test.ts

@@ -0,0 +1,122 @@
+import { createWgpuRenderStateForTest, installWgpuMock } from '@flighthq/render-wgpu';
+
+import {
+  registerAntialiasingWgpuRenderEffects,
+  registerBloomWgpuRenderEffects,
+  registerBlurWgpuRenderEffects,
+  registerColorWgpuRenderEffects,
+  registerScreenSpaceWgpuRenderEffects,
+  registerStandardWgpuRenderEffects,
+  registerStylizeWgpuRenderEffects,
+} from './wgpuRenderEffectRegistrants';
+import { getWgpuRenderEffectRunner } from './wgpuRenderEffectRegistry';
+
+beforeAll(() => {
+  installWgpuMock();
+});
+
+describe('registerAntialiasingWgpuRenderEffects', () => {
+  it('registers FxaaEffect, SmaaEffect, and TaaEffect runners', async () => {
+    const state = await createWgpuRenderStateForTest();
+    registerAntialiasingWgpuRenderEffects(state);
+    expect(getWgpuRenderEffectRunner(state, 'FxaaEffect')).not.toBe(null);
+    expect(getWgpuRenderEffectRunner(state, 'SmaaEffect')).not.toBe(null);
+    expect(getWgpuRenderEffectRunner(state, 'TaaEffect')).not.toBe(null);
+  });
+});
+
+describe('registerBloomWgpuRenderEffects', () => {
+  it('registers all bloom and optical effect runners', async () => {
+    const state = await createWgpuRenderStateForTest();
+    registerBloomWgpuRenderEffects(state);
+    expect(getWgpuRenderEffectRunner(state, 'BloomEffect')).not.toBe(null);
+    expect(getWgpuRenderEffectRunner(state, 'ChromaticAberrationEffect')).not.toBe(null);
+    expect(getWgpuRenderEffectRunner(state, 'GodRaysEffect')).not.toBe(null);
+    expect(getWgpuRenderEffectRunner(state, 'LensDirtEffect')).not.toBe(null);
+    expect(getWgpuRenderEffectRunner(state, 'LensDistortionEffect')).not.toBe(null);
+    expect(getWgpuRenderEffectRunner(state, 'LensFlareEffect')).not.toBe(null);
+    expect(getWgpuRenderEffectRunner(state, 'VignetteEffect')).not.toBe(null);
+  });
+});
+
+describe('registerBlurWgpuRenderEffects', () => {
+  it('registers all blur effect runners', async () => {
+    const state = await createWgpuRenderStateForTest();
+    registerBlurWgpuRenderEffects(state);
+    expect(getWgpuRenderEffectRunner(state, 'BokehDepthOfFieldEffect')).not.toBe(null);
+    expect(getWgpuRenderEffectRunner(state, 'CameraMotionBlurEffect')).not.toBe(null);
+    expect(getWgpuRenderEffectRunner(state, 'DirectionalBlurEffect')).not.toBe(null);
+    expect(getWgpuRenderEffectRunner(state, 'MotionBlurEffect')).not.toBe(null);
+    expect(getWgpuRenderEffectRunner(state, 'RadialBlurEffect')).not.toBe(null);
+    expect(getWgpuRenderEffectRunner(state, 'TiltShiftEffect')).not.toBe(null);
+  });
+});
+
+describe('registerColorWgpuRenderEffects', () => {
+  it('registers all color and tone effect runners', async () => {
+    const state = await createWgpuRenderStateForTest();
+    registerColorWgpuRenderEffects(state);
+    expect(getWgpuRenderEffectRunner(state, 'BrightnessContrastEffect')).not.toBe(null);
+    expect(getWgpuRenderEffectRunner(state, 'ChannelMixerEffect')).not.toBe(null);
+    expect(getWgpuRenderEffectRunner(state, 'ColorGradeEffect')).not.toBe(null);
+    expect(getWgpuRenderEffectRunner(state, 'ExposureEffect')).not.toBe(null);
+    expect(getWgpuRenderEffectRunner(state, 'GrayscaleEffect')).not.toBe(null);
+    expect(getWgpuRenderEffectRunner(state, 'HueSaturationEffect')).not.toBe(null);
+    expect(getWgpuRenderEffectRunner(state, 'InvertEffect')).not.toBe(null);
+    expect(getWgpuRenderEffectRunner(state, 'LiftGammaGainEffect')).not.toBe(null);
+    expect(getWgpuRenderEffectRunner(state, 'LookupTableGradeEffect')).not.toBe(null);
+    expect(getWgpuRenderEffectRunner(state, 'PosterizeEffect')).not.toBe(null);
+    expect(getWgpuRenderEffectRunner(state, 'SepiaEffect')).not.toBe(null);
+    expect(getWgpuRenderEffectRunner(state, 'ToneMapEffect')).not.toBe(null);
+    expect(getWgpuRenderEffectRunner(state, 'WhiteBalanceEffect')).not.toBe(null);
+  });
+});
+
+describe('registerScreenSpaceWgpuRenderEffects', () => {
+  it('registers all screen-space and atmospheric effect runners', async () => {
+    const state = await createWgpuRenderStateForTest();
+    registerScreenSpaceWgpuRenderEffects(state);
+    expect(getWgpuRenderEffectRunner(state, 'DisplacementEffect')).not.toBe(null);
+    expect(getWgpuRenderEffectRunner(state, 'ScreenSpaceFogEffect')).not.toBe(null);
+    expect(getWgpuRenderEffectRunner(state, 'SharpenEffect')).not.toBe(null);
+    expect(getWgpuRenderEffectRunner(state, 'SsaoEffect')).not.toBe(null);
+    expect(getWgpuRenderEffectRunner(state, 'SsrEffect')).not.toBe(null);
+  });
+});
+
+describe('registerStandardWgpuRenderEffects', () => {
+  it('registers all 45 standard effect runners', async () => {
+    const state = await createWgpuRenderStateForTest();
+    registerStandardWgpuRenderEffects(state);
+    // Spot-check one from each band.
+    expect(getWgpuRenderEffectRunner(state, 'FxaaEffect')).not.toBe(null);
+    expect(getWgpuRenderEffectRunner(state, 'BloomEffect')).not.toBe(null);
+    expect(getWgpuRenderEffectRunner(state, 'DirectionalBlurEffect')).not.toBe(null);
+    expect(getWgpuRenderEffectRunner(state, 'GrayscaleEffect')).not.toBe(null);
+    expect(getWgpuRenderEffectRunner(state, 'SsaoEffect')).not.toBe(null);
+    expect(getWgpuRenderEffectRunner(state, 'HalftoneEffect')).not.toBe(null);
+  });
+
+  it('does not register runners for unknown kinds', async () => {
+    const state = await createWgpuRenderStateForTest();
+    registerStandardWgpuRenderEffects(state);
+    expect(getWgpuRenderEffectRunner(state, 'acme.UnknownEffect')).toBe(null);
+  });
+});
+
+describe('registerStylizeWgpuRenderEffects', () => {
+  it('registers all stylize effect runners', async () => {
+    const state = await createWgpuRenderStateForTest();
+    registerStylizeWgpuRenderEffects(state);
+    expect(getWgpuRenderEffectRunner(state, 'CrtEffect')).not.toBe(null);
+    expect(getWgpuRenderEffectRunner(state, 'DitherEffect')).not.toBe(null);
+    expect(getWgpuRenderEffectRunner(state, 'FilmGrainEffect')).not.toBe(null);
+    expect(getWgpuRenderEffectRunner(state, 'GlitchEffect')).not.toBe(null);
+    expect(getWgpuRenderEffectRunner(state, 'HalftoneEffect')).not.toBe(null);
+    expect(getWgpuRenderEffectRunner(state, 'KuwaharaEffect')).not.toBe(null);
+    expect(getWgpuRenderEffectRunner(state, 'OutlineEffect')).not.toBe(null);
+    expect(getWgpuRenderEffectRunner(state, 'PixelateEffect')).not.toBe(null);
+    expect(getWgpuRenderEffectRunner(state, 'ScanlinesEffect')).not.toBe(null);
+    expect(getWgpuRenderEffectRunner(state, 'SketchEffect')).not.toBe(null);
+  });
+});

package/src/wgpuRenderEffectRegistry.test.ts

@@ -0,0 +1,40 @@
+import { createWgpuRenderStateForTest, installWgpuMock } from '@flighthq/render-wgpu';
+
+import {
+  getWgpuRenderEffectRunner,
+  hasWgpuRenderEffectRunner,
+  registerWgpuRenderEffect,
+} from './wgpuRenderEffectRegistry';
+
+beforeAll(() => {
+  installWgpuMock();
+});
+
+describe('getWgpuRenderEffectRunner', () => {
+  it('returns null when no runner is registered for the kind', async () => {
+    const state = await createWgpuRenderStateForTest();
+    expect(getWgpuRenderEffectRunner(state, 'VignetteEffect')).toBe(null);
+  });
+});
+
+describe('hasWgpuRenderEffectRunner', () => {
+  it('returns false when no runner is registered for the kind', async () => {
+    const state = await createWgpuRenderStateForTest();
+    expect(hasWgpuRenderEffectRunner(state, 'VignetteEffect')).toBe(false);
+  });
+
+  it('returns true after a runner is registered for the kind', async () => {
+    const state = await createWgpuRenderStateForTest();
+    registerWgpuRenderEffect(state, 'VignetteEffect', vi.fn());
+    expect(hasWgpuRenderEffectRunner(state, 'VignetteEffect')).toBe(true);
+  });
+});
+
+describe('registerWgpuRenderEffect', () => {
+  it('registers a runner retrievable by its kind', async () => {
+    const state = await createWgpuRenderStateForTest();
+    const runner = vi.fn();
+    registerWgpuRenderEffect(state, 'VignetteEffect', runner);
+    expect(getWgpuRenderEffectRunner(state, 'VignetteEffect')).toBe(runner);
+  });
+});

package/src/wgpuScanlinesEffect.test.ts

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

package/src/wgpuScreenSpaceFogEffect.test.ts

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

package/src/wgpuSepiaEffect.test.ts

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

package/src/wgpuSharpenEffect.test.ts

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

package/src/wgpuSketchEffect.test.ts

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

package/src/wgpuSmaaEffect.test.ts

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

package/src/wgpuSsaoEffect.test.ts

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

package/src/wgpuSsrEffect.test.ts

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

package/src/wgpuTaaEffect.test.ts

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

package/src/wgpuTiltShiftEffect.test.ts

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

package/src/wgpuToneMapEffect.test.ts

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

package/src/wgpuVignetteEffect.test.ts

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

package/src/wgpuWhiteBalanceEffect.test.ts

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