@flighthq/effects-wgpu 0.1.0

package/dist/wgpuHalftoneEffect.d.ts

@@ -0,0 +1,4 @@
+import type { HalftoneEffect, WgpuRenderEffectRunner, WgpuRenderState, WgpuRenderTarget } from '@flighthq/types';
+export declare function applyHalftoneEffectToWgpu(state: WgpuRenderState, source: Readonly<WgpuRenderTarget>, dest: Readonly<WgpuRenderTarget>, effect: Readonly<HalftoneEffect>): void;
+export declare const defaultWgpuHalftoneEffectRunner: WgpuRenderEffectRunner;
+//# sourceMappingURL=wgpuHalftoneEffect.d.ts.map

package/dist/wgpuHalftoneEffect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wgpuHalftoneEffect.d.ts","sourceRoot":"","sources":["../src/wgpuHalftoneEffect.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,sBAAsB,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAMjH,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,eAAe,EACtB,MAAM,EAAE,QAAQ,CAAC,gBAAgB,CAAC,EAClC,IAAI,EAAE,QAAQ,CAAC,gBAAgB,CAAC,EAChC,MAAM,EAAE,QAAQ,CAAC,cAAc,CAAC,GAC/B,IAAI,CAWN;AAED,eAAO,MAAM,+BAA+B,EAAE,sBAE7C,CAAC"}

package/dist/wgpuHalftoneEffect.js

@@ -0,0 +1,45 @@
+import { drawWgpuFilterPass } from '@flighthq/filters-wgpu';
+import { getWgpuEffectPipeline } from './wgpuEffectProgramCache';
+// 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 applyHalftoneEffectToWgpu(state, source, dest, effect) {
+    const scale = effect.scale ?? 6;
+    const angle = effect.angle ?? 0.4;
+    const pipeline = getWgpuEffectPipeline(state, 'stylization.halftone', HALFTONE_FRAGMENT_WGSL, 'replace');
+    drawWgpuFilterPass(state, source, dest, pipeline, (f32) => {
+        f32[0] = Math.max(1, scale);
+        f32[1] = angle;
+        // u_resolution (vec2f) aligns to slot [2].
+        f32[2] = source.width;
+        f32[3] = source.height;
+    });
+}
+export const defaultWgpuHalftoneEffectRunner = (ctx, effect) => {
+    applyHalftoneEffectToWgpu(ctx.state, ctx.source, ctx.dest, effect);
+};
+// Slot layout: [0]=scale, [1]=angle, [2..3]=resolution.
+const HALFTONE_FRAGMENT_WGSL = /* wgsl */ `
+struct Uniforms {
+  u_scale : f32,
+  u_angle : f32,
+  u_resolution : vec2f,
+}
+@group(0) @binding(0) var<uniform> uni : Uniforms;
+@group(1) @binding(0) var tex : texture_2d<f32>;
+@group(1) @binding(1) var smp : sampler;
+
+@fragment
+fn fs_main(@location(0) uv : vec2f) -> @location(0) vec4f {
+  let c = textureSampleLevel(tex, smp, uv, 0.0);
+  let lum = dot(c.rgb, vec3f(0.2126, 0.7152, 0.0722));
+  let p = uv * uni.u_resolution;
+  let s = sin(uni.u_angle);
+  let co = cos(uni.u_angle);
+  let rp = vec2f(p.x * co - p.y * s, p.x * s + p.y * co);
+  let cell = (rp % vec2f(uni.u_scale)) - uni.u_scale * 0.5;
+  let dist = length(cell) / (uni.u_scale * 0.5);
+  let radius = sqrt(1.0 - lum);
+  let dot1 = step(dist, radius);
+  return vec4f(c.rgb * dot1, c.a);
+}`;
+//# sourceMappingURL=wgpuHalftoneEffect.js.map

package/dist/wgpuHalftoneEffect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wgpuHalftoneEffect.js","sourceRoot":"","sources":["../src/wgpuHalftoneEffect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAG5D,OAAO,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AAEjE,mGAAmG;AACnG,oFAAoF;AACpF,MAAM,UAAU,yBAAyB,CACvC,KAAsB,EACtB,MAAkC,EAClC,IAAgC,EAChC,MAAgC;IAEhC,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,IAAI,CAAC,CAAC;IAChC,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,IAAI,GAAG,CAAC;IAClC,MAAM,QAAQ,GAAG,qBAAqB,CAAC,KAAK,EAAE,sBAAsB,EAAE,sBAAsB,EAAE,SAAS,CAAC,CAAC;IACzG,kBAAkB,CAAC,KAAK,EAAE,MAA0B,EAAE,IAAwB,EAAE,QAAQ,EAAE,CAAC,GAAG,EAAE,EAAE;QAChG,GAAG,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;QAC5B,GAAG,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC;QACf,2CAA2C;QAC3C,GAAG,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC;QACtB,GAAG,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,CAAC;IACzB,CAAC,CAAC,CAAC;AACL,CAAC;AAED,MAAM,CAAC,MAAM,+BAA+B,GAA2B,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE;IACrF,yBAAyB,CAAC,GAAG,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,IAAI,EAAE,MAAwB,CAAC,CAAC;AACvF,CAAC,CAAC;AAEF,wDAAwD;AACxD,MAAM,sBAAsB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;EAuBxC,CAAC"}

package/dist/wgpuHueSaturationEffect.d.ts

@@ -0,0 +1,4 @@
+import type { HueSaturationEffect, WgpuRenderEffectRunner, WgpuRenderState, WgpuRenderTarget } from '@flighthq/types';
+export declare function applyHueSaturationEffectToWgpu(state: WgpuRenderState, source: Readonly<WgpuRenderTarget>, dest: Readonly<WgpuRenderTarget>, effect: Readonly<HueSaturationEffect>): void;
+export declare const defaultWgpuHueSaturationEffectRunner: WgpuRenderEffectRunner;
+//# sourceMappingURL=wgpuHueSaturationEffect.d.ts.map

package/dist/wgpuHueSaturationEffect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wgpuHueSaturationEffect.d.ts","sourceRoot":"","sources":["../src/wgpuHueSaturationEffect.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,mBAAmB,EAAE,sBAAsB,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAKtH,wBAAgB,8BAA8B,CAC5C,KAAK,EAAE,eAAe,EACtB,MAAM,EAAE,QAAQ,CAAC,gBAAgB,CAAC,EAClC,IAAI,EAAE,QAAQ,CAAC,gBAAgB,CAAC,EAChC,MAAM,EAAE,QAAQ,CAAC,mBAAmB,CAAC,GACpC,IAAI,CAUN;AAED,eAAO,MAAM,oCAAoC,EAAE,sBAElD,CAAC"}

package/dist/wgpuHueSaturationEffect.js

@@ -0,0 +1,75 @@
+import { drawWgpuFilterPass } from '@flighthq/filters-wgpu';
+import { getWgpuEffectPipeline } from './wgpuEffectProgramCache';
+// Hue/saturation/lightness: convert to HSL, adjust, convert back.
+export function applyHueSaturationEffectToWgpu(state, source, dest, effect) {
+    const hue = (effect.hue ?? 0) / 360;
+    const saturation = effect.saturation ?? 1;
+    const lightness = effect.lightness ?? 0;
+    const pipeline = getWgpuEffectPipeline(state, 'colorGrade.hueSaturation', HUE_SATURATION_FRAGMENT_WGSL, 'replace');
+    drawWgpuFilterPass(state, source, dest, pipeline, (f32) => {
+        f32[0] = hue;
+        f32[1] = saturation;
+        f32[2] = lightness;
+    });
+}
+export const defaultWgpuHueSaturationEffectRunner = (ctx, effect) => {
+    applyHueSaturationEffectToWgpu(ctx.state, ctx.source, ctx.dest, effect);
+};
+// Slot layout: [0]=hue (turns), [1]=saturation, [2]=lightness.
+const HUE_SATURATION_FRAGMENT_WGSL = /* wgsl */ `
+struct Uniforms { u_hue : f32, u_saturation : f32, u_lightness : f32, _pad0 : f32, }
+@group(0) @binding(0) var<uniform> uni : Uniforms;
+@group(1) @binding(0) var tex : texture_2d<f32>;
+@group(1) @binding(1) var smp : sampler;
+
+fn rgb2hsl(c : vec3f) -> vec3f {
+  let mx = max(c.r, max(c.g, c.b));
+  let mn = min(c.r, min(c.g, c.b));
+  let l = (mx + mn) * 0.5;
+  var h = 0.0;
+  var s = 0.0;
+  let d = mx - mn;
+  if (d > 0.0001) {
+    s = select(d / (2.0 - mx - mn), d / (mx + mn), l < 0.5);
+    if (mx == c.r) {
+      h = (c.g - c.b) / d + select(0.0, 6.0, c.g < c.b);
+    } 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 vec3f(h, s, l);
+}
+
+fn hue2rgb(p : f32, q : f32, t_in : f32) -> f32 {
+  var t = t_in;
+  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;
+}
+
+fn hsl2rgb(hsl : vec3f) -> vec3f {
+  let h = hsl.x;
+  let s = hsl.y;
+  let l = hsl.z;
+  if (s <= 0.0) { return vec3f(l); }
+  let q = select(l + s - l * s, l * (1.0 + s), l < 0.5);
+  let p = 2.0 * l - q;
+  return vec3f(hue2rgb(p, q, h + 1.0 / 3.0), hue2rgb(p, q, h), hue2rgb(p, q, h - 1.0 / 3.0));
+}
+
+@fragment
+fn fs_main(@location(0) uv : vec2f) -> @location(0) vec4f {
+  let c = textureSampleLevel(tex, smp, uv, 0.0);
+  var hsl = rgb2hsl(c.rgb);
+  hsl.x = fract(hsl.x + uni.u_hue);
+  hsl.y = clamp(hsl.y * uni.u_saturation, 0.0, 1.0);
+  hsl.z = clamp(hsl.z + uni.u_lightness, 0.0, 1.0);
+  return vec4f(hsl2rgb(hsl), c.a);
+}`;
+//# sourceMappingURL=wgpuHueSaturationEffect.js.map

package/dist/wgpuHueSaturationEffect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wgpuHueSaturationEffect.js","sourceRoot":"","sources":["../src/wgpuHueSaturationEffect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAG5D,OAAO,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AAEjE,kEAAkE;AAClE,MAAM,UAAU,8BAA8B,CAC5C,KAAsB,EACtB,MAAkC,EAClC,IAAgC,EAChC,MAAqC;IAErC,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC,CAAC,GAAG,GAAG,CAAC;IACpC,MAAM,UAAU,GAAG,MAAM,CAAC,UAAU,IAAI,CAAC,CAAC;IAC1C,MAAM,SAAS,GAAG,MAAM,CAAC,SAAS,IAAI,CAAC,CAAC;IACxC,MAAM,QAAQ,GAAG,qBAAqB,CAAC,KAAK,EAAE,0BAA0B,EAAE,4BAA4B,EAAE,SAAS,CAAC,CAAC;IACnH,kBAAkB,CAAC,KAAK,EAAE,MAA0B,EAAE,IAAwB,EAAE,QAAQ,EAAE,CAAC,GAAG,EAAE,EAAE;QAChG,GAAG,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC;QACb,GAAG,CAAC,CAAC,CAAC,GAAG,UAAU,CAAC;QACpB,GAAG,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC;IACrB,CAAC,CAAC,CAAC;AACL,CAAC;AAED,MAAM,CAAC,MAAM,oCAAoC,GAA2B,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE;IAC1F,8BAA8B,CAAC,GAAG,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,IAAI,EAAE,MAA6B,CAAC,CAAC;AACjG,CAAC,CAAC;AAEF,+DAA+D;AAC/D,MAAM,4BAA4B,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuD9C,CAAC"}

package/dist/wgpuInvertEffect.d.ts

@@ -0,0 +1,4 @@
+import type { InvertEffect, WgpuRenderEffectRunner, WgpuRenderState, WgpuRenderTarget } from '@flighthq/types';
+export declare function applyInvertEffectToWgpu(state: WgpuRenderState, source: Readonly<WgpuRenderTarget>, dest: Readonly<WgpuRenderTarget>, effect: Readonly<InvertEffect>): void;
+export declare const defaultWgpuInvertEffectRunner: WgpuRenderEffectRunner;
+//# sourceMappingURL=wgpuInvertEffect.d.ts.map

package/dist/wgpuInvertEffect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wgpuInvertEffect.d.ts","sourceRoot":"","sources":["../src/wgpuInvertEffect.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,sBAAsB,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAK/G,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,eAAe,EACtB,MAAM,EAAE,QAAQ,CAAC,gBAAgB,CAAC,EAClC,IAAI,EAAE,QAAQ,CAAC,gBAAgB,CAAC,EAChC,MAAM,EAAE,QAAQ,CAAC,YAAY,CAAC,GAC7B,IAAI,CAMN;AAED,eAAO,MAAM,6BAA6B,EAAE,sBAE3C,CAAC"}

package/dist/wgpuInvertEffect.js

@@ -0,0 +1,26 @@
+import { drawWgpuFilterPass } from '@flighthq/filters-wgpu';
+import { getWgpuEffectPipeline } from './wgpuEffectProgramCache';
+// Invert: mix toward 1 - rgb by intensity.
+export function applyInvertEffectToWgpu(state, source, dest, effect) {
+    const intensity = effect.intensity ?? 1;
+    const pipeline = getWgpuEffectPipeline(state, 'colorGrade.invert', INVERT_FRAGMENT_WGSL, 'replace');
+    drawWgpuFilterPass(state, source, dest, pipeline, (f32) => {
+        f32[0] = intensity;
+    });
+}
+export const defaultWgpuInvertEffectRunner = (ctx, effect) => {
+    applyInvertEffectToWgpu(ctx.state, ctx.source, ctx.dest, effect);
+};
+// Slot layout: [0]=intensity.
+const INVERT_FRAGMENT_WGSL = /* wgsl */ `
+struct Uniforms { u_intensity : f32, _pad0 : f32, _pad1 : f32, _pad2 : f32, }
+@group(0) @binding(0) var<uniform> uni : Uniforms;
+@group(1) @binding(0) var tex : texture_2d<f32>;
+@group(1) @binding(1) var smp : sampler;
+
+@fragment
+fn fs_main(@location(0) uv : vec2f) -> @location(0) vec4f {
+  let c = textureSampleLevel(tex, smp, uv, 0.0);
+  return vec4f(mix(c.rgb, vec3f(1.0) - c.rgb, uni.u_intensity), c.a);
+}`;
+//# sourceMappingURL=wgpuInvertEffect.js.map

package/dist/wgpuInvertEffect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wgpuInvertEffect.js","sourceRoot":"","sources":["../src/wgpuInvertEffect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAG5D,OAAO,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AAEjE,2CAA2C;AAC3C,MAAM,UAAU,uBAAuB,CACrC,KAAsB,EACtB,MAAkC,EAClC,IAAgC,EAChC,MAA8B;IAE9B,MAAM,SAAS,GAAG,MAAM,CAAC,SAAS,IAAI,CAAC,CAAC;IACxC,MAAM,QAAQ,GAAG,qBAAqB,CAAC,KAAK,EAAE,mBAAmB,EAAE,oBAAoB,EAAE,SAAS,CAAC,CAAC;IACpG,kBAAkB,CAAC,KAAK,EAAE,MAA0B,EAAE,IAAwB,EAAE,QAAQ,EAAE,CAAC,GAAG,EAAE,EAAE;QAChG,GAAG,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC;IACrB,CAAC,CAAC,CAAC;AACL,CAAC;AAED,MAAM,CAAC,MAAM,6BAA6B,GAA2B,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE;IACnF,uBAAuB,CAAC,GAAG,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,IAAI,EAAE,MAAsB,CAAC,CAAC;AACnF,CAAC,CAAC;AAEF,8BAA8B;AAC9B,MAAM,oBAAoB,GAAG,UAAU,CAAC;;;;;;;;;;EAUtC,CAAC"}

package/dist/wgpuKuwaharaEffect.d.ts

@@ -0,0 +1,4 @@
+import type { KuwaharaEffect, WgpuRenderEffectRunner, WgpuRenderState, WgpuRenderTarget } from '@flighthq/types';
+export declare function applyKuwaharaEffectToWgpu(state: WgpuRenderState, source: Readonly<WgpuRenderTarget>, dest: Readonly<WgpuRenderTarget>, effect: Readonly<KuwaharaEffect>): void;
+export declare const defaultWgpuKuwaharaEffectRunner: WgpuRenderEffectRunner;
+//# sourceMappingURL=wgpuKuwaharaEffect.d.ts.map

package/dist/wgpuKuwaharaEffect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wgpuKuwaharaEffect.d.ts","sourceRoot":"","sources":["../src/wgpuKuwaharaEffect.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,sBAAsB,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAOjH,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,eAAe,EACtB,MAAM,EAAE,QAAQ,CAAC,gBAAgB,CAAC,EAClC,IAAI,EAAE,QAAQ,CAAC,gBAAgB,CAAC,EAChC,MAAM,EAAE,QAAQ,CAAC,cAAc,CAAC,GAC/B,IAAI,CASN;AAED,eAAO,MAAM,+BAA+B,EAAE,sBAE7C,CAAC"}

package/dist/wgpuKuwaharaEffect.js

@@ -0,0 +1,69 @@
+import { drawWgpuFilterPass } from '@flighthq/filters-wgpu';
+import { getWgpuEffectPipeline } from './wgpuEffectProgramCache';
+// 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 applyKuwaharaEffectToWgpu(state, source, dest, effect) {
+    const radius = effect.radius ?? 3;
+    const pipeline = getWgpuEffectPipeline(state, 'stylization.kuwahara', KUWAHARA_FRAGMENT_WGSL, 'replace');
+    drawWgpuFilterPass(state, source, dest, pipeline, (f32) => {
+        f32[0] = Math.max(1, radius);
+        // u_resolution (vec2f) aligns to slot [2].
+        f32[2] = source.width;
+        f32[3] = source.height;
+    });
+}
+export const defaultWgpuKuwaharaEffectRunner = (ctx, effect) => {
+    applyKuwaharaEffectToWgpu(ctx.state, ctx.source, ctx.dest, effect);
+};
+// Slot layout: [0]=radius, [1]=pad, [2..3]=resolution.
+const KUWAHARA_FRAGMENT_WGSL = /* wgsl */ `
+struct Uniforms {
+  u_radius : f32,
+  _pad0 : f32,
+  u_resolution : vec2f,
+}
+@group(0) @binding(0) var<uniform> uni : Uniforms;
+@group(1) @binding(0) var tex : texture_2d<f32>;
+@group(1) @binding(1) var smp : sampler;
+
+const R : i32 = 4;
+
+@fragment
+fn fs_main(@location(0) uv : vec2f) -> @location(0) vec4f {
+  let texel = 1.0 / uni.u_resolution;
+  let r = i32(min(f32(R), uni.u_radius));
+  var means : array<vec3f, 4>;
+  var vars : array<f32, 4>;
+  var lo = array<vec2i, 4>(vec2i(-1, -1), vec2i(0, -1), vec2i(-1, 0), vec2i(0, 0));
+  for (var q = 0; q < 4; q++) {
+    var sum = vec3f(0.0);
+    var sumSq = vec3f(0.0);
+    var n = 0.0;
+    for (var y = 0; y <= R; y++) {
+      for (var x = 0; x <= R; x++) {
+        if (x > r || y > r) { continue; }
+        let d = vec2i(x, y) * sign(lo[q] + vec2i(1)) + lo[q] * r;
+        let off = vec2f(f32(d.x), f32(d.y)) * texel;
+        let col = textureSampleLevel(tex, smp, uv + off, 0.0).rgb;
+        sum += col;
+        sumSq += col * col;
+        n += 1.0;
+      }
+    }
+    let mean = sum / n;
+    means[q] = mean;
+    let v = sumSq / n - mean * mean;
+    vars[q] = v.r + v.g + v.b;
+  }
+  var minVar = vars[0];
+  var result = means[0];
+  for (var q = 1; q < 4; q++) {
+    if (vars[q] < minVar) {
+      minVar = vars[q];
+      result = means[q];
+    }
+  }
+  return vec4f(result, textureSampleLevel(tex, smp, uv, 0.0).a);
+}`;
+//# sourceMappingURL=wgpuKuwaharaEffect.js.map

package/dist/wgpuKuwaharaEffect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wgpuKuwaharaEffect.js","sourceRoot":"","sources":["../src/wgpuKuwaharaEffect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAG5D,OAAO,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AAEjE,kGAAkG;AAClG,sGAAsG;AACtG,wEAAwE;AACxE,MAAM,UAAU,yBAAyB,CACvC,KAAsB,EACtB,MAAkC,EAClC,IAAgC,EAChC,MAAgC;IAEhC,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,IAAI,CAAC,CAAC;IAClC,MAAM,QAAQ,GAAG,qBAAqB,CAAC,KAAK,EAAE,sBAAsB,EAAE,sBAAsB,EAAE,SAAS,CAAC,CAAC;IACzG,kBAAkB,CAAC,KAAK,EAAE,MAA0B,EAAE,IAAwB,EAAE,QAAQ,EAAE,CAAC,GAAG,EAAE,EAAE;QAChG,GAAG,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC;QAC7B,2CAA2C;QAC3C,GAAG,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC;QACtB,GAAG,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,CAAC;IACzB,CAAC,CAAC,CAAC;AACL,CAAC;AAED,MAAM,CAAC,MAAM,+BAA+B,GAA2B,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE;IACrF,yBAAyB,CAAC,GAAG,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,IAAI,EAAE,MAAwB,CAAC,CAAC;AACvF,CAAC,CAAC;AAEF,uDAAuD;AACvD,MAAM,sBAAsB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgDxC,CAAC"}

package/dist/wgpuLensDirtEffect.d.ts

@@ -0,0 +1,4 @@
+import type { LensDirtEffect, WgpuRenderEffectRunner, WgpuRenderState, WgpuRenderTarget } from '@flighthq/types';
+export declare function applyLensDirtEffectToWgpu(state: WgpuRenderState, source: Readonly<WgpuRenderTarget>, dest: Readonly<WgpuRenderTarget>, effect: Readonly<LensDirtEffect>): void;
+export declare const defaultWgpuLensDirtEffectRunner: WgpuRenderEffectRunner;
+//# sourceMappingURL=wgpuLensDirtEffect.d.ts.map

package/dist/wgpuLensDirtEffect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wgpuLensDirtEffect.d.ts","sourceRoot":"","sources":["../src/wgpuLensDirtEffect.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,sBAAsB,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAKjH,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,eAAe,EACtB,MAAM,EAAE,QAAQ,CAAC,gBAAgB,CAAC,EAClC,IAAI,EAAE,QAAQ,CAAC,gBAAgB,CAAC,EAChC,MAAM,EAAE,QAAQ,CAAC,cAAc,CAAC,GAC/B,IAAI,CAUN;AAED,eAAO,MAAM,+BAA+B,EAAE,sBAE7C,CAAC"}

package/dist/wgpuLensDirtEffect.js

@@ -0,0 +1,51 @@
+import { drawWgpuFilterPass } from '@flighthq/filters-wgpu';
+import { getWgpuEffectPipeline } from './wgpuEffectProgramCache';
+// Lens dirt: procedural soft smudges that brighten where the scene is bright — a cheap bloom-dirt overlay.
+export function applyLensDirtEffectToWgpu(state, source, dest, effect) {
+    const intensity = effect.intensity ?? 1;
+    const threshold = effect.threshold ?? 0.55;
+    const seed = effect.seed ?? 0;
+    const pipeline = getWgpuEffectPipeline(state, 'lens.lensDirt', LENS_DIRT_FRAGMENT_WGSL, 'replace');
+    drawWgpuFilterPass(state, source, dest, pipeline, (f32) => {
+        f32[0] = intensity;
+        f32[1] = threshold;
+        f32[2] = seed;
+    });
+}
+export const defaultWgpuLensDirtEffectRunner = (ctx, effect) => {
+    applyLensDirtEffectToWgpu(ctx.state, ctx.source, ctx.dest, effect);
+};
+// Slot layout: [0]=intensity, [1]=threshold, [2]=seed.
+const LENS_DIRT_FRAGMENT_WGSL = /* wgsl */ `
+struct Uniforms {
+  u_intensity : f32,
+  u_threshold : f32,
+  u_seed : f32,
+}
+@group(0) @binding(0) var<uniform> uni : Uniforms;
+@group(1) @binding(0) var tex : texture_2d<f32>;
+@group(1) @binding(1) var smp : sampler;
+
+fn dirtHash(p : vec2f) -> f32 { return fract(sin(dot(p, vec2f(127.1, 311.7))) * 43758.5453123); }
+
+fn dirtAmount(uv : vec2f, seed : f32) -> f32 {
+  var acc = 0.0;
+  for (var i = 0; i < 8; i = i + 1) {
+    let fi = f32(i);
+    let c = vec2f(dirtHash(vec2f(fi, seed)), dirtHash(vec2f(fi + 9.0, seed)));
+    let r = 0.06 + 0.16 * dirtHash(vec2f(fi + 3.0, seed));
+    let d = distance(uv, c) / r;
+    acc = acc + smoothstep(1.0, 0.0, d) * (0.3 + 0.7 * dirtHash(vec2f(fi + 5.0, seed)));
+  }
+  return clamp(acc, 0.0, 1.0);
+}
+
+@fragment
+fn fs_main(@location(0) uv : vec2f) -> @location(0) vec4f {
+  let c = textureSampleLevel(tex, smp, uv, 0.0);
+  let lum = dot(c.rgb, vec3f(0.299, 0.587, 0.114));
+  let bright = max(0.0, lum - uni.u_threshold);
+  let dirt = dirtAmount(uv, uni.u_seed + 1.0);
+  return vec4f(c.rgb + bright * dirt * uni.u_intensity * 2.0, c.a);
+}`;
+//# sourceMappingURL=wgpuLensDirtEffect.js.map

package/dist/wgpuLensDirtEffect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wgpuLensDirtEffect.js","sourceRoot":"","sources":["../src/wgpuLensDirtEffect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAG5D,OAAO,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AAEjE,2GAA2G;AAC3G,MAAM,UAAU,yBAAyB,CACvC,KAAsB,EACtB,MAAkC,EAClC,IAAgC,EAChC,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,QAAQ,GAAG,qBAAqB,CAAC,KAAK,EAAE,eAAe,EAAE,uBAAuB,EAAE,SAAS,CAAC,CAAC;IACnG,kBAAkB,CAAC,KAAK,EAAE,MAA0B,EAAE,IAAwB,EAAE,QAAQ,EAAE,CAAC,GAAG,EAAE,EAAE;QAChG,GAAG,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC;QACnB,GAAG,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC;QACnB,GAAG,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;IAChB,CAAC,CAAC,CAAC;AACL,CAAC;AAED,MAAM,CAAC,MAAM,+BAA+B,GAA2B,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE;IACrF,yBAAyB,CAAC,GAAG,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,IAAI,EAAE,MAAwB,CAAC,CAAC;AACvF,CAAC,CAAC;AAEF,uDAAuD;AACvD,MAAM,uBAAuB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+BzC,CAAC"}

package/dist/wgpuLensDistortionEffect.d.ts

@@ -0,0 +1,4 @@
+import type { LensDistortionEffect, WgpuRenderEffectRunner, WgpuRenderState, WgpuRenderTarget } from '@flighthq/types';
+export declare function applyLensDistortionEffectToWgpu(state: WgpuRenderState, source: Readonly<WgpuRenderTarget>, dest: Readonly<WgpuRenderTarget>, effect: Readonly<LensDistortionEffect>): void;
+export declare const defaultWgpuLensDistortionEffectRunner: WgpuRenderEffectRunner;
+//# sourceMappingURL=wgpuLensDistortionEffect.d.ts.map

package/dist/wgpuLensDistortionEffect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wgpuLensDistortionEffect.d.ts","sourceRoot":"","sources":["../src/wgpuLensDistortionEffect.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,sBAAsB,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAMvH,wBAAgB,+BAA+B,CAC7C,KAAK,EAAE,eAAe,EACtB,MAAM,EAAE,QAAQ,CAAC,gBAAgB,CAAC,EAClC,IAAI,EAAE,QAAQ,CAAC,gBAAgB,CAAC,EAChC,MAAM,EAAE,QAAQ,CAAC,oBAAoB,CAAC,GACrC,IAAI,CAQN;AAED,eAAO,MAAM,qCAAqC,EAAE,sBAEnD,CAAC"}

package/dist/wgpuLensDistortionEffect.js

@@ -0,0 +1,36 @@
+import { drawWgpuFilterPass } from '@flighthq/filters-wgpu';
+import { getWgpuEffectPipeline } from './wgpuEffectProgramCache';
+// 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 applyLensDistortionEffectToWgpu(state, source, dest, effect) {
+    const amount = effect.amount ?? 0.2;
+    const scale = effect.scale ?? 1;
+    const pipeline = getWgpuEffectPipeline(state, 'lens.lensDistortion', LENS_DISTORTION_FRAGMENT_WGSL, 'replace');
+    drawWgpuFilterPass(state, source, dest, pipeline, (f32) => {
+        f32[0] = amount;
+        f32[1] = scale;
+    });
+}
+export const defaultWgpuLensDistortionEffectRunner = (ctx, effect) => {
+    applyLensDistortionEffectToWgpu(ctx.state, ctx.source, ctx.dest, effect);
+};
+const LENS_DISTORTION_FRAGMENT_WGSL = /* wgsl */ `
+struct Uniforms {
+  u_amount : f32,
+  u_scale : f32,
+}
+@group(0) @binding(0) var<uniform> uni : Uniforms;
+@group(1) @binding(0) var tex : texture_2d<f32>;
+@group(1) @binding(1) var smp : sampler;
+
+@fragment
+fn fs_main(@location(0) uv : vec2f) -> @location(0) vec4f {
+  let centered = (uv - vec2f(0.5)) / uni.u_scale;
+  let r2 = dot(centered, centered);
+  let distorted = centered * (1.0 + uni.u_amount * r2) + vec2f(0.5);
+  if (distorted.x < 0.0 || distorted.x > 1.0 || distorted.y < 0.0 || distorted.y > 1.0) {
+    return vec4f(0.0, 0.0, 0.0, 1.0);
+  }
+  return textureSampleLevel(tex, smp, distorted, 0.0);
+}`;
+//# sourceMappingURL=wgpuLensDistortionEffect.js.map

package/dist/wgpuLensDistortionEffect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wgpuLensDistortionEffect.js","sourceRoot":"","sources":["../src/wgpuLensDistortionEffect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAG5D,OAAO,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AAEjE,sGAAsG;AACtG,mFAAmF;AACnF,MAAM,UAAU,+BAA+B,CAC7C,KAAsB,EACtB,MAAkC,EAClC,IAAgC,EAChC,MAAsC;IAEtC,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,IAAI,GAAG,CAAC;IACpC,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,IAAI,CAAC,CAAC;IAChC,MAAM,QAAQ,GAAG,qBAAqB,CAAC,KAAK,EAAE,qBAAqB,EAAE,6BAA6B,EAAE,SAAS,CAAC,CAAC;IAC/G,kBAAkB,CAAC,KAAK,EAAE,MAA0B,EAAE,IAAwB,EAAE,QAAQ,EAAE,CAAC,GAAG,EAAE,EAAE;QAChG,GAAG,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC;QAChB,GAAG,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC;IACjB,CAAC,CAAC,CAAC;AACL,CAAC;AAED,MAAM,CAAC,MAAM,qCAAqC,GAA2B,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE;IAC3F,+BAA+B,CAAC,GAAG,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,IAAI,EAAE,MAA8B,CAAC,CAAC;AACnG,CAAC,CAAC;AAEF,MAAM,6BAA6B,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;EAkB/C,CAAC"}

package/dist/wgpuLensFlareEffect.d.ts

@@ -0,0 +1,4 @@
+import type { LensFlareEffect, WgpuRenderEffectRunner, WgpuRenderState, WgpuRenderTarget } from '@flighthq/types';
+export declare function applyLensFlareEffectToWgpu(state: WgpuRenderState, source: Readonly<WgpuRenderTarget>, dest: Readonly<WgpuRenderTarget>, effect: Readonly<LensFlareEffect>): void;
+export declare const defaultWgpuLensFlareEffectRunner: WgpuRenderEffectRunner;
+//# sourceMappingURL=wgpuLensFlareEffect.d.ts.map

package/dist/wgpuLensFlareEffect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wgpuLensFlareEffect.d.ts","sourceRoot":"","sources":["../src/wgpuLensFlareEffect.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,sBAAsB,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AASlH,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,eAAe,EACtB,MAAM,EAAE,QAAQ,CAAC,gBAAgB,CAAC,EAClC,IAAI,EAAE,QAAQ,CAAC,gBAAgB,CAAC,EAChC,MAAM,EAAE,QAAQ,CAAC,eAAe,CAAC,GAChC,IAAI,CAYN;AAED,eAAO,MAAM,gCAAgC,EAAE,sBAE9C,CAAC"}

package/dist/wgpuLensFlareEffect.js

@@ -0,0 +1,61 @@
+import { drawWgpuFilterPass } from '@flighthq/filters-wgpu';
+import { getWgpuEffectPipeline } from './wgpuEffectProgramCache';
+// 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 applyLensFlareEffectToWgpu(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 pipeline = getWgpuEffectPipeline(state, 'lens.lensFlare', LENS_FLARE_FRAGMENT_WGSL, 'replace');
+    drawWgpuFilterPass(state, source, dest, pipeline, (f32) => {
+        f32[0] = threshold;
+        f32[1] = intensity;
+        f32[2] = ghosts;
+        f32[3] = halo;
+    });
+}
+export const defaultWgpuLensFlareEffectRunner = (ctx, effect) => {
+    applyLensFlareEffectToWgpu(ctx.state, ctx.source, ctx.dest, effect);
+};
+// Slot layout: [0]=threshold, [1]=intensity, [2]=ghosts, [3]=halo.
+const LENS_FLARE_FRAGMENT_WGSL = /* wgsl */ `
+struct Uniforms {
+  u_threshold : f32,
+  u_intensity : f32,
+  u_ghosts : f32,
+  u_halo : f32,
+}
+@group(0) @binding(0) var<uniform> uni : Uniforms;
+@group(1) @binding(0) var tex : texture_2d<f32>;
+@group(1) @binding(1) var smp : sampler;
+
+fn brightPass(uv : vec2f) -> vec3f {
+  if (uv.x < 0.0 || uv.x > 1.0 || uv.y < 0.0 || uv.y > 1.0) { return vec3f(0.0); }
+  let c = textureSampleLevel(tex, smp, uv, 0.0).rgb;
+  let l = dot(c, vec3f(0.2126, 0.7152, 0.0722));
+  return c * max(0.0, l - uni.u_threshold);
+}
+
+@fragment
+fn fs_main(@location(0) uv : vec2f) -> @location(0) vec4f {
+  let scene = textureSampleLevel(tex, smp, uv, 0.0);
+  // 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).
+  let toCenter = vec2f(0.5) - uv;
+  var flare = vec3f(0.0);
+  let count = i32(clamp(uni.u_ghosts, 0.0, 8.0));
+  for (var i = 0; i < 8; i = i + 1) {
+    if (i >= count) { break; }
+    let t = (f32(i) + 1.0) / (f32(count) + 1.0);
+    let ghostUv = uv + toCenter * (2.0 * t);
+    flare = flare + brightPass(ghostUv);
+  }
+  let haloDir = normalize(toCenter + vec2f(1e-5));
+  flare = flare + brightPass(uv + haloDir * uni.u_halo) * uni.u_halo;
+  return vec4f(scene.rgb + flare * uni.u_intensity, scene.a);
+}`;
+//# sourceMappingURL=wgpuLensFlareEffect.js.map

package/dist/wgpuLensFlareEffect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wgpuLensFlareEffect.js","sourceRoot":"","sources":["../src/wgpuLensFlareEffect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAG5D,OAAO,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AAEjE,oGAAoG;AACpG,mGAAmG;AACnG,sGAAsG;AACtG,wGAAwG;AACxG,UAAU;AACV,MAAM,UAAU,0BAA0B,CACxC,KAAsB,EACtB,MAAkC,EAClC,IAAgC,EAChC,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,QAAQ,GAAG,qBAAqB,CAAC,KAAK,EAAE,gBAAgB,EAAE,wBAAwB,EAAE,SAAS,CAAC,CAAC;IACrG,kBAAkB,CAAC,KAAK,EAAE,MAA0B,EAAE,IAAwB,EAAE,QAAQ,EAAE,CAAC,GAAG,EAAE,EAAE;QAChG,GAAG,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC;QACnB,GAAG,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC;QACnB,GAAG,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC;QAChB,GAAG,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;IAChB,CAAC,CAAC,CAAC;AACL,CAAC;AAED,MAAM,CAAC,MAAM,gCAAgC,GAA2B,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE;IACtF,0BAA0B,CAAC,GAAG,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,IAAI,EAAE,MAAyB,CAAC,CAAC;AACzF,CAAC,CAAC;AAEF,mEAAmE;AACnE,MAAM,wBAAwB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmC1C,CAAC"}

package/dist/wgpuLiftGammaGainEffect.d.ts

@@ -0,0 +1,4 @@
+import type { LiftGammaGainEffect, WgpuRenderEffectRunner, WgpuRenderState, WgpuRenderTarget } from '@flighthq/types';
+export declare function applyLiftGammaGainEffectToWgpu(state: WgpuRenderState, source: Readonly<WgpuRenderTarget>, dest: Readonly<WgpuRenderTarget>, effect: Readonly<LiftGammaGainEffect>): void;
+export declare const defaultWgpuLiftGammaGainEffectRunner: WgpuRenderEffectRunner;
+//# sourceMappingURL=wgpuLiftGammaGainEffect.d.ts.map

package/dist/wgpuLiftGammaGainEffect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wgpuLiftGammaGainEffect.d.ts","sourceRoot":"","sources":["../src/wgpuLiftGammaGainEffect.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,mBAAmB,EAAE,sBAAsB,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAOtH,wBAAgB,8BAA8B,CAC5C,KAAK,EAAE,eAAe,EACtB,MAAM,EAAE,QAAQ,CAAC,gBAAgB,CAAC,EAClC,IAAI,EAAE,QAAQ,CAAC,gBAAgB,CAAC,EAChC,MAAM,EAAE,QAAQ,CAAC,mBAAmB,CAAC,GACpC,IAAI,CAsBN;AAED,eAAO,MAAM,oCAAoC,EAAE,sBAElD,CAAC"}

package/dist/wgpuLiftGammaGainEffect.js

@@ -0,0 +1,51 @@
+import { drawWgpuFilterPass } from '@flighthq/filters-wgpu';
+import { getWgpuEffectPipeline } from './wgpuEffectProgramCache';
+// Lift/gamma/gain: unpack packed-RGBA neutrals to per-channel offsets/exponents/multipliers in JS.
+// Neutral packed values: lift 0x000000ff, gamma 0x808080ff, gain 0xffffffff. Each vec3 is uploaded
+// into its own 16-byte-aligned slot so the std140 vec3 alignment is satisfied.
+export function applyLiftGammaGainEffectToWgpu(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 pipeline = getWgpuEffectPipeline(state, 'colorGrade.liftGammaGain', LIFT_GAMMA_GAIN_FRAGMENT_WGSL, 'replace');
+    drawWgpuFilterPass(state, source, dest, pipeline, (f32) => {
+        f32[0] = lift[0];
+        f32[1] = lift[1];
+        f32[2] = lift[2];
+        f32[4] = gamma[0];
+        f32[5] = gamma[1];
+        f32[6] = gamma[2];
+        f32[8] = gain[0];
+        f32[9] = gain[1];
+        f32[10] = gain[2];
+    });
+}
+export const defaultWgpuLiftGammaGainEffectRunner = (ctx, effect) => {
+    applyLiftGammaGainEffectToWgpu(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];
+}
+// Slot layout: three vec3 in 16-byte-aligned slots — [0..2]=lift, [4..6]=gamma, [8..10]=gain.
+const LIFT_GAMMA_GAIN_FRAGMENT_WGSL = /* wgsl */ `
+struct Uniforms { u_lift : vec3f, u_gamma : vec3f, u_gain : vec3f, }
+@group(0) @binding(0) var<uniform> uni : Uniforms;
+@group(1) @binding(0) var tex : texture_2d<f32>;
+@group(1) @binding(1) var smp : sampler;
+
+@fragment
+fn fs_main(@location(0) uv : vec2f) -> @location(0) vec4f {
+  let c = textureSampleLevel(tex, smp, uv, 0.0);
+  var rgb = c.rgb * uni.u_gain + uni.u_lift * (vec3f(1.0) - c.rgb);
+  rgb = pow(max(rgb, vec3f(0.0)), uni.u_gamma);
+  return vec4f(clamp(rgb, vec3f(0.0), vec3f(1.0)), c.a);
+}`;
+//# sourceMappingURL=wgpuLiftGammaGainEffect.js.map

package/dist/wgpuLiftGammaGainEffect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wgpuLiftGammaGainEffect.js","sourceRoot":"","sources":["../src/wgpuLiftGammaGainEffect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAG5D,OAAO,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AAEjE,mGAAmG;AACnG,mGAAmG;AACnG,+EAA+E;AAC/E,MAAM,UAAU,8BAA8B,CAC5C,KAAsB,EACtB,MAAkC,EAClC,IAAgC,EAChC,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,QAAQ,GAAG,qBAAqB,CAAC,KAAK,EAAE,0BAA0B,EAAE,6BAA6B,EAAE,SAAS,CAAC,CAAC;IACpH,kBAAkB,CAAC,KAAK,EAAE,MAA0B,EAAE,IAAwB,EAAE,QAAQ,EAAE,CAAC,GAAG,EAAE,EAAE;QAChG,GAAG,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;QACjB,GAAG,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;QACjB,GAAG,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;QACjB,GAAG,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;QAClB,GAAG,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;QAClB,GAAG,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;QAClB,GAAG,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;QACjB,GAAG,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;QACjB,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;IACpB,CAAC,CAAC,CAAC;AACL,CAAC;AAED,MAAM,CAAC,MAAM,oCAAoC,GAA2B,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE;IAC1F,8BAA8B,CAAC,GAAG,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,IAAI,EAAE,MAA6B,CAAC,CAAC;AACjG,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,8FAA8F;AAC9F,MAAM,6BAA6B,GAAG,UAAU,CAAC;;;;;;;;;;;;EAY/C,CAAC"}

package/dist/wgpuLookupTableGradeEffect.d.ts

@@ -0,0 +1,4 @@
+import type { LookupTableGradeEffect, WgpuRenderEffectRunner, WgpuRenderState, WgpuRenderTarget } from '@flighthq/types';
+export declare function applyLookupTableGradeEffectToWgpu(state: WgpuRenderState, source: Readonly<WgpuRenderTarget>, dest: Readonly<WgpuRenderTarget>, effect: Readonly<LookupTableGradeEffect>): void;
+export declare const defaultWgpuLookupTableGradeEffectRunner: WgpuRenderEffectRunner;
+//# sourceMappingURL=wgpuLookupTableGradeEffect.d.ts.map

package/dist/wgpuLookupTableGradeEffect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wgpuLookupTableGradeEffect.d.ts","sourceRoot":"","sources":["../src/wgpuLookupTableGradeEffect.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,sBAAsB,EACtB,sBAAsB,EACtB,eAAe,EACf,gBAAgB,EACjB,MAAM,iBAAiB,CAAC;AAOzB,wBAAgB,iCAAiC,CAC/C,KAAK,EAAE,eAAe,EACtB,MAAM,EAAE,QAAQ,CAAC,gBAAgB,CAAC,EAClC,IAAI,EAAE,QAAQ,CAAC,gBAAgB,CAAC,EAChC,MAAM,EAAE,QAAQ,CAAC,sBAAsB,CAAC,GACvC,IAAI,CAMN;AAED,eAAO,MAAM,uCAAuC,EAAE,sBAErD,CAAC"}

package/dist/wgpuLookupTableGradeEffect.js

@@ -0,0 +1,30 @@
+import { drawWgpuFilterPass } from '@flighthq/filters-wgpu';
+import { getWgpuEffectPipeline } from './wgpuEffectProgramCache';
+// 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 as an extra bound texture; that texture path is not yet
+// wired, so this keeps the pass compiling and color-neutral until the LUT upload is added.
+export function applyLookupTableGradeEffectToWgpu(state, source, dest, effect) {
+    const strength = effect.strength ?? 1;
+    const pipeline = getWgpuEffectPipeline(state, 'colorGrade.lutGrade', LUT_GRADE_FRAGMENT_WGSL, 'replace');
+    drawWgpuFilterPass(state, source, dest, pipeline, (f32) => {
+        f32[0] = strength;
+    });
+}
+export const defaultWgpuLookupTableGradeEffectRunner = (ctx, effect) => {
+    applyLookupTableGradeEffectToWgpu(ctx.state, ctx.source, ctx.dest, effect);
+};
+// Slot layout: [0]=strength.
+const LUT_GRADE_FRAGMENT_WGSL = /* wgsl */ `
+struct Uniforms { u_strength : f32, _pad0 : f32, _pad1 : f32, _pad2 : f32, }
+@group(0) @binding(0) var<uniform> uni : Uniforms;
+@group(1) @binding(0) var tex : texture_2d<f32>;
+@group(1) @binding(1) var smp : sampler;
+
+@fragment
+fn fs_main(@location(0) uv : vec2f) -> @location(0) vec4f {
+  let c = textureSampleLevel(tex, smp, uv, 0.0);
+  // Passthrough: a real 3D LUT samples an uploaded LUT cube texture here, then mixes by u_strength.
+  let graded = c.rgb;
+  return vec4f(mix(c.rgb, graded, uni.u_strength), c.a);
+}`;
+//# sourceMappingURL=wgpuLookupTableGradeEffect.js.map

package/dist/wgpuLookupTableGradeEffect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wgpuLookupTableGradeEffect.js","sourceRoot":"","sources":["../src/wgpuLookupTableGradeEffect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAQ5D,OAAO,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AAEjE,qGAAqG;AACrG,oGAAoG;AACpG,2FAA2F;AAC3F,MAAM,UAAU,iCAAiC,CAC/C,KAAsB,EACtB,MAAkC,EAClC,IAAgC,EAChC,MAAwC;IAExC,MAAM,QAAQ,GAAG,MAAM,CAAC,QAAQ,IAAI,CAAC,CAAC;IACtC,MAAM,QAAQ,GAAG,qBAAqB,CAAC,KAAK,EAAE,qBAAqB,EAAE,uBAAuB,EAAE,SAAS,CAAC,CAAC;IACzG,kBAAkB,CAAC,KAAK,EAAE,MAA0B,EAAE,IAAwB,EAAE,QAAQ,EAAE,CAAC,GAAG,EAAE,EAAE;QAChG,GAAG,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC;IACpB,CAAC,CAAC,CAAC;AACL,CAAC;AAED,MAAM,CAAC,MAAM,uCAAuC,GAA2B,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE;IAC7F,iCAAiC,CAAC,GAAG,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,IAAI,EAAE,MAAgC,CAAC,CAAC;AACvG,CAAC,CAAC;AAEF,6BAA6B;AAC7B,MAAM,uBAAuB,GAAG,UAAU,CAAC;;;;;;;;;;;;EAYzC,CAAC"}

package/dist/wgpuMotionBlurEffect.d.ts

@@ -0,0 +1,4 @@
+import type { MotionBlurEffect, WgpuRenderEffectRunner, WgpuRenderState, WgpuRenderTarget } from '@flighthq/types';
+export declare function applyMotionBlurEffectToWgpu(state: WgpuRenderState, source: Readonly<WgpuRenderTarget>, dest: Readonly<WgpuRenderTarget>, velocityTexture: GPUTexture | null, effect: Readonly<MotionBlurEffect>): void;
+export declare const defaultWgpuMotionBlurEffectRunner: WgpuRenderEffectRunner;
+//# sourceMappingURL=wgpuMotionBlurEffect.d.ts.map

package/dist/wgpuMotionBlurEffect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wgpuMotionBlurEffect.d.ts","sourceRoot":"","sources":["../src/wgpuMotionBlurEffect.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,gBAAgB,EAAE,sBAAsB,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAWnH,wBAAgB,2BAA2B,CACzC,KAAK,EAAE,eAAe,EACtB,MAAM,EAAE,QAAQ,CAAC,gBAAgB,CAAC,EAClC,IAAI,EAAE,QAAQ,CAAC,gBAAgB,CAAC,EAChC,eAAe,EAAE,UAAU,GAAG,IAAI,EAClC,MAAM,EAAE,QAAQ,CAAC,gBAAgB,CAAC,GACjC,IAAI,CAwCN;AAED,eAAO,MAAM,iCAAiC,EAAE,sBAE/C,CAAC"}