@flighthq/effects-gl 0.1.0

package/dist/glHalftoneEffect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"glHalftoneEffect.js","sourceRoot":"","sources":["../src/glHalftoneEffect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAG3D,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAE5D,mGAAmG;AACnG,oFAAoF;AACpF,MAAM,UAAU,uBAAuB,CACrC,KAAoB,EACpB,MAAgC,EAChC,IAA8B,EAC9B,MAAgC;IAEhC,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,IAAI,CAAC,CAAC;IAChC,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,IAAI,GAAG,CAAC;IAClC,MAAM,OAAO,GAAG,kBAAkB,CAAC,KAAK,EAAE,sBAAsB,EAAE,qBAAqB,CAAC,CAAC;IACzF,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,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC;QAC9E,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,cAAc,CAAC,EAAE,MAAM,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC;IAC9F,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;;;;;;;;;;;;;;;;;;;EAmB5B,CAAC"}

package/dist/glHueSaturationEffect.d.ts

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

package/dist/glHueSaturationEffect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"glHueSaturationEffect.d.ts","sourceRoot":"","sources":["../src/glHueSaturationEffect.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,aAAa,EAAE,cAAc,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAKhH,wBAAgB,4BAA4B,CAC1C,KAAK,EAAE,aAAa,EACpB,MAAM,EAAE,QAAQ,CAAC,cAAc,CAAC,EAChC,IAAI,EAAE,QAAQ,CAAC,cAAc,CAAC,EAC9B,MAAM,EAAE,QAAQ,CAAC,mBAAmB,CAAC,GACpC,IAAI,CAUN;AAED,eAAO,MAAM,kCAAkC,EAAE,oBAEhD,CAAC"}

package/dist/glHueSaturationEffect.js

@@ -0,0 +1,67 @@
+import { drawGlFullscreenPass } from '@flighthq/render-gl';
+import { getGlEffectProgram } from './glEffectProgramCache';
+// Hue/saturation/lightness: convert to HSL, adjust, convert back.
+export function applyHueSaturationEffectToGl(state, source, dest, effect) {
+    const hue = effect.hue ?? 0;
+    const saturation = effect.saturation ?? 1;
+    const lightness = effect.lightness ?? 0;
+    const program = getGlEffectProgram(state, 'colorGrade.hueSaturation', HUE_SATURATION_FRAGMENT_SRC);
+    drawGlFullscreenPass(state, program, [source.texture], dest, (gl, p) => {
+        gl.uniform1f(gl.getUniformLocation(p.program, 'u_hue'), hue / 360);
+        gl.uniform1f(gl.getUniformLocation(p.program, 'u_saturation'), saturation);
+        gl.uniform1f(gl.getUniformLocation(p.program, 'u_lightness'), lightness);
+    });
+}
+export const defaultGlHueSaturationEffectRunner = (ctx, effect) => {
+    applyHueSaturationEffectToGl(ctx.state, ctx.source, ctx.dest, effect);
+};
+const HUE_SATURATION_FRAGMENT_SRC = `#version 300 es
+precision highp float;
+in vec2 v_texCoord;
+uniform sampler2D u_texture0;
+uniform float u_hue;
+uniform float u_saturation;
+uniform float u_lightness;
+out vec4 o_color;
+vec3 rgb2hsl(vec3 c) {
+  float mx = max(c.r, max(c.g, c.b));
+  float mn = min(c.r, min(c.g, c.b));
+  float l = (mx + mn) * 0.5;
+  float h = 0.0;
+  float s = 0.0;
+  float d = mx - mn;
+  if (d > 0.0001) {
+    s = l < 0.5 ? d / (mx + mn) : d / (2.0 - mx - mn);
+    if (mx == c.r) h = (c.g - c.b) / d + (c.g < c.b ? 6.0 : 0.0);
+    else if (mx == c.g) h = (c.b - c.r) / d + 2.0;
+    else h = (c.r - c.g) / d + 4.0;
+    h /= 6.0;
+  }
+  return vec3(h, s, l);
+}
+float hue2rgb(float p, float q, float t) {
+  if (t < 0.0) t += 1.0;
+  if (t > 1.0) t -= 1.0;
+  if (t < 1.0 / 6.0) return p + (q - p) * 6.0 * t;
+  if (t < 1.0 / 2.0) return q;
+  if (t < 2.0 / 3.0) return p + (q - p) * (2.0 / 3.0 - t) * 6.0;
+  return p;
+}
+vec3 hsl2rgb(vec3 hsl) {
+  float h = hsl.x;
+  float s = hsl.y;
+  float l = hsl.z;
+  if (s <= 0.0) return vec3(l);
+  float q = l < 0.5 ? l * (1.0 + s) : l + s - l * s;
+  float p = 2.0 * l - q;
+  return vec3(hue2rgb(p, q, h + 1.0 / 3.0), hue2rgb(p, q, h), hue2rgb(p, q, h - 1.0 / 3.0));
+}
+void main() {
+  vec4 c = texture(u_texture0, v_texCoord);
+  vec3 hsl = rgb2hsl(c.rgb);
+  hsl.x = fract(hsl.x + u_hue);
+  hsl.y = clamp(hsl.y * u_saturation, 0.0, 1.0);
+  hsl.z = clamp(hsl.z + u_lightness, 0.0, 1.0);
+  o_color = vec4(hsl2rgb(hsl), c.a);
+}`;
+//# sourceMappingURL=glHueSaturationEffect.js.map

package/dist/glHueSaturationEffect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"glHueSaturationEffect.js","sourceRoot":"","sources":["../src/glHueSaturationEffect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAG3D,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAE5D,kEAAkE;AAClE,MAAM,UAAU,4BAA4B,CAC1C,KAAoB,EACpB,MAAgC,EAChC,IAA8B,EAC9B,MAAqC;IAErC,MAAM,GAAG,GAAG,MAAM,CAAC,GAAG,IAAI,CAAC,CAAC;IAC5B,MAAM,UAAU,GAAG,MAAM,CAAC,UAAU,IAAI,CAAC,CAAC;IAC1C,MAAM,SAAS,GAAG,MAAM,CAAC,SAAS,IAAI,CAAC,CAAC;IACxC,MAAM,OAAO,GAAG,kBAAkB,CAAC,KAAK,EAAE,0BAA0B,EAAE,2BAA2B,CAAC,CAAC;IACnG,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,OAAO,CAAC,EAAE,GAAG,GAAG,GAAG,CAAC,CAAC;QACnE,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,aAAa,CAAC,EAAE,SAAS,CAAC,CAAC;IAC3E,CAAC,CAAC,CAAC;AACL,CAAC;AAED,MAAM,CAAC,MAAM,kCAAkC,GAAyB,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE;IACtF,4BAA4B,CAAC,GAAG,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,IAAI,EAAE,MAA6B,CAAC,CAAC;AAC/F,CAAC,CAAC;AAEF,MAAM,2BAA2B,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgDlC,CAAC"}

package/dist/glInvertEffect.d.ts

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

package/dist/glInvertEffect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"glInvertEffect.d.ts","sourceRoot":"","sources":["../src/glInvertEffect.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,aAAa,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAKzG,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,CAMN;AAED,eAAO,MAAM,2BAA2B,EAAE,oBAEzC,CAAC"}

package/dist/glInvertEffect.js

@@ -0,0 +1,24 @@
+import { drawGlFullscreenPass } from '@flighthq/render-gl';
+import { getGlEffectProgram } from './glEffectProgramCache';
+// Invert: mix toward 1 - rgb by intensity.
+export function applyInvertEffectToGl(state, source, dest, effect) {
+    const intensity = effect.intensity ?? 1;
+    const program = getGlEffectProgram(state, 'colorGrade.invert', INVERT_FRAGMENT_SRC);
+    drawGlFullscreenPass(state, program, [source.texture], dest, (gl, p) => {
+        gl.uniform1f(gl.getUniformLocation(p.program, 'u_intensity'), intensity);
+    });
+}
+export const defaultGlInvertEffectRunner = (ctx, effect) => {
+    applyInvertEffectToGl(ctx.state, ctx.source, ctx.dest, effect);
+};
+const INVERT_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);
+  o_color = vec4(mix(c.rgb, 1.0 - c.rgb, u_intensity), c.a);
+}`;
+//# sourceMappingURL=glInvertEffect.js.map

package/dist/glInvertEffect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"glInvertEffect.js","sourceRoot":"","sources":["../src/glInvertEffect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAG3D,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAE5D,2CAA2C;AAC3C,MAAM,UAAU,qBAAqB,CACnC,KAAoB,EACpB,MAAgC,EAChC,IAA8B,EAC9B,MAA8B;IAE9B,MAAM,SAAS,GAAG,MAAM,CAAC,SAAS,IAAI,CAAC,CAAC;IACxC,MAAM,OAAO,GAAG,kBAAkB,CAAC,KAAK,EAAE,mBAAmB,EAAE,mBAAmB,CAAC,CAAC;IACpF,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,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;;;;;;;;;EAS1B,CAAC"}

package/dist/glKuwaharaEffect.d.ts

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

package/dist/glKuwaharaEffect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"glKuwaharaEffect.d.ts","sourceRoot":"","sources":["../src/glKuwaharaEffect.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,aAAa,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAO3G,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,CAON;AAED,eAAO,MAAM,6BAA6B,EAAE,oBAE3C,CAAC"}

package/dist/glKuwaharaEffect.js

@@ -0,0 +1,61 @@
+import { drawGlFullscreenPass } from '@flighthq/render-gl';
+import { getGlEffectProgram } from './glEffectProgramCache';
+// Kuwahara: edge-preserving smoothing. Over a fixed small radius split the neighborhood into four
+// overlapping quadrants, compute each mean and variance, and emit the lowest-variance mean — flattens
+// regions while keeping edges crisp. `radius` gates the sampled extent.
+export function applyKuwaharaEffectToGl(state, source, dest, effect) {
+    const radius = effect.radius ?? 3;
+    const program = getGlEffectProgram(state, 'stylization.kuwahara', KUWAHARA_FRAGMENT_SRC);
+    drawGlFullscreenPass(state, program, [source.texture], dest, (gl, p) => {
+        gl.uniform1f(gl.getUniformLocation(p.program, 'u_radius'), Math.max(1, radius));
+        gl.uniform2f(gl.getUniformLocation(p.program, 'u_resolution'), source.width, source.height);
+    });
+}
+export const defaultGlKuwaharaEffectRunner = (ctx, effect) => {
+    applyKuwaharaEffectToGl(ctx.state, ctx.source, ctx.dest, effect);
+};
+const KUWAHARA_FRAGMENT_SRC = `#version 300 es
+precision highp float;
+in vec2 v_texCoord;
+uniform sampler2D u_texture0;
+uniform float u_radius;
+uniform vec2 u_resolution;
+out vec4 o_color;
+const int R = 4;
+void main() {
+  vec2 texel = 1.0 / u_resolution;
+  int r = int(min(float(R), u_radius));
+  vec3 means[4];
+  float vars[4];
+  ivec2 lo[4] = ivec2[4](ivec2(-1, -1), ivec2(0, -1), ivec2(-1, 0), ivec2(0, 0));
+  for (int q = 0; q < 4; q++) {
+    vec3 sum = vec3(0.0);
+    vec3 sumSq = vec3(0.0);
+    float n = 0.0;
+    for (int y = 0; y <= R; y++) {
+      for (int x = 0; x <= R; x++) {
+        if (x > r || y > r) continue;
+        ivec2 d = ivec2(x, y) * sign(lo[q] + ivec2(1)) + lo[q] * r;
+        vec2 off = vec2(float(d.x), float(d.y)) * texel;
+        vec3 col = texture(u_texture0, v_texCoord + off).rgb;
+        sum += col;
+        sumSq += col * col;
+        n += 1.0;
+      }
+    }
+    vec3 mean = sum / n;
+    means[q] = mean;
+    vec3 v = sumSq / n - mean * mean;
+    vars[q] = v.r + v.g + v.b;
+  }
+  float minVar = vars[0];
+  vec3 result = means[0];
+  for (int q = 1; q < 4; q++) {
+    if (vars[q] < minVar) {
+      minVar = vars[q];
+      result = means[q];
+    }
+  }
+  o_color = vec4(result, texture(u_texture0, v_texCoord).a);
+}`;
+//# sourceMappingURL=glKuwaharaEffect.js.map

package/dist/glKuwaharaEffect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"glKuwaharaEffect.js","sourceRoot":"","sources":["../src/glKuwaharaEffect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAG3D,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAE5D,kGAAkG;AAClG,sGAAsG;AACtG,wEAAwE;AACxE,MAAM,UAAU,uBAAuB,CACrC,KAAoB,EACpB,MAAgC,EAChC,IAA8B,EAC9B,MAAgC;IAEhC,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,IAAI,CAAC,CAAC;IAClC,MAAM,OAAO,GAAG,kBAAkB,CAAC,KAAK,EAAE,sBAAsB,EAAE,qBAAqB,CAAC,CAAC;IACzF,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,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2C5B,CAAC"}

package/dist/glLensDirtEffect.d.ts

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

package/dist/glLensDirtEffect.d.ts.map

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

package/dist/glLensDirtEffect.js

@@ -0,0 +1,45 @@
+import { drawGlFullscreenPass } from '@flighthq/render-gl';
+import { getGlEffectProgram } from './glEffectProgramCache';
+// Lens dirt: procedural soft smudges that brighten where the scene is bright — a cheap bloom-dirt overlay.
+export function applyLensDirtEffectToGl(state, source, dest, effect) {
+    const intensity = effect.intensity ?? 1;
+    const threshold = effect.threshold ?? 0.55;
+    const seed = effect.seed ?? 0;
+    const program = getGlEffectProgram(state, 'lens.lensDirt', LENS_DIRT_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_threshold'), threshold);
+        gl.uniform1f(gl.getUniformLocation(p.program, 'u_seed'), seed);
+    });
+}
+export const defaultGlLensDirtEffectRunner = (ctx, effect) => {
+    applyLensDirtEffectToGl(ctx.state, ctx.source, ctx.dest, effect);
+};
+const LENS_DIRT_FRAGMENT_SRC = `#version 300 es
+precision highp float;
+in vec2 v_texCoord;
+uniform sampler2D u_texture0;
+uniform float u_intensity;
+uniform float u_threshold;
+uniform float u_seed;
+out vec4 o_color;
+float dirtHash(vec2 p) { return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453123); }
+float dirtAmount(vec2 uv, float seed) {
+  float acc = 0.0;
+  for (int i = 0; i < 8; i++) {
+    float fi = float(i);
+    vec2 c = vec2(dirtHash(vec2(fi, seed)), dirtHash(vec2(fi + 9.0, seed)));
+    float r = 0.06 + 0.16 * dirtHash(vec2(fi + 3.0, seed));
+    float d = distance(uv, c) / r;
+    acc += smoothstep(1.0, 0.0, d) * (0.3 + 0.7 * dirtHash(vec2(fi + 5.0, seed)));
+  }
+  return clamp(acc, 0.0, 1.0);
+}
+void main() {
+  vec4 c = texture(u_texture0, v_texCoord);
+  float lum = dot(c.rgb, vec3(0.299, 0.587, 0.114));
+  float bright = max(0.0, lum - u_threshold);
+  float dirt = dirtAmount(v_texCoord, u_seed + 1.0);
+  o_color = vec4(c.rgb + bright * dirt * u_intensity * 2.0, c.a);
+}`;
+//# sourceMappingURL=glLensDirtEffect.js.map

package/dist/glLensDirtEffect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"glLensDirtEffect.js","sourceRoot":"","sources":["../src/glLensDirtEffect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAG3D,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAE5D,2GAA2G;AAC3G,MAAM,UAAU,uBAAuB,CACrC,KAAoB,EACpB,MAAgC,EAChC,IAA8B,EAC9B,MAAgC;IAEhC,MAAM,SAAS,GAAG,MAAM,CAAC,SAAS,IAAI,CAAC,CAAC;IACxC,MAAM,SAAS,GAAG,MAAM,CAAC,SAAS,IAAI,IAAI,CAAC;IAC3C,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,IAAI,CAAC,CAAC;IAC9B,MAAM,OAAO,GAAG,kBAAkB,CAAC,KAAK,EAAE,eAAe,EAAE,sBAAsB,CAAC,CAAC;IACnF,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;IACjE,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,sBAAsB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;EA0B7B,CAAC"}

package/dist/glLensDistortionEffect.d.ts

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

package/dist/glLensDistortionEffect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"glLensDistortionEffect.d.ts","sourceRoot":"","sources":["../src/glLensDistortionEffect.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,aAAa,EAAE,cAAc,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAMjH,wBAAgB,6BAA6B,CAC3C,KAAK,EAAE,aAAa,EACpB,MAAM,EAAE,QAAQ,CAAC,cAAc,CAAC,EAChC,IAAI,EAAE,QAAQ,CAAC,cAAc,CAAC,EAC9B,MAAM,EAAE,QAAQ,CAAC,oBAAoB,CAAC,GACrC,IAAI,CAQN;AAED,eAAO,MAAM,mCAAmC,EAAE,oBAEjD,CAAC"}

package/dist/glLensDistortionEffect.js

@@ -0,0 +1,34 @@
+import { drawGlFullscreenPass } from '@flighthq/render-gl';
+import { getGlEffectProgram } from './glEffectProgramCache';
+// Lens distortion: remap uv by a radial polynomial. Positive amount bulges outward (barrel), negative
+// pinches inward (pincushion); scale re-frames the result so corners stay in view.
+export function applyLensDistortionEffectToGl(state, source, dest, effect) {
+    const amount = effect.amount ?? 0.2;
+    const scale = effect.scale ?? 1;
+    const program = getGlEffectProgram(state, 'lens.lensDistortion', LENS_DISTORTION_FRAGMENT_SRC);
+    drawGlFullscreenPass(state, program, [source.texture], dest, (gl, p) => {
+        gl.uniform1f(gl.getUniformLocation(p.program, 'u_amount'), amount);
+        gl.uniform1f(gl.getUniformLocation(p.program, 'u_scale'), scale);
+    });
+}
+export const defaultGlLensDistortionEffectRunner = (ctx, effect) => {
+    applyLensDistortionEffectToGl(ctx.state, ctx.source, ctx.dest, effect);
+};
+const LENS_DISTORTION_FRAGMENT_SRC = `#version 300 es
+precision highp float;
+in vec2 v_texCoord;
+uniform sampler2D u_texture0;
+uniform float u_amount;
+uniform float u_scale;
+out vec4 o_color;
+void main() {
+  vec2 centered = (v_texCoord - 0.5) / u_scale;
+  float r2 = dot(centered, centered);
+  vec2 distorted = centered * (1.0 + u_amount * r2) + 0.5;
+  if (distorted.x < 0.0 || distorted.x > 1.0 || distorted.y < 0.0 || distorted.y > 1.0) {
+    o_color = vec4(0.0, 0.0, 0.0, 1.0);
+  } else {
+    o_color = texture(u_texture0, distorted);
+  }
+}`;
+//# sourceMappingURL=glLensDistortionEffect.js.map

package/dist/glLensDistortionEffect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"glLensDistortionEffect.js","sourceRoot":"","sources":["../src/glLensDistortionEffect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAG3D,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAE5D,sGAAsG;AACtG,mFAAmF;AACnF,MAAM,UAAU,6BAA6B,CAC3C,KAAoB,EACpB,MAAgC,EAChC,IAA8B,EAC9B,MAAsC;IAEtC,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,IAAI,GAAG,CAAC;IACpC,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,IAAI,CAAC,CAAC;IAChC,MAAM,OAAO,GAAG,kBAAkB,CAAC,KAAK,EAAE,qBAAqB,EAAE,4BAA4B,CAAC,CAAC;IAC/F,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,MAAM,CAAC,CAAC;QACnE,EAAE,CAAC,SAAS,CAAC,EAAE,CAAC,kBAAkB,CAAC,CAAC,CAAC,OAAO,EAAE,SAAS,CAAC,EAAE,KAAK,CAAC,CAAC;IACnE,CAAC,CAAC,CAAC;AACL,CAAC;AAED,MAAM,CAAC,MAAM,mCAAmC,GAAyB,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE;IACvF,6BAA6B,CAAC,GAAG,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,IAAI,EAAE,MAA8B,CAAC,CAAC;AACjG,CAAC,CAAC;AAEF,MAAM,4BAA4B,GAAG;;;;;;;;;;;;;;;;EAgBnC,CAAC"}

package/dist/glLensFlareEffect.d.ts

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

package/dist/glLensFlareEffect.d.ts.map

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

package/dist/glLensFlareEffect.js

@@ -0,0 +1,56 @@
+import { drawGlFullscreenPass } from '@flighthq/render-gl';
+import { getGlEffectProgram } from './glEffectProgramCache';
+// Lens flare: a single-pass approximation. A true flare is a multi-pass recipe (downsample a bright
+// pass, then accumulate ghosts and a halo from it). Here, on each fragment, we sample the source's
+// bright spots along the vector from the pixel toward the center, adding `ghosts` evenly spaced ghost
+// samples plus a halo ring, scaled by threshold/intensity. It previews the look without the bright-pass
+// buffer.
+export function applyLensFlareEffectToGl(state, source, dest, effect) {
+    const threshold = effect.threshold ?? 0.8;
+    const intensity = effect.intensity ?? 1;
+    const ghosts = effect.ghosts ?? 4;
+    const halo = effect.halo ?? 0.5;
+    const program = getGlEffectProgram(state, 'lens.lensFlare', LENS_FLARE_FRAGMENT_SRC);
+    drawGlFullscreenPass(state, program, [source.texture], dest, (gl, p) => {
+        gl.uniform1f(gl.getUniformLocation(p.program, 'u_threshold'), threshold);
+        gl.uniform1f(gl.getUniformLocation(p.program, 'u_intensity'), intensity);
+        gl.uniform1f(gl.getUniformLocation(p.program, 'u_ghosts'), ghosts);
+        gl.uniform1f(gl.getUniformLocation(p.program, 'u_halo'), halo);
+    });
+}
+export const defaultGlLensFlareEffectRunner = (ctx, effect) => {
+    applyLensFlareEffectToGl(ctx.state, ctx.source, ctx.dest, effect);
+};
+const LENS_FLARE_FRAGMENT_SRC = `#version 300 es
+precision highp float;
+in vec2 v_texCoord;
+uniform sampler2D u_texture0;
+uniform float u_threshold;
+uniform float u_intensity;
+uniform float u_ghosts;
+uniform float u_halo;
+out vec4 o_color;
+vec3 brightPass(vec2 uv) {
+  if (uv.x < 0.0 || uv.x > 1.0 || uv.y < 0.0 || uv.y > 1.0) return vec3(0.0);
+  vec3 c = texture(u_texture0, uv).rgb;
+  float l = dot(c, vec3(0.2126, 0.7152, 0.0722));
+  return c * max(0.0, l - u_threshold);
+}
+void main() {
+  vec4 scene = texture(u_texture0, v_texCoord);
+  // Single-pass approximation of a flare: walk ghost samples along the vector toward the optical
+  // center and add a halo ring, all from the bright pass of the scene itself (no separate buffer).
+  vec2 toCenter = (vec2(0.5) - v_texCoord);
+  vec3 flare = vec3(0.0);
+  int count = int(clamp(u_ghosts, 0.0, 8.0));
+  for (int i = 0; i < 8; i++) {
+    if (i >= count) break;
+    float t = (float(i) + 1.0) / (float(count) + 1.0);
+    vec2 uv = v_texCoord + toCenter * (2.0 * t);
+    flare += brightPass(uv);
+  }
+  vec2 haloDir = normalize(toCenter + vec2(1e-5));
+  flare += brightPass(v_texCoord + haloDir * u_halo) * u_halo;
+  o_color = vec4(scene.rgb + flare * u_intensity, scene.a);
+}`;
+//# sourceMappingURL=glLensFlareEffect.js.map

package/dist/glLensFlareEffect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"glLensFlareEffect.js","sourceRoot":"","sources":["../src/glLensFlareEffect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAG3D,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAE5D,oGAAoG;AACpG,mGAAmG;AACnG,sGAAsG;AACtG,wGAAwG;AACxG,UAAU;AACV,MAAM,UAAU,wBAAwB,CACtC,KAAoB,EACpB,MAAgC,EAChC,IAA8B,EAC9B,MAAiC;IAEjC,MAAM,SAAS,GAAG,MAAM,CAAC,SAAS,IAAI,GAAG,CAAC;IAC1C,MAAM,SAAS,GAAG,MAAM,CAAC,SAAS,IAAI,CAAC,CAAC;IACxC,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,IAAI,CAAC,CAAC;IAClC,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,IAAI,GAAG,CAAC;IAChC,MAAM,OAAO,GAAG,kBAAkB,CAAC,KAAK,EAAE,gBAAgB,EAAE,uBAAuB,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,UAAU,CAAC,EAAE,MAAM,CAAC,CAAC;QACnE,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+B9B,CAAC"}

package/dist/glLiftGammaGainEffect.d.ts

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

package/dist/glLiftGammaGainEffect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"glLiftGammaGainEffect.d.ts","sourceRoot":"","sources":["../src/glLiftGammaGainEffect.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,aAAa,EAAE,cAAc,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAMhH,wBAAgB,4BAA4B,CAC1C,KAAK,EAAE,aAAa,EACpB,MAAM,EAAE,QAAQ,CAAC,cAAc,CAAC,EAChC,IAAI,EAAE,QAAQ,CAAC,cAAc,CAAC,EAC9B,MAAM,EAAE,QAAQ,CAAC,mBAAmB,CAAC,GACpC,IAAI,CAgBN;AAED,eAAO,MAAM,kCAAkC,EAAE,oBAEhD,CAAC"}

package/dist/glLiftGammaGainEffect.js

@@ -0,0 +1,44 @@
+import { drawGlFullscreenPass } from '@flighthq/render-gl';
+import { getGlEffectProgram } from './glEffectProgramCache';
+// Lift/gamma/gain: unpack packed-RGBA neutrals to per-channel offsets/exponents/multipliers in JS.
+// Neutral packed values: lift 0x000000ff, gamma 0x808080ff, gain 0xffffffff.
+export function applyLiftGammaGainEffectToGl(state, source, dest, effect) {
+    const lift = unpackColor(effect.lift ?? 0x000000ff);
+    const gammaRaw = unpackColor(effect.gamma ?? 0x808080ff);
+    const gain = unpackColor(effect.gain ?? 0xffffffff);
+    // Map gamma's 0.5-neutral to a 1.0-neutral exponent so 0x808080 leaves the image unchanged.
+    const gamma = [
+        1 / Math.max(gammaRaw[0] * 2, 1e-3),
+        1 / Math.max(gammaRaw[1] * 2, 1e-3),
+        1 / Math.max(gammaRaw[2] * 2, 1e-3),
+    ];
+    const program = getGlEffectProgram(state, 'colorGrade.liftGammaGain', LIFT_GAMMA_GAIN_FRAGMENT_SRC);
+    drawGlFullscreenPass(state, program, [source.texture], dest, (gl, p) => {
+        gl.uniform3f(gl.getUniformLocation(p.program, 'u_lift'), lift[0], lift[1], lift[2]);
+        gl.uniform3f(gl.getUniformLocation(p.program, 'u_gamma'), gamma[0], gamma[1], gamma[2]);
+        gl.uniform3f(gl.getUniformLocation(p.program, 'u_gain'), gain[0], gain[1], gain[2]);
+    });
+}
+export const defaultGlLiftGammaGainEffectRunner = (ctx, effect) => {
+    applyLiftGammaGainEffectToGl(ctx.state, ctx.source, ctx.dest, effect);
+};
+// Unpack a packed RGBA integer (0xRRGGBBAA) into normalized [r, g, b] floats. Alpha is dropped — these
+// grade values describe RGB channels only.
+function unpackColor(c) {
+    return [((c >>> 24) & 255) / 255, ((c >>> 16) & 255) / 255, ((c >>> 8) & 255) / 255];
+}
+const LIFT_GAMMA_GAIN_FRAGMENT_SRC = `#version 300 es
+precision highp float;
+in vec2 v_texCoord;
+uniform sampler2D u_texture0;
+uniform vec3 u_lift;
+uniform vec3 u_gamma;
+uniform vec3 u_gain;
+out vec4 o_color;
+void main() {
+  vec4 c = texture(u_texture0, v_texCoord);
+  vec3 rgb = c.rgb * u_gain + u_lift * (1.0 - c.rgb);
+  rgb = pow(max(rgb, 0.0), u_gamma);
+  o_color = vec4(clamp(rgb, 0.0, 1.0), c.a);
+}`;
+//# sourceMappingURL=glLiftGammaGainEffect.js.map

package/dist/glLiftGammaGainEffect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"glLiftGammaGainEffect.js","sourceRoot":"","sources":["../src/glLiftGammaGainEffect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAG3D,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAE5D,mGAAmG;AACnG,6EAA6E;AAC7E,MAAM,UAAU,4BAA4B,CAC1C,KAAoB,EACpB,MAAgC,EAChC,IAA8B,EAC9B,MAAqC;IAErC,MAAM,IAAI,GAAG,WAAW,CAAC,MAAM,CAAC,IAAI,IAAI,UAAU,CAAC,CAAC;IACpD,MAAM,QAAQ,GAAG,WAAW,CAAC,MAAM,CAAC,KAAK,IAAI,UAAU,CAAC,CAAC;IACzD,MAAM,IAAI,GAAG,WAAW,CAAC,MAAM,CAAC,IAAI,IAAI,UAAU,CAAC,CAAC;IACpD,4FAA4F;IAC5F,MAAM,KAAK,GAAsC;QAC/C,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,IAAI,CAAC;QACnC,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,IAAI,CAAC;QACnC,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,IAAI,CAAC;KACpC,CAAC;IACF,MAAM,OAAO,GAAG,kBAAkB,CAAC,KAAK,EAAE,0BAA0B,EAAE,4BAA4B,CAAC,CAAC;IACpG,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,QAAQ,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;QACpF,EAAE,CAAC,SAAS,CAAC,EAAE,CAAC,kBAAkB,CAAC,CAAC,CAAC,OAAO,EAAE,SAAS,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;QACxF,EAAE,CAAC,SAAS,CAAC,EAAE,CAAC,kBAAkB,CAAC,CAAC,CAAC,OAAO,EAAE,QAAQ,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;IACtF,CAAC,CAAC,CAAC;AACL,CAAC;AAED,MAAM,CAAC,MAAM,kCAAkC,GAAyB,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE;IACtF,4BAA4B,CAAC,GAAG,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,IAAI,EAAE,MAA6B,CAAC,CAAC;AAC/F,CAAC,CAAC;AAEF,uGAAuG;AACvG,2CAA2C;AAC3C,SAAS,WAAW,CAAC,CAAS;IAC5B,OAAO,CAAC,CAAC,CAAC,CAAC,KAAK,EAAE,CAAC,GAAG,GAAG,CAAC,GAAG,GAAG,EAAE,CAAC,CAAC,CAAC,KAAK,EAAE,CAAC,GAAG,GAAG,CAAC,GAAG,GAAG,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,GAAG,GAAG,CAAC,GAAG,GAAG,CAAC,CAAC;AACvF,CAAC;AAED,MAAM,4BAA4B,GAAG;;;;;;;;;;;;;EAanC,CAAC"}

package/dist/glLookupTableGradeEffect.d.ts

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

package/dist/glLookupTableGradeEffect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"glLookupTableGradeEffect.d.ts","sourceRoot":"","sources":["../src/glLookupTableGradeEffect.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,aAAa,EAAE,cAAc,EAAE,sBAAsB,EAAE,MAAM,iBAAiB,CAAC;AAOnH,wBAAgB,+BAA+B,CAC7C,KAAK,EAAE,aAAa,EACpB,MAAM,EAAE,QAAQ,CAAC,cAAc,CAAC,EAChC,IAAI,EAAE,QAAQ,CAAC,cAAc,CAAC,EAC9B,MAAM,EAAE,QAAQ,CAAC,sBAAsB,CAAC,GACvC,IAAI,CAMN;AAED,eAAO,MAAM,qCAAqC,EAAE,oBAEnD,CAAC"}

package/dist/glLookupTableGradeEffect.js

@@ -0,0 +1,28 @@
+import { drawGlFullscreenPass } from '@flighthq/render-gl';
+import { getGlEffectProgram } from './glEffectProgramCache';
+// LUT grade: passthrough with a strength mix. A real 3D LUT grade needs an uploaded LUT cube texture
+// (size from effect.size) sampled per pixel; that texture path is not yet wired, so this keeps the
+// pass compiling and color-neutral until the LUT upload is added.
+export function applyLookupTableGradeEffectToGl(state, source, dest, effect) {
+    const strength = effect.strength ?? 1;
+    const program = getGlEffectProgram(state, 'colorGrade.lutGrade', LUT_GRADE_FRAGMENT_SRC);
+    drawGlFullscreenPass(state, program, [source.texture], dest, (gl, p) => {
+        gl.uniform1f(gl.getUniformLocation(p.program, 'u_strength'), strength);
+    });
+}
+export const defaultGlLookupTableGradeEffectRunner = (ctx, effect) => {
+    applyLookupTableGradeEffectToGl(ctx.state, ctx.source, ctx.dest, effect);
+};
+const LUT_GRADE_FRAGMENT_SRC = `#version 300 es
+precision highp float;
+in vec2 v_texCoord;
+uniform sampler2D u_texture0;
+uniform float u_strength;
+out vec4 o_color;
+void main() {
+  vec4 c = texture(u_texture0, v_texCoord);
+  // Passthrough: a real 3D LUT samples an uploaded LUT cube here, then mixes by u_strength.
+  vec3 graded = c.rgb;
+  o_color = vec4(mix(c.rgb, graded, u_strength), c.a);
+}`;
+//# sourceMappingURL=glLookupTableGradeEffect.js.map

package/dist/glLookupTableGradeEffect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"glLookupTableGradeEffect.js","sourceRoot":"","sources":["../src/glLookupTableGradeEffect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAG3D,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAE5D,qGAAqG;AACrG,mGAAmG;AACnG,kEAAkE;AAClE,MAAM,UAAU,+BAA+B,CAC7C,KAAoB,EACpB,MAAgC,EAChC,IAA8B,EAC9B,MAAwC;IAExC,MAAM,QAAQ,GAAG,MAAM,CAAC,QAAQ,IAAI,CAAC,CAAC;IACtC,MAAM,OAAO,GAAG,kBAAkB,CAAC,KAAK,EAAE,qBAAqB,EAAE,sBAAsB,CAAC,CAAC;IACzF,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,QAAQ,CAAC,CAAC;IACzE,CAAC,CAAC,CAAC;AACL,CAAC;AAED,MAAM,CAAC,MAAM,qCAAqC,GAAyB,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE;IACzF,+BAA+B,CAAC,GAAG,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,IAAI,EAAE,MAAgC,CAAC,CAAC;AACrG,CAAC,CAAC;AAEF,MAAM,sBAAsB,GAAG;;;;;;;;;;;EAW7B,CAAC"}

package/dist/glMotionBlurEffect.d.ts

@@ -0,0 +1,4 @@
+import type { GlRenderEffectRunner, GlRenderState, GlRenderTarget, MotionBlurEffect } from '@flighthq/types';
+export declare function applyMotionBlurEffectToGl(state: GlRenderState, source: Readonly<GlRenderTarget>, dest: Readonly<GlRenderTarget>, velocityTexture: WebGLTexture | null, effect: Readonly<MotionBlurEffect>): void;
+export declare const defaultGlMotionBlurEffectRunner: GlRenderEffectRunner;
+//# sourceMappingURL=glMotionBlurEffect.d.ts.map

package/dist/glMotionBlurEffect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"glMotionBlurEffect.d.ts","sourceRoot":"","sources":["../src/glMotionBlurEffect.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,aAAa,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAW7G,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,aAAa,EACpB,MAAM,EAAE,QAAQ,CAAC,cAAc,CAAC,EAChC,IAAI,EAAE,QAAQ,CAAC,cAAc,CAAC,EAC9B,eAAe,EAAE,YAAY,GAAG,IAAI,EACpC,MAAM,EAAE,QAAQ,CAAC,gBAAgB,CAAC,GACjC,IAAI,CAYN;AAED,eAAO,MAAM,+BAA+B,EAAE,oBAE7C,CAAC"}

package/dist/glMotionBlurEffect.js

@@ -0,0 +1,61 @@
+import { drawGlFullscreenPass } from '@flighthq/render-gl';
+import { getGlEffectProgram } from './glEffectProgramCache';
+// Motion blur (per-object): the velocity-driven analog of the depth consumers (fog/DoF). When the scene
+// produced a per-pixel velocity buffer (`velocityTexture`, rgba16f screen-space velocity in pixels in the
+// RG channels), this is the real recipe — read each fragment's velocity, scale it by `intensity`, and
+// accumulate `samples` taps spread along that vector centered on the fragment, smearing every object by
+// its own motion. When velocity is absent (the scene did not write the buffer), u_hasVelocity=0 and it is
+// a passthrough copy (sentinel path), preserving the pipeline stage without altering the image. Demonstrates
+// the ctx.sceneVelocityTexture seam: real velocity path when present, sentinel copy when null.
+export function applyMotionBlurEffectToGl(state, source, dest, velocityTexture, effect) {
+    const intensity = effect.intensity ?? 1;
+    const samples = effect.samples ?? 16;
+    const program = getGlEffectProgram(state, 'motionBlur', MOTION_BLUR_FRAGMENT_SRC);
+    const inputs = velocityTexture ? [source.texture, velocityTexture] : [source.texture];
+    drawGlFullscreenPass(state, program, inputs, dest, (gl, p) => {
+        gl.uniform1f(gl.getUniformLocation(p.program, 'u_intensity'), intensity);
+        gl.uniform1f(gl.getUniformLocation(p.program, 'u_samples'), samples);
+        // u_resolution converts the pixel-space velocity vector into UV-space tap offsets.
+        gl.uniform2f(gl.getUniformLocation(p.program, 'u_resolution'), source.width, source.height);
+        gl.uniform1f(gl.getUniformLocation(p.program, 'u_hasVelocity'), velocityTexture ? 1 : 0);
+    });
+}
+export const defaultGlMotionBlurEffectRunner = (ctx, effect) => {
+    applyMotionBlurEffectToGl(ctx.state, ctx.source, ctx.dest, ctx.sceneVelocityTexture, effect);
+};
+const MOTION_BLUR_FRAGMENT_SRC = `#version 300 es
+precision highp float;
+in vec2 v_texCoord;
+uniform sampler2D u_texture0;
+uniform sampler2D u_texture1;
+uniform float u_intensity;
+uniform float u_samples;
+uniform vec2 u_resolution;
+uniform float u_hasVelocity;
+out vec4 o_color;
+const int SAMPLES = 16;
+void main() {
+  vec4 base = texture(u_texture0, v_texCoord);
+  if (u_hasVelocity < 0.5) {
+    // Sentinel path: no velocity buffer written — passthrough copy.
+    o_color = base;
+    return;
+  }
+  // Velocity decode: rgba16f buffer stores screen-space velocity in pixels in the RG channels. Convert
+  // to a UV-space smear vector via u_resolution and scale by intensity.
+  vec2 velocityPixels = texture(u_texture1, v_texCoord).rg;
+  vec2 smear = (velocityPixels / u_resolution) * u_intensity;
+  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;
+    // Center the taps on the fragment: t in [-0.5, 0.5] spreads the accumulation along the motion vector.
+    float t = count > 1.0 ? (float(i) / (count - 1.0)) - 0.5 : 0.0;
+    vec2 uv = v_texCoord + smear * t;
+    sum += texture(u_texture0, uv);
+    taken += 1.0;
+  }
+  o_color = sum / max(taken, 1.0);
+}`;
+//# sourceMappingURL=glMotionBlurEffect.js.map

package/dist/glMotionBlurEffect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"glMotionBlurEffect.js","sourceRoot":"","sources":["../src/glMotionBlurEffect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAG3D,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAE5D,wGAAwG;AACxG,0GAA0G;AAC1G,sGAAsG;AACtG,wGAAwG;AACxG,0GAA0G;AAC1G,6GAA6G;AAC7G,+FAA+F;AAC/F,MAAM,UAAU,yBAAyB,CACvC,KAAoB,EACpB,MAAgC,EAChC,IAA8B,EAC9B,eAAoC,EACpC,MAAkC;IAElC,MAAM,SAAS,GAAG,MAAM,CAAC,SAAS,IAAI,CAAC,CAAC;IACxC,MAAM,OAAO,GAAG,MAAM,CAAC,OAAO,IAAI,EAAE,CAAC;IACrC,MAAM,OAAO,GAAG,kBAAkB,CAAC,KAAK,EAAE,YAAY,EAAE,wBAAwB,CAAC,CAAC;IAClF,MAAM,MAAM,GAAG,eAAe,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,OAAO,EAAE,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;IACtF,oBAAoB,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,EAAE,EAAE,CAAC,EAAE,EAAE;QAC3D,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,WAAW,CAAC,EAAE,OAAO,CAAC,CAAC;QACrE,mFAAmF;QACnF,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,eAAe,CAAC,EAAE,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAC3F,CAAC,CAAC,CAAC;AACL,CAAC;AAED,MAAM,CAAC,MAAM,+BAA+B,GAAyB,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE;IACnF,yBAAyB,CAAC,GAAG,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,IAAI,EAAE,GAAG,CAAC,oBAAoB,EAAE,MAA0B,CAAC,CAAC;AACnH,CAAC,CAAC;AAEF,MAAM,wBAAwB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkC/B,CAAC"}

package/dist/glOutlineEffect.d.ts

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

package/dist/glOutlineEffect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"glOutlineEffect.d.ts","sourceRoot":"","sources":["../src/glOutlineEffect.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,aAAa,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAM1G,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"}