@flighthq/effects-gl 0.1.0 → 0.2.1-next.410.a23f189

package/dist/glCompositeEffect.d.ts

@@ -0,0 +1,5 @@
+import type { CompositeEffect, CompositeOperator, GlRenderEffectRunner, GlRenderState, GlRenderTarget } from '@flighthq/types';
+export declare function applyCompositeEffectToGl(state: GlRenderState, source: Readonly<GlRenderTarget>, dest: Readonly<GlRenderTarget>, effect: Readonly<CompositeEffect>): void;
+export declare const defaultGlCompositeEffectRunner: GlRenderEffectRunner;
+export declare function getCompositeEffectOperatorIndex(operator: CompositeOperator): number;
+//# sourceMappingURL=glCompositeEffect.d.ts.map

package/dist/glCompositeEffect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"glCompositeEffect.d.ts","sourceRoot":"","sources":["../src/glCompositeEffect.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,eAAe,EACf,iBAAiB,EACjB,oBAAoB,EACpB,aAAa,EACb,cAAc,EACf,MAAM,iBAAiB,CAAC;AAiBzB,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,aAAa,EACpB,MAAM,EAAE,QAAQ,CAAC,cAAc,CAAC,EAChC,IAAI,EAAE,QAAQ,CAAC,cAAc,CAAC,EAC9B,MAAM,EAAE,QAAQ,CAAC,eAAe,CAAC,GAChC,IAAI,CAeN;AAED,eAAO,MAAM,8BAA8B,EAAE,oBAE5C,CAAC;AAIF,wBAAgB,+BAA+B,CAAC,QAAQ,EAAE,iBAAiB,GAAG,MAAM,CAEnF"}

package/dist/glCompositeEffect.js

@@ -0,0 +1,90 @@
+import { drawGlFullscreenPass } from '@flighthq/render-gl';
+import { CompositeOperator as CompositeOperatorValues } from '@flighthq/types';
+import { getGlBlendEffectBackdrop } from './glBlendEffect';
+import { getGlEffectProgram, getGlEffectUniformLocation } from './glEffectProgramCache';
+// Porter-Duff composite pass: sample the incoming layer (`u_texture0`, the effect's `source`) and a
+// registered backdrop (`u_texture1`), combine them with the coverage factors of the effect's `operator`
+// (`Fa*layer + Fb*backdrop` on premultiplied color), and write to `dest`. This is the GL realization of
+// the CompositeEffect — the fixed-function-cost sibling of the shader-based BlendEffect. The GLSL factor
+// formulas mirror @flighthq/effects compositeOperatorMath exactly, so the pass is verified against those
+// plain-number tests.
+//
+// The backdrop is shared with BlendEffect: looked up by the effect's `backdropKey` in the per-state
+// registry populated by registerGlBlendEffectBackdrop. A null/unregistered key composites over an implicit
+// transparent backdrop (source-over reduces to passthrough; erase/mask reduce to clear) rather than
+// erroring.
+export function applyCompositeEffectToGl(state, source, dest, effect) {
+    const backdrop = getGlBlendEffectBackdrop(state, effect.backdropKey ?? null);
+    const program = getGlEffectProgram(state, 'composite.porterduff', COMPOSITE_FRAGMENT_SRC);
+    const operatorIndex = getCompositeEffectOperatorIndex(effect.operator);
+    const hasBackdrop = backdrop !== null;
+    // Bind the layer to unit 0 and the backdrop (or the layer itself as a harmless stand-in) to unit 1;
+    // `u_hasBackdrop` gates whether unit 1 is read, so a missing backdrop composites over transparent.
+    const inputs = [source.texture, hasBackdrop ? backdrop : source.texture];
+    drawGlFullscreenPass(state, program, inputs, dest, (gl, p) => {
+        const operatorLoc = getGlEffectUniformLocation(state, p, 'u_operator');
+        const hasBackdropLoc = getGlEffectUniformLocation(state, p, 'u_hasBackdrop');
+        if (operatorLoc !== null)
+            gl.uniform1i(operatorLoc, operatorIndex);
+        if (hasBackdropLoc !== null)
+            gl.uniform1i(hasBackdropLoc, hasBackdrop ? 1 : 0);
+    });
+}
+export const defaultGlCompositeEffectRunner = (ctx, effect) => {
+    applyCompositeEffectToGl(ctx.state, ctx.source, ctx.dest, effect);
+};
+// Maps a CompositeOperator string to the integer the fragment shader switches on. Kept in lockstep with
+// the COMPOSITE_FRAGMENT_SRC branch order; an unknown (vendor) operator maps to 0 (SourceOver).
+export function getCompositeEffectOperatorIndex(operator) {
+    return COMPOSITE_OPERATOR_INDEX[operator] ?? 0;
+}
+// CompositeOperator → shader branch index. Kept in lockstep with the if-chain in COMPOSITE_FRAGMENT_SRC
+// and with the factor formulas in @flighthq/effects compositeOperatorMath.
+const COMPOSITE_OPERATOR_INDEX = {
+    [CompositeOperatorValues.SourceOver]: 0,
+    [CompositeOperatorValues.DestinationOver]: 1,
+    [CompositeOperatorValues.SourceIn]: 2,
+    [CompositeOperatorValues.DestinationIn]: 3,
+    [CompositeOperatorValues.SourceOut]: 4,
+    [CompositeOperatorValues.DestinationOut]: 5,
+    [CompositeOperatorValues.SourceAtop]: 6,
+    [CompositeOperatorValues.DestinationAtop]: 7,
+    [CompositeOperatorValues.Xor]: 8,
+    [CompositeOperatorValues.Copy]: 9,
+    [CompositeOperatorValues.Clear]: 10,
+};
+// Premultiplied Porter-Duff fragment shader. Layer = u_texture0, backdrop = u_texture1, both premultiplied.
+// The composited pixel is `Fa*layer + Fb*backdrop`, where Fa/Fb depend on the operator and the coverage
+// alphas (as = layer.a, ab = backdrop.a) — the same factors as compositeOperatorMath. Premultiplication is
+// what lets one factor pair drive rgb and a alike, so no un-premultiply is needed (unlike BlendEffect).
+const COMPOSITE_FRAGMENT_SRC = `#version 300 es
+precision highp float;
+in vec2 v_texCoord;
+uniform sampler2D u_texture0;
+uniform sampler2D u_texture1;
+uniform int u_operator;
+uniform int u_hasBackdrop;
+out vec4 o_color;
+
+void main() {
+  vec4 layer = texture(u_texture0, v_texCoord);
+  vec4 back = u_hasBackdrop == 1 ? texture(u_texture1, v_texCoord) : vec4(0.0);
+  float as = layer.a;
+  float ab = back.a;
+
+  float fa = 1.0;
+  float fb = 1.0 - as;                                              // SourceOver (0, default)
+  if (u_operator == 1) { fa = 1.0 - ab; fb = 1.0; }                 // DestinationOver
+  else if (u_operator == 2) { fa = ab; fb = 0.0; }                  // SourceIn
+  else if (u_operator == 3) { fa = 0.0; fb = as; }                  // DestinationIn
+  else if (u_operator == 4) { fa = 1.0 - ab; fb = 0.0; }            // SourceOut
+  else if (u_operator == 5) { fa = 0.0; fb = 1.0 - as; }            // DestinationOut
+  else if (u_operator == 6) { fa = ab; fb = 1.0 - as; }            // SourceAtop
+  else if (u_operator == 7) { fa = 1.0 - ab; fb = as; }            // DestinationAtop
+  else if (u_operator == 8) { fa = 1.0 - ab; fb = 1.0 - as; }      // Xor
+  else if (u_operator == 9) { fa = 1.0; fb = 0.0; }                // Copy
+  else if (u_operator == 10) { fa = 0.0; fb = 0.0; }               // Clear
+
+  o_color = fa * layer + fb * back;
+}`;
+//# sourceMappingURL=glCompositeEffect.js.map

package/dist/glCompositeEffect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"glCompositeEffect.js","sourceRoot":"","sources":["../src/glCompositeEffect.ts"],"names":[],"mappings":"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"}

package/dist/glConvolutionEffect.d.ts

@@ -0,0 +1,5 @@
+import type { ConvolutionEffect, GlRenderEffectRunner, GlRenderState, GlRenderTarget } from '@flighthq/types';
+export declare const MAX_CONVOLUTION_EFFECT_GL_KERNEL_SIZE = 49;
+export declare function applyConvolutionEffectToGl(state: GlRenderState, source: Readonly<GlRenderTarget>, dest: Readonly<GlRenderTarget>, effect: Readonly<ConvolutionEffect>): void;
+export declare const defaultGlConvolutionEffectRunner: GlRenderEffectRunner;
+//# sourceMappingURL=glConvolutionEffect.d.ts.map

package/dist/glConvolutionEffect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"glConvolutionEffect.d.ts","sourceRoot":"","sources":["../src/glConvolutionEffect.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,oBAAoB,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAM9G,eAAO,MAAM,qCAAqC,KAAK,CAAC;AAIxD,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,aAAa,EACpB,MAAM,EAAE,QAAQ,CAAC,cAAc,CAAC,EAChC,IAAI,EAAE,QAAQ,CAAC,cAAc,CAAC,EAC9B,MAAM,EAAE,QAAQ,CAAC,iBAAiB,CAAC,GAClC,IAAI,CAkCN;AAED,eAAO,MAAM,gCAAgC,EAAE,oBAE9C,CAAC"}

package/dist/glConvolutionEffect.js

@@ -0,0 +1,94 @@
+import { drawGlFullscreenPass } from '@flighthq/render-gl';
+import { getGlEffectProgram } from './glEffectProgramCache';
+// Largest kernel the WebGL path supports (a 7×7). The cap is the fixed uniform-array size in the
+// fragment shader; larger kernels are unsupported on this backend.
+export const MAX_CONVOLUTION_EFFECT_GL_KERNEL_SIZE = 49;
+// Generic matrix-kernel convolution: each output pixel is the weighted sum of its matrixX×matrixY
+// neighborhood, normalized by `divisor` (defaults to the matrix sum) and offset by `bias`.
+export function applyConvolutionEffectToGl(state, source, dest, effect) {
+    const { matrix, matrixX, matrixY } = effect;
+    if (matrixX <= 0 || matrixY <= 0)
+        throw new Error('Convolution matrix dimensions must be positive');
+    if (matrixX * matrixY > MAX_CONVOLUTION_EFFECT_GL_KERNEL_SIZE)
+        throw new Error(`Convolution kernel exceeds the WebGL maximum of 7×7 (${matrixX}×${matrixY} given)`);
+    if (matrix.length < matrixX * matrixY)
+        throw new Error('Convolution matrix does not match its declared dimensions');
+    const bias = effect.bias ?? 0;
+    const clampEdge = effect.clamp ?? true;
+    const preserveAlpha = effect.preserveAlpha ?? true;
+    const edgeColor = effect.color ?? 0;
+    const divisor = effect.divisor ?? getAutoDivisor(matrix, matrixX * matrixY);
+    const matrixData = new Float32Array(MAX_CONVOLUTION_EFFECT_GL_KERNEL_SIZE);
+    for (let i = 0; i < matrixX * matrixY; i++)
+        matrixData[i] = matrix[i];
+    const program = getGlEffectProgram(state, 'stylization.convolution', CONVOLUTION_FRAGMENT_SRC);
+    drawGlFullscreenPass(state, program, [source.texture], dest, (gl, p) => {
+        gl.uniform2f(gl.getUniformLocation(p.program, 'u_texelSize'), 1 / source.width, 1 / source.height);
+        gl.uniform1fv(gl.getUniformLocation(p.program, 'u_matrix[0]'), matrixData);
+        gl.uniform1i(gl.getUniformLocation(p.program, 'u_matrixX'), matrixX);
+        gl.uniform1i(gl.getUniformLocation(p.program, 'u_matrixY'), matrixY);
+        gl.uniform1f(gl.getUniformLocation(p.program, 'u_divisor'), divisor);
+        gl.uniform1f(gl.getUniformLocation(p.program, 'u_bias'), bias);
+        gl.uniform1i(gl.getUniformLocation(p.program, 'u_clamp'), clampEdge ? 1 : 0);
+        gl.uniform1i(gl.getUniformLocation(p.program, 'u_preserveAlpha'), preserveAlpha ? 1 : 0);
+        gl.uniform4f(gl.getUniformLocation(p.program, 'u_edgeColor'), ((edgeColor >> 16) & 0xff) / 255, ((edgeColor >> 8) & 0xff) / 255, (edgeColor & 0xff) / 255, ((edgeColor >>> 24) & 0xff) / 255);
+    });
+}
+export const defaultGlConvolutionEffectRunner = (ctx, effect) => {
+    applyConvolutionEffectToGl(ctx.state, ctx.source, ctx.dest, effect);
+};
+// Sums the kernel weights; returns 1 when the sum is 0 (e.g. an edge-detect kernel) so the divide is safe.
+function getAutoDivisor(matrix, length) {
+    let sum = 0;
+    for (let i = 0; i < length; i++)
+        sum += matrix[i];
+    return sum === 0 ? 1 : sum;
+}
+const CONVOLUTION_FRAGMENT_SRC = `#version 300 es
+precision mediump float;
+in vec2 v_texCoord;
+uniform sampler2D u_texture0;
+uniform vec2 u_texelSize;
+uniform float u_matrix[${MAX_CONVOLUTION_EFFECT_GL_KERNEL_SIZE}];
+uniform int u_matrixX;
+uniform int u_matrixY;
+uniform float u_divisor;
+uniform float u_bias;
+uniform bool u_clamp;
+uniform bool u_preserveAlpha;
+uniform vec4 u_edgeColor;
+out vec4 fragColor;
+
+vec4 sampleAt(vec2 uv) {
+  if (u_clamp) {
+    return texture(u_texture0, clamp(uv, vec2(0.0), vec2(1.0)));
+  }
+  if (uv.x < 0.0 || uv.x > 1.0 || uv.y < 0.0 || uv.y > 1.0) {
+    return u_edgeColor;
+  }
+  return texture(u_texture0, uv);
+}
+
+void main() {
+  int offsetX = u_matrixX / 2;
+  int offsetY = u_matrixY / 2;
+  vec4 sum = vec4(0.0);
+  for (int ky = 0; ky < u_matrixY; ky++) {
+    for (int kx = 0; kx < u_matrixX; kx++) {
+      float weight = u_matrix[ky * u_matrixX + kx];
+      vec2 off = vec2(float(kx - offsetX), float(ky - offsetY)) * u_texelSize;
+      sum += sampleAt(v_texCoord + off) * weight;
+    }
+  }
+  sum /= u_divisor;
+  sum += u_bias / 255.0;
+  sum = clamp(sum, 0.0, 1.0);
+  if (u_preserveAlpha) {
+    // Keep the convolved color and restore the source alpha, matching the reference: a zero-sum
+    // kernel (e.g. edge-detect) drives the convolved alpha to 0, so overriding only .a leaves the
+    // color channels as the non-preserve branch produces them.
+    sum.a = texture(u_texture0, v_texCoord).a;
+  }
+  fragColor = sum;
+}`;
+//# sourceMappingURL=glConvolutionEffect.js.map

package/dist/glConvolutionEffect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"glConvolutionEffect.js","sourceRoot":"","sources":["../src/glConvolutionEffect.ts"],"names":[],"mappings":"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"}

package/dist/glDropShadowEffect.d.ts

@@ -0,0 +1,4 @@
+import type { DropShadowEffect, GlRenderEffectRunner, GlRenderState, GlRenderTarget, GlRenderTargetPool } from '@flighthq/types';
+export declare function applyDropShadowEffectToGl(state: GlRenderState, source: Readonly<GlRenderTarget>, dest: Readonly<GlRenderTarget>, pool: GlRenderTargetPool, effect: Readonly<DropShadowEffect>): void;
+export declare const defaultGlDropShadowEffectRunner: GlRenderEffectRunner;
+//# sourceMappingURL=glDropShadowEffect.d.ts.map

package/dist/glDropShadowEffect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"glDropShadowEffect.d.ts","sourceRoot":"","sources":["../src/glDropShadowEffect.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,gBAAgB,EAChB,oBAAoB,EACpB,aAAa,EACb,cAAc,EACd,kBAAkB,EACnB,MAAM,iBAAiB,CAAC;AAYzB,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,aAAa,EACpB,MAAM,EAAE,QAAQ,CAAC,cAAc,CAAC,EAChC,IAAI,EAAE,QAAQ,CAAC,cAAc,CAAC,EAC9B,IAAI,EAAE,kBAAkB,EACxB,MAAM,EAAE,QAAQ,CAAC,gBAAgB,CAAC,GACjC,IAAI,CA6CN;AAED,eAAO,MAAM,+BAA+B,EAAE,oBAE7C,CAAC"}

package/dist/glDropShadowEffect.js

@@ -0,0 +1,53 @@
+import { acquireGlRenderTarget, clearGlRenderTarget, releaseGlRenderTarget } from '@flighthq/render-gl';
+import { applyGlEffectBlitOffsetPass, applyGlEffectBlitPass, applyGlEffectErasePass } from './glEffectBlitShader';
+import { applyGlEffectBoxBlur } from './glEffectBoxBlur';
+import { applyGlEffectTintPass } from './glEffectTintShader';
+// Drop-shadow composite effect: tint the scene silhouette, blur it, offset it by angle/distance, then composite the source over the shadow.
+// Full-frame realization: acquires the recipe's three scratch targets from the effect pool, runs the
+// inlined multi-pass recipe, then releases them.
+//
+// Compositing order depends on `sourceMode`: 'draw' composites shadow → source, 'hide' composites
+// shadow only, and 'knockout' composites shadow then erases the un-offset source silhouette.
+export function applyDropShadowEffectToGl(state, source, dest, pool, effect) {
+    const descriptor = { width: source.width, height: source.height, format: source.format };
+    const s0 = acquireGlRenderTarget(state, pool, descriptor);
+    const s1 = acquireGlRenderTarget(state, pool, descriptor);
+    const s2 = acquireGlRenderTarget(state, pool, descriptor);
+    const src = source;
+    const dst = dest;
+    const angle = ((effect.angle ?? 45) * Math.PI) / 180;
+    const distance = effect.distance ?? 4;
+    const dx = Math.cos(angle) * distance;
+    const dy = Math.sin(angle) * distance;
+    const color = effect.color ?? 0;
+    const alpha = effect.alpha ?? 1;
+    const strength = effect.strength ?? 1;
+    const quality = Math.max(1, Math.round(effect.quality ?? 1));
+    const sourceMode = effect.sourceMode ?? 'draw';
+    const tintStrength = Math.min(1, strength);
+    const shadowPasses = Math.max(1, Math.floor(strength));
+    const [mask, blurred, blurTemp] = [s0, s1, s2];
+    applyGlEffectTintPass(state, src, mask, color, alpha, tintStrength);
+    applyGlEffectBoxBlur(state, mask, blurred, blurTemp, {
+        blurX: effect.blurX ?? 4,
+        blurY: effect.blurY ?? 4,
+        passes: quality,
+    });
+    clearGlRenderTarget(state, dst);
+    for (let i = 0; i < shadowPasses; i++) {
+        applyGlEffectBlitOffsetPass(state, blurred, dst, dx, dy);
+    }
+    if (sourceMode === 'knockout') {
+        applyGlEffectErasePass(state, src, dst);
+    }
+    else if (sourceMode === 'draw') {
+        applyGlEffectBlitPass(state, src, dst);
+    }
+    releaseGlRenderTarget(pool, s0);
+    releaseGlRenderTarget(pool, s1);
+    releaseGlRenderTarget(pool, s2);
+}
+export const defaultGlDropShadowEffectRunner = (ctx, effect) => {
+    applyDropShadowEffectToGl(ctx.state, ctx.source, ctx.dest, ctx.pool, effect);
+};
+//# sourceMappingURL=glDropShadowEffect.js.map

package/dist/glDropShadowEffect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"glDropShadowEffect.js","sourceRoot":"","sources":["../src/glDropShadowEffect.ts"],"names":[],"mappings":"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"}

package/dist/glEffectBlitShader.d.ts

@@ -0,0 +1,12 @@
+import type { GlRenderTarget } from '@flighthq/render-gl';
+import type { GlRenderState } from '@flighthq/types';
+/**
+ * Blits source into dest at a pixel offset (dx, dy in screen-space Y-down).
+ * Pixels sampling outside the source bounds produce transparent output.
+ */
+export declare function applyGlEffectBlitOffsetPass(state: GlRenderState, source: GlRenderTarget, dest: GlRenderTarget, dx: number, dy: number): void;
+/** Blits source directly into dest without modification. */
+export declare function applyGlEffectBlitPass(state: GlRenderState, source: GlRenderTarget, dest: GlRenderTarget): void;
+/** Erases dest by the source alpha mask, equivalent to destination-out compositing. */
+export declare function applyGlEffectErasePass(state: GlRenderState, source: GlRenderTarget, dest: GlRenderTarget): void;
+//# sourceMappingURL=glEffectBlitShader.d.ts.map

package/dist/glEffectBlitShader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"glEffectBlitShader.d.ts","sourceRoot":"","sources":["../src/glEffectBlitShader.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAE1D,OAAO,KAAK,EAAuB,aAAa,EAAE,MAAM,iBAAiB,CAAC;AA+C1E;;;GAGG;AACH,wBAAgB,2BAA2B,CACzC,KAAK,EAAE,aAAa,EACpB,MAAM,EAAE,cAAc,EACtB,IAAI,EAAE,cAAc,EACpB,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,GACT,IAAI,CAKN;AAED,4DAA4D;AAC5D,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,aAAa,EAAE,MAAM,EAAE,cAAc,EAAE,IAAI,EAAE,cAAc,GAAG,IAAI,CAG9G;AAED,uFAAuF;AACvF,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,aAAa,EAAE,MAAM,EAAE,cAAc,EAAE,IAAI,EAAE,cAAc,GAAG,IAAI,CAK/G"}

package/dist/glEffectBlitShader.js

@@ -0,0 +1,89 @@
+import { compileGlFullscreenProgram, drawGlFullscreenPass } from '@flighthq/render-gl';
+// Blits a tinted texture at a UV offset. Out-of-bounds samples produce transparent output.
+const BLIT_OFFSET_FRAGMENT_SRC = `#version 300 es
+precision mediump float;
+in vec2 v_texCoord;
+uniform sampler2D u_texture;
+uniform vec2 u_offset;
+out vec4 fragColor;
+void main() {
+  vec2 uv = v_texCoord + u_offset;
+  if (uv.x < 0.0 || uv.x > 1.0 || uv.y < 0.0 || uv.y > 1.0) {
+    fragColor = vec4(0.0);
+    return;
+  }
+  fragColor = texture(u_texture, uv);
+}`;
+// Pass-through blit.
+const BLIT_FRAGMENT_SRC = `#version 300 es
+precision mediump float;
+in vec2 v_texCoord;
+uniform sampler2D u_texture;
+out vec4 fragColor;
+void main() {
+  fragColor = texture(u_texture, v_texCoord);
+}`;
+// Emits source alpha for a destination-out erase pass; blend state supplies the coverage operator.
+const ERASE_FRAGMENT_SRC = `#version 300 es
+precision mediump float;
+in vec2 v_texCoord;
+uniform sampler2D u_texture;
+out vec4 fragColor;
+void main() {
+  float a = texture(u_texture, v_texCoord).a;
+  fragColor = vec4(0.0, 0.0, 0.0, a);
+}`;
+const blitOffsetShaders = new WeakMap();
+const blitShaders = new WeakMap();
+const eraseShaders = new WeakMap();
+/**
+ * Blits source into dest at a pixel offset (dx, dy in screen-space Y-down).
+ * Pixels sampling outside the source bounds produce transparent output.
+ */
+export function applyGlEffectBlitOffsetPass(state, source, dest, dx, dy) {
+    const loc = getGlBlitOffsetShader(state);
+    drawGlFullscreenPass(state, loc, [source.texture], dest, (gl) => {
+        gl.uniform2f(loc.locOffset, -dx / source.width, dy / source.height);
+    });
+}
+/** Blits source directly into dest without modification. */
+export function applyGlEffectBlitPass(state, source, dest) {
+    const loc = getGlBlitShader(state);
+    drawGlFullscreenPass(state, loc, [source.texture], dest, () => { });
+}
+/** Erases dest by the source alpha mask, equivalent to destination-out compositing. */
+export function applyGlEffectErasePass(state, source, dest) {
+    const loc = getGlEraseShader(state);
+    drawGlFullscreenPass(state, loc, [source.texture], dest, (gl) => {
+        gl.blendFunc(gl.ZERO, gl.ONE_MINUS_SRC_ALPHA);
+    });
+}
+function getGlBlitOffsetShader(state) {
+    let loc = blitOffsetShaders.get(state);
+    if (loc === undefined) {
+        const gl = state.gl;
+        const base = compileGlFullscreenProgram(gl, BLIT_OFFSET_FRAGMENT_SRC);
+        loc = { ...base, locOffset: gl.getUniformLocation(base.program, 'u_offset') };
+        blitOffsetShaders.set(state, loc);
+    }
+    return loc;
+}
+function getGlBlitShader(state) {
+    let loc = blitShaders.get(state);
+    if (loc === undefined) {
+        const gl = state.gl;
+        loc = compileGlFullscreenProgram(gl, BLIT_FRAGMENT_SRC);
+        blitShaders.set(state, loc);
+    }
+    return loc;
+}
+function getGlEraseShader(state) {
+    let loc = eraseShaders.get(state);
+    if (loc === undefined) {
+        const gl = state.gl;
+        loc = compileGlFullscreenProgram(gl, ERASE_FRAGMENT_SRC);
+        eraseShaders.set(state, loc);
+    }
+    return loc;
+}
+//# sourceMappingURL=glEffectBlitShader.js.map

package/dist/glEffectBlitShader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"glEffectBlitShader.js","sourceRoot":"","sources":["../src/glEffectBlitShader.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,0BAA0B,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAGvF,2FAA2F;AAC3F,MAAM,wBAAwB,GAAG;;;;;;;;;;;;;EAa/B,CAAC;AAEH,qBAAqB;AACrB,MAAM,iBAAiB,GAAG;;;;;;;EAOxB,CAAC;AAEH,mGAAmG;AACnG,MAAM,kBAAkB,GAAG;;;;;;;;EAQzB,CAAC;AAMH,MAAM,iBAAiB,GAAG,IAAI,OAAO,EAA4C,CAAC;AAClF,MAAM,WAAW,GAAG,IAAI,OAAO,EAAsC,CAAC;AACtE,MAAM,YAAY,GAAG,IAAI,OAAO,EAAsC,CAAC;AAEvE;;;GAGG;AACH,MAAM,UAAU,2BAA2B,CACzC,KAAoB,EACpB,MAAsB,EACtB,IAAoB,EACpB,EAAU,EACV,EAAU;IAEV,MAAM,GAAG,GAAG,qBAAqB,CAAC,KAAK,CAAC,CAAC;IACzC,oBAAoB,CAAC,KAAK,EAAE,GAAG,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,EAAE,EAAE;QAC9D,EAAE,CAAC,SAAS,CAAC,GAAG,CAAC,SAAS,EAAE,CAAC,EAAE,GAAG,MAAM,CAAC,KAAK,EAAE,EAAE,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC;IACtE,CAAC,CAAC,CAAC;AACL,CAAC;AAED,4DAA4D;AAC5D,MAAM,UAAU,qBAAqB,CAAC,KAAoB,EAAE,MAAsB,EAAE,IAAoB;IACtG,MAAM,GAAG,GAAG,eAAe,CAAC,KAAK,CAAC,CAAC;IACnC,oBAAoB,CAAC,KAAK,EAAE,GAAG,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,IAAI,EAAE,GAAG,EAAE,GAAE,CAAC,CAAC,CAAC;AACrE,CAAC;AAED,uFAAuF;AACvF,MAAM,UAAU,sBAAsB,CAAC,KAAoB,EAAE,MAAsB,EAAE,IAAoB;IACvG,MAAM,GAAG,GAAG,gBAAgB,CAAC,KAAK,CAAC,CAAC;IACpC,oBAAoB,CAAC,KAAK,EAAE,GAAG,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,EAAE,EAAE;QAC9D,EAAE,CAAC,SAAS,CAAC,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,mBAAmB,CAAC,CAAC;IAChD,CAAC,CAAC,CAAC;AACL,CAAC;AAED,SAAS,qBAAqB,CAAC,KAAoB;IACjD,IAAI,GAAG,GAAG,iBAAiB,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;IACvC,IAAI,GAAG,KAAK,SAAS,EAAE,CAAC;QACtB,MAAM,EAAE,GAAG,KAAK,CAAC,EAAE,CAAC;QACpB,MAAM,IAAI,GAAG,0BAA0B,CAAC,EAAE,EAAE,wBAAwB,CAAC,CAAC;QACtE,GAAG,GAAG,EAAE,GAAG,IAAI,EAAE,SAAS,EAAE,EAAE,CAAC,kBAAkB,CAAC,IAAI,CAAC,OAAO,EAAE,UAAU,CAAE,EAAE,CAAC;QAC/E,iBAAiB,CAAC,GAAG,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;IACpC,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC;AAED,SAAS,eAAe,CAAC,KAAoB;IAC3C,IAAI,GAAG,GAAG,WAAW,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;IACjC,IAAI,GAAG,KAAK,SAAS,EAAE,CAAC;QACtB,MAAM,EAAE,GAAG,KAAK,CAAC,EAAE,CAAC;QACpB,GAAG,GAAG,0BAA0B,CAAC,EAAE,EAAE,iBAAiB,CAAC,CAAC;QACxD,WAAW,CAAC,GAAG,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;IAC9B,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC;AAED,SAAS,gBAAgB,CAAC,KAAoB;IAC5C,IAAI,GAAG,GAAG,YAAY,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;IAClC,IAAI,GAAG,KAAK,SAAS,EAAE,CAAC;QACtB,MAAM,EAAE,GAAG,KAAK,CAAC,EAAE,CAAC;QACpB,GAAG,GAAG,0BAA0B,CAAC,EAAE,EAAE,kBAAkB,CAAC,CAAC;QACzD,YAAY,CAAC,GAAG,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;IAC/B,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC"}

package/dist/glEffectBoxBlur.d.ts

@@ -0,0 +1,16 @@
+import type { GlRenderTarget } from '@flighthq/render-gl';
+import type { GlRenderState } from '@flighthq/types';
+/**
+ * Applies a separable box blur to `source`, writing to `dest`. `blurX`/`blurY` are the target
+ * Gaussian standard deviations; `passes` is the number of box passes per axis (more passes
+ * converge on a Gaussian — see `computeBoxBlurPassRadius` — not a larger blur). A box blur is cheap
+ * and the right building block for soft spreads (glow, drop shadow). `temp` is a caller-provided
+ * ping-pong scratch target distinct from both `source` and `dest`.
+ */
+export declare function applyGlEffectBoxBlur(state: GlRenderState, source: GlRenderTarget, dest: GlRenderTarget, temp: GlRenderTarget, options: Readonly<{
+    blurX?: number;
+    blurY?: number;
+    passes?: number;
+    edgeColor?: readonly [number, number, number, number];
+}>): void;
+//# sourceMappingURL=glEffectBoxBlur.d.ts.map

package/dist/glEffectBoxBlur.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"glEffectBoxBlur.d.ts","sourceRoot":"","sources":["../src/glEffectBoxBlur.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAE1D,OAAO,KAAK,EAAuB,aAAa,EAAE,MAAM,iBAAiB,CAAC;AA4C1E;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,aAAa,EACpB,MAAM,EAAE,cAAc,EACtB,IAAI,EAAE,cAAc,EACpB,IAAI,EAAE,cAAc,EACpB,OAAO,EAAE,QAAQ,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;CACvD,CAAC,GACD,IAAI,CA8BN"}

package/dist/glEffectBoxBlur.js

@@ -0,0 +1,112 @@
+import { computeBoxBlurPassRadius } from '@flighthq/effects';
+import { compileGlFullscreenProgram, drawGlFullscreenPass } from '@flighthq/render-gl';
+const BOX_BLUR_FRAGMENT_SRC = `#version 300 es
+precision mediump float;
+in vec2 v_texCoord;
+uniform sampler2D u_texture;
+uniform vec2 u_texelSize;
+uniform float u_radius;
+uniform vec2 u_direction;
+uniform vec4 u_edgeColor;
+uniform float u_useEdgeColor;
+out vec4 fragColor;
+vec4 sampleBlur(vec2 uv) {
+  if (u_useEdgeColor > 0.5 && (uv.x < 0.0 || uv.x > 1.0 || uv.y < 0.0 || uv.y > 1.0)) {
+    return u_edgeColor;
+  }
+  return texture(u_texture, uv);
+}
+void main() {
+  int r = max(0, int(u_radius));
+  if (r == 0) {
+    fragColor = sampleBlur(v_texCoord);
+    return;
+  }
+  vec4 sum = vec4(0.0);
+  int count = 2 * r + 1;
+  for (int i = -r; i <= r; i++) {
+    sum += sampleBlur(v_texCoord + float(i) * u_texelSize * u_direction);
+  }
+  fragColor = sum / float(count);
+}`;
+const boxBlurShaders = new WeakMap();
+/**
+ * Applies a separable box blur to `source`, writing to `dest`. `blurX`/`blurY` are the target
+ * Gaussian standard deviations; `passes` is the number of box passes per axis (more passes
+ * converge on a Gaussian — see `computeBoxBlurPassRadius` — not a larger blur). A box blur is cheap
+ * and the right building block for soft spreads (glow, drop shadow). `temp` is a caller-provided
+ * ping-pong scratch target distinct from both `source` and `dest`.
+ */
+export function applyGlEffectBoxBlur(state, source, dest, temp, options) {
+    const passes = Math.max(1, Math.round(options.passes ?? 1));
+    const blurX = options.blurX ?? 4;
+    const blurY = options.blurY ?? 4;
+    const edgeColor = options.edgeColor;
+    const loc = getBoxBlurShader(state);
+    let read = source;
+    let write = temp;
+    // Each pass may use a different radius per axis so the box widths converge on the target sigma;
+    // zero-radius passes are skipped. If nothing is written, the tail blit copies source to dest.
+    for (let pass = 0; pass < passes; pass++) {
+        const radiusX = computeBoxBlurPassRadius(blurX, passes, pass);
+        if (radiusX > 0) {
+            applyBoxBlurPass(state, read, write, loc, radiusX, 1, 0, edgeColor);
+            read = write;
+            write = write === temp ? dest : temp;
+        }
+        const radiusY = computeBoxBlurPassRadius(blurY, passes, pass);
+        if (radiusY > 0) {
+            applyBoxBlurPass(state, read, write, loc, radiusY, 0, 1, edgeColor);
+            read = write;
+            write = write === temp ? dest : temp;
+        }
+    }
+    if (read !== dest) {
+        applyBlurBlit(state, read, dest);
+    }
+}
+function applyBlurBlit(state, source, dest) {
+    const loc = getBoxBlurShader(state);
+    drawGlFullscreenPass(state, loc, [source.texture], dest, (gl) => {
+        gl.uniform2f(loc.locTexelSize, 0, 0);
+        gl.uniform1f(loc.locRadius, 0);
+        gl.uniform2f(loc.locDirection, 0, 0);
+        gl.uniform4f(loc.locEdgeColor, 0, 0, 0, 0);
+        gl.uniform1f(loc.locUseEdgeColor, 0);
+        gl.blendFunc(gl.ONE, gl.ZERO);
+    });
+}
+function applyBoxBlurPass(state, source, dest, loc, radius, dirX, dirY, edgeColor) {
+    drawGlFullscreenPass(state, loc, [source.texture], dest, (gl) => {
+        gl.uniform2f(loc.locTexelSize, 1 / source.width, 1 / source.height);
+        gl.uniform1f(loc.locRadius, radius);
+        gl.uniform2f(loc.locDirection, dirX, dirY);
+        if (edgeColor === undefined) {
+            gl.uniform4f(loc.locEdgeColor, 0, 0, 0, 0);
+            gl.uniform1f(loc.locUseEdgeColor, 0);
+        }
+        else {
+            gl.uniform4f(loc.locEdgeColor, edgeColor[0], edgeColor[1], edgeColor[2], edgeColor[3]);
+            gl.uniform1f(loc.locUseEdgeColor, 1);
+        }
+        gl.blendFunc(gl.ONE, gl.ZERO);
+    });
+}
+function getBoxBlurShader(state) {
+    let loc = boxBlurShaders.get(state);
+    if (loc === undefined) {
+        const gl = state.gl;
+        const base = compileGlFullscreenProgram(gl, BOX_BLUR_FRAGMENT_SRC);
+        loc = {
+            ...base,
+            locTexelSize: gl.getUniformLocation(base.program, 'u_texelSize'),
+            locRadius: gl.getUniformLocation(base.program, 'u_radius'),
+            locDirection: gl.getUniformLocation(base.program, 'u_direction'),
+            locEdgeColor: gl.getUniformLocation(base.program, 'u_edgeColor'),
+            locUseEdgeColor: gl.getUniformLocation(base.program, 'u_useEdgeColor'),
+        };
+        boxBlurShaders.set(state, loc);
+    }
+    return loc;
+}
+//# sourceMappingURL=glEffectBoxBlur.js.map

package/dist/glEffectBoxBlur.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"glEffectBoxBlur.js","sourceRoot":"","sources":["../src/glEffectBoxBlur.ts"],"names":[],"mappings":"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"}

package/dist/glEffectGradientRamp.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Builds a 256-entry RGBA gradient ramp on the GPU. The caller owns the
+ * returned texture and must delete it with `gl.deleteTexture` when done.
+ *
+ * `ratios` are in byte scale [0,255]. Colors are packed RGB integers.
+ * `alphas` are in [0,1].
+ */
+export declare function createGlEffectGradientRampTexture(gl: WebGL2RenderingContext, colors: ReadonlyArray<number>, alphas: ReadonlyArray<number>, ratios: ReadonlyArray<number>): WebGLTexture;
+//# sourceMappingURL=glEffectGradientRamp.d.ts.map

package/dist/glEffectGradientRamp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"glEffectGradientRamp.d.ts","sourceRoot":"","sources":["../src/glEffectGradientRamp.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,wBAAgB,iCAAiC,CAC/C,EAAE,EAAE,sBAAsB,EAC1B,MAAM,EAAE,aAAa,CAAC,MAAM,CAAC,EAC7B,MAAM,EAAE,aAAa,CAAC,MAAM,CAAC,EAC7B,MAAM,EAAE,aAAa,CAAC,MAAM,CAAC,GAC5B,YAAY,CAWd"}

package/dist/glEffectGradientRamp.js

@@ -0,0 +1,64 @@
+/**
+ * Builds a 256-entry RGBA gradient ramp on the GPU. The caller owns the
+ * returned texture and must delete it with `gl.deleteTexture` when done.
+ *
+ * `ratios` are in byte scale [0,255]. Colors are packed RGB integers.
+ * `alphas` are in [0,1].
+ */
+export function createGlEffectGradientRampTexture(gl, colors, alphas, ratios) {
+    const data = buildRampData(colors, alphas, ratios);
+    const texture = gl.createTexture();
+    gl.bindTexture(gl.TEXTURE_2D, texture);
+    gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA8, 256, 1, 0, gl.RGBA, gl.UNSIGNED_BYTE, data);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+    gl.bindTexture(gl.TEXTURE_2D, null);
+    return texture;
+}
+function buildRampData(colors, alphas, ratios) {
+    const out = new Uint8ClampedArray(256 * 4);
+    if (colors.length === 0)
+        return out;
+    for (let i = 0; i < 256; i++) {
+        const t = i;
+        let r = 0, g = 0, b = 0, a = 0;
+        if (t <= ratios[0]) {
+            const c = colors[0];
+            r = (c >> 16) & 0xff;
+            g = (c >> 8) & 0xff;
+            b = c & 0xff;
+            a = Math.round(alphas[0] * 255);
+        }
+        else if (t >= ratios[ratios.length - 1]) {
+            const c = colors[colors.length - 1];
+            r = (c >> 16) & 0xff;
+            g = (c >> 8) & 0xff;
+            b = c & 0xff;
+            a = Math.round(alphas[alphas.length - 1] * 255);
+        }
+        else {
+            for (let j = 0; j < ratios.length - 1; j++) {
+                const r0 = ratios[j];
+                const r1 = ratios[j + 1];
+                if (t >= r0 && t <= r1) {
+                    const blend = r1 > r0 ? (t - r0) / (r1 - r0) : 0;
+                    const c0 = colors[j];
+                    const c1 = colors[j + 1];
+                    r = Math.round(((c0 >> 16) & 0xff) * (1 - blend) + ((c1 >> 16) & 0xff) * blend);
+                    g = Math.round(((c0 >> 8) & 0xff) * (1 - blend) + ((c1 >> 8) & 0xff) * blend);
+                    b = Math.round((c0 & 0xff) * (1 - blend) + (c1 & 0xff) * blend);
+                    a = Math.round(alphas[j] * 255 * (1 - blend) + alphas[j + 1] * 255 * blend);
+                    break;
+                }
+            }
+        }
+        out[i * 4] = r;
+        out[i * 4 + 1] = g;
+        out[i * 4 + 2] = b;
+        out[i * 4 + 3] = a;
+    }
+    return out;
+}
+//# sourceMappingURL=glEffectGradientRamp.js.map