@flighthq/effects-gl 0.3.0-next.906.07cea63 → 0.3.0

package/src/glGodRaysEffect.test.ts

@@ -1,4 +1,4 @@
-import { applyGodRaysEffectToGl, defaultGlGodRaysEffectRunner } from './glGodRaysEffect';
+import { applyGodRaysEffectToGl, defaultGlGodRaysEffectRunner, registerGlGodRaysEffect } from './glGodRaysEffect';
 
 describe('applyGodRaysEffectToGl', () => {
   it('is a function', () => {
@@ -11,3 +11,9 @@ describe('defaultGlGodRaysEffectRunner', () => {
     expect(typeof defaultGlGodRaysEffectRunner).toBe('function');
   });
 });
+
+describe('registerGlGodRaysEffect', () => {
+  it('is a separately importable registration primitive', () => {
+    expect(registerGlGodRaysEffect).toBeTypeOf('function');
+  });
+});

package/src/glGradientBevelEffect.test.ts

@@ -1,4 +1,8 @@
-import { applyGradientBevelEffectToGl, defaultGlGradientBevelEffectRunner } from './glGradientBevelEffect';
+import {
+  applyGradientBevelEffectToGl,
+  defaultGlGradientBevelEffectRunner,
+  registerGlGradientBevelEffect,
+} from './glGradientBevelEffect';
 
 describe('applyGradientBevelEffectToGl', () => {
   it('is a function', () => {
@@ -11,3 +15,9 @@ describe('defaultGlGradientBevelEffectRunner', () => {
     expect(typeof defaultGlGradientBevelEffectRunner).toBe('function');
   });
 });
+
+describe('registerGlGradientBevelEffect', () => {
+  it('is a separately importable registration primitive', () => {
+    expect(registerGlGradientBevelEffect).toBeTypeOf('function');
+  });
+});

package/src/glGradientGlowEffect.test.ts

@@ -1,4 +1,8 @@
-import { applyGradientGlowEffectToGl, defaultGlGradientGlowEffectRunner } from './glGradientGlowEffect';
+import {
+  applyGradientGlowEffectToGl,
+  defaultGlGradientGlowEffectRunner,
+  registerGlGradientGlowEffect,
+} from './glGradientGlowEffect';
 
 describe('applyGradientGlowEffectToGl', () => {
   it('is a function', () => {
@@ -11,3 +15,9 @@ describe('defaultGlGradientGlowEffectRunner', () => {
     expect(typeof defaultGlGradientGlowEffectRunner).toBe('function');
   });
 });
+
+describe('registerGlGradientGlowEffect', () => {
+  it('is a separately importable registration primitive', () => {
+    expect(registerGlGradientGlowEffect).toBeTypeOf('function');
+  });
+});

package/src/glHalftoneEffect.test.ts

@@ -1,4 +1,4 @@
-import { applyHalftoneEffectToGl, defaultGlHalftoneEffectRunner } from './glHalftoneEffect';
+import { applyHalftoneEffectToGl, defaultGlHalftoneEffectRunner, registerGlHalftoneEffect } from './glHalftoneEffect';
 
 describe('applyHalftoneEffectToGl', () => {
   it('is a function', () => {
@@ -11,3 +11,9 @@ describe('defaultGlHalftoneEffectRunner', () => {
     expect(typeof defaultGlHalftoneEffectRunner).toBe('function');
   });
 });
+
+describe('registerGlHalftoneEffect', () => {
+  it('is a separately importable registration primitive', () => {
+    expect(registerGlHalftoneEffect).toBeTypeOf('function');
+  });
+});

package/src/glInnerGlowEffect.test.ts

@@ -33,7 +33,11 @@ import { drawGlFullscreenPass } from '@flighthq/render-gl/contract';
 
 import { applyGlEffectBlitPass } from './glEffectBlitShader';
 import { applyGlEffectBoxBlur } from './glEffectBoxBlur';
-import { applyInnerGlowEffectToGl, defaultGlInnerGlowEffectRunner } from './glInnerGlowEffect';
+import {
+  applyInnerGlowEffectToGl,
+  defaultGlInnerGlowEffectRunner,
+  registerGlInnerGlowEffect,
+} from './glInnerGlowEffect';
 
 describe('applyInnerGlowEffectToGl', () => {
   it('is a function', () => {
@@ -124,14 +128,6 @@ 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;
 }
@@ -143,3 +139,9 @@ function createPool(): never {
 function createTarget(id: string): never {
   return { id, width: 32, height: 16, format: 'rgba8', texture: {} } as never;
 }
+
+describe('registerGlInnerGlowEffect', () => {
+  it('is a separately importable registration primitive', () => {
+    expect(registerGlInnerGlowEffect).toBeTypeOf('function');
+  });
+});

package/src/glInnerShadowEffect.test.ts

@@ -34,7 +34,11 @@ import { drawGlFullscreenPass } from '@flighthq/render-gl/contract';
 
 import { applyGlEffectBlitPass } from './glEffectBlitShader';
 import { applyGlEffectBoxBlur } from './glEffectBoxBlur';
-import { applyInnerShadowEffectToGl, defaultGlInnerShadowEffectRunner } from './glInnerShadowEffect';
+import {
+  applyInnerShadowEffectToGl,
+  defaultGlInnerShadowEffectRunner,
+  registerGlInnerShadowEffect,
+} from './glInnerShadowEffect';
 
 describe('applyInnerShadowEffectToGl', () => {
   it('is a function', () => {
@@ -124,14 +128,6 @@ 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;
 }
@@ -143,3 +139,9 @@ function createPool(): never {
 function createTarget(id: string): never {
   return { id, width: 32, height: 16, format: 'rgba8', texture: {} } as never;
 }
+
+describe('registerGlInnerShadowEffect', () => {
+  it('is a separately importable registration primitive', () => {
+    expect(registerGlInnerShadowEffect).toBeTypeOf('function');
+  });
+});

package/src/glKuwaharaEffect.test.ts

@@ -1,4 +1,4 @@
-import { applyKuwaharaEffectToGl, defaultGlKuwaharaEffectRunner } from './glKuwaharaEffect';
+import { applyKuwaharaEffectToGl, defaultGlKuwaharaEffectRunner, registerGlKuwaharaEffect } from './glKuwaharaEffect';
 
 describe('applyKuwaharaEffectToGl', () => {
   it('is a function', () => {
@@ -11,3 +11,9 @@ describe('defaultGlKuwaharaEffectRunner', () => {
     expect(typeof defaultGlKuwaharaEffectRunner).toBe('function');
   });
 });
+
+describe('registerGlKuwaharaEffect', () => {
+  it('is a separately importable registration primitive', () => {
+    expect(registerGlKuwaharaEffect).toBeTypeOf('function');
+  });
+});

package/src/glLensDirtEffect.test.ts

@@ -1,4 +1,4 @@
-import { applyLensDirtEffectToGl, defaultGlLensDirtEffectRunner } from './glLensDirtEffect';
+import { applyLensDirtEffectToGl, defaultGlLensDirtEffectRunner, registerGlLensDirtEffect } from './glLensDirtEffect';
 
 describe('applyLensDirtEffectToGl', () => {
   it('is a function', () => {
@@ -11,3 +11,9 @@ describe('defaultGlLensDirtEffectRunner', () => {
     expect(typeof defaultGlLensDirtEffectRunner).toBe('function');
   });
 });
+
+describe('registerGlLensDirtEffect', () => {
+  it('is a separately importable registration primitive', () => {
+    expect(registerGlLensDirtEffect).toBeTypeOf('function');
+  });
+});

package/src/glLensDistortionEffect.test.ts

@@ -1,4 +1,8 @@
-import { applyLensDistortionEffectToGl, defaultGlLensDistortionEffectRunner } from './glLensDistortionEffect';
+import {
+  applyLensDistortionEffectToGl,
+  defaultGlLensDistortionEffectRunner,
+  registerGlLensDistortionEffect,
+} from './glLensDistortionEffect';
 
 describe('applyLensDistortionEffectToGl', () => {
   it('is a function', () => {
@@ -11,3 +15,9 @@ describe('defaultGlLensDistortionEffectRunner', () => {
     expect(typeof defaultGlLensDistortionEffectRunner).toBe('function');
   });
 });
+
+describe('registerGlLensDistortionEffect', () => {
+  it('is a separately importable registration primitive', () => {
+    expect(registerGlLensDistortionEffect).toBeTypeOf('function');
+  });
+});

package/src/glLensFlareEffect.test.ts

@@ -1,4 +1,8 @@
-import { applyLensFlareEffectToGl, defaultGlLensFlareEffectRunner } from './glLensFlareEffect';
+import {
+  applyLensFlareEffectToGl,
+  defaultGlLensFlareEffectRunner,
+  registerGlLensFlareEffect,
+} from './glLensFlareEffect';
 
 describe('applyLensFlareEffectToGl', () => {
   it('is a function', () => {
@@ -11,3 +15,9 @@ describe('defaultGlLensFlareEffectRunner', () => {
     expect(typeof defaultGlLensFlareEffectRunner).toBe('function');
   });
 });
+
+describe('registerGlLensFlareEffect', () => {
+  it('is a separately importable registration primitive', () => {
+    expect(registerGlLensFlareEffect).toBeTypeOf('function');
+  });
+});

package/src/glMedianEffect.test.ts

@@ -1,4 +1,4 @@
-import { applyMedianEffectToGl, defaultGlMedianEffectRunner } from './glMedianEffect';
+import { applyMedianEffectToGl, defaultGlMedianEffectRunner, registerGlMedianEffect } from './glMedianEffect';
 
 describe('applyMedianEffectToGl', () => {
   it('is a function', () => {
@@ -11,3 +11,9 @@ describe('defaultGlMedianEffectRunner', () => {
     expect(typeof defaultGlMedianEffectRunner).toBe('function');
   });
 });
+
+describe('registerGlMedianEffect', () => {
+  it('is a separately importable registration primitive', () => {
+    expect(registerGlMedianEffect).toBeTypeOf('function');
+  });
+});

package/src/glMotionBlurEffect.test.ts

@@ -1,4 +1,8 @@
-import { applyMotionBlurEffectToGl, defaultGlMotionBlurEffectRunner } from './glMotionBlurEffect';
+import {
+  applyMotionBlurEffectToGl,
+  defaultGlMotionBlurEffectRunner,
+  registerGlMotionBlurEffect,
+} from './glMotionBlurEffect';
 
 describe('applyMotionBlurEffectToGl', () => {
   it('is a function', () => {
@@ -11,3 +15,9 @@ describe('defaultGlMotionBlurEffectRunner', () => {
     expect(typeof defaultGlMotionBlurEffectRunner).toBe('function');
   });
 });
+
+describe('registerGlMotionBlurEffect', () => {
+  it('is a separately importable registration primitive', () => {
+    expect(registerGlMotionBlurEffect).toBeTypeOf('function');
+  });
+});

package/src/glOuterGlowEffect.test.ts

@@ -29,7 +29,11 @@ vi.mock('./glEffectTintShader', () => ({
 }));
 
 import { applyGlEffectBlitPass, applyGlEffectErasePass } from './glEffectBlitShader';
-import { applyOuterGlowEffectToGl, defaultGlOuterGlowEffectRunner } from './glOuterGlowEffect';
+import {
+  applyOuterGlowEffectToGl,
+  defaultGlOuterGlowEffectRunner,
+  registerGlOuterGlowEffect,
+} from './glOuterGlowEffect';
 
 describe('applyOuterGlowEffectToGl', () => {
   it('is a function', () => {
@@ -83,14 +87,6 @@ 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;
 }
@@ -102,3 +98,9 @@ function createPool(): never {
 function createTarget(id: string): never {
   return { id, width: 32, height: 16, format: 'rgba8', texture: {} } as never;
 }
+
+describe('registerGlOuterGlowEffect', () => {
+  it('is a separately importable registration primitive', () => {
+    expect(registerGlOuterGlowEffect).toBeTypeOf('function');
+  });
+});

package/src/glOutlineEffect.test.ts

@@ -1,4 +1,4 @@
-import { applyOutlineEffectToGl, defaultGlOutlineEffectRunner } from './glOutlineEffect';
+import { applyOutlineEffectToGl, defaultGlOutlineEffectRunner, registerGlOutlineEffect } from './glOutlineEffect';
 
 describe('applyOutlineEffectToGl', () => {
   it('is a function', () => {
@@ -11,3 +11,9 @@ describe('defaultGlOutlineEffectRunner', () => {
     expect(typeof defaultGlOutlineEffectRunner).toBe('function');
   });
 });
+
+describe('registerGlOutlineEffect', () => {
+  it('is a separately importable registration primitive', () => {
+    expect(registerGlOutlineEffect).toBeTypeOf('function');
+  });
+});

package/src/glPixelateEffect.test.ts

@@ -1,4 +1,4 @@
-import { applyPixelateEffectToGl, defaultGlPixelateEffectRunner } from './glPixelateEffect';
+import { applyPixelateEffectToGl, defaultGlPixelateEffectRunner, registerGlPixelateEffect } from './glPixelateEffect';
 
 describe('applyPixelateEffectToGl', () => {
   it('is a function', () => {
@@ -11,3 +11,9 @@ describe('defaultGlPixelateEffectRunner', () => {
     expect(typeof defaultGlPixelateEffectRunner).toBe('function');
   });
 });
+
+describe('registerGlPixelateEffect', () => {
+  it('is a separately importable registration primitive', () => {
+    expect(registerGlPixelateEffect).toBeTypeOf('function');
+  });
+});

package/src/glPosterizeEffect.test.ts

@@ -1,4 +1,8 @@
-import { applyPosterizeEffectToGl, defaultGlPosterizeEffectRunner } from './glPosterizeEffect';
+import {
+  applyPosterizeEffectToGl,
+  defaultGlPosterizeEffectRunner,
+  registerGlPosterizeEffect,
+} from './glPosterizeEffect';
 
 describe('applyPosterizeEffectToGl', () => {
   it('is a function', () => {
@@ -11,3 +15,9 @@ describe('defaultGlPosterizeEffectRunner', () => {
     expect(typeof defaultGlPosterizeEffectRunner).toBe('function');
   });
 });
+
+describe('registerGlPosterizeEffect', () => {
+  it('is a separately importable registration primitive', () => {
+    expect(registerGlPosterizeEffect).toBeTypeOf('function');
+  });
+});

package/src/glRadialBlurEffect.test.ts

@@ -1,4 +1,8 @@
-import { applyRadialBlurEffectToGl, defaultGlRadialBlurEffectRunner } from './glRadialBlurEffect';
+import {
+  applyRadialBlurEffectToGl,
+  defaultGlRadialBlurEffectRunner,
+  registerGlRadialBlurEffect,
+} from './glRadialBlurEffect';
 
 describe('applyRadialBlurEffectToGl', () => {
   it('is a function', () => {
@@ -11,3 +15,9 @@ describe('defaultGlRadialBlurEffectRunner', () => {
     expect(typeof defaultGlRadialBlurEffectRunner).toBe('function');
   });
 });
+
+describe('registerGlRadialBlurEffect', () => {
+  it('is a separately importable registration primitive', () => {
+    expect(registerGlRadialBlurEffect).toBeTypeOf('function');
+  });
+});

package/src/glRenderEffectPipeline.test.ts

@@ -1,3 +1,5 @@
+import { createGlRenderState, endGlRenderPass } from '@flighthq/render-gl/contract';
+
 import {
   beginGlRenderEffectPipeline,
   createGlRenderEffectPipeline,
@@ -10,6 +12,19 @@ describe('beginGlRenderEffectPipeline', () => {
   it('is a function', () => {
     expect(typeof beginGlRenderEffectPipeline).toBe('function');
   });
+
+  it('redeclares the explicit color space on a reused scene target', () => {
+    const state = createGlRenderState(document.createElement('canvas'));
+    const pipeline = createGlRenderEffectPipeline(state);
+
+    beginGlRenderEffectPipeline(state, pipeline);
+    const target = pipeline.sceneTarget;
+    endGlRenderPass(state);
+    beginGlRenderEffectPipeline(state, pipeline, 'linear');
+
+    expect(pipeline.sceneTarget).toBe(target);
+    expect(target?.colorSpace).toBe('linear');
+  });
 });
 
 describe('createGlRenderEffectPipeline', () => {

package/src/glRenderEffectRegistry.test.ts

@@ -1,3 +1,6 @@
+import { createGlRenderState } from '@flighthq/render-gl/contract';
+import type { GlRenderState } from '@flighthq/types/contract';
+
 import { getGlRenderEffectRunner, hasGlRenderEffectRunner, registerGlRenderEffect } from './glRenderEffectRegistry';
 
 describe('getGlRenderEffectRunner', () => {
@@ -6,8 +9,8 @@ describe('getGlRenderEffectRunner', () => {
   });
 
   it('returns null for an unregistered kind', () => {
-    const fakeState = {} as never;
-    expect(getGlRenderEffectRunner(fakeState, 'UnknownEffect')).toBeNull();
+    const state = createState();
+    expect(getGlRenderEffectRunner(state, 'UnknownEffect')).toBeNull();
   });
 });
 
@@ -17,15 +20,15 @@ describe('hasGlRenderEffectRunner', () => {
   });
 
   it('returns false for an unregistered kind', () => {
-    const fakeState = {} as never;
-    expect(hasGlRenderEffectRunner(fakeState, 'NotRegisteredEffect')).toBe(false);
+    const state = createState();
+    expect(hasGlRenderEffectRunner(state, 'NotRegisteredEffect')).toBe(false);
   });
 
   it('returns true after a runner is registered', () => {
-    const fakeState = {} as never;
+    const state = createState();
     const runner = vi.fn();
-    registerGlRenderEffect(fakeState, 'HasTestEffect', runner);
-    expect(hasGlRenderEffectRunner(fakeState, 'HasTestEffect')).toBe(true);
+    registerGlRenderEffect(state, 'HasTestEffect', runner);
+    expect(hasGlRenderEffectRunner(state, 'HasTestEffect')).toBe(true);
   });
 });
 
@@ -35,18 +38,25 @@ describe('registerGlRenderEffect', () => {
   });
 
   it('registers and retrieves a runner', () => {
-    const fakeState = {} as never;
+    const state = createState();
     const runner = vi.fn();
-    registerGlRenderEffect(fakeState, 'TestEffect', runner);
-    expect(getGlRenderEffectRunner(fakeState, 'TestEffect')).toBe(runner);
+    registerGlRenderEffect(state, 'TestEffect', runner);
+    expect(getGlRenderEffectRunner(state, 'TestEffect')).toBe(runner);
   });
 
   it('overwrites an existing runner under the same kind', () => {
-    const fakeState = {} as never;
+    const state = createState();
     const runnerA = vi.fn();
     const runnerB = vi.fn();
-    registerGlRenderEffect(fakeState, 'TestEffect2', runnerA);
-    registerGlRenderEffect(fakeState, 'TestEffect2', runnerB);
-    expect(getGlRenderEffectRunner(fakeState, 'TestEffect2')).toBe(runnerB);
+    registerGlRenderEffect(state, 'TestEffect2', runnerA);
+    registerGlRenderEffect(state, 'TestEffect2', runnerB);
+    expect(getGlRenderEffectRunner(state, 'TestEffect2')).toBe(runnerB);
   });
 });
+
+function createState(): GlRenderState {
+  const canvas = document.createElement('canvas');
+  canvas.width = 16;
+  canvas.height = 16;
+  return createGlRenderState(canvas);
+}