@flighthq/effects-wgpu 0.1.0

package/dist/wgpuCrtEffect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wgpuCrtEffect.js","sourceRoot":"","sources":["../src/wgpuCrtEffect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAG5D,OAAO,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AAEjE,sGAAsG;AACtG,uEAAuE;AACvE,MAAM,UAAU,oBAAoB,CAClC,KAAsB,EACtB,MAAkC,EAClC,IAAgC,EAChC,MAA2B;IAE3B,MAAM,SAAS,GAAG,MAAM,CAAC,SAAS,IAAI,GAAG,CAAC;IAC1C,MAAM,iBAAiB,GAAG,MAAM,CAAC,iBAAiB,IAAI,GAAG,CAAC;IAC1D,MAAM,QAAQ,GAAG,MAAM,CAAC,QAAQ,IAAI,GAAG,CAAC;IACxC,MAAM,UAAU,GAAG,MAAM,CAAC,UAAU,IAAI,KAAK,CAAC;IAC9C,MAAM,QAAQ,GAAG,qBAAqB,CAAC,KAAK,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,SAAS,CAAC,CAAC;IAC/F,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,iBAAiB,CAAC;QAC3B,GAAG,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC;QAClB,GAAG,CAAC,CAAC,CAAC,GAAG,UAAU,CAAC;QACpB,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,0BAA0B,GAA2B,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE;IAChF,oBAAoB,CAAC,GAAG,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,IAAI,EAAE,MAAmB,CAAC,CAAC;AAC7E,CAAC,CAAC;AAEF,sGAAsG;AACtG,MAAM,iBAAiB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmCnC,CAAC"}

package/dist/wgpuDirectionalBlurEffect.d.ts

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

package/dist/wgpuDirectionalBlurEffect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wgpuDirectionalBlurEffect.d.ts","sourceRoot":"","sources":["../src/wgpuDirectionalBlurEffect.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,qBAAqB,EAAE,sBAAsB,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAOxH,wBAAgB,gCAAgC,CAC9C,KAAK,EAAE,eAAe,EACtB,MAAM,EAAE,QAAQ,CAAC,gBAAgB,CAAC,EAClC,IAAI,EAAE,QAAQ,CAAC,gBAAgB,CAAC,EAChC,MAAM,EAAE,QAAQ,CAAC,qBAAqB,CAAC,GACtC,IAAI,CAYN;AAED,eAAO,MAAM,sCAAsC,EAAE,sBAEpD,CAAC"}

package/dist/wgpuDirectionalBlurEffect.js

@@ -0,0 +1,52 @@
+import { drawWgpuFilterPass } from '@flighthq/filters-wgpu';
+import { getWgpuEffectPipeline } from './wgpuEffectProgramCache';
+// Directional blur: accumulate samples stepped along `angle` over `length` texels, normalized by the
+// sample count. Single-pass reference recipe, the Wgpu mirror of effects-gl's
+// applyDirectionalBlurEffectToGl. u_resolution converts the texel length into UV space.
+export function applyDirectionalBlurEffectToWgpu(state, source, dest, effect) {
+    const angle = effect.angle ?? 0;
+    const length = effect.length ?? 8;
+    const samples = effect.samples ?? 16;
+    const pipeline = getWgpuEffectPipeline(state, 'motion.directionalBlur', DIRECTIONAL_BLUR_FRAGMENT_WGSL, 'replace');
+    drawWgpuFilterPass(state, source, dest, pipeline, (f32) => {
+        f32[0] = angle;
+        f32[1] = length;
+        f32[2] = samples;
+        f32[4] = source.width;
+        f32[5] = source.height;
+    });
+}
+export const defaultWgpuDirectionalBlurEffectRunner = (ctx, effect) => {
+    applyDirectionalBlurEffectToWgpu(ctx.state, ctx.source, ctx.dest, effect);
+};
+// Slot layout: [0]=angle, [1]=length, [2]=samples, [3]=pad, [4]=resolution.x, [5]=resolution.y.
+const DIRECTIONAL_BLUR_FRAGMENT_WGSL = /* wgsl */ `
+struct Uniforms {
+  u_angle : f32,
+  u_length : f32,
+  u_samples : 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 SAMPLES : i32 = 16;
+
+@fragment
+fn fs_main(@location(0) uv : vec2f) -> @location(0) vec4f {
+  let dir = vec2f(cos(uni.u_angle), sin(uni.u_angle)) * (uni.u_length / uni.u_resolution);
+  let count = min(uni.u_samples, 16.0);
+  var sum = vec4f(0.0);
+  var taken = 0.0;
+  for (var i = 0; i < SAMPLES; i = i + 1) {
+    if (f32(i) >= count) { break; }
+    let t = select(0.0, (f32(i) / (count - 1.0)) - 0.5, count > 1.0);
+    let p = uv + dir * t;
+    sum = sum + textureSampleLevel(tex, smp, p, 0.0);
+    taken = taken + 1.0;
+  }
+  return sum / max(taken, 1.0);
+}`;
+//# sourceMappingURL=wgpuDirectionalBlurEffect.js.map

package/dist/wgpuDirectionalBlurEffect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wgpuDirectionalBlurEffect.js","sourceRoot":"","sources":["../src/wgpuDirectionalBlurEffect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAG5D,OAAO,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AAEjE,qGAAqG;AACrG,8EAA8E;AAC9E,wFAAwF;AACxF,MAAM,UAAU,gCAAgC,CAC9C,KAAsB,EACtB,MAAkC,EAClC,IAAgC,EAChC,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,QAAQ,GAAG,qBAAqB,CAAC,KAAK,EAAE,wBAAwB,EAAE,8BAA8B,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,KAAK,CAAC;QACf,GAAG,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC;QAChB,GAAG,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC;QACjB,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,sCAAsC,GAA2B,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE;IAC5F,gCAAgC,CAAC,GAAG,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,IAAI,EAAE,MAA+B,CAAC,CAAC;AACrG,CAAC,CAAC;AAEF,gGAAgG;AAChG,MAAM,8BAA8B,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4BhD,CAAC"}

package/dist/wgpuDisplacementEffect.d.ts

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

package/dist/wgpuDisplacementEffect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wgpuDisplacementEffect.d.ts","sourceRoot":"","sources":["../src/wgpuDisplacementEffect.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,sBAAsB,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAKrH,wBAAgB,6BAA6B,CAC3C,KAAK,EAAE,eAAe,EACtB,MAAM,EAAE,QAAQ,CAAC,gBAAgB,CAAC,EAClC,IAAI,EAAE,QAAQ,CAAC,gBAAgB,CAAC,EAChC,MAAM,EAAE,QAAQ,CAAC,kBAAkB,CAAC,GACnC,IAAI,CAaN;AAED,eAAO,MAAM,mCAAmC,EAAE,sBAEjD,CAAC"}

package/dist/wgpuDisplacementEffect.js

@@ -0,0 +1,44 @@
+import { drawWgpuFilterPass } from '@flighthq/filters-wgpu';
+import { getWgpuEffectPipeline } from './wgpuEffectProgramCache';
+// Displacement / heat-haze: warp the sample uv by an animated sine field for a refractive wobble.
+export function applyDisplacementEffectToWgpu(state, source, dest, effect) {
+    const intensity = effect.intensity ?? 8;
+    const frequency = effect.frequency ?? 12;
+    const seed = effect.seed ?? 0;
+    const pipeline = getWgpuEffectPipeline(state, 'lens.displacement', DISPLACEMENT_FRAGMENT_WGSL, 'replace');
+    drawWgpuFilterPass(state, source, dest, pipeline, (f32) => {
+        f32[0] = intensity;
+        f32[1] = frequency;
+        f32[2] = seed;
+        // u_resolution (vec2f) aligns to slot [4].
+        f32[4] = source.width;
+        f32[5] = source.height;
+    });
+}
+export const defaultWgpuDisplacementEffectRunner = (ctx, effect) => {
+    applyDisplacementEffectToWgpu(ctx.state, ctx.source, ctx.dest, effect);
+};
+// Slot layout: [0]=amount, [1]=scale.
+// Slot layout: [0]=intensity, [1]=frequency, [2]=seed, [4..5]=resolution.
+const DISPLACEMENT_FRAGMENT_WGSL = /* wgsl */ `
+struct Uniforms {
+  u_intensity : f32,
+  u_frequency : f32,
+  u_seed : 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 f = uni.u_frequency;
+  let warp = vec2f(
+    sin(uv.y * f + uni.u_seed) + sin(uv.y * f * 2.3 + uni.u_seed * 1.7) * 0.5,
+    cos(uv.x * f * 0.8 + uni.u_seed * 1.3)
+  );
+  let displaced = uv + warp * (uni.u_intensity / uni.u_resolution);
+  return textureSampleLevel(tex, smp, displaced, 0.0);
+}`;
+//# sourceMappingURL=wgpuDisplacementEffect.js.map

package/dist/wgpuDisplacementEffect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wgpuDisplacementEffect.js","sourceRoot":"","sources":["../src/wgpuDisplacementEffect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAG5D,OAAO,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AAEjE,kGAAkG;AAClG,MAAM,UAAU,6BAA6B,CAC3C,KAAsB,EACtB,MAAkC,EAClC,IAAgC,EAChC,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,QAAQ,GAAG,qBAAqB,CAAC,KAAK,EAAE,mBAAmB,EAAE,0BAA0B,EAAE,SAAS,CAAC,CAAC;IAC1G,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;QACd,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,mCAAmC,GAA2B,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE;IACzF,6BAA6B,CAAC,GAAG,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,IAAI,EAAE,MAA4B,CAAC,CAAC;AAC/F,CAAC,CAAC;AAEF,sCAAsC;AACtC,0EAA0E;AAC1E,MAAM,0BAA0B,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;EAoB5C,CAAC"}

package/dist/wgpuDitherEffect.d.ts

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

package/dist/wgpuDitherEffect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wgpuDitherEffect.d.ts","sourceRoot":"","sources":["../src/wgpuDitherEffect.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,sBAAsB,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAM/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,CASN;AAED,eAAO,MAAM,6BAA6B,EAAE,sBAE3C,CAAC"}

package/dist/wgpuDitherEffect.js

@@ -0,0 +1,45 @@
+import { drawWgpuFilterPass } from '@flighthq/filters-wgpu';
+import { getWgpuEffectPipeline } from './wgpuEffectProgramCache';
+// Dither: quantize each channel to `levels` steps with a 4x4 ordered Bayer threshold for a retro
+// banded-but-textured look.
+export function applyDitherEffectToWgpu(state, source, dest, effect) {
+    const levels = effect.levels ?? 4;
+    const pipeline = getWgpuEffectPipeline(state, 'stylization.dither', DITHER_FRAGMENT_WGSL, 'replace');
+    drawWgpuFilterPass(state, source, dest, pipeline, (f32) => {
+        f32[0] = Math.max(2, levels);
+        // u_resolution (vec2f) aligns to slot [2].
+        f32[2] = source.width;
+        f32[3] = source.height;
+    });
+}
+export const defaultWgpuDitherEffectRunner = (ctx, effect) => {
+    applyDitherEffectToWgpu(ctx.state, ctx.source, ctx.dest, effect);
+};
+// Slot layout: [0]=levels, [1]=pad, [2..3]=resolution.
+const DITHER_FRAGMENT_WGSL = /* wgsl */ `
+struct Uniforms {
+  u_levels : 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;
+
+fn bayer(p : vec2i) -> f32 {
+  let x = p.x & 3;
+  let y = p.y & 3;
+  var m = array<i32, 16>(0, 8, 2, 10, 12, 4, 14, 6, 3, 11, 1, 9, 15, 7, 13, 5);
+  return f32(m[y * 4 + x]) / 16.0;
+}
+
+@fragment
+fn fs_main(@location(0) uv : vec2f) -> @location(0) vec4f {
+  let c = textureSampleLevel(tex, smp, uv, 0.0);
+  let px = vec2i(uv * uni.u_resolution);
+  let t = bayer(px) - 0.5;
+  let steps = uni.u_levels - 1.0;
+  let q = floor(c.rgb * steps + 0.5 + t) / steps;
+  return vec4f(clamp(q, vec3f(0.0), vec3f(1.0)), c.a);
+}`;
+//# sourceMappingURL=wgpuDitherEffect.js.map

package/dist/wgpuDitherEffect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wgpuDitherEffect.js","sourceRoot":"","sources":["../src/wgpuDitherEffect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAG5D,OAAO,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AAEjE,iGAAiG;AACjG,4BAA4B;AAC5B,MAAM,UAAU,uBAAuB,CACrC,KAAsB,EACtB,MAAkC,EAClC,IAAgC,EAChC,MAA8B;IAE9B,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,IAAI,CAAC,CAAC;IAClC,MAAM,QAAQ,GAAG,qBAAqB,CAAC,KAAK,EAAE,oBAAoB,EAAE,oBAAoB,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,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,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,uDAAuD;AACvD,MAAM,oBAAoB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;EAyBtC,CAAC"}

package/dist/wgpuEffectProgramCache.d.ts

@@ -0,0 +1,4 @@
+import type { WgpuFilterPipeline } from '@flighthq/filters-wgpu';
+import type { WgpuRenderState } from '@flighthq/types';
+export declare function getWgpuEffectPipeline(state: WgpuRenderState, key: string, fragmentWGSL: string, blend?: 'premul' | 'replace'): WgpuFilterPipeline;
+//# sourceMappingURL=wgpuEffectProgramCache.d.ts.map

package/dist/wgpuEffectProgramCache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wgpuEffectProgramCache.d.ts","sourceRoot":"","sources":["../src/wgpuEffectProgramCache.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAEjE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAavD,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,eAAe,EACtB,GAAG,EAAE,MAAM,EACX,YAAY,EAAE,MAAM,EACpB,KAAK,GAAE,QAAQ,GAAG,SAAqB,GACtC,kBAAkB,CAWpB"}

package/dist/wgpuEffectProgramCache.js

@@ -0,0 +1,26 @@
+import { createWgpuFilterPipeline } from '@flighthq/filters-wgpu';
+// Per-state cache of compiled effect filter pipelines, keyed by a stable string. Effect recipes call
+// getWgpuEffectPipeline with their own key + fragment WGSL so each pipeline compiles once per state
+// and is reused every frame. The WGSL is the fragment half only; createWgpuFilterPipeline prepends
+// the shared fullscreen-quad vertex (FILTER_VERTEX_WGSL). Keeps compiled pipelines off the render-state
+// runtime type. Mirrors effects-gl's getGlEffectProgram.
+//
+// Uniform-slot convention every recipe follows: the fragment declares
+//   struct Uniforms { ... } @group(0) @binding(0) var<uniform> uni : Uniforms;
+//   @group(1) @binding(0) var tex : texture_2d<f32>; @group(1) @binding(1) var smp : sampler;
+// and packs its scalars into the f32/i32 slot written by drawWgpuFilterPass's setUniforms callback.
+export function getWgpuEffectPipeline(state, key, fragmentWGSL, blend = 'replace') {
+    let cache = _pipelines.get(state);
+    if (cache === undefined) {
+        cache = new Map();
+        _pipelines.set(state, cache);
+    }
+    const existing = cache.get(key);
+    if (existing !== undefined)
+        return existing;
+    const compiled = createWgpuFilterPipeline(state, fragmentWGSL, blend);
+    cache.set(key, compiled);
+    return compiled;
+}
+const _pipelines = new WeakMap();
+//# sourceMappingURL=wgpuEffectProgramCache.js.map

package/dist/wgpuEffectProgramCache.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wgpuEffectProgramCache.js","sourceRoot":"","sources":["../src/wgpuEffectProgramCache.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,wBAAwB,EAAE,MAAM,wBAAwB,CAAC;AAGlE,qGAAqG;AACrG,oGAAoG;AACpG,mGAAmG;AACnG,wGAAwG;AACxG,yDAAyD;AACzD,EAAE;AACF,sEAAsE;AACtE,+EAA+E;AAC/E,8FAA8F;AAC9F,oGAAoG;AAEpG,MAAM,UAAU,qBAAqB,CACnC,KAAsB,EACtB,GAAW,EACX,YAAoB,EACpB,QAA8B,SAAS;IAEvC,IAAI,KAAK,GAAG,UAAU,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;IAClC,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;QACxB,KAAK,GAAG,IAAI,GAAG,EAAE,CAAC;QAClB,UAAU,CAAC,GAAG,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;IAC/B,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,wBAAwB,CAAC,KAAK,EAAE,YAAY,EAAE,KAAK,CAAC,CAAC;IACtE,KAAK,CAAC,GAAG,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAC;IACzB,OAAO,QAAQ,CAAC;AAClB,CAAC;AAED,MAAM,UAAU,GAAG,IAAI,OAAO,EAAoD,CAAC"}

package/dist/wgpuExposureEffect.d.ts

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

package/dist/wgpuExposureEffect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wgpuExposureEffect.d.ts","sourceRoot":"","sources":["../src/wgpuExposureEffect.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,CAON;AAED,eAAO,MAAM,+BAA+B,EAAE,sBAE7C,CAAC"}

package/dist/wgpuExposureEffect.js

@@ -0,0 +1,28 @@
+import { drawWgpuFilterPass } from '@flighthq/filters-wgpu';
+import { getWgpuEffectPipeline } from './wgpuEffectProgramCache';
+// Exposure: scale linear color by 2^stops. Single-pass reference recipe, the Wgpu mirror of
+// effects-gl's applyExposureEffectToGl. The stops are converted to a linear multiplier in JS.
+export function applyExposureEffectToWgpu(state, source, dest, effect) {
+    const exposure = effect.exposure ?? 0;
+    const multiplier = Math.pow(2, exposure);
+    const pipeline = getWgpuEffectPipeline(state, 'exposure', EXPOSURE_FRAGMENT_WGSL, 'replace');
+    drawWgpuFilterPass(state, source, dest, pipeline, (f32) => {
+        f32[0] = multiplier;
+    });
+}
+export const defaultWgpuExposureEffectRunner = (ctx, effect) => {
+    applyExposureEffectToWgpu(ctx.state, ctx.source, ctx.dest, effect);
+};
+// Slot [0]=multiplier (2^stops, precomputed in JS); the scalar struct pads to a 16-byte boundary.
+const EXPOSURE_FRAGMENT_WGSL = /* wgsl */ `
+struct Uniforms { u_exposure : 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(c.rgb * uni.u_exposure, c.a);
+}`;
+//# sourceMappingURL=wgpuExposureEffect.js.map

package/dist/wgpuExposureEffect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wgpuExposureEffect.js","sourceRoot":"","sources":["../src/wgpuExposureEffect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAG5D,OAAO,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AAEjE,4FAA4F;AAC5F,8FAA8F;AAC9F,MAAM,UAAU,yBAAyB,CACvC,KAAsB,EACtB,MAAkC,EAClC,IAAgC,EAChC,MAAgC;IAEhC,MAAM,QAAQ,GAAG,MAAM,CAAC,QAAQ,IAAI,CAAC,CAAC;IACtC,MAAM,UAAU,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC;IACzC,MAAM,QAAQ,GAAG,qBAAqB,CAAC,KAAK,EAAE,UAAU,EAAE,sBAAsB,EAAE,SAAS,CAAC,CAAC;IAC7F,kBAAkB,CAAC,KAAK,EAAE,MAA0B,EAAE,IAAwB,EAAE,QAAQ,EAAE,CAAC,GAAG,EAAE,EAAE;QAChG,GAAG,CAAC,CAAC,CAAC,GAAG,UAAU,CAAC;IACtB,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,kGAAkG;AAClG,MAAM,sBAAsB,GAAG,UAAU,CAAC;;;;;;;;;;EAUxC,CAAC"}

package/dist/wgpuFilmGrainEffect.d.ts

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

package/dist/wgpuFilmGrainEffect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wgpuFilmGrainEffect.d.ts","sourceRoot":"","sources":["../src/wgpuFilmGrainEffect.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,sBAAsB,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAMlH,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,CAUN;AAED,eAAO,MAAM,gCAAgC,EAAE,sBAE9C,CAAC"}

package/dist/wgpuFilmGrainEffect.js

@@ -0,0 +1,41 @@
+import { drawWgpuFilterPass } from '@flighthq/filters-wgpu';
+import { getWgpuEffectPipeline } from './wgpuEffectProgramCache';
+// 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 applyFilmGrainEffectToWgpu(state, source, dest, effect) {
+    const intensity = effect.intensity ?? 0.1;
+    const size = effect.size ?? 1;
+    const seed = effect.seed ?? 0;
+    const pipeline = getWgpuEffectPipeline(state, 'stylization.filmGrain', FILM_GRAIN_FRAGMENT_WGSL, 'replace');
+    drawWgpuFilterPass(state, source, dest, pipeline, (f32) => {
+        f32[0] = intensity;
+        f32[1] = Math.max(0.0001, size);
+        f32[2] = seed;
+    });
+}
+export const defaultWgpuFilmGrainEffectRunner = (ctx, effect) => {
+    applyFilmGrainEffectToWgpu(ctx.state, ctx.source, ctx.dest, effect);
+};
+// Slot layout: [0]=intensity, [1]=size, [2]=seed.
+const FILM_GRAIN_FRAGMENT_WGSL = /* wgsl */ `
+struct Uniforms {
+  u_intensity : f32,
+  u_size : 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 hash(pIn : vec2f) -> f32 {
+  let p = floor(pIn / uni.u_size);
+  return fract(sin(dot(p, vec2f(127.1, 311.7)) + uni.u_seed) * 43758.5453123);
+}
+
+@fragment
+fn fs_main(@location(0) uv : vec2f) -> @location(0) vec4f {
+  let c = textureSampleLevel(tex, smp, uv, 0.0);
+  let n = hash(uv * 1024.0) - 0.5;
+  return vec4f(c.rgb + n * uni.u_intensity, c.a);
+}`;
+//# sourceMappingURL=wgpuFilmGrainEffect.js.map

package/dist/wgpuFilmGrainEffect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wgpuFilmGrainEffect.js","sourceRoot":"","sources":["../src/wgpuFilmGrainEffect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAG5D,OAAO,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AAEjE,mGAAmG;AACnG,wCAAwC;AACxC,MAAM,UAAU,0BAA0B,CACxC,KAAsB,EACtB,MAAkC,EAClC,IAAgC,EAChC,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,QAAQ,GAAG,qBAAqB,CAAC,KAAK,EAAE,uBAAuB,EAAE,wBAAwB,EAAE,SAAS,CAAC,CAAC;IAC5G,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,IAAI,CAAC,GAAG,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;QAChC,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,kDAAkD;AAClD,MAAM,wBAAwB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;EAoB1C,CAAC"}

package/dist/wgpuFxaaEffect.d.ts

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

package/dist/wgpuFxaaEffect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wgpuFxaaEffect.d.ts","sourceRoot":"","sources":["../src/wgpuFxaaEffect.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,sBAAsB,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAM7G,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,eAAe,EACtB,MAAM,EAAE,QAAQ,CAAC,gBAAgB,CAAC,EAClC,IAAI,EAAE,QAAQ,CAAC,gBAAgB,CAAC,EAChC,MAAM,EAAE,QAAQ,CAAC,UAAU,CAAC,GAC3B,IAAI,CAUN;AAED,eAAO,MAAM,2BAA2B,EAAE,sBAEzC,CAAC"}

package/dist/wgpuFxaaEffect.js

@@ -0,0 +1,65 @@
+import { drawWgpuFilterPass } from '@flighthq/filters-wgpu';
+import { getWgpuEffectPipeline } from './wgpuEffectProgramCache';
+// FXAA: luminance edge detection + directional blend along the detected edge. Single-pass reference
+// recipe. Reads `tex`; u_resolution gives the texel size; u_edgeThreshold gates edge detection.
+export function applyFxaaEffectToWgpu(state, source, dest, effect) {
+    const edgeThreshold = effect.edgeThreshold ?? 0.0312;
+    const width = source.width;
+    const height = source.height;
+    const pipeline = getWgpuEffectPipeline(state, 'antialiasing.fxaa', FXAA_FRAGMENT_WGSL, 'replace');
+    drawWgpuFilterPass(state, source, dest, pipeline, (f32) => {
+        f32[0] = width;
+        f32[1] = height;
+        f32[2] = edgeThreshold;
+    });
+}
+export const defaultWgpuFxaaEffectRunner = (ctx, effect) => {
+    applyFxaaEffectToWgpu(ctx.state, ctx.source, ctx.dest, effect);
+};
+// Slots [0..1]=resolution (vec2f), [2]=edgeThreshold; the trailing scalar fits in the same 16-byte block.
+const FXAA_FRAGMENT_WGSL = /* wgsl */ `
+struct Uniforms { u_resolution : vec2f, u_edgeThreshold : 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 luma(c : vec3f) -> f32 {
+  return dot(c, vec3f(0.299, 0.587, 0.114));
+}
+
+@fragment
+fn fs_main(@location(0) uv : vec2f) -> @location(0) vec4f {
+  let texel = 1.0 / uni.u_resolution;
+  let rgbM = textureSampleLevel(tex, smp, uv, 0.0).rgb;
+  let rgbNW = textureSampleLevel(tex, smp, uv + vec2f(-1.0, -1.0) * texel, 0.0).rgb;
+  let rgbNE = textureSampleLevel(tex, smp, uv + vec2f(1.0, -1.0) * texel, 0.0).rgb;
+  let rgbSW = textureSampleLevel(tex, smp, uv + vec2f(-1.0, 1.0) * texel, 0.0).rgb;
+  let rgbSE = textureSampleLevel(tex, smp, uv + vec2f(1.0, 1.0) * texel, 0.0).rgb;
+  let lumaM = luma(rgbM);
+  let lumaNW = luma(rgbNW);
+  let lumaNE = luma(rgbNE);
+  let lumaSW = luma(rgbSW);
+  let lumaSE = luma(rgbSE);
+  let lumaMin = min(lumaM, min(min(lumaNW, lumaNE), min(lumaSW, lumaSE)));
+  let lumaMax = max(lumaM, max(max(lumaNW, lumaNE), max(lumaSW, lumaSE)));
+  let range = lumaMax - lumaMin;
+  if (range < max(uni.u_edgeThreshold, lumaMax * 0.125)) {
+    return vec4f(rgbM, textureSampleLevel(tex, smp, uv, 0.0).a);
+  }
+  var dir : vec2f;
+  dir.x = -((lumaNW + lumaNE) - (lumaSW + lumaSE));
+  dir.y = ((lumaNW + lumaSW) - (lumaNE + lumaSE));
+  let dirReduce = max((lumaNW + lumaNE + lumaSW + lumaSE) * 0.03125, 0.0078125);
+  let rcpDirMin = 1.0 / (min(abs(dir.x), abs(dir.y)) + dirReduce);
+  dir = clamp(dir * rcpDirMin, vec2f(-8.0), vec2f(8.0)) * texel;
+  let rgbA = 0.5 * (
+    textureSampleLevel(tex, smp, uv + dir * (1.0 / 3.0 - 0.5), 0.0).rgb +
+    textureSampleLevel(tex, smp, uv + dir * (2.0 / 3.0 - 0.5), 0.0).rgb);
+  let rgbB = rgbA * 0.5 + 0.25 * (
+    textureSampleLevel(tex, smp, uv + dir * -0.5, 0.0).rgb +
+    textureSampleLevel(tex, smp, uv + dir * 0.5, 0.0).rgb);
+  let lumaB = luma(rgbB);
+  let result = select(rgbB, rgbA, lumaB < lumaMin || lumaB > lumaMax);
+  return vec4f(result, textureSampleLevel(tex, smp, uv, 0.0).a);
+}`;
+//# sourceMappingURL=wgpuFxaaEffect.js.map

package/dist/wgpuFxaaEffect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wgpuFxaaEffect.js","sourceRoot":"","sources":["../src/wgpuFxaaEffect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAG5D,OAAO,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AAEjE,oGAAoG;AACpG,gGAAgG;AAChG,MAAM,UAAU,qBAAqB,CACnC,KAAsB,EACtB,MAAkC,EAClC,IAAgC,EAChC,MAA4B;IAE5B,MAAM,aAAa,GAAG,MAAM,CAAC,aAAa,IAAI,MAAM,CAAC;IACrD,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC;IAC3B,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;IAC7B,MAAM,QAAQ,GAAG,qBAAqB,CAAC,KAAK,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,SAAS,CAAC,CAAC;IAClG,kBAAkB,CAAC,KAAK,EAAE,MAA0B,EAAE,IAAwB,EAAE,QAAQ,EAAE,CAAC,GAAG,EAAE,EAAE;QAChG,GAAG,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC;QACf,GAAG,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC;QAChB,GAAG,CAAC,CAAC,CAAC,GAAG,aAAa,CAAC;IACzB,CAAC,CAAC,CAAC;AACL,CAAC;AAED,MAAM,CAAC,MAAM,2BAA2B,GAA2B,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE;IACjF,qBAAqB,CAAC,GAAG,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,IAAI,EAAE,MAAoB,CAAC,CAAC;AAC/E,CAAC,CAAC;AAEF,0GAA0G;AAC1G,MAAM,kBAAkB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4CpC,CAAC"}

package/dist/wgpuGlitchEffect.d.ts

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

package/dist/wgpuGlitchEffect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wgpuGlitchEffect.d.ts","sourceRoot":"","sources":["../src/wgpuGlitchEffect.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,sBAAsB,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAM/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,CAeN;AAED,eAAO,MAAM,6BAA6B,EAAE,sBAE3C,CAAC"}

package/dist/wgpuGlitchEffect.js

@@ -0,0 +1,60 @@
+import { drawWgpuFilterPass } from '@flighthq/filters-wgpu';
+import { getWgpuEffectPipeline } from './wgpuEffectProgramCache';
+// 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 applyGlitchEffectToWgpu(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 pipeline = getWgpuEffectPipeline(state, 'stylization.glitch', GLITCH_FRAGMENT_WGSL, 'replace');
+    drawWgpuFilterPass(state, source, dest, pipeline, (f32) => {
+        f32[0] = intensity;
+        f32[1] = blockSize;
+        f32[2] = colorShift;
+        f32[3] = seed;
+        // u_resolution (vec2f) aligns to slot [4].
+        f32[4] = source.width;
+        f32[5] = source.height;
+    });
+}
+export const defaultWgpuGlitchEffectRunner = (ctx, effect) => {
+    applyGlitchEffectToWgpu(ctx.state, ctx.source, ctx.dest, effect);
+};
+// Slot layout: [0]=intensity, [1]=blockSize, [2]=colorShift, [3]=seed, [4..5]=resolution.
+const GLITCH_FRAGMENT_WGSL = /* wgsl */ `
+struct Uniforms {
+  u_intensity : f32,
+  u_blockSize : f32,
+  u_colorShift : f32,
+  u_seed : 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;
+
+fn glitchHash(n : f32) -> f32 { return fract(sin(n) * 43758.5453123); }
+
+@fragment
+fn fs_main(@location(0) uv : vec2f) -> @location(0) vec4f {
+  let blockSize = max(2.0, uni.u_blockSize);
+  let block = floor(uv.y * uni.u_resolution.y / blockSize);
+  let r = glitchHash(block + uni.u_seed * 7.0);
+  // Higher intensity activates more blocks; a torn block tears horizontally.
+  let tear = step(1.0 - uni.u_intensity * 0.6, r);
+  let shiftPx = (glitchHash(block * 1.7 + uni.u_seed) - 0.5) * 2.0 * tear * uni.u_intensity * 40.0;
+  let baseUv = vec2f(uv.x + shiftPx / uni.u_resolution.x, uv.y);
+  // RGB channel separation, wider on torn blocks.
+  let cs = (uni.u_colorShift * (0.4 + tear)) / uni.u_resolution.x;
+  let rC = textureSampleLevel(tex, smp, vec2f(baseUv.x + cs, baseUv.y), 0.0).r;
+  let gC = textureSampleLevel(tex, smp, baseUv, 0.0).g;
+  let bC = textureSampleLevel(tex, smp, vec2f(baseUv.x - cs, baseUv.y), 0.0).b;
+  let a = textureSampleLevel(tex, smp, baseUv, 0.0).a;
+  var col = vec3f(rC, gC, bC);
+  // Occasional bright block corruption.
+  let corrupt = step(0.985 - uni.u_intensity * 0.04, glitchHash(block * 3.3 + uni.u_seed * 2.0));
+  col = mix(col, vec3f(1.0), corrupt * 0.6);
+  return vec4f(col, a);
+}`;
+//# sourceMappingURL=wgpuGlitchEffect.js.map

package/dist/wgpuGlitchEffect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wgpuGlitchEffect.js","sourceRoot":"","sources":["../src/wgpuGlitchEffect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAG5D,OAAO,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AAEjE,sGAAsG;AACtG,4FAA4F;AAC5F,MAAM,UAAU,uBAAuB,CACrC,KAAsB,EACtB,MAAkC,EAClC,IAAgC,EAChC,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,QAAQ,GAAG,qBAAqB,CAAC,KAAK,EAAE,oBAAoB,EAAE,oBAAoB,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,UAAU,CAAC;QACpB,GAAG,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;QACd,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,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,0FAA0F;AAC1F,MAAM,oBAAoB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkCtC,CAAC"}

package/dist/wgpuGodRaysEffect.d.ts

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

package/dist/wgpuGodRaysEffect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wgpuGodRaysEffect.d.ts","sourceRoot":"","sources":["../src/wgpuGodRaysEffect.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,sBAAsB,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAShH,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,eAAe,EACtB,MAAM,EAAE,QAAQ,CAAC,gBAAgB,CAAC,EAClC,IAAI,EAAE,QAAQ,CAAC,gBAAgB,CAAC,EAChC,MAAM,EAAE,QAAQ,CAAC,aAAa,CAAC,GAC9B,IAAI,CAsBN;AAED,eAAO,MAAM,8BAA8B,EAAE,sBAE5C,CAAC"}

package/dist/wgpuGodRaysEffect.js

@@ -0,0 +1,67 @@
+import { drawWgpuFilterPass } from '@flighthq/filters-wgpu';
+import { getWgpuEffectPipeline } from './wgpuEffectProgramCache';
+// 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. The sample
+// count is baked into the WGSL (loop bound must be const) and keyed into the pipeline cache, so each
+// distinct sample count compiles once.
+export function applyGodRaysEffectToWgpu(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 pipeline = getWgpuEffectPipeline(state, `atmospheric.godRays.${samples}`, buildGodRaysFragment(samples), 'replace');
+    drawWgpuFilterPass(state, source, dest, pipeline, (f32) => {
+        f32[0] = centerX;
+        f32[1] = centerY;
+        f32[2] = density;
+        f32[3] = decay;
+        f32[4] = weight;
+        f32[5] = exposure;
+    });
+}
+export const defaultWgpuGodRaysEffectRunner = (ctx, effect) => {
+    applyGodRaysEffectToWgpu(ctx.state, ctx.source, ctx.dest, effect);
+};
+function buildGodRaysFragment(samples) {
+    return GOD_RAYS_FRAGMENT_HEAD + samples.toString() + GOD_RAYS_FRAGMENT_TAIL;
+}
+// Slot layout: [0]=centerX, [1]=centerY, [2]=density, [3]=decay, [4]=weight, [5]=exposure. All scalars
+// pack into one vec4-aligned run, so no padding gaps are needed.
+const GOD_RAYS_FRAGMENT_HEAD = /* wgsl */ `
+struct Uniforms {
+  u_centerX : f32,
+  u_centerY : f32,
+  u_density : f32,
+  u_decay : f32,
+  u_weight : f32,
+  u_exposure : 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;
+
+const SAMPLES : i32 = `;
+const GOD_RAYS_FRAGMENT_TAIL = `;
+
+@fragment
+fn fs_main(@location(0) uv : vec2f) -> @location(0) vec4f {
+  let light = vec2f(uni.u_centerX, uni.u_centerY);
+  let delta = (uv - light) * (uni.u_density / f32(SAMPLES));
+  var coord = uv;
+  let base = textureSampleLevel(tex, smp, uv, 0.0);
+  var accum = base.rgb;
+  var illumination = 1.0;
+  for (var i = 0; i < SAMPLES; i = i + 1) {
+    coord = coord - delta;
+    var s = textureSampleLevel(tex, smp, coord, 0.0).rgb;
+    s = s * (illumination * uni.u_weight);
+    accum = accum + s;
+    illumination = illumination * uni.u_decay;
+  }
+  return vec4f(base.rgb + accum * uni.u_exposure, base.a);
+}`;
+//# sourceMappingURL=wgpuGodRaysEffect.js.map

package/dist/wgpuGodRaysEffect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wgpuGodRaysEffect.js","sourceRoot":"","sources":["../src/wgpuGodRaysEffect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAG5D,OAAO,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AAEjE,mGAAmG;AACnG,oGAAoG;AACpG,qGAAqG;AACrG,qGAAqG;AACrG,uCAAuC;AACvC,MAAM,UAAU,wBAAwB,CACtC,KAAsB,EACtB,MAAkC,EAClC,IAAgC,EAChC,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,QAAQ,GAAG,qBAAqB,CACpC,KAAK,EACL,uBAAuB,OAAO,EAAE,EAChC,oBAAoB,CAAC,OAAO,CAAC,EAC7B,SAAS,CACV,CAAC;IACF,kBAAkB,CAAC,KAAK,EAAE,MAA0B,EAAE,IAAwB,EAAE,QAAQ,EAAE,CAAC,GAAG,EAAE,EAAE;QAChG,GAAG,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC;QACjB,GAAG,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC;QACjB,GAAG,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC;QACjB,GAAG,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC;QACf,GAAG,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC;QAChB,GAAG,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC;IACpB,CAAC,CAAC,CAAC;AACL,CAAC;AAED,MAAM,CAAC,MAAM,8BAA8B,GAA2B,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE;IACpF,wBAAwB,CAAC,GAAG,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,IAAI,EAAE,MAAuB,CAAC,CAAC;AACrF,CAAC,CAAC;AAEF,SAAS,oBAAoB,CAAC,OAAe;IAC3C,OAAO,sBAAsB,GAAG,OAAO,CAAC,QAAQ,EAAE,GAAG,sBAAsB,CAAC;AAC9E,CAAC;AAED,uGAAuG;AACvG,iEAAiE;AACjE,MAAM,sBAAsB,GAAG,UAAU,CAAC;;;;;;;;;;;;;uBAanB,CAAC;AAExB,MAAM,sBAAsB,GAAG;;;;;;;;;;;;;;;;;;EAkB7B,CAAC"}

package/dist/wgpuGrayscaleEffect.d.ts

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

package/dist/wgpuGrayscaleEffect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wgpuGrayscaleEffect.d.ts","sourceRoot":"","sources":["../src/wgpuGrayscaleEffect.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,sBAAsB,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAKlH,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,CAMN;AAED,eAAO,MAAM,gCAAgC,EAAE,sBAE9C,CAAC"}

package/dist/wgpuGrayscaleEffect.js

@@ -0,0 +1,27 @@
+import { drawWgpuFilterPass } from '@flighthq/filters-wgpu';
+import { getWgpuEffectPipeline } from './wgpuEffectProgramCache';
+// Grayscale: mix toward luminance by intensity.
+export function applyGrayscaleEffectToWgpu(state, source, dest, effect) {
+    const intensity = effect.intensity ?? 1;
+    const pipeline = getWgpuEffectPipeline(state, 'colorGrade.grayscale', GRAYSCALE_FRAGMENT_WGSL, 'replace');
+    drawWgpuFilterPass(state, source, dest, pipeline, (f32) => {
+        f32[0] = intensity;
+    });
+}
+export const defaultWgpuGrayscaleEffectRunner = (ctx, effect) => {
+    applyGrayscaleEffectToWgpu(ctx.state, ctx.source, ctx.dest, effect);
+};
+// Slot layout: [0]=intensity.
+const GRAYSCALE_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);
+  let l = dot(c.rgb, vec3f(0.2126, 0.7152, 0.0722));
+  return vec4f(mix(c.rgb, vec3f(l), uni.u_intensity), c.a);
+}`;
+//# sourceMappingURL=wgpuGrayscaleEffect.js.map

package/dist/wgpuGrayscaleEffect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wgpuGrayscaleEffect.js","sourceRoot":"","sources":["../src/wgpuGrayscaleEffect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAG5D,OAAO,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AAEjE,gDAAgD;AAChD,MAAM,UAAU,0BAA0B,CACxC,KAAsB,EACtB,MAAkC,EAClC,IAAgC,EAChC,MAAiC;IAEjC,MAAM,SAAS,GAAG,MAAM,CAAC,SAAS,IAAI,CAAC,CAAC;IACxC,MAAM,QAAQ,GAAG,qBAAqB,CAAC,KAAK,EAAE,sBAAsB,EAAE,uBAAuB,EAAE,SAAS,CAAC,CAAC;IAC1G,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,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,8BAA8B;AAC9B,MAAM,uBAAuB,GAAG,UAAU,CAAC;;;;;;;;;;;EAWzC,CAAC"}