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

package/src/glRenderTextureEffect.test.ts

@@ -0,0 +1,246 @@
+import {
+  acquireGlRenderTexture,
+  clearGlRenderTexture,
+  copyGlRenderStateRegistrations,
+  createGlOffscreenRenderState,
+  createGlRenderState,
+  createGlRenderTexturePool,
+  getGlRenderTextureTarget,
+  isGlRenderTextureReady,
+  writeGlRenderTextureTarget,
+} from '@flighthq/render-gl/contract';
+import type { GlRenderEffectRunner, GlRenderState, RenderEffect } from '@flighthq/types/contract';
+
+import { applyGaussianBlurToGlRenderTextures } from './glBlurEffect';
+import { getGlRenderEffectRunner, registerGlRenderEffect } from './glRenderEffectRegistry';
+import {
+  applyGlRenderEffectsToRenderTexture,
+  explainGlRenderEffectApplication,
+  setGlRenderEffectApplicationGuard,
+} from './glRenderTextureEffect';
+
+describe('applyGaussianBlurToGlRenderTextures', () => {
+  it('publishes destination and scratch RenderTextures after the two Gaussian target passes', () => {
+    const state = createState();
+    const pool = createGlRenderTexturePool();
+    const source = acquireGlRenderTexture(state, pool, { width: 16, height: 12 });
+    const dest = acquireGlRenderTexture(state, pool, { width: 16, height: 12 });
+    const scratch = acquireGlRenderTexture(state, pool, { width: 16, height: 12 });
+    writeGlRenderTextureTarget(state, source, () => {});
+
+    expect(applyGaussianBlurToGlRenderTextures(state, source, dest, scratch, { blurX: 2, blurY: 3 })).toBe(true);
+    expect(isGlRenderTextureReady(state, dest)).toBe(true);
+    expect(isGlRenderTextureReady(state, scratch)).toBe(true);
+    expect(dest.version).toBe(1);
+    expect(scratch.version).toBe(1);
+  });
+});
+
+describe('applyGlRenderEffectsToRenderTexture', () => {
+  it('ping-pongs registered effects so an even chain still finishes in the destination lease', () => {
+    const state = createState();
+    const pool = createGlRenderTexturePool();
+    const source = acquireGlRenderTexture(state, pool, { width: 8, height: 8 });
+    const dest = acquireGlRenderTexture(state, pool, { width: 8, height: 8 });
+    const scratch = acquireGlRenderTexture(state, pool, { width: 8, height: 8 });
+    writeGlRenderTextureTarget(state, source, () => {});
+    const first: GlRenderEffectRunner = vi.fn();
+    const second: GlRenderEffectRunner = vi.fn();
+    registerGlRenderEffect(state, 'acme.First', first);
+    registerGlRenderEffect(state, 'acme.Second', second);
+
+    expect(
+      applyGlRenderEffectsToRenderTexture(state, pool, source, dest, scratch, [
+        { kind: 'acme.First' },
+        { kind: 'acme.Second' },
+      ]),
+    ).toBe(true);
+
+    expect(first).toHaveBeenCalledOnce();
+    expect(second).toHaveBeenCalledOnce();
+    expect(vi.mocked(first).mock.calls[0][0].dest).toBe(getGlRenderTextureTarget(state, scratch));
+    expect(vi.mocked(second).mock.calls[0][0].dest).toBe(getGlRenderTextureTarget(state, dest));
+    expect(isGlRenderTextureReady(state, dest)).toBe(true);
+  });
+
+  it('leaves the destination unpublished when no effect kind is registered', () => {
+    const state = createState();
+    const pool = createGlRenderTexturePool();
+    const source = acquireGlRenderTexture(state, pool, { width: 8, height: 8 });
+    const dest = acquireGlRenderTexture(state, pool, { width: 8, height: 8 });
+    const scratch = acquireGlRenderTexture(state, pool, { width: 8, height: 8 });
+    writeGlRenderTextureTarget(state, source, () => {});
+
+    expect(applyGlRenderEffectsToRenderTexture(state, pool, source, dest, scratch, [{ kind: 'acme.Missing' }])).toBe(
+      false,
+    );
+    expect(isGlRenderTextureReady(state, dest)).toBe(false);
+  });
+
+  it('is byte-stable across constant-input frames only when reused destinations are cleared', () => {
+    const state = createState();
+    const pool = createGlRenderTexturePool();
+    const source = acquireGlRenderTexture(state, pool, { width: 1, height: 1 });
+    const dest = acquireGlRenderTexture(state, pool, { width: 1, height: 1 });
+    const scratch = acquireGlRenderTexture(state, pool, { width: 1, height: 1 });
+    const constantSource = Uint8Array.from([64, 32, 16, 128]);
+    let destinationPixel: Uint8Array = new Uint8Array(4);
+    let clearObserved = false;
+    vi.mocked(state.gl.clear).mockImplementation(() => {
+      clearObserved = true;
+    });
+    registerGlRenderEffect(state, 'test.constant-frame', () => {
+      if (clearObserved) {
+        destinationPixel.fill(0);
+        clearObserved = false;
+      }
+      destinationPixel = compositePremultipliedPixel(destinationPixel, constantSource);
+    });
+    writeGlRenderTextureTarget(state, source, () => {});
+    const effect = effects(['test.constant-frame']);
+
+    const clearedFrames = Array.from({ length: 4 }, () => {
+      clearGlRenderTexture(state, dest);
+      expect(applyGlRenderEffectsToRenderTexture(state, pool, source, dest, scratch, effect)).toBe(true);
+      return Array.from(destinationPixel);
+    });
+
+    destinationPixel.fill(0);
+    clearObserved = false;
+    const accumulatedFrames = Array.from({ length: 4 }, () => {
+      expect(applyGlRenderEffectsToRenderTexture(state, pool, source, dest, scratch, effect)).toBe(true);
+      return Array.from(destinationPixel);
+    });
+
+    expect(clearedFrames).toEqual(Array.from({ length: 4 }, () => [64, 32, 16, 128]));
+    expect(accumulatedFrames).toEqual([
+      [64, 32, 16, 128],
+      [96, 48, 24, 192],
+      [112, 56, 28, 224],
+      [120, 60, 30, 240],
+    ]);
+  });
+});
+
+describe('explainGlRenderEffectApplication', () => {
+  it('separates an empty chain from one whose effects are all unregistered', () => {
+    const state = createState();
+    // Both return false from the apply path, but only the second is a registration miss.
+    expect(explainGlRenderEffectApplication(state, [], true).status).toBe('no-effects');
+    expect(explainGlRenderEffectApplication(state, effects(['test.explain-a']), true).status).toBe(
+      'unregistered-effects',
+    );
+  });
+
+  it('reports partial registration, the case that SUCCEEDS while dropping effects', () => {
+    const state = createState();
+    registerGlRenderEffect(state, 'test.explain-b', () => {});
+    const explanation = explainGlRenderEffectApplication(state, effects(['test.explain-b', 'test.explain-c']), true);
+    expect(explanation).toEqual({
+      registeredCount: 1,
+      requestedCount: 2,
+      status: 'partial-registration',
+      unregisteredKinds: ['test.explain-c'],
+    });
+  });
+
+  it('blames an unrealized source ahead of registration, since it explains a false return either way', () => {
+    const state = createState();
+    registerGlRenderEffect(state, 'test.explain-d', () => {});
+    expect(explainGlRenderEffectApplication(state, effects(['test.explain-d']), false).status).toBe(
+      'source-unavailable',
+    );
+  });
+
+  it('reports a fully registered chain as complete', () => {
+    const state = createState();
+    registerGlRenderEffect(state, 'test.explain-e', () => {});
+    expect(explainGlRenderEffectApplication(state, effects(['test.explain-e']), true).status).toBe('complete');
+  });
+
+  it('reports a ready destination as stale when a failed call cannot replace it', () => {
+    const state = createState();
+    expect(explainGlRenderEffectApplication(state, effects(['test.explain-f']), true, true).status).toBe(
+      'stale-destination',
+    );
+    registerGlRenderEffect(state, 'test.explain-g', () => {});
+    expect(explainGlRenderEffectApplication(state, effects(['test.explain-g']), false, true).status).toBe(
+      'stale-destination',
+    );
+  });
+});
+
+function createState(): GlRenderState {
+  const canvas = document.createElement('canvas');
+  canvas.width = 32;
+  canvas.height = 24;
+  return createGlRenderState(canvas);
+}
+
+describe('offscreen effect registration snapshots', () => {
+  it('copies registered runners at derivation and requires explicit re-copy for later runners', () => {
+    const screen = createState();
+    const first: GlRenderEffectRunner = vi.fn();
+    const later: GlRenderEffectRunner = vi.fn();
+    registerGlRenderEffect(screen, 'acme.First', first);
+    const offscreen = createGlOffscreenRenderState(screen);
+    registerGlRenderEffect(screen, 'acme.Later', later);
+
+    expect(getGlRenderEffectRunner(offscreen, 'acme.First')).toBe(first);
+    expect(getGlRenderEffectRunner(offscreen, 'acme.Later')).toBeNull();
+
+    copyGlRenderStateRegistrations(offscreen, screen);
+    expect(getGlRenderEffectRunner(offscreen, 'acme.Later')).toBe(later);
+  });
+});
+
+describe('setGlRenderEffectApplicationGuard', () => {
+  it('reports only the sentinel outcomes, and stops once cleared', () => {
+    const state = createState();
+    const seen: string[] = [];
+    setGlRenderEffectApplicationGuard(state, (_s, explanation) => seen.push(explanation.status));
+    const pool = createGlRenderTexturePool();
+    const source = acquireGlRenderTexture(state, pool, { width: 8, height: 8 });
+    const dest = acquireGlRenderTexture(state, pool, { width: 8, height: 8 });
+    const scratch = acquireGlRenderTexture(state, pool, { width: 8, height: 8 });
+    writeGlRenderTextureTarget(state, source, () => {});
+
+    applyGlRenderEffectsToRenderTexture(state, pool, source, dest, scratch, effects(['test.guard-a']));
+    applyGlRenderEffectsToRenderTexture(state, pool, source, dest, scratch, []);
+    expect(seen).toEqual(['unregistered-effects']);
+
+    setGlRenderEffectApplicationGuard(state, null);
+    applyGlRenderEffectsToRenderTexture(state, pool, source, dest, scratch, effects(['test.guard-b']));
+    expect(seen).toEqual(['unregistered-effects']);
+  });
+
+  it('reports a previously published destination as stale when no runner can replace it', () => {
+    const state = createState();
+    const seen: string[] = [];
+    setGlRenderEffectApplicationGuard(state, (_s, explanation) => seen.push(explanation.status));
+    const pool = createGlRenderTexturePool();
+    const source = acquireGlRenderTexture(state, pool, { width: 8, height: 8 });
+    const dest = acquireGlRenderTexture(state, pool, { width: 8, height: 8 });
+    const scratch = acquireGlRenderTexture(state, pool, { width: 8, height: 8 });
+    writeGlRenderTextureTarget(state, source, () => {});
+    writeGlRenderTextureTarget(state, dest, () => {});
+
+    expect(applyGlRenderEffectsToRenderTexture(state, pool, source, dest, scratch, effects(['test.guard-stale']))).toBe(
+      false,
+    );
+    expect(seen).toEqual(['stale-destination']);
+  });
+});
+
+function effects(kinds: readonly string[]): ReadonlyArray<Readonly<RenderEffect>> {
+  return kinds.map((kind) => ({ kind }) as unknown as Readonly<RenderEffect>);
+}
+
+function compositePremultipliedPixel(destination: Uint8Array, source: Uint8Array): Uint8Array {
+  const result = new Uint8Array(4);
+  const destinationScale = 1 - source[3] / 255;
+  for (let channel = 0; channel < 4; channel++) {
+    result[channel] = Math.round(source[channel] + destination[channel] * destinationScale);
+  }
+  return result;
+}

package/src/glScanlinesEffect.test.ts

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

package/src/glScreenSpaceFogEffect.test.ts

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

package/src/glSharpenEffect.test.ts

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

package/src/glSketchEffect.test.ts

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

package/src/glSmaaEffect.test.ts

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

package/src/glSpatialEffectRegistration.test.ts

@@ -0,0 +1,64 @@
+import { createGlRenderState } from '@flighthq/render-gl/contract';
+
+import * as contractEffects from './contract';
+import { getGlRenderEffectRunner } from './glRenderEffectRegistry';
+import * as publicEffects from './index';
+
+describe('GL effect registration', () => {
+  it.each([
+    ['BevelEffect', 'registerGlBevelEffect', 'defaultGlBevelEffectRunner'],
+    ['BlendEffect', 'registerGlBlendEffect', 'defaultGlBlendEffectRunner'],
+    ['BloomEffect', 'registerGlBloomEffect', 'defaultGlBloomEffectRunner'],
+    ['BlurEffect', 'registerGlBlurEffect', 'defaultGlBlurEffectRunner'],
+    ['BokehDepthOfFieldEffect', 'registerGlBokehDepthOfFieldEffect', 'defaultGlBokehDepthOfFieldEffectRunner'],
+    ['CameraMotionBlurEffect', 'registerGlCameraMotionBlurEffect', 'defaultGlCameraMotionBlurEffectRunner'],
+    ['ChromaticAberrationEffect', 'registerGlChromaticAberrationEffect', 'defaultGlChromaticAberrationEffectRunner'],
+    ['CompositeEffect', 'registerGlCompositeEffect', 'defaultGlCompositeEffectRunner'],
+    ['ContactShadowsEffect', 'registerGlContactShadowsEffect', 'defaultGlContactShadowsEffectRunner'],
+    ['ConvolutionEffect', 'registerGlConvolutionEffect', 'defaultGlConvolutionEffectRunner'],
+    ['CrtEffect', 'registerGlCrtEffect', 'defaultGlCrtEffectRunner'],
+    ['CustomShaderEffect', 'registerGlCustomShaderEffect', 'defaultGlCustomShaderEffectRunner'],
+    ['DirectionalBlurEffect', 'registerGlDirectionalBlurEffect', 'defaultGlDirectionalBlurEffectRunner'],
+    ['DisplacementEffect', 'registerGlDisplacementEffect', 'defaultGlDisplacementEffectRunner'],
+    ['DitherEffect', 'registerGlDitherEffect', 'defaultGlDitherEffectRunner'],
+    ['DropShadowEffect', 'registerGlDropShadowEffect', 'defaultGlDropShadowEffectRunner'],
+    ['FilmGrainEffect', 'registerGlFilmGrainEffect', 'defaultGlFilmGrainEffectRunner'],
+    ['FxaaEffect', 'registerGlFxaaEffect', 'defaultGlFxaaEffectRunner'],
+    ['GlitchEffect', 'registerGlGlitchEffect', 'defaultGlGlitchEffectRunner'],
+    ['GodRaysEffect', 'registerGlGodRaysEffect', 'defaultGlGodRaysEffectRunner'],
+    ['GradientBevelEffect', 'registerGlGradientBevelEffect', 'defaultGlGradientBevelEffectRunner'],
+    ['GradientGlowEffect', 'registerGlGradientGlowEffect', 'defaultGlGradientGlowEffectRunner'],
+    ['HalftoneEffect', 'registerGlHalftoneEffect', 'defaultGlHalftoneEffectRunner'],
+    ['InnerGlowEffect', 'registerGlInnerGlowEffect', 'defaultGlInnerGlowEffectRunner'],
+    ['InnerShadowEffect', 'registerGlInnerShadowEffect', 'defaultGlInnerShadowEffectRunner'],
+    ['KuwaharaEffect', 'registerGlKuwaharaEffect', 'defaultGlKuwaharaEffectRunner'],
+    ['LensDirtEffect', 'registerGlLensDirtEffect', 'defaultGlLensDirtEffectRunner'],
+    ['LensDistortionEffect', 'registerGlLensDistortionEffect', 'defaultGlLensDistortionEffectRunner'],
+    ['LensFlareEffect', 'registerGlLensFlareEffect', 'defaultGlLensFlareEffectRunner'],
+    ['MedianEffect', 'registerGlMedianEffect', 'defaultGlMedianEffectRunner'],
+    ['MotionBlurEffect', 'registerGlMotionBlurEffect', 'defaultGlMotionBlurEffectRunner'],
+    ['OuterGlowEffect', 'registerGlOuterGlowEffect', 'defaultGlOuterGlowEffectRunner'],
+    ['OutlineEffect', 'registerGlOutlineEffect', 'defaultGlOutlineEffectRunner'],
+    ['PixelateEffect', 'registerGlPixelateEffect', 'defaultGlPixelateEffectRunner'],
+    ['PosterizeEffect', 'registerGlPosterizeEffect', 'defaultGlPosterizeEffectRunner'],
+    ['RadialBlurEffect', 'registerGlRadialBlurEffect', 'defaultGlRadialBlurEffectRunner'],
+    ['ScanlinesEffect', 'registerGlScanlinesEffect', 'defaultGlScanlinesEffectRunner'],
+    ['ScreenSpaceFogEffect', 'registerGlScreenSpaceFogEffect', 'defaultGlScreenSpaceFogEffectRunner'],
+    ['SharpenEffect', 'registerGlSharpenEffect', 'defaultGlSharpenEffectRunner'],
+    ['SketchEffect', 'registerGlSketchEffect', 'defaultGlSketchEffectRunner'],
+    ['SmaaEffect', 'registerGlSmaaEffect', 'defaultGlSmaaEffectRunner'],
+    ['SsaoEffect', 'registerGlSsaoEffect', 'defaultGlSsaoEffectRunner'],
+    ['TiltShiftEffect', 'registerGlTiltShiftEffect', 'defaultGlTiltShiftEffectRunner'],
+    ['ToneMapEffect', 'registerGlToneMapEffect', 'defaultGlToneMapEffectRunner'],
+    ['VignetteEffect', 'registerGlVignetteEffect', 'defaultGlVignetteEffectRunner'],
+    ['WhiteBalanceEffect', 'registerGlWhiteBalanceEffect', 'defaultGlWhiteBalanceEffectRunner'],
+  ] as const)('registers the public %s runner on only the supplied state', (kind, registerName, runnerName) => {
+    const state = createGlRenderState(document.createElement('canvas'));
+    const other = createGlRenderState(document.createElement('canvas'));
+
+    publicEffects[registerName](state);
+
+    expect(getGlRenderEffectRunner(state, kind)).toBe(contractEffects[runnerName]);
+    expect(getGlRenderEffectRunner(other, kind)).toBeNull();
+  });
+});

package/src/glSsaoEffect.test.ts

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

package/src/glTiltShiftEffect.test.ts

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

package/src/glToneMapEffect.test.ts

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

package/src/glVignetteEffect.test.ts

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

package/src/glWhiteBalanceEffect.test.ts

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

package/dist/glSsrEffect.d.ts

@@ -1,4 +0,0 @@
-import type { GlRenderEffectRunner, GlRenderState, GlRenderTarget, SsrEffect } from '@flighthq/types/contract';
-export declare function applySsrEffectToGl(state: GlRenderState, source: Readonly<GlRenderTarget>, dest: Readonly<GlRenderTarget>, effect: Readonly<SsrEffect>): void;
-export declare const defaultGlSsrEffectRunner: GlRenderEffectRunner;
-//# sourceMappingURL=glSsrEffect.d.ts.map

package/dist/glSsrEffect.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"glSsrEffect.d.ts","sourceRoot":"","sources":["../src/glSsrEffect.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,aAAa,EAAE,cAAc,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AAQ/G,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,aAAa,EACpB,MAAM,EAAE,QAAQ,CAAC,cAAc,CAAC,EAChC,IAAI,EAAE,QAAQ,CAAC,cAAc,CAAC,EAE9B,MAAM,EAAE,QAAQ,CAAC,SAAS,CAAC,GAC1B,IAAI,CAGN;AAED,eAAO,MAAM,wBAAwB,EAAE,oBAEtC,CAAC"}

package/dist/glSsrEffect.js

@@ -1,24 +0,0 @@
-import { drawGlFullscreenPass } from '@flighthq/render-gl/contract';
-import { getGlEffectProgram } from './glEffectProgramCache';
-// SSR: screen-space reflections. The real recipe ray-marches reflected rays against a sampleable DEPTH
-// buffer using view-space normals, walking `steps` increments up to `maxDistance` at the given
-// `resolution`; depth and normals are absent in the color-only context, so this is a passthrough copy
-// that preserves the pipeline scene2d. maxDistance/resolution/steps are reserved for the depth-driven recipe.
-export function applySsrEffectToGl(state, source, dest, 
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-effect) {
-    const program = getGlEffectProgram(state, 'atmospheric.ssr', SSR_FRAGMENT_SRC);
-    drawGlFullscreenPass(state, program, [source.texture], dest, () => { });
-}
-export const defaultGlSsrEffectRunner = (ctx, effect) => {
-    applySsrEffectToGl(ctx.state, ctx.source, ctx.dest, effect);
-};
-const SSR_FRAGMENT_SRC = `#version 300 es
-precision highp float;
-in vec2 v_texCoord;
-uniform sampler2D u_texture0;
-out vec4 o_color;
-void main() {
-  o_color = texture(u_texture0, v_texCoord);
-}`;
-//# sourceMappingURL=glSsrEffect.js.map

package/dist/glSsrEffect.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"glSsrEffect.js","sourceRoot":"","sources":["../src/glSsrEffect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AAGpE,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAE5D,uGAAuG;AACvG,+FAA+F;AAC/F,sGAAsG;AACtG,8GAA8G;AAC9G,MAAM,UAAU,kBAAkB,CAChC,KAAoB,EACpB,MAAgC,EAChC,IAA8B;AAC9B,6DAA6D;AAC7D,MAA2B;IAE3B,MAAM,OAAO,GAAG,kBAAkB,CAAC,KAAK,EAAE,iBAAiB,EAAE,gBAAgB,CAAC,CAAC;IAC/E,oBAAoB,CAAC,KAAK,EAAE,OAAO,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,IAAI,EAAE,GAAG,EAAE,GAAE,CAAC,CAAC,CAAC;AACzE,CAAC;AAED,MAAM,CAAC,MAAM,wBAAwB,GAAyB,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE;IAC5E,kBAAkB,CAAC,GAAG,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,IAAI,EAAE,MAAmB,CAAC,CAAC;AAC3E,CAAC,CAAC;AAEF,MAAM,gBAAgB,GAAG;;;;;;;EAOvB,CAAC"}

package/dist/glTaaEffect.d.ts

@@ -1,4 +0,0 @@
-import type { GlRenderEffectRunner, GlRenderState, GlRenderTarget, TaaEffect } from '@flighthq/types/contract';
-export declare function applyTaaEffectToGl(state: GlRenderState, source: Readonly<GlRenderTarget>, dest: Readonly<GlRenderTarget>, _effect: Readonly<TaaEffect>): void;
-export declare const defaultGlTaaEffectRunner: GlRenderEffectRunner;
-//# sourceMappingURL=glTaaEffect.d.ts.map

package/dist/glTaaEffect.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"glTaaEffect.d.ts","sourceRoot":"","sources":["../src/glTaaEffect.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,aAAa,EAAE,cAAc,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AAO/G,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,aAAa,EACpB,MAAM,EAAE,QAAQ,CAAC,cAAc,CAAC,EAChC,IAAI,EAAE,QAAQ,CAAC,cAAc,CAAC,EAC9B,OAAO,EAAE,QAAQ,CAAC,SAAS,CAAC,GAC3B,IAAI,CAGN;AAED,eAAO,MAAM,wBAAwB,EAAE,oBAEtC,CAAC"}

package/dist/glTaaEffect.js

@@ -1,22 +0,0 @@
-import { drawGlFullscreenPass } from '@flighthq/render-gl/contract';
-import { getGlEffectProgram } from './glEffectProgramCache';
-// TAA: passthrough copy of source → dest. Real temporal AA needs a history buffer + motion vectors to
-// reproject and accumulate prior frames; neither is available in the single-frame effect context, so
-// this is a placeholder that preserves the pipeline scene2d without altering the image.
-export function applyTaaEffectToGl(state, source, dest, _effect) {
-    const program = getGlEffectProgram(state, 'antialiasing.taa', TAA_FRAGMENT_SRC);
-    drawGlFullscreenPass(state, program, [source.texture], dest, _noopSetUniforms);
-}
-export const defaultGlTaaEffectRunner = (ctx, effect) => {
-    applyTaaEffectToGl(ctx.state, ctx.source, ctx.dest, effect);
-};
-function _noopSetUniforms() { }
-const TAA_FRAGMENT_SRC = `#version 300 es
-precision highp float;
-in vec2 v_texCoord;
-uniform sampler2D u_texture0;
-out vec4 o_color;
-void main() {
-  o_color = texture(u_texture0, v_texCoord);
-}`;
-//# sourceMappingURL=glTaaEffect.js.map

package/dist/glTaaEffect.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"glTaaEffect.js","sourceRoot":"","sources":["../src/glTaaEffect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AAGpE,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAE5D,sGAAsG;AACtG,qGAAqG;AACrG,wFAAwF;AACxF,MAAM,UAAU,kBAAkB,CAChC,KAAoB,EACpB,MAAgC,EAChC,IAA8B,EAC9B,OAA4B;IAE5B,MAAM,OAAO,GAAG,kBAAkB,CAAC,KAAK,EAAE,kBAAkB,EAAE,gBAAgB,CAAC,CAAC;IAChF,oBAAoB,CAAC,KAAK,EAAE,OAAO,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,IAAI,EAAE,gBAAgB,CAAC,CAAC;AACjF,CAAC;AAED,MAAM,CAAC,MAAM,wBAAwB,GAAyB,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE;IAC5E,kBAAkB,CAAC,GAAG,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,IAAI,EAAE,MAAmB,CAAC,CAAC;AAC3E,CAAC,CAAC;AAEF,SAAS,gBAAgB,KAAU,CAAC;AAEpC,MAAM,gBAAgB,GAAG;;;;;;;EAOvB,CAAC"}

package/src/glSsrEffect.test.ts

@@ -1,13 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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');
-  });
-});