@flighthq/effects-gl 0.1.0

package/src/glLensDirtEffect.test.ts

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

package/src/glLensDistortionEffect.test.ts

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

package/src/glLensFlareEffect.test.ts

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

package/src/glLiftGammaGainEffect.test.ts

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

package/src/glLookupTableGradeEffect.test.ts

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

package/src/glMotionBlurEffect.test.ts

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

package/src/glOutlineEffect.test.ts

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

package/src/glPixelateEffect.test.ts

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

package/src/glPosterizeEffect.test.ts

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

package/src/glRadialBlurEffect.test.ts

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

package/src/glRenderEffectPipeline.test.ts

@@ -0,0 +1,37 @@
+import {
+  beginGlRenderEffectPipeline,
+  createGlRenderEffectPipeline,
+  destroyGlRenderEffectPipeline,
+  endGlRenderEffectPipeline,
+  setGlRenderEffectVelocityTexture,
+} from './glRenderEffectPipeline';
+
+describe('beginGlRenderEffectPipeline', () => {
+  it('is a function', () => {
+    expect(typeof beginGlRenderEffectPipeline).toBe('function');
+  });
+});
+
+describe('createGlRenderEffectPipeline', () => {
+  it('is a function', () => {
+    expect(typeof createGlRenderEffectPipeline).toBe('function');
+  });
+});
+
+describe('destroyGlRenderEffectPipeline', () => {
+  it('is a function', () => {
+    expect(typeof destroyGlRenderEffectPipeline).toBe('function');
+  });
+});
+
+describe('endGlRenderEffectPipeline', () => {
+  it('is a function', () => {
+    expect(typeof endGlRenderEffectPipeline).toBe('function');
+  });
+});
+
+describe('setGlRenderEffectVelocityTexture', () => {
+  it('is a function', () => {
+    expect(typeof setGlRenderEffectVelocityTexture).toBe('function');
+  });
+});

package/src/glRenderEffectRegistrar.test.ts

@@ -0,0 +1,187 @@
+import {
+  getGlRenderEffectKinds,
+  registerAntialiasingGlRenderEffects,
+  registerBloomGlRenderEffects,
+  registerBlurGlRenderEffects,
+  registerColorGlRenderEffects,
+  registerColorGradeGlRenderEffects,
+  registerCustomShaderGlRenderEffect,
+  registerDefaultGlRenderEffects,
+  registerScreenSpaceGlRenderEffects,
+  registerStandardGlRenderEffects,
+  registerStylizeGlRenderEffects,
+} from './glRenderEffectRegistrar';
+import { hasGlRenderEffectRunner } from './glRenderEffectRegistry';
+
+describe('getGlRenderEffectKinds', () => {
+  it('is a function', () => {
+    expect(typeof getGlRenderEffectKinds).toBe('function');
+  });
+
+  it('returns a non-empty readonly array of strings', () => {
+    const kinds = getGlRenderEffectKinds();
+    expect(kinds.length).toBeGreaterThan(0);
+    expect(kinds.every((k) => typeof k === 'string')).toBe(true);
+  });
+
+  it('returns the same reference on repeated calls', () => {
+    expect(getGlRenderEffectKinds()).toBe(getGlRenderEffectKinds());
+  });
+
+  it('is sorted alphabetically', () => {
+    const kinds = getGlRenderEffectKinds();
+    const sorted = [...kinds].sort();
+    expect(kinds).toEqual(sorted);
+  });
+});
+
+describe('registerAntialiasingGlRenderEffects', () => {
+  it('is a function', () => {
+    expect(typeof registerAntialiasingGlRenderEffects).toBe('function');
+  });
+
+  it('registers FxaaEffect, SmaaEffect, and TaaEffect runners', () => {
+    const state = {} as never;
+    registerAntialiasingGlRenderEffects(state);
+    expect(hasGlRenderEffectRunner(state, 'FxaaEffect')).toBe(true);
+    expect(hasGlRenderEffectRunner(state, 'SmaaEffect')).toBe(true);
+    expect(hasGlRenderEffectRunner(state, 'TaaEffect')).toBe(true);
+  });
+});
+
+describe('registerBloomGlRenderEffects', () => {
+  it('is a function', () => {
+    expect(typeof registerBloomGlRenderEffects).toBe('function');
+  });
+
+  it('registers BloomEffect, VignetteEffect, and ChromaticAberrationEffect runners', () => {
+    const state = {} as never;
+    registerBloomGlRenderEffects(state);
+    expect(hasGlRenderEffectRunner(state, 'BloomEffect')).toBe(true);
+    expect(hasGlRenderEffectRunner(state, 'VignetteEffect')).toBe(true);
+    expect(hasGlRenderEffectRunner(state, 'ChromaticAberrationEffect')).toBe(true);
+  });
+});
+
+describe('registerBlurGlRenderEffects', () => {
+  it('is a function', () => {
+    expect(typeof registerBlurGlRenderEffects).toBe('function');
+  });
+
+  it('registers DirectionalBlurEffect and MotionBlurEffect runners', () => {
+    const state = {} as never;
+    registerBlurGlRenderEffects(state);
+    expect(hasGlRenderEffectRunner(state, 'DirectionalBlurEffect')).toBe(true);
+    expect(hasGlRenderEffectRunner(state, 'MotionBlurEffect')).toBe(true);
+  });
+
+  it('does not register BloomEffect (moved to bloom band)', () => {
+    const state = {} as never;
+    registerBlurGlRenderEffects(state);
+    expect(hasGlRenderEffectRunner(state, 'BloomEffect')).toBe(false);
+  });
+});
+
+describe('registerColorGlRenderEffects', () => {
+  it('is a function', () => {
+    expect(typeof registerColorGlRenderEffects).toBe('function');
+  });
+
+  it('registers BrightnessContrastEffect and GrayscaleEffect runners', () => {
+    const state = {} as never;
+    registerColorGlRenderEffects(state);
+    expect(hasGlRenderEffectRunner(state, 'BrightnessContrastEffect')).toBe(true);
+    expect(hasGlRenderEffectRunner(state, 'GrayscaleEffect')).toBe(true);
+  });
+
+  it('does not register DitherEffect (moved to stylize band)', () => {
+    const state = {} as never;
+    registerColorGlRenderEffects(state);
+    expect(hasGlRenderEffectRunner(state, 'DitherEffect')).toBe(false);
+  });
+});
+
+describe('registerColorGradeGlRenderEffects', () => {
+  it('is a function', () => {
+    expect(typeof registerColorGradeGlRenderEffects).toBe('function');
+  });
+
+  it('registers BrightnessContrastEffect and GrayscaleEffect runners', () => {
+    const state = {} as never;
+    registerColorGradeGlRenderEffects(state);
+    expect(hasGlRenderEffectRunner(state, 'BrightnessContrastEffect')).toBe(true);
+    expect(hasGlRenderEffectRunner(state, 'GrayscaleEffect')).toBe(true);
+  });
+});
+
+describe('registerCustomShaderGlRenderEffect', () => {
+  it('is a function', () => {
+    expect(typeof registerCustomShaderGlRenderEffect).toBe('function');
+  });
+
+  it('registers the CustomShaderEffect runner', () => {
+    const state = {} as never;
+    registerCustomShaderGlRenderEffect(state);
+    expect(hasGlRenderEffectRunner(state, 'CustomShaderEffect')).toBe(true);
+  });
+});
+
+describe('registerDefaultGlRenderEffects', () => {
+  it('is a function', () => {
+    expect(typeof registerDefaultGlRenderEffects).toBe('function');
+  });
+
+  it('registers a runner for every kind returned by getGlRenderEffectKinds', () => {
+    const state = {} as never;
+    registerDefaultGlRenderEffects(state);
+    for (const kind of getGlRenderEffectKinds()) {
+      expect(hasGlRenderEffectRunner(state, kind)).toBe(true);
+    }
+  });
+});
+
+describe('registerScreenSpaceGlRenderEffects', () => {
+  it('is a function', () => {
+    expect(typeof registerScreenSpaceGlRenderEffects).toBe('function');
+  });
+
+  it('registers DisplacementEffect and SsaoEffect runners', () => {
+    const state = {} as never;
+    registerScreenSpaceGlRenderEffects(state);
+    expect(hasGlRenderEffectRunner(state, 'DisplacementEffect')).toBe(true);
+    expect(hasGlRenderEffectRunner(state, 'SsaoEffect')).toBe(true);
+  });
+});
+
+describe('registerStandardGlRenderEffects', () => {
+  it('is a function', () => {
+    expect(typeof registerStandardGlRenderEffects).toBe('function');
+  });
+
+  it('registers a runner for every kind returned by getGlRenderEffectKinds', () => {
+    const state = {} as never;
+    registerStandardGlRenderEffects(state);
+    for (const kind of getGlRenderEffectKinds()) {
+      expect(hasGlRenderEffectRunner(state, kind)).toBe(true);
+    }
+  });
+});
+
+describe('registerStylizeGlRenderEffects', () => {
+  it('is a function', () => {
+    expect(typeof registerStylizeGlRenderEffects).toBe('function');
+  });
+
+  it('registers DitherEffect and FilmGrainEffect runners', () => {
+    const state = {} as never;
+    registerStylizeGlRenderEffects(state);
+    expect(hasGlRenderEffectRunner(state, 'DitherEffect')).toBe(true);
+    expect(hasGlRenderEffectRunner(state, 'FilmGrainEffect')).toBe(true);
+  });
+
+  it('does not register VignetteEffect (moved to bloom band)', () => {
+    const state = {} as never;
+    registerStylizeGlRenderEffects(state);
+    expect(hasGlRenderEffectRunner(state, 'VignetteEffect')).toBe(false);
+  });
+});

package/src/glRenderEffectRegistry.test.ts

@@ -0,0 +1,52 @@
+import { getGlRenderEffectRunner, hasGlRenderEffectRunner, registerGlRenderEffect } from './glRenderEffectRegistry';
+
+describe('getGlRenderEffectRunner', () => {
+  it('is a function', () => {
+    expect(typeof getGlRenderEffectRunner).toBe('function');
+  });
+
+  it('returns null for an unregistered kind', () => {
+    const fakeState = {} as never;
+    expect(getGlRenderEffectRunner(fakeState, 'UnknownEffect')).toBeNull();
+  });
+});
+
+describe('hasGlRenderEffectRunner', () => {
+  it('is a function', () => {
+    expect(typeof hasGlRenderEffectRunner).toBe('function');
+  });
+
+  it('returns false for an unregistered kind', () => {
+    const fakeState = {} as never;
+    expect(hasGlRenderEffectRunner(fakeState, 'NotRegisteredEffect')).toBe(false);
+  });
+
+  it('returns true after a runner is registered', () => {
+    const fakeState = {} as never;
+    const runner = vi.fn();
+    registerGlRenderEffect(fakeState, 'HasTestEffect', runner);
+    expect(hasGlRenderEffectRunner(fakeState, 'HasTestEffect')).toBe(true);
+  });
+});
+
+describe('registerGlRenderEffect', () => {
+  it('is a function', () => {
+    expect(typeof registerGlRenderEffect).toBe('function');
+  });
+
+  it('registers and retrieves a runner', () => {
+    const fakeState = {} as never;
+    const runner = vi.fn();
+    registerGlRenderEffect(fakeState, 'TestEffect', runner);
+    expect(getGlRenderEffectRunner(fakeState, 'TestEffect')).toBe(runner);
+  });
+
+  it('overwrites an existing runner under the same kind', () => {
+    const fakeState = {} as never;
+    const runnerA = vi.fn();
+    const runnerB = vi.fn();
+    registerGlRenderEffect(fakeState, 'TestEffect2', runnerA);
+    registerGlRenderEffect(fakeState, 'TestEffect2', runnerB);
+    expect(getGlRenderEffectRunner(fakeState, 'TestEffect2')).toBe(runnerB);
+  });
+});

package/src/glScanlinesEffect.test.ts

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

package/src/glScreenSpaceFogEffect.test.ts

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

package/src/glSepiaEffect.test.ts

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

package/src/glSharpenEffect.test.ts

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

package/src/glSketchEffect.test.ts

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

package/src/glSmaaEffect.test.ts

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

package/src/glSsaoEffect.test.ts

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

package/src/glSsrEffect.test.ts

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

package/src/glTaaEffect.test.ts

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

package/src/glTiltShiftEffect.test.ts

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

package/src/glToneMapEffect.test.ts

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

package/src/glVignetteEffect.test.ts

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

package/src/glWhiteBalanceEffect.test.ts

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