@flighthq/effects-gl 0.1.0

package/dist/glDirectionalBlurEffect.js

@@ -0,0 +1,44 @@
+import { drawGlFullscreenPass } from '@flighthq/render-gl';
+import { getGlEffectProgram } from './glEffectProgramCache';
+// Directional blur: accumulate samples stepped along `angle` over `length` texels, normalized by the
+// sample count. Single-pass reference recipe. u_resolution converts the texel length into UV space.
+export function applyDirectionalBlurEffectToGl(state, source, dest, effect) {
+    const angle = effect.angle ?? 0;
+    const length = effect.length ?? 8;
+    const samples = effect.samples ?? 16;
+    const program = getGlEffectProgram(state, 'directionalBlur', DIRECTIONAL_BLUR_FRAGMENT_SRC);
+    drawGlFullscreenPass(state, program, [source.texture], dest, (gl, p) => {
+        gl.uniform1f(gl.getUniformLocation(p.program, 'u_angle'), angle);
+        gl.uniform1f(gl.getUniformLocation(p.program, 'u_length'), length);
+        gl.uniform1f(gl.getUniformLocation(p.program, 'u_samples'), samples);
+        gl.uniform2f(gl.getUniformLocation(p.program, 'u_resolution'), source.width, source.height);
+    });
+}
+export const defaultGlDirectionalBlurEffectRunner = (ctx, effect) => {
+    applyDirectionalBlurEffectToGl(ctx.state, ctx.source, ctx.dest, effect);
+};
+const DIRECTIONAL_BLUR_FRAGMENT_SRC = `#version 300 es
+precision highp float;
+in vec2 v_texCoord;
+uniform sampler2D u_texture0;
+uniform float u_angle;
+uniform float u_length;
+uniform float u_samples;
+uniform vec2 u_resolution;
+out vec4 o_color;
+const int SAMPLES = 16;
+void main() {
+  vec2 dir = vec2(cos(u_angle), sin(u_angle)) * (u_length / u_resolution);
+  float count = min(u_samples, 16.0);
+  vec4 sum = vec4(0.0);
+  float taken = 0.0;
+  for (int i = 0; i < SAMPLES; i++) {
+    if (float(i) >= count) break;
+    float t = count > 1.0 ? (float(i) / (count - 1.0)) - 0.5 : 0.0;
+    vec2 uv = v_texCoord + dir * t;
+    sum += texture(u_texture0, uv);
+    taken += 1.0;
+  }
+  o_color = sum / max(taken, 1.0);
+}`;
+//# sourceMappingURL=glDirectionalBlurEffect.js.map

package/dist/glDirectionalBlurEffect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"glDirectionalBlurEffect.js","sourceRoot":"","sources":["../src/glDirectionalBlurEffect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAG3D,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAE5D,qGAAqG;AACrG,oGAAoG;AACpG,MAAM,UAAU,8BAA8B,CAC5C,KAAoB,EACpB,MAAgC,EAChC,IAA8B,EAC9B,MAAuC;IAEvC,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,IAAI,CAAC,CAAC;IAChC,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,IAAI,CAAC,CAAC;IAClC,MAAM,OAAO,GAAG,MAAM,CAAC,OAAO,IAAI,EAAE,CAAC;IACrC,MAAM,OAAO,GAAG,kBAAkB,CAAC,KAAK,EAAE,iBAAiB,EAAE,6BAA6B,CAAC,CAAC;IAC5F,oBAAoB,CAAC,KAAK,EAAE,OAAO,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,EAAE,CAAC,EAAE,EAAE;QACrE,EAAE,CAAC,SAAS,CAAC,EAAE,CAAC,kBAAkB,CAAC,CAAC,CAAC,OAAO,EAAE,SAAS,CAAC,EAAE,KAAK,CAAC,CAAC;QACjE,EAAE,CAAC,SAAS,CAAC,EAAE,CAAC,kBAAkB,CAAC,CAAC,CAAC,OAAO,EAAE,UAAU,CAAC,EAAE,MAAM,CAAC,CAAC;QACnE,EAAE,CAAC,SAAS,CAAC,EAAE,CAAC,kBAAkB,CAAC,CAAC,CAAC,OAAO,EAAE,WAAW,CAAC,EAAE,OAAO,CAAC,CAAC;QACrE,EAAE,CAAC,SAAS,CAAC,EAAE,CAAC,kBAAkB,CAAC,CAAC,CAAC,OAAO,EAAE,cAAc,CAAC,EAAE,MAAM,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC;IAC9F,CAAC,CAAC,CAAC;AACL,CAAC;AAED,MAAM,CAAC,MAAM,oCAAoC,GAAyB,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE;IACxF,8BAA8B,CAAC,GAAG,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,IAAI,EAAE,MAA+B,CAAC,CAAC;AACnG,CAAC,CAAC;AAEF,MAAM,6BAA6B,GAAG;;;;;;;;;;;;;;;;;;;;;;;EAuBpC,CAAC"}

package/dist/glDisplacementEffect.d.ts

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

package/dist/glDisplacementEffect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"glDisplacementEffect.d.ts","sourceRoot":"","sources":["../src/glDisplacementEffect.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,oBAAoB,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAK/G,wBAAgB,2BAA2B,CACzC,KAAK,EAAE,aAAa,EACpB,MAAM,EAAE,QAAQ,CAAC,cAAc,CAAC,EAChC,IAAI,EAAE,QAAQ,CAAC,cAAc,CAAC,EAC9B,MAAM,EAAE,QAAQ,CAAC,kBAAkB,CAAC,GACnC,IAAI,CAWN;AAED,eAAO,MAAM,iCAAiC,EAAE,oBAE/C,CAAC"}

package/dist/glDisplacementEffect.js

@@ -0,0 +1,37 @@
+import { drawGlFullscreenPass } from '@flighthq/render-gl';
+import { getGlEffectProgram } from './glEffectProgramCache';
+// Displacement / heat-haze: warp the sample uv by an animated sine field for a refractive wobble.
+export function applyDisplacementEffectToGl(state, source, dest, effect) {
+    const intensity = effect.intensity ?? 8;
+    const frequency = effect.frequency ?? 12;
+    const seed = effect.seed ?? 0;
+    const program = getGlEffectProgram(state, 'lens.displacement', DISPLACEMENT_FRAGMENT_SRC);
+    drawGlFullscreenPass(state, program, [source.texture], dest, (gl, p) => {
+        gl.uniform1f(gl.getUniformLocation(p.program, 'u_intensity'), intensity);
+        gl.uniform1f(gl.getUniformLocation(p.program, 'u_frequency'), frequency);
+        gl.uniform1f(gl.getUniformLocation(p.program, 'u_seed'), seed);
+        gl.uniform2f(gl.getUniformLocation(p.program, 'u_resolution'), source.width, source.height);
+    });
+}
+export const defaultGlDisplacementEffectRunner = (ctx, effect) => {
+    applyDisplacementEffectToGl(ctx.state, ctx.source, ctx.dest, effect);
+};
+const DISPLACEMENT_FRAGMENT_SRC = `#version 300 es
+precision highp float;
+in vec2 v_texCoord;
+uniform sampler2D u_texture0;
+uniform float u_intensity;
+uniform float u_frequency;
+uniform float u_seed;
+uniform vec2 u_resolution;
+out vec4 o_color;
+void main() {
+  float f = u_frequency;
+  vec2 warp = vec2(
+    sin(v_texCoord.y * f + u_seed) + sin(v_texCoord.y * f * 2.3 + u_seed * 1.7) * 0.5,
+    cos(v_texCoord.x * f * 0.8 + u_seed * 1.3)
+  );
+  vec2 displaced = v_texCoord + warp * (u_intensity / u_resolution);
+  o_color = texture(u_texture0, displaced);
+}`;
+//# sourceMappingURL=glDisplacementEffect.js.map

package/dist/glDisplacementEffect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"glDisplacementEffect.js","sourceRoot":"","sources":["../src/glDisplacementEffect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAG3D,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAE5D,kGAAkG;AAClG,MAAM,UAAU,2BAA2B,CACzC,KAAoB,EACpB,MAAgC,EAChC,IAA8B,EAC9B,MAAoC;IAEpC,MAAM,SAAS,GAAG,MAAM,CAAC,SAAS,IAAI,CAAC,CAAC;IACxC,MAAM,SAAS,GAAG,MAAM,CAAC,SAAS,IAAI,EAAE,CAAC;IACzC,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,IAAI,CAAC,CAAC;IAC9B,MAAM,OAAO,GAAG,kBAAkB,CAAC,KAAK,EAAE,mBAAmB,EAAE,yBAAyB,CAAC,CAAC;IAC1F,oBAAoB,CAAC,KAAK,EAAE,OAAO,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,EAAE,CAAC,EAAE,EAAE;QACrE,EAAE,CAAC,SAAS,CAAC,EAAE,CAAC,kBAAkB,CAAC,CAAC,CAAC,OAAO,EAAE,aAAa,CAAC,EAAE,SAAS,CAAC,CAAC;QACzE,EAAE,CAAC,SAAS,CAAC,EAAE,CAAC,kBAAkB,CAAC,CAAC,CAAC,OAAO,EAAE,aAAa,CAAC,EAAE,SAAS,CAAC,CAAC;QACzE,EAAE,CAAC,SAAS,CAAC,EAAE,CAAC,kBAAkB,CAAC,CAAC,CAAC,OAAO,EAAE,QAAQ,CAAC,EAAE,IAAI,CAAC,CAAC;QAC/D,EAAE,CAAC,SAAS,CAAC,EAAE,CAAC,kBAAkB,CAAC,CAAC,CAAC,OAAO,EAAE,cAAc,CAAC,EAAE,MAAM,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC;IAC9F,CAAC,CAAC,CAAC;AACL,CAAC;AAED,MAAM,CAAC,MAAM,iCAAiC,GAAyB,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE;IACrF,2BAA2B,CAAC,GAAG,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,IAAI,EAAE,MAA4B,CAAC,CAAC;AAC7F,CAAC,CAAC;AAEF,MAAM,yBAAyB,GAAG;;;;;;;;;;;;;;;;;EAiBhC,CAAC"}

package/dist/glDitherEffect.d.ts

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

package/dist/glDitherEffect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"glDitherEffect.d.ts","sourceRoot":"","sources":["../src/glDitherEffect.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,oBAAoB,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAMzG,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,aAAa,EACpB,MAAM,EAAE,QAAQ,CAAC,cAAc,CAAC,EAChC,IAAI,EAAE,QAAQ,CAAC,cAAc,CAAC,EAC9B,MAAM,EAAE,QAAQ,CAAC,YAAY,CAAC,GAC7B,IAAI,CAON;AAED,eAAO,MAAM,2BAA2B,EAAE,oBAEzC,CAAC"}

package/dist/glDitherEffect.js

@@ -0,0 +1,37 @@
+import { drawGlFullscreenPass } from '@flighthq/render-gl';
+import { getGlEffectProgram } from './glEffectProgramCache';
+// Dither: quantize each channel to `levels` steps with a 4x4 ordered Bayer threshold for a retro
+// banded-but-textured look.
+export function applyDitherEffectToGl(state, source, dest, effect) {
+    const levels = effect.levels ?? 4;
+    const program = getGlEffectProgram(state, 'stylization.dither', DITHER_FRAGMENT_SRC);
+    drawGlFullscreenPass(state, program, [source.texture], dest, (gl, p) => {
+        gl.uniform1f(gl.getUniformLocation(p.program, 'u_levels'), Math.max(2, levels));
+        gl.uniform2f(gl.getUniformLocation(p.program, 'u_resolution'), source.width, source.height);
+    });
+}
+export const defaultGlDitherEffectRunner = (ctx, effect) => {
+    applyDitherEffectToGl(ctx.state, ctx.source, ctx.dest, effect);
+};
+const DITHER_FRAGMENT_SRC = `#version 300 es
+precision highp float;
+in vec2 v_texCoord;
+uniform sampler2D u_texture0;
+uniform float u_levels;
+uniform vec2 u_resolution;
+out vec4 o_color;
+float bayer(ivec2 p) {
+  int x = p.x & 3;
+  int y = p.y & 3;
+  int m[16] = int[16](0, 8, 2, 10, 12, 4, 14, 6, 3, 11, 1, 9, 15, 7, 13, 5);
+  return float(m[y * 4 + x]) / 16.0;
+}
+void main() {
+  vec4 c = texture(u_texture0, v_texCoord);
+  ivec2 px = ivec2(v_texCoord * u_resolution);
+  float t = bayer(px) - 0.5;
+  float steps = u_levels - 1.0;
+  vec3 q = floor(c.rgb * steps + 0.5 + t) / steps;
+  o_color = vec4(clamp(q, 0.0, 1.0), c.a);
+}`;
+//# sourceMappingURL=glDitherEffect.js.map

package/dist/glDitherEffect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"glDitherEffect.js","sourceRoot":"","sources":["../src/glDitherEffect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAG3D,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAE5D,iGAAiG;AACjG,4BAA4B;AAC5B,MAAM,UAAU,qBAAqB,CACnC,KAAoB,EACpB,MAAgC,EAChC,IAA8B,EAC9B,MAA8B;IAE9B,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,IAAI,CAAC,CAAC;IAClC,MAAM,OAAO,GAAG,kBAAkB,CAAC,KAAK,EAAE,oBAAoB,EAAE,mBAAmB,CAAC,CAAC;IACrF,oBAAoB,CAAC,KAAK,EAAE,OAAO,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,EAAE,CAAC,EAAE,EAAE;QACrE,EAAE,CAAC,SAAS,CAAC,EAAE,CAAC,kBAAkB,CAAC,CAAC,CAAC,OAAO,EAAE,UAAU,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC;QAChF,EAAE,CAAC,SAAS,CAAC,EAAE,CAAC,kBAAkB,CAAC,CAAC,CAAC,OAAO,EAAE,cAAc,CAAC,EAAE,MAAM,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC;IAC9F,CAAC,CAAC,CAAC;AACL,CAAC;AAED,MAAM,CAAC,MAAM,2BAA2B,GAAyB,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE;IAC/E,qBAAqB,CAAC,GAAG,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,IAAI,EAAE,MAAsB,CAAC,CAAC;AACjF,CAAC,CAAC;AAEF,MAAM,mBAAmB,GAAG;;;;;;;;;;;;;;;;;;;;EAoB1B,CAAC"}

package/dist/glEffectProgramCache.d.ts

@@ -0,0 +1,4 @@
+import type { GlFullscreenProgram, GlRenderState } from '@flighthq/types';
+export declare function getGlEffectProgram(state: GlRenderState, key: string, fragmentSource: string): GlFullscreenProgram;
+export declare function getGlEffectUniformLocation(state: GlRenderState, program: Readonly<GlFullscreenProgram>, name: string): WebGLUniformLocation | null;
+//# sourceMappingURL=glEffectProgramCache.d.ts.map

package/dist/glEffectProgramCache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"glEffectProgramCache.d.ts","sourceRoot":"","sources":["../src/glEffectProgramCache.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,mBAAmB,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAM1E,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,aAAa,EAAE,GAAG,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,GAAG,mBAAmB,CAWjH;AAQD,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,aAAa,EACpB,OAAO,EAAE,QAAQ,CAAC,mBAAmB,CAAC,EACtC,IAAI,EAAE,MAAM,GACX,oBAAoB,GAAG,IAAI,CAW7B"}

package/dist/glEffectProgramCache.js

@@ -0,0 +1,42 @@
+import { compileGlFullscreenProgram } from '@flighthq/render-gl';
+// Per-state cache of compiled effect fragment programs, keyed by a stable string. Effect recipes call
+// getGlEffectProgram with their own key + fragment source so each program compiles once per state
+// and is reused every frame. Keeps compiled programs off the render-state runtime type.
+export function getGlEffectProgram(state, key, fragmentSource) {
+    let cache = _programs.get(state);
+    if (cache === undefined) {
+        cache = new Map();
+        _programs.set(state, cache);
+    }
+    const existing = cache.get(key);
+    if (existing !== undefined)
+        return existing;
+    const compiled = compileGlFullscreenProgram(state.gl, fragmentSource);
+    cache.set(key, compiled);
+    return compiled;
+}
+// Returns a cached WebGLUniformLocation for the given program and uniform name. The texture-slot
+// locations (u_texture0..N) are already resolved by compileGlFullscreenProgram and live on
+// GlFullscreenProgram.textures. This cache covers the per-effect uniforms (u_threshold, u_intensity,
+// u_matrix, etc.) that the render-gl layer does not pre-resolve. Because getUniformLocation is a
+// GL driver call that involves string hashing on every draw, caching here removes O(N * uniforms)
+// driver round-trips per frame for a 44-effect chain.
+export function getGlEffectUniformLocation(state, program, name) {
+    let cache = _uniformLocations.get(program);
+    if (cache === undefined) {
+        cache = new Map();
+        _uniformLocations.set(program, cache);
+    }
+    const existing = cache.get(name);
+    if (existing !== undefined)
+        return existing;
+    const loc = state.gl.getUniformLocation(program.program, name);
+    cache.set(name, loc);
+    return loc;
+}
+const _programs = new WeakMap();
+// Keyed by program object (not state) so the cache survives state-key rotation and is naturally
+// freed when the program itself is garbage-collected (all GlFullscreenPrograms are stored in
+// _programs above, which is already WeakMap-keyed by state).
+const _uniformLocations = new WeakMap();
+//# sourceMappingURL=glEffectProgramCache.js.map

package/dist/glEffectProgramCache.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"glEffectProgramCache.js","sourceRoot":"","sources":["../src/glEffectProgramCache.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,0BAA0B,EAAE,MAAM,qBAAqB,CAAC;AAGjE,sGAAsG;AACtG,kGAAkG;AAClG,wFAAwF;AAExF,MAAM,UAAU,kBAAkB,CAAC,KAAoB,EAAE,GAAW,EAAE,cAAsB;IAC1F,IAAI,KAAK,GAAG,SAAS,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;IACjC,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;QACxB,KAAK,GAAG,IAAI,GAAG,EAAE,CAAC;QAClB,SAAS,CAAC,GAAG,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;IAC9B,CAAC;IACD,MAAM,QAAQ,GAAG,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IAChC,IAAI,QAAQ,KAAK,SAAS;QAAE,OAAO,QAAQ,CAAC;IAC5C,MAAM,QAAQ,GAAG,0BAA0B,CAAC,KAAK,CAAC,EAAE,EAAE,cAAc,CAAC,CAAC;IACtE,KAAK,CAAC,GAAG,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAC;IACzB,OAAO,QAAQ,CAAC;AAClB,CAAC;AAED,iGAAiG;AACjG,2FAA2F;AAC3F,qGAAqG;AACrG,iGAAiG;AACjG,kGAAkG;AAClG,sDAAsD;AACtD,MAAM,UAAU,0BAA0B,CACxC,KAAoB,EACpB,OAAsC,EACtC,IAAY;IAEZ,IAAI,KAAK,GAAG,iBAAiB,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;IAC3C,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;QACxB,KAAK,GAAG,IAAI,GAAG,EAAE,CAAC;QAClB,iBAAiB,CAAC,GAAG,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;IACxC,CAAC;IACD,MAAM,QAAQ,GAAG,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IACjC,IAAI,QAAQ,KAAK,SAAS;QAAE,OAAO,QAAQ,CAAC;IAC5C,MAAM,GAAG,GAAG,KAAK,CAAC,EAAE,CAAC,kBAAkB,CAAC,OAAO,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;IAC/D,KAAK,CAAC,GAAG,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;IACrB,OAAO,GAAG,CAAC;AACb,CAAC;AAED,MAAM,SAAS,GAAG,IAAI,OAAO,EAAmD,CAAC;AAEjF,gGAAgG;AAChG,6FAA6F;AAC7F,6DAA6D;AAC7D,MAAM,iBAAiB,GAAG,IAAI,OAAO,EAA2E,CAAC"}

package/dist/glExposureEffect.d.ts

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

package/dist/glExposureEffect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"glExposureEffect.d.ts","sourceRoot":"","sources":["../src/glExposureEffect.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,oBAAoB,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAK3G,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,aAAa,EACpB,MAAM,EAAE,QAAQ,CAAC,cAAc,CAAC,EAChC,IAAI,EAAE,QAAQ,CAAC,cAAc,CAAC,EAC9B,MAAM,EAAE,QAAQ,CAAC,cAAc,CAAC,GAC/B,IAAI,CAMN;AAED,eAAO,MAAM,6BAA6B,EAAE,oBAE3C,CAAC"}

package/dist/glExposureEffect.js

@@ -0,0 +1,24 @@
+import { drawGlFullscreenPass } from '@flighthq/render-gl';
+import { getGlEffectProgram } from './glEffectProgramCache';
+// Exposure: scale linear color by 2^stops. Single-pass reference recipe.
+export function applyExposureEffectToGl(state, source, dest, effect) {
+    const exposure = effect.exposure ?? 0;
+    const program = getGlEffectProgram(state, 'exposure', EXPOSURE_FRAGMENT_SRC);
+    drawGlFullscreenPass(state, program, [source.texture], dest, (gl, p) => {
+        gl.uniform1f(gl.getUniformLocation(p.program, 'u_exposure'), Math.pow(2, exposure));
+    });
+}
+export const defaultGlExposureEffectRunner = (ctx, effect) => {
+    applyExposureEffectToGl(ctx.state, ctx.source, ctx.dest, effect);
+};
+const EXPOSURE_FRAGMENT_SRC = `#version 300 es
+precision highp float;
+in vec2 v_texCoord;
+uniform sampler2D u_texture0;
+uniform float u_exposure;
+out vec4 o_color;
+void main() {
+  vec4 c = texture(u_texture0, v_texCoord);
+  o_color = vec4(c.rgb * u_exposure, c.a);
+}`;
+//# sourceMappingURL=glExposureEffect.js.map

package/dist/glExposureEffect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"glExposureEffect.js","sourceRoot":"","sources":["../src/glExposureEffect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAG3D,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAE5D,yEAAyE;AACzE,MAAM,UAAU,uBAAuB,CACrC,KAAoB,EACpB,MAAgC,EAChC,IAA8B,EAC9B,MAAgC;IAEhC,MAAM,QAAQ,GAAG,MAAM,CAAC,QAAQ,IAAI,CAAC,CAAC;IACtC,MAAM,OAAO,GAAG,kBAAkB,CAAC,KAAK,EAAE,UAAU,EAAE,qBAAqB,CAAC,CAAC;IAC7E,oBAAoB,CAAC,KAAK,EAAE,OAAO,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,EAAE,CAAC,EAAE,EAAE;QACrE,EAAE,CAAC,SAAS,CAAC,EAAE,CAAC,kBAAkB,CAAC,CAAC,CAAC,OAAO,EAAE,YAAY,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC;IACtF,CAAC,CAAC,CAAC;AACL,CAAC;AAED,MAAM,CAAC,MAAM,6BAA6B,GAAyB,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE;IACjF,uBAAuB,CAAC,GAAG,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,IAAI,EAAE,MAAwB,CAAC,CAAC;AACrF,CAAC,CAAC;AAEF,MAAM,qBAAqB,GAAG;;;;;;;;;EAS5B,CAAC"}

package/dist/glFilmGrainEffect.d.ts

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

package/dist/glFilmGrainEffect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"glFilmGrainEffect.d.ts","sourceRoot":"","sources":["../src/glFilmGrainEffect.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,oBAAoB,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAM5G,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,CAUN;AAED,eAAO,MAAM,8BAA8B,EAAE,oBAE5C,CAAC"}

package/dist/glFilmGrainEffect.js

@@ -0,0 +1,36 @@
+import { drawGlFullscreenPass } from '@flighthq/render-gl';
+import { getGlEffectProgram } from './glEffectProgramCache';
+// Film grain: add per-pixel hash noise scaled by intensity, with grain cell size and a seed so the
+// noise can be animated frame to frame.
+export function applyFilmGrainEffectToGl(state, source, dest, effect) {
+    const intensity = effect.intensity ?? 0.1;
+    const size = effect.size ?? 1;
+    const seed = effect.seed ?? 0;
+    const program = getGlEffectProgram(state, 'stylization.filmGrain', FILM_GRAIN_FRAGMENT_SRC);
+    drawGlFullscreenPass(state, program, [source.texture], dest, (gl, p) => {
+        gl.uniform1f(gl.getUniformLocation(p.program, 'u_intensity'), intensity);
+        gl.uniform1f(gl.getUniformLocation(p.program, 'u_size'), Math.max(0.0001, size));
+        gl.uniform1f(gl.getUniformLocation(p.program, 'u_seed'), seed);
+    });
+}
+export const defaultGlFilmGrainEffectRunner = (ctx, effect) => {
+    applyFilmGrainEffectToGl(ctx.state, ctx.source, ctx.dest, effect);
+};
+const FILM_GRAIN_FRAGMENT_SRC = `#version 300 es
+precision highp float;
+in vec2 v_texCoord;
+uniform sampler2D u_texture0;
+uniform float u_intensity;
+uniform float u_size;
+uniform float u_seed;
+out vec4 o_color;
+float hash(vec2 p) {
+  p = floor(p / u_size);
+  return fract(sin(dot(p, vec2(127.1, 311.7)) + u_seed) * 43758.5453123);
+}
+void main() {
+  vec4 c = texture(u_texture0, v_texCoord);
+  float n = hash(v_texCoord * 1024.0) - 0.5;
+  o_color = vec4(c.rgb + n * u_intensity, c.a);
+}`;
+//# sourceMappingURL=glFilmGrainEffect.js.map

package/dist/glFilmGrainEffect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"glFilmGrainEffect.js","sourceRoot":"","sources":["../src/glFilmGrainEffect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAG3D,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAE5D,mGAAmG;AACnG,wCAAwC;AACxC,MAAM,UAAU,wBAAwB,CACtC,KAAoB,EACpB,MAAgC,EAChC,IAA8B,EAC9B,MAAiC;IAEjC,MAAM,SAAS,GAAG,MAAM,CAAC,SAAS,IAAI,GAAG,CAAC;IAC1C,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,IAAI,CAAC,CAAC;IAC9B,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,IAAI,CAAC,CAAC;IAC9B,MAAM,OAAO,GAAG,kBAAkB,CAAC,KAAK,EAAE,uBAAuB,EAAE,uBAAuB,CAAC,CAAC;IAC5F,oBAAoB,CAAC,KAAK,EAAE,OAAO,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,EAAE,CAAC,EAAE,EAAE;QACrE,EAAE,CAAC,SAAS,CAAC,EAAE,CAAC,kBAAkB,CAAC,CAAC,CAAC,OAAO,EAAE,aAAa,CAAC,EAAE,SAAS,CAAC,CAAC;QACzE,EAAE,CAAC,SAAS,CAAC,EAAE,CAAC,kBAAkB,CAAC,CAAC,CAAC,OAAO,EAAE,QAAQ,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC,CAAC;QACjF,EAAE,CAAC,SAAS,CAAC,EAAE,CAAC,kBAAkB,CAAC,CAAC,CAAC,OAAO,EAAE,QAAQ,CAAC,EAAE,IAAI,CAAC,CAAC;IACjE,CAAC,CAAC,CAAC;AACL,CAAC;AAED,MAAM,CAAC,MAAM,8BAA8B,GAAyB,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE;IAClF,wBAAwB,CAAC,GAAG,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,IAAI,EAAE,MAAyB,CAAC,CAAC;AACvF,CAAC,CAAC;AAEF,MAAM,uBAAuB,GAAG;;;;;;;;;;;;;;;;EAgB9B,CAAC"}

package/dist/glFxaaEffect.d.ts

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

package/dist/glFxaaEffect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"glFxaaEffect.d.ts","sourceRoot":"","sources":["../src/glFxaaEffect.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,oBAAoB,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAMvG,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,aAAa,EACpB,MAAM,EAAE,QAAQ,CAAC,cAAc,CAAC,EAChC,IAAI,EAAE,QAAQ,CAAC,cAAc,CAAC,EAC9B,MAAM,EAAE,QAAQ,CAAC,UAAU,CAAC,GAC3B,IAAI,CAON;AAED,eAAO,MAAM,yBAAyB,EAAE,oBAEvC,CAAC"}

package/dist/glFxaaEffect.js

@@ -0,0 +1,61 @@
+import { drawGlFullscreenPass } from '@flighthq/render-gl';
+import { getGlEffectProgram } from './glEffectProgramCache';
+// FXAA: luminance edge detection + directional blend along the detected edge. Single-pass reference
+// recipe. Reads u_texture0; u_resolution gives the texel size; u_edgeThreshold gates edge detection.
+export function applyFxaaEffectToGl(state, source, dest, effect) {
+    const edgeThreshold = effect.edgeThreshold ?? 0.0312;
+    const program = getGlEffectProgram(state, 'antialiasing.fxaa', FXAA_FRAGMENT_SRC);
+    drawGlFullscreenPass(state, program, [source.texture], dest, (gl, p) => {
+        gl.uniform2f(gl.getUniformLocation(p.program, 'u_resolution'), source.width, source.height);
+        gl.uniform1f(gl.getUniformLocation(p.program, 'u_edgeThreshold'), edgeThreshold);
+    });
+}
+export const defaultGlFxaaEffectRunner = (ctx, effect) => {
+    applyFxaaEffectToGl(ctx.state, ctx.source, ctx.dest, effect);
+};
+const FXAA_FRAGMENT_SRC = `#version 300 es
+precision highp float;
+in vec2 v_texCoord;
+uniform sampler2D u_texture0;
+uniform vec2 u_resolution;
+uniform float u_edgeThreshold;
+out vec4 o_color;
+float luma(vec3 c) {
+  return dot(c, vec3(0.299, 0.587, 0.114));
+}
+void main() {
+  vec2 texel = 1.0 / u_resolution;
+  vec3 rgbM = texture(u_texture0, v_texCoord).rgb;
+  vec3 rgbNW = texture(u_texture0, v_texCoord + vec2(-1.0, -1.0) * texel).rgb;
+  vec3 rgbNE = texture(u_texture0, v_texCoord + vec2(1.0, -1.0) * texel).rgb;
+  vec3 rgbSW = texture(u_texture0, v_texCoord + vec2(-1.0, 1.0) * texel).rgb;
+  vec3 rgbSE = texture(u_texture0, v_texCoord + vec2(1.0, 1.0) * texel).rgb;
+  float lumaM = luma(rgbM);
+  float lumaNW = luma(rgbNW);
+  float lumaNE = luma(rgbNE);
+  float lumaSW = luma(rgbSW);
+  float lumaSE = luma(rgbSE);
+  float lumaMin = min(lumaM, min(min(lumaNW, lumaNE), min(lumaSW, lumaSE)));
+  float lumaMax = max(lumaM, max(max(lumaNW, lumaNE), max(lumaSW, lumaSE)));
+  float range = lumaMax - lumaMin;
+  if (range < max(u_edgeThreshold, lumaMax * 0.125)) {
+    o_color = vec4(rgbM, texture(u_texture0, v_texCoord).a);
+    return;
+  }
+  vec2 dir;
+  dir.x = -((lumaNW + lumaNE) - (lumaSW + lumaSE));
+  dir.y = ((lumaNW + lumaSW) - (lumaNE + lumaSE));
+  float dirReduce = max((lumaNW + lumaNE + lumaSW + lumaSE) * 0.03125, 0.0078125);
+  float rcpDirMin = 1.0 / (min(abs(dir.x), abs(dir.y)) + dirReduce);
+  dir = clamp(dir * rcpDirMin, vec2(-8.0), vec2(8.0)) * texel;
+  vec3 rgbA = 0.5 * (
+    texture(u_texture0, v_texCoord + dir * (1.0 / 3.0 - 0.5)).rgb +
+    texture(u_texture0, v_texCoord + dir * (2.0 / 3.0 - 0.5)).rgb);
+  vec3 rgbB = rgbA * 0.5 + 0.25 * (
+    texture(u_texture0, v_texCoord + dir * -0.5).rgb +
+    texture(u_texture0, v_texCoord + dir * 0.5).rgb);
+  float lumaB = luma(rgbB);
+  vec3 result = (lumaB < lumaMin || lumaB > lumaMax) ? rgbA : rgbB;
+  o_color = vec4(result, texture(u_texture0, v_texCoord).a);
+}`;
+//# sourceMappingURL=glFxaaEffect.js.map

package/dist/glFxaaEffect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"glFxaaEffect.js","sourceRoot":"","sources":["../src/glFxaaEffect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAG3D,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAE5D,oGAAoG;AACpG,qGAAqG;AACrG,MAAM,UAAU,mBAAmB,CACjC,KAAoB,EACpB,MAAgC,EAChC,IAA8B,EAC9B,MAA4B;IAE5B,MAAM,aAAa,GAAG,MAAM,CAAC,aAAa,IAAI,MAAM,CAAC;IACrD,MAAM,OAAO,GAAG,kBAAkB,CAAC,KAAK,EAAE,mBAAmB,EAAE,iBAAiB,CAAC,CAAC;IAClF,oBAAoB,CAAC,KAAK,EAAE,OAAO,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,EAAE,CAAC,EAAE,EAAE;QACrE,EAAE,CAAC,SAAS,CAAC,EAAE,CAAC,kBAAkB,CAAC,CAAC,CAAC,OAAO,EAAE,cAAc,CAAC,EAAE,MAAM,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC;QAC5F,EAAE,CAAC,SAAS,CAAC,EAAE,CAAC,kBAAkB,CAAC,CAAC,CAAC,OAAO,EAAE,iBAAiB,CAAC,EAAE,aAAa,CAAC,CAAC;IACnF,CAAC,CAAC,CAAC;AACL,CAAC;AAED,MAAM,CAAC,MAAM,yBAAyB,GAAyB,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE;IAC7E,mBAAmB,CAAC,GAAG,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,IAAI,EAAE,MAAoB,CAAC,CAAC;AAC7E,CAAC,CAAC;AAEF,MAAM,iBAAiB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4CxB,CAAC"}

package/dist/glGlitchEffect.d.ts

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

package/dist/glGlitchEffect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"glGlitchEffect.d.ts","sourceRoot":"","sources":["../src/glGlitchEffect.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,oBAAoB,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAMzG,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,aAAa,EACpB,MAAM,EAAE,QAAQ,CAAC,cAAc,CAAC,EAChC,IAAI,EAAE,QAAQ,CAAC,cAAc,CAAC,EAC9B,MAAM,EAAE,QAAQ,CAAC,YAAY,CAAC,GAC7B,IAAI,CAaN;AAED,eAAO,MAAM,2BAA2B,EAAE,oBAEzC,CAAC"}

package/dist/glGlitchEffect.js

@@ -0,0 +1,50 @@
+import { drawGlFullscreenPass } from '@flighthq/render-gl';
+import { getGlEffectProgram } from './glEffectProgramCache';
+// Glitch: split the frame into horizontal blocks, displace each by a per-block hash (data-mosh tear),
+// separate the RGB channels, and corrupt the occasional block to white. `seed` animates it.
+export function applyGlitchEffectToGl(state, source, dest, effect) {
+    const intensity = effect.intensity ?? 0.5;
+    const blockSize = effect.blockSize ?? 24;
+    const colorShift = effect.colorShift ?? 8;
+    const seed = effect.seed ?? 0;
+    const program = getGlEffectProgram(state, 'stylization.glitch', GLITCH_FRAGMENT_SRC);
+    drawGlFullscreenPass(state, program, [source.texture], dest, (gl, p) => {
+        gl.uniform1f(gl.getUniformLocation(p.program, 'u_intensity'), intensity);
+        gl.uniform1f(gl.getUniformLocation(p.program, 'u_blockSize'), blockSize);
+        gl.uniform1f(gl.getUniformLocation(p.program, 'u_colorShift'), colorShift);
+        gl.uniform1f(gl.getUniformLocation(p.program, 'u_seed'), seed);
+        gl.uniform2f(gl.getUniformLocation(p.program, 'u_resolution'), source.width, source.height);
+    });
+}
+export const defaultGlGlitchEffectRunner = (ctx, effect) => {
+    applyGlitchEffectToGl(ctx.state, ctx.source, ctx.dest, effect);
+};
+const GLITCH_FRAGMENT_SRC = `#version 300 es
+precision highp float;
+in vec2 v_texCoord;
+uniform sampler2D u_texture0;
+uniform float u_intensity;
+uniform float u_blockSize;
+uniform float u_colorShift;
+uniform float u_seed;
+uniform vec2 u_resolution;
+out vec4 o_color;
+float ghash(float n) { return fract(sin(n) * 43758.5453123); }
+void main() {
+  float blockSize = max(2.0, u_blockSize);
+  float block = floor(v_texCoord.y * u_resolution.y / blockSize);
+  float r = ghash(block + u_seed * 7.0);
+  float tear = step(1.0 - u_intensity * 0.6, r);
+  float shiftPx = (ghash(block * 1.7 + u_seed) - 0.5) * 2.0 * tear * u_intensity * 40.0;
+  vec2 baseUv = vec2(v_texCoord.x + shiftPx / u_resolution.x, v_texCoord.y);
+  float cs = (u_colorShift * (0.4 + tear)) / u_resolution.x;
+  float rC = texture(u_texture0, vec2(baseUv.x + cs, baseUv.y)).r;
+  float gC = texture(u_texture0, baseUv).g;
+  float bC = texture(u_texture0, vec2(baseUv.x - cs, baseUv.y)).b;
+  float a = texture(u_texture0, baseUv).a;
+  vec3 col = vec3(rC, gC, bC);
+  float corrupt = step(0.985 - u_intensity * 0.04, ghash(block * 3.3 + u_seed * 2.0));
+  col = mix(col, vec3(1.0), corrupt * 0.6);
+  o_color = vec4(col, a);
+}`;
+//# sourceMappingURL=glGlitchEffect.js.map

package/dist/glGlitchEffect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"glGlitchEffect.js","sourceRoot":"","sources":["../src/glGlitchEffect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAG3D,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAE5D,sGAAsG;AACtG,4FAA4F;AAC5F,MAAM,UAAU,qBAAqB,CACnC,KAAoB,EACpB,MAAgC,EAChC,IAA8B,EAC9B,MAA8B;IAE9B,MAAM,SAAS,GAAG,MAAM,CAAC,SAAS,IAAI,GAAG,CAAC;IAC1C,MAAM,SAAS,GAAG,MAAM,CAAC,SAAS,IAAI,EAAE,CAAC;IACzC,MAAM,UAAU,GAAG,MAAM,CAAC,UAAU,IAAI,CAAC,CAAC;IAC1C,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,IAAI,CAAC,CAAC;IAC9B,MAAM,OAAO,GAAG,kBAAkB,CAAC,KAAK,EAAE,oBAAoB,EAAE,mBAAmB,CAAC,CAAC;IACrF,oBAAoB,CAAC,KAAK,EAAE,OAAO,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,EAAE,CAAC,EAAE,EAAE;QACrE,EAAE,CAAC,SAAS,CAAC,EAAE,CAAC,kBAAkB,CAAC,CAAC,CAAC,OAAO,EAAE,aAAa,CAAC,EAAE,SAAS,CAAC,CAAC;QACzE,EAAE,CAAC,SAAS,CAAC,EAAE,CAAC,kBAAkB,CAAC,CAAC,CAAC,OAAO,EAAE,aAAa,CAAC,EAAE,SAAS,CAAC,CAAC;QACzE,EAAE,CAAC,SAAS,CAAC,EAAE,CAAC,kBAAkB,CAAC,CAAC,CAAC,OAAO,EAAE,cAAc,CAAC,EAAE,UAAU,CAAC,CAAC;QAC3E,EAAE,CAAC,SAAS,CAAC,EAAE,CAAC,kBAAkB,CAAC,CAAC,CAAC,OAAO,EAAE,QAAQ,CAAC,EAAE,IAAI,CAAC,CAAC;QAC/D,EAAE,CAAC,SAAS,CAAC,EAAE,CAAC,kBAAkB,CAAC,CAAC,CAAC,OAAO,EAAE,cAAc,CAAC,EAAE,MAAM,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC;IAC9F,CAAC,CAAC,CAAC;AACL,CAAC;AAED,MAAM,CAAC,MAAM,2BAA2B,GAAyB,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE;IAC/E,qBAAqB,CAAC,GAAG,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,IAAI,EAAE,MAAsB,CAAC,CAAC;AACjF,CAAC,CAAC;AAEF,MAAM,mBAAmB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2B1B,CAAC"}

package/dist/glGodRaysEffect.d.ts

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

package/dist/glGodRaysEffect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"glGodRaysEffect.d.ts","sourceRoot":"","sources":["../src/glGodRaysEffect.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,aAAa,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAQ1G,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,aAAa,EACpB,MAAM,EAAE,QAAQ,CAAC,cAAc,CAAC,EAChC,IAAI,EAAE,QAAQ,CAAC,cAAc,CAAC,EAC9B,MAAM,EAAE,QAAQ,CAAC,aAAa,CAAC,GAC9B,IAAI,CAiBN;AAED,eAAO,MAAM,4BAA4B,EAAE,oBAE1C,CAAC"}

package/dist/glGodRaysEffect.js

@@ -0,0 +1,59 @@
+import { drawGlFullscreenPass } from '@flighthq/render-gl';
+import { getGlEffectProgram } from './glEffectProgramCache';
+// God rays: radial light scattering from a screen-space light position (centerX, centerY). Marches
+// SAMPLES steps along the ray from each fragment toward the light, accumulating color with per-step
+// decay and weight, then scales by exposure. A true single-pass recipe — no depth needed. Reads
+// u_texture0; u_resolution is set so the light direction is computed in a consistent space.
+export function applyGodRaysEffectToGl(state, source, dest, effect) {
+    const centerX = effect.centerX ?? 0.5;
+    const centerY = effect.centerY ?? 0.5;
+    const density = effect.density ?? 0.96;
+    const decay = effect.decay ?? 0.93;
+    const weight = effect.weight ?? 0.4;
+    const exposure = effect.exposure ?? 0.6;
+    const samples = Math.max(1, Math.round(effect.samples ?? 64));
+    const program = getGlEffectProgram(state, `atmospheric.godRays.${samples}`, buildGodRaysFragment(samples));
+    drawGlFullscreenPass(state, program, [source.texture], dest, (gl, p) => {
+        gl.uniform2f(gl.getUniformLocation(p.program, 'u_resolution'), source.width, source.height);
+        gl.uniform2f(gl.getUniformLocation(p.program, 'u_lightPosition'), centerX, centerY);
+        gl.uniform1f(gl.getUniformLocation(p.program, 'u_density'), density);
+        gl.uniform1f(gl.getUniformLocation(p.program, 'u_decay'), decay);
+        gl.uniform1f(gl.getUniformLocation(p.program, 'u_weight'), weight);
+        gl.uniform1f(gl.getUniformLocation(p.program, 'u_exposure'), exposure);
+    });
+}
+export const defaultGlGodRaysEffectRunner = (ctx, effect) => {
+    applyGodRaysEffectToGl(ctx.state, ctx.source, ctx.dest, effect);
+};
+function buildGodRaysFragment(samples) {
+    return GOD_RAYS_FRAGMENT_HEAD + samples.toFixed(1) + GOD_RAYS_FRAGMENT_TAIL;
+}
+const GOD_RAYS_FRAGMENT_HEAD = `#version 300 es
+precision highp float;
+in vec2 v_texCoord;
+uniform sampler2D u_texture0;
+uniform vec2 u_resolution;
+uniform vec2 u_lightPosition;
+uniform float u_density;
+uniform float u_decay;
+uniform float u_weight;
+uniform float u_exposure;
+out vec4 o_color;
+const float SAMPLES = `;
+const GOD_RAYS_FRAGMENT_TAIL = `;
+void main() {
+  vec2 delta = (v_texCoord - u_lightPosition) * (u_density / SAMPLES);
+  vec2 coord = v_texCoord;
+  vec4 base = texture(u_texture0, v_texCoord);
+  vec3 accum = base.rgb;
+  float illumination = 1.0;
+  for (int i = 0; i < int(SAMPLES); i++) {
+    coord -= delta;
+    vec3 s = texture(u_texture0, coord).rgb;
+    s *= illumination * u_weight;
+    accum += s;
+    illumination *= u_decay;
+  }
+  o_color = vec4(base.rgb + accum * u_exposure, base.a);
+}`;
+//# sourceMappingURL=glGodRaysEffect.js.map

package/dist/glGodRaysEffect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"glGodRaysEffect.js","sourceRoot":"","sources":["../src/glGodRaysEffect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAG3D,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAE5D,mGAAmG;AACnG,oGAAoG;AACpG,gGAAgG;AAChG,4FAA4F;AAC5F,MAAM,UAAU,sBAAsB,CACpC,KAAoB,EACpB,MAAgC,EAChC,IAA8B,EAC9B,MAA+B;IAE/B,MAAM,OAAO,GAAG,MAAM,CAAC,OAAO,IAAI,GAAG,CAAC;IACtC,MAAM,OAAO,GAAG,MAAM,CAAC,OAAO,IAAI,GAAG,CAAC;IACtC,MAAM,OAAO,GAAG,MAAM,CAAC,OAAO,IAAI,IAAI,CAAC;IACvC,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,IAAI,IAAI,CAAC;IACnC,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,IAAI,GAAG,CAAC;IACpC,MAAM,QAAQ,GAAG,MAAM,CAAC,QAAQ,IAAI,GAAG,CAAC;IACxC,MAAM,OAAO,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,OAAO,IAAI,EAAE,CAAC,CAAC,CAAC;IAC9D,MAAM,OAAO,GAAG,kBAAkB,CAAC,KAAK,EAAE,uBAAuB,OAAO,EAAE,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC,CAAC;IAC3G,oBAAoB,CAAC,KAAK,EAAE,OAAO,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,EAAE,CAAC,EAAE,EAAE;QACrE,EAAE,CAAC,SAAS,CAAC,EAAE,CAAC,kBAAkB,CAAC,CAAC,CAAC,OAAO,EAAE,cAAc,CAAC,EAAE,MAAM,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC;QAC5F,EAAE,CAAC,SAAS,CAAC,EAAE,CAAC,kBAAkB,CAAC,CAAC,CAAC,OAAO,EAAE,iBAAiB,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC;QACpF,EAAE,CAAC,SAAS,CAAC,EAAE,CAAC,kBAAkB,CAAC,CAAC,CAAC,OAAO,EAAE,WAAW,CAAC,EAAE,OAAO,CAAC,CAAC;QACrE,EAAE,CAAC,SAAS,CAAC,EAAE,CAAC,kBAAkB,CAAC,CAAC,CAAC,OAAO,EAAE,SAAS,CAAC,EAAE,KAAK,CAAC,CAAC;QACjE,EAAE,CAAC,SAAS,CAAC,EAAE,CAAC,kBAAkB,CAAC,CAAC,CAAC,OAAO,EAAE,UAAU,CAAC,EAAE,MAAM,CAAC,CAAC;QACnE,EAAE,CAAC,SAAS,CAAC,EAAE,CAAC,kBAAkB,CAAC,CAAC,CAAC,OAAO,EAAE,YAAY,CAAC,EAAE,QAAQ,CAAC,CAAC;IACzE,CAAC,CAAC,CAAC;AACL,CAAC;AAED,MAAM,CAAC,MAAM,4BAA4B,GAAyB,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE;IAChF,sBAAsB,CAAC,GAAG,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,IAAI,EAAE,MAAuB,CAAC,CAAC;AACnF,CAAC,CAAC;AAEF,SAAS,oBAAoB,CAAC,OAAe;IAC3C,OAAO,sBAAsB,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,sBAAsB,CAAC;AAC9E,CAAC;AAED,MAAM,sBAAsB,GAAG;;;;;;;;;;;uBAWR,CAAC;AAExB,MAAM,sBAAsB,GAAG;;;;;;;;;;;;;;;EAe7B,CAAC"}

package/dist/glGrayscaleEffect.d.ts

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

package/dist/glGrayscaleEffect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"glGrayscaleEffect.d.ts","sourceRoot":"","sources":["../src/glGrayscaleEffect.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,aAAa,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAK5G,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,CAMN;AAED,eAAO,MAAM,8BAA8B,EAAE,oBAE5C,CAAC"}

package/dist/glGrayscaleEffect.js

@@ -0,0 +1,25 @@
+import { drawGlFullscreenPass } from '@flighthq/render-gl';
+import { getGlEffectProgram } from './glEffectProgramCache';
+// Grayscale: mix toward luminance by intensity.
+export function applyGrayscaleEffectToGl(state, source, dest, effect) {
+    const intensity = effect.intensity ?? 1;
+    const program = getGlEffectProgram(state, 'colorGrade.grayscale', GRAYSCALE_FRAGMENT_SRC);
+    drawGlFullscreenPass(state, program, [source.texture], dest, (gl, p) => {
+        gl.uniform1f(gl.getUniformLocation(p.program, 'u_intensity'), intensity);
+    });
+}
+export const defaultGlGrayscaleEffectRunner = (ctx, effect) => {
+    applyGrayscaleEffectToGl(ctx.state, ctx.source, ctx.dest, effect);
+};
+const GRAYSCALE_FRAGMENT_SRC = `#version 300 es
+precision highp float;
+in vec2 v_texCoord;
+uniform sampler2D u_texture0;
+uniform float u_intensity;
+out vec4 o_color;
+void main() {
+  vec4 c = texture(u_texture0, v_texCoord);
+  float l = dot(c.rgb, vec3(0.2126, 0.7152, 0.0722));
+  o_color = vec4(mix(c.rgb, vec3(l), u_intensity), c.a);
+}`;
+//# sourceMappingURL=glGrayscaleEffect.js.map

package/dist/glGrayscaleEffect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"glGrayscaleEffect.js","sourceRoot":"","sources":["../src/glGrayscaleEffect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAG3D,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAE5D,gDAAgD;AAChD,MAAM,UAAU,wBAAwB,CACtC,KAAoB,EACpB,MAAgC,EAChC,IAA8B,EAC9B,MAAiC;IAEjC,MAAM,SAAS,GAAG,MAAM,CAAC,SAAS,IAAI,CAAC,CAAC;IACxC,MAAM,OAAO,GAAG,kBAAkB,CAAC,KAAK,EAAE,sBAAsB,EAAE,sBAAsB,CAAC,CAAC;IAC1F,oBAAoB,CAAC,KAAK,EAAE,OAAO,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,EAAE,CAAC,EAAE,EAAE;QACrE,EAAE,CAAC,SAAS,CAAC,EAAE,CAAC,kBAAkB,CAAC,CAAC,CAAC,OAAO,EAAE,aAAa,CAAC,EAAE,SAAS,CAAC,CAAC;IAC3E,CAAC,CAAC,CAAC;AACL,CAAC;AAED,MAAM,CAAC,MAAM,8BAA8B,GAAyB,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE;IAClF,wBAAwB,CAAC,GAAG,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,IAAI,EAAE,MAAyB,CAAC,CAAC;AACvF,CAAC,CAAC;AAEF,MAAM,sBAAsB,GAAG;;;;;;;;;;EAU7B,CAAC"}

package/dist/glHalftoneEffect.d.ts

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

package/dist/glHalftoneEffect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"glHalftoneEffect.d.ts","sourceRoot":"","sources":["../src/glHalftoneEffect.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,aAAa,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAM3G,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,aAAa,EACpB,MAAM,EAAE,QAAQ,CAAC,cAAc,CAAC,EAChC,IAAI,EAAE,QAAQ,CAAC,cAAc,CAAC,EAC9B,MAAM,EAAE,QAAQ,CAAC,cAAc,CAAC,GAC/B,IAAI,CASN;AAED,eAAO,MAAM,6BAA6B,EAAE,oBAE3C,CAAC"}

package/dist/glHalftoneEffect.js

@@ -0,0 +1,38 @@
+import { drawGlFullscreenPass } from '@flighthq/render-gl';
+import { getGlEffectProgram } from './glEffectProgramCache';
+// Halftone: sample luminance, then carve a rotated dot grid whose dot radius tracks darkness — the
+// classic print/comic screen. `scale` sets the cell size, `angle` rotates the grid.
+export function applyHalftoneEffectToGl(state, source, dest, effect) {
+    const scale = effect.scale ?? 6;
+    const angle = effect.angle ?? 0.4;
+    const program = getGlEffectProgram(state, 'stylization.halftone', HALFTONE_FRAGMENT_SRC);
+    drawGlFullscreenPass(state, program, [source.texture], dest, (gl, p) => {
+        gl.uniform1f(gl.getUniformLocation(p.program, 'u_scale'), Math.max(1, scale));
+        gl.uniform1f(gl.getUniformLocation(p.program, 'u_angle'), angle);
+        gl.uniform2f(gl.getUniformLocation(p.program, 'u_resolution'), source.width, source.height);
+    });
+}
+export const defaultGlHalftoneEffectRunner = (ctx, effect) => {
+    applyHalftoneEffectToGl(ctx.state, ctx.source, ctx.dest, effect);
+};
+const HALFTONE_FRAGMENT_SRC = `#version 300 es
+precision highp float;
+in vec2 v_texCoord;
+uniform sampler2D u_texture0;
+uniform float u_scale;
+uniform float u_angle;
+uniform vec2 u_resolution;
+out vec4 o_color;
+void main() {
+  vec4 c = texture(u_texture0, v_texCoord);
+  float lum = dot(c.rgb, vec3(0.2126, 0.7152, 0.0722));
+  vec2 p = v_texCoord * u_resolution;
+  float s = sin(u_angle), co = cos(u_angle);
+  vec2 rp = vec2(p.x * co - p.y * s, p.x * s + p.y * co);
+  vec2 cell = mod(rp, u_scale) - u_scale * 0.5;
+  float dist = length(cell) / (u_scale * 0.5);
+  float radius = sqrt(1.0 - lum);
+  float dot1 = step(dist, radius);
+  o_color = vec4(c.rgb * dot1, c.a);
+}`;
+//# sourceMappingURL=glHalftoneEffect.js.map