@flighthq/effects-wgpu 0.1.0

package/dist/wgpuMotionBlurEffect.js

@@ -0,0 +1,97 @@
+import { createWgpuDualSourcePipeline } from '@flighthq/filters-wgpu';
+import { drawWgpuDualSourcePass } from '@flighthq/filters-wgpu';
+// Motion blur (per-object): the velocity-driven analog of the depth consumers (fog/DoF), the Wgpu
+// mirror of effects-gl's applyMotionBlurEffectToGl. 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. The
+// velocity texture binds as the second source via drawWgpuDualSourcePass (@group(2)). 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 applyMotionBlurEffectToWgpu(state, source, dest, velocityTexture, effect) {
+    const intensity = effect.intensity ?? 1;
+    const samples = effect.samples ?? 16;
+    const pipeline = getMotionBlurPipeline(state);
+    if (velocityTexture === null) {
+        // Sentinel path: no velocity buffer — bind source as both inputs so the dual-source layout is
+        // satisfied, and u_hasVelocity=0 makes the fragment a passthrough copy.
+        drawWgpuDualSourcePass(state, source, source, dest, pipeline, (f32) => {
+            f32[0] = intensity;
+            f32[1] = samples;
+            f32[2] = source.width;
+            f32[3] = source.height;
+            f32[4] = 0;
+        });
+        return;
+    }
+    // Wrap the raw velocity GPUTexture as a minimal second source: drawWgpuDualSourcePass reads only the
+    // `.view`, so a view over the velocity texture is all that is required for the @group(2) binding.
+    const velocitySource = { view: velocityTexture.createView() };
+    drawWgpuDualSourcePass(state, source, velocitySource, dest, pipeline, (f32) => {
+        f32[0] = intensity;
+        f32[1] = samples;
+        f32[2] = source.width;
+        f32[3] = source.height;
+        f32[4] = 1;
+    });
+}
+export const defaultWgpuMotionBlurEffectRunner = (ctx, effect) => {
+    applyMotionBlurEffectToWgpu(ctx.state, ctx.source, ctx.dest, ctx.sceneVelocityTexture, effect);
+};
+// Motion blur needs two source bindings (color = group 1, velocity = group 2), so it uses the
+// dual-source filter primitive; cached per state alongside the single-source effect pipelines.
+function getMotionBlurPipeline(state) {
+    let pipeline = _motionBlurPipelines.get(state);
+    if (pipeline === undefined) {
+        pipeline = createWgpuDualSourcePipeline(state, MOTION_BLUR_FRAGMENT_WGSL, 'replace');
+        _motionBlurPipelines.set(state, pipeline);
+    }
+    return pipeline;
+}
+const _motionBlurPipelines = new WeakMap();
+// Slot layout: [0]=intensity, [1]=samples, [2]=resolution.x, [3]=resolution.y, [4]=hasVelocity. Color
+// binds at group 1, velocity at group 2. u_resolution converts the pixel-space velocity into UV offsets.
+const MOTION_BLUR_FRAGMENT_WGSL = /* wgsl */ `
+struct Uniforms {
+  u_intensity : f32,
+  u_samples : f32,
+  u_resolution : vec2f,
+  u_hasVelocity : f32,
+  _pad0 : f32,
+  _pad1 : f32,
+  _pad2 : f32,
+}
+@group(0) @binding(0) var<uniform> uni : Uniforms;
+@group(1) @binding(0) var tex0 : texture_2d<f32>;
+@group(1) @binding(1) var smp0 : sampler;
+@group(2) @binding(0) var tex1 : texture_2d<f32>;
+@group(2) @binding(1) var smp1 : sampler;
+
+const SAMPLES : i32 = 16;
+
+@fragment
+fn fs_main(@location(0) uv : vec2f) -> @location(0) vec4f {
+  let base = textureSampleLevel(tex0, smp0, uv, 0.0);
+  if (uni.u_hasVelocity < 0.5) {
+    // Sentinel path: no velocity buffer written — passthrough copy.
+    return base;
+  }
+  // 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.
+  let velocityPixels = textureSampleLevel(tex1, smp1, uv, 0.0).rg;
+  let smear = (velocityPixels / uni.u_resolution) * uni.u_intensity;
+  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; }
+    // Center the taps on the fragment: t in [-0.5, 0.5] spreads the accumulation along the motion vector.
+    let t = select(0.0, (f32(i) / (count - 1.0)) - 0.5, count > 1.0);
+    let p = uv + smear * t;
+    sum = sum + textureSampleLevel(tex0, smp0, p, 0.0);
+    taken = taken + 1.0;
+  }
+  return sum / max(taken, 1.0);
+}`;
+//# sourceMappingURL=wgpuMotionBlurEffect.js.map

package/dist/wgpuMotionBlurEffect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wgpuMotionBlurEffect.js","sourceRoot":"","sources":["../src/wgpuMotionBlurEffect.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,4BAA4B,EAAE,MAAM,wBAAwB,CAAC;AACtE,OAAO,EAAE,sBAAsB,EAAE,MAAM,wBAAwB,CAAC;AAGhE,kGAAkG;AAClG,iGAAiG;AACjG,sGAAsG;AACtG,sGAAsG;AACtG,kGAAkG;AAClG,uGAAuG;AACvG,sGAAsG;AACtG,oFAAoF;AACpF,2FAA2F;AAC3F,MAAM,UAAU,2BAA2B,CACzC,KAAsB,EACtB,MAAkC,EAClC,IAAgC,EAChC,eAAkC,EAClC,MAAkC;IAElC,MAAM,SAAS,GAAG,MAAM,CAAC,SAAS,IAAI,CAAC,CAAC;IACxC,MAAM,OAAO,GAAG,MAAM,CAAC,OAAO,IAAI,EAAE,CAAC;IACrC,MAAM,QAAQ,GAAG,qBAAqB,CAAC,KAAK,CAAC,CAAC;IAC9C,IAAI,eAAe,KAAK,IAAI,EAAE,CAAC;QAC7B,8FAA8F;QAC9F,wEAAwE;QACxE,sBAAsB,CACpB,KAAK,EACL,MAA0B,EAC1B,MAA0B,EAC1B,IAAwB,EACxB,QAAQ,EACR,CAAC,GAAG,EAAE,EAAE;YACN,GAAG,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC;YACnB,GAAG,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC;YACjB,GAAG,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC;YACtB,GAAG,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,CAAC;YACvB,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;QACb,CAAC,CACF,CAAC;QACF,OAAO;IACT,CAAC;IACD,qGAAqG;IACrG,kGAAkG;IAClG,MAAM,cAAc,GAAG,EAAE,IAAI,EAAE,eAAe,CAAC,UAAU,EAAE,EAAsB,CAAC;IAClF,sBAAsB,CACpB,KAAK,EACL,MAA0B,EAC1B,cAAc,EACd,IAAwB,EACxB,QAAQ,EACR,CAAC,GAAG,EAAE,EAAE;QACN,GAAG,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC;QACnB,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;QACvB,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;IACb,CAAC,CACF,CAAC;AACJ,CAAC;AAED,MAAM,CAAC,MAAM,iCAAiC,GAA2B,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE;IACvF,2BAA2B,CAAC,GAAG,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,IAAI,EAAE,GAAG,CAAC,oBAAoB,EAAE,MAA0B,CAAC,CAAC;AACrH,CAAC,CAAC;AAEF,8FAA8F;AAC9F,+FAA+F;AAC/F,SAAS,qBAAqB,CAAC,KAAsB;IACnD,IAAI,QAAQ,GAAG,oBAAoB,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;IAC/C,IAAI,QAAQ,KAAK,SAAS,EAAE,CAAC;QAC3B,QAAQ,GAAG,4BAA4B,CAAC,KAAK,EAAE,yBAAyB,EAAE,SAAS,CAAC,CAAC;QACrF,oBAAoB,CAAC,GAAG,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;IAC5C,CAAC;IACD,OAAO,QAAQ,CAAC;AAClB,CAAC;AAED,MAAM,oBAAoB,GAAG,IAAI,OAAO,EAA2C,CAAC;AAEpF,sGAAsG;AACtG,yGAAyG;AACzG,MAAM,yBAAyB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyC3C,CAAC"}

package/dist/wgpuOutlineEffect.d.ts

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

package/dist/wgpuOutlineEffect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wgpuOutlineEffect.d.ts","sourceRoot":"","sources":["../src/wgpuOutlineEffect.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,sBAAsB,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAMhH,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,CAqBN;AAED,eAAO,MAAM,8BAA8B,EAAE,sBAE5C,CAAC"}

package/dist/wgpuOutlineEffect.js

@@ -0,0 +1,64 @@
+import { drawWgpuFilterPass } from '@flighthq/filters-wgpu';
+import { getWgpuEffectPipeline } from './wgpuEffectProgramCache';
+// Outline: Sobel edge detection on luminance; where the gradient magnitude exceeds `threshold`, mix
+// the pixel toward the outline color by `thickness`. Color arrives packed RGBA, unpacked to 0..1 here.
+export function applyOutlineEffectToWgpu(state, source, dest, effect) {
+    const threshold = effect.threshold ?? 0.2;
+    const thickness = effect.thickness ?? 1;
+    const color = effect.color ?? 0x000000ff;
+    const r = ((color >>> 24) & 0xff) / 255;
+    const g = ((color >>> 16) & 0xff) / 255;
+    const b = ((color >>> 8) & 0xff) / 255;
+    const a = (color & 0xff) / 255;
+    const pipeline = getWgpuEffectPipeline(state, 'stylization.outline', OUTLINE_FRAGMENT_WGSL, 'replace');
+    drawWgpuFilterPass(state, source, dest, pipeline, (f32) => {
+        f32[0] = threshold;
+        f32[1] = thickness;
+        // u_resolution (vec2f) aligns to slot [2].
+        f32[2] = source.width;
+        f32[3] = source.height;
+        // u_color (vec4f) aligns to slot [4].
+        f32[4] = r;
+        f32[5] = g;
+        f32[6] = b;
+        f32[7] = a;
+    });
+}
+export const defaultWgpuOutlineEffectRunner = (ctx, effect) => {
+    applyOutlineEffectToWgpu(ctx.state, ctx.source, ctx.dest, effect);
+};
+// Slot layout: [0]=threshold, [1]=thickness, [2..3]=resolution, [4..7]=color rgba.
+const OUTLINE_FRAGMENT_WGSL = /* wgsl */ `
+struct Uniforms {
+  u_threshold : f32,
+  u_thickness : f32,
+  u_resolution : vec2f,
+  u_color : vec4f,
+}
+@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 lum(uv : vec2f) -> f32 {
+  return dot(textureSampleLevel(tex, smp, uv, 0.0).rgb, vec3f(0.2126, 0.7152, 0.0722));
+}
+
+@fragment
+fn fs_main(@location(0) uv : vec2f) -> @location(0) vec4f {
+  let texel = uni.u_thickness / uni.u_resolution;
+  let tl = lum(uv + texel * vec2f(-1.0, -1.0));
+  let t = lum(uv + texel * vec2f(0.0, -1.0));
+  let tr = lum(uv + texel * vec2f(1.0, -1.0));
+  let l = lum(uv + texel * vec2f(-1.0, 0.0));
+  let rr = lum(uv + texel * vec2f(1.0, 0.0));
+  let bl = lum(uv + texel * vec2f(-1.0, 1.0));
+  let b = lum(uv + texel * vec2f(0.0, 1.0));
+  let br = lum(uv + texel * vec2f(1.0, 1.0));
+  let gx = -tl - 2.0 * l - bl + tr + 2.0 * rr + br;
+  let gy = -tl - 2.0 * t - tr + bl + 2.0 * b + br;
+  let edge = sqrt(gx * gx + gy * gy);
+  let c = textureSampleLevel(tex, smp, uv, 0.0);
+  let k = step(uni.u_threshold, edge);
+  return mix(c, uni.u_color, k * uni.u_color.a);
+}`;
+//# sourceMappingURL=wgpuOutlineEffect.js.map

package/dist/wgpuOutlineEffect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wgpuOutlineEffect.js","sourceRoot":"","sources":["../src/wgpuOutlineEffect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAG5D,OAAO,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AAEjE,oGAAoG;AACpG,uGAAuG;AACvG,MAAM,UAAU,wBAAwB,CACtC,KAAsB,EACtB,MAAkC,EAClC,IAAgC,EAChC,MAA+B;IAE/B,MAAM,SAAS,GAAG,MAAM,CAAC,SAAS,IAAI,GAAG,CAAC;IAC1C,MAAM,SAAS,GAAG,MAAM,CAAC,SAAS,IAAI,CAAC,CAAC;IACxC,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,IAAI,UAAU,CAAC;IACzC,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,KAAK,EAAE,CAAC,GAAG,IAAI,CAAC,GAAG,GAAG,CAAC;IACxC,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,KAAK,EAAE,CAAC,GAAG,IAAI,CAAC,GAAG,GAAG,CAAC;IACxC,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,KAAK,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,GAAG,CAAC;IACvC,MAAM,CAAC,GAAG,CAAC,KAAK,GAAG,IAAI,CAAC,GAAG,GAAG,CAAC;IAC/B,MAAM,QAAQ,GAAG,qBAAqB,CAAC,KAAK,EAAE,qBAAqB,EAAE,qBAAqB,EAAE,SAAS,CAAC,CAAC;IACvG,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,2CAA2C;QAC3C,GAAG,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC;QACtB,GAAG,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,CAAC;QACvB,sCAAsC;QACtC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;QACX,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;QACX,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;QACX,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;IACb,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,mFAAmF;AACnF,MAAM,qBAAqB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgCvC,CAAC"}

package/dist/wgpuPixelateEffect.d.ts

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

package/dist/wgpuPixelateEffect.d.ts.map

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

package/dist/wgpuPixelateEffect.js

@@ -0,0 +1,34 @@
+import { drawWgpuFilterPass } from '@flighthq/filters-wgpu';
+import { getWgpuEffectPipeline } from './wgpuEffectProgramCache';
+// Pixelate: snap uv to the center of `size`-pixel blocks before sampling, producing hard mosaic blocks.
+export function applyPixelateEffectToWgpu(state, source, dest, effect) {
+    const size = effect.size ?? 8;
+    const pipeline = getWgpuEffectPipeline(state, 'stylization.pixelate', PIXELATE_FRAGMENT_WGSL, 'replace');
+    drawWgpuFilterPass(state, source, dest, pipeline, (f32) => {
+        f32[0] = Math.max(1, size);
+        // u_resolution (vec2f) aligns to slot [2].
+        f32[2] = source.width;
+        f32[3] = source.height;
+    });
+}
+export const defaultWgpuPixelateEffectRunner = (ctx, effect) => {
+    applyPixelateEffectToWgpu(ctx.state, ctx.source, ctx.dest, effect);
+};
+// Slot layout: [0]=size, [1]=pad, [2..3]=resolution.
+const PIXELATE_FRAGMENT_WGSL = /* wgsl */ `
+struct Uniforms {
+  u_size : 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;
+
+@fragment
+fn fs_main(@location(0) uvIn : vec2f) -> @location(0) vec4f {
+  let blocks = uni.u_resolution / uni.u_size;
+  let uv = (floor(uvIn * blocks) + 0.5) / blocks;
+  return textureSampleLevel(tex, smp, uv, 0.0);
+}`;
+//# sourceMappingURL=wgpuPixelateEffect.js.map

package/dist/wgpuPixelateEffect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wgpuPixelateEffect.js","sourceRoot":"","sources":["../src/wgpuPixelateEffect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAG5D,OAAO,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AAEjE,wGAAwG;AACxG,MAAM,UAAU,yBAAyB,CACvC,KAAsB,EACtB,MAAkC,EAClC,IAAgC,EAChC,MAAgC;IAEhC,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,IAAI,CAAC,CAAC;IAC9B,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,IAAI,CAAC,CAAC;QAC3B,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,qDAAqD;AACrD,MAAM,sBAAsB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;EAexC,CAAC"}

package/dist/wgpuPosterizeEffect.d.ts

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

package/dist/wgpuPosterizeEffect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wgpuPosterizeEffect.d.ts","sourceRoot":"","sources":["../src/wgpuPosterizeEffect.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/wgpuPosterizeEffect.js

@@ -0,0 +1,27 @@
+import { drawWgpuFilterPass } from '@flighthq/filters-wgpu';
+import { getWgpuEffectPipeline } from './wgpuEffectProgramCache';
+// Posterize: floor each channel to `levels` discrete steps.
+export function applyPosterizeEffectToWgpu(state, source, dest, effect) {
+    const levels = Math.max(2, effect.levels ?? 8);
+    const pipeline = getWgpuEffectPipeline(state, 'colorGrade.posterize', POSTERIZE_FRAGMENT_WGSL, 'replace');
+    drawWgpuFilterPass(state, source, dest, pipeline, (f32) => {
+        f32[0] = levels;
+    });
+}
+export const defaultWgpuPosterizeEffectRunner = (ctx, effect) => {
+    applyPosterizeEffectToWgpu(ctx.state, ctx.source, ctx.dest, effect);
+};
+// Slot layout: [0]=levels.
+const POSTERIZE_FRAGMENT_WGSL = /* wgsl */ `
+struct Uniforms { u_levels : 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 rgb = floor(c.rgb * uni.u_levels) / (uni.u_levels - 1.0);
+  return vec4f(clamp(rgb, vec3f(0.0), vec3f(1.0)), c.a);
+}`;
+//# sourceMappingURL=wgpuPosterizeEffect.js.map

package/dist/wgpuPosterizeEffect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wgpuPosterizeEffect.js","sourceRoot":"","sources":["../src/wgpuPosterizeEffect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAG5D,OAAO,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AAEjE,4DAA4D;AAC5D,MAAM,UAAU,0BAA0B,CACxC,KAAsB,EACtB,MAAkC,EAClC,IAAgC,EAChC,MAAiC;IAEjC,MAAM,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,MAAM,CAAC,MAAM,IAAI,CAAC,CAAC,CAAC;IAC/C,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,MAAM,CAAC;IAClB,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,2BAA2B;AAC3B,MAAM,uBAAuB,GAAG,UAAU,CAAC;;;;;;;;;;;EAWzC,CAAC"}

package/dist/wgpuRadialBlurEffect.d.ts

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

package/dist/wgpuRadialBlurEffect.d.ts.map

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

package/dist/wgpuRadialBlurEffect.js

@@ -0,0 +1,50 @@
+import { drawWgpuFilterPass } from '@flighthq/filters-wgpu';
+import { getWgpuEffectPipeline } from './wgpuEffectProgramCache';
+// Radial blur: accumulate samples stepped from the current uv toward (centerX, centerY) scaled by
+// `strength`, normalized by the sample count. Single-pass reference recipe, the Wgpu mirror of
+// effects-gl's applyRadialBlurEffectToGl.
+export function applyRadialBlurEffectToWgpu(state, source, dest, effect) {
+    const centerX = effect.centerX ?? 0.5;
+    const centerY = effect.centerY ?? 0.5;
+    const strength = effect.strength ?? 0.2;
+    const samples = effect.samples ?? 16;
+    const pipeline = getWgpuEffectPipeline(state, 'motion.radialBlur', RADIAL_BLUR_FRAGMENT_WGSL, 'replace');
+    drawWgpuFilterPass(state, source, dest, pipeline, (f32) => {
+        f32[0] = centerX;
+        f32[1] = centerY;
+        f32[2] = strength;
+        f32[3] = samples;
+    });
+}
+export const defaultWgpuRadialBlurEffectRunner = (ctx, effect) => {
+    applyRadialBlurEffectToWgpu(ctx.state, ctx.source, ctx.dest, effect);
+};
+// Slot layout: [0]=center.x, [1]=center.y, [2]=strength, [3]=samples.
+const RADIAL_BLUR_FRAGMENT_WGSL = /* wgsl */ `
+struct Uniforms {
+  u_center : vec2f,
+  u_strength : f32,
+  u_samples : 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 = 16;
+
+@fragment
+fn fs_main(@location(0) uv : vec2f) -> @location(0) vec4f {
+  let toCenter = uni.u_center - uv;
+  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), count > 1.0);
+    let p = uv + toCenter * (t * uni.u_strength);
+    sum = sum + textureSampleLevel(tex, smp, p, 0.0);
+    taken = taken + 1.0;
+  }
+  return sum / max(taken, 1.0);
+}`;
+//# sourceMappingURL=wgpuRadialBlurEffect.js.map

package/dist/wgpuRadialBlurEffect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wgpuRadialBlurEffect.js","sourceRoot":"","sources":["../src/wgpuRadialBlurEffect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAG5D,OAAO,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AAEjE,kGAAkG;AAClG,+FAA+F;AAC/F,0CAA0C;AAC1C,MAAM,UAAU,2BAA2B,CACzC,KAAsB,EACtB,MAAkC,EAClC,IAAgC,EAChC,MAAkC;IAElC,MAAM,OAAO,GAAG,MAAM,CAAC,OAAO,IAAI,GAAG,CAAC;IACtC,MAAM,OAAO,GAAG,MAAM,CAAC,OAAO,IAAI,GAAG,CAAC;IACtC,MAAM,QAAQ,GAAG,MAAM,CAAC,QAAQ,IAAI,GAAG,CAAC;IACxC,MAAM,OAAO,GAAG,MAAM,CAAC,OAAO,IAAI,EAAE,CAAC;IACrC,MAAM,QAAQ,GAAG,qBAAqB,CAAC,KAAK,EAAE,mBAAmB,EAAE,yBAAyB,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,OAAO,CAAC;QACjB,GAAG,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC;QACjB,GAAG,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC;QAClB,GAAG,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC;IACnB,CAAC,CAAC,CAAC;AACL,CAAC;AAED,MAAM,CAAC,MAAM,iCAAiC,GAA2B,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE;IACvF,2BAA2B,CAAC,GAAG,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,IAAI,EAAE,MAA0B,CAAC,CAAC;AAC3F,CAAC,CAAC;AAEF,sEAAsE;AACtE,MAAM,yBAAyB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;EA0B3C,CAAC"}

package/dist/wgpuRenderEffectPipeline.d.ts

@@ -0,0 +1,7 @@
+import type { RenderEffect, RenderEffectPipelineOptions, WgpuRenderEffectPipeline, WgpuRenderState } from '@flighthq/types';
+export declare function beginWgpuRenderEffectPipeline(state: WgpuRenderState, pipeline: WgpuRenderEffectPipeline): void;
+export declare function createWgpuRenderEffectPipeline(_state: WgpuRenderState, options?: Readonly<RenderEffectPipelineOptions>): WgpuRenderEffectPipeline;
+export declare function destroyWgpuRenderEffectPipeline(state: WgpuRenderState, pipeline: WgpuRenderEffectPipeline): void;
+export declare function endWgpuRenderEffectPipeline(state: WgpuRenderState, pipeline: WgpuRenderEffectPipeline, effects: ReadonlyArray<RenderEffect>): void;
+export declare function setWgpuRenderEffectVelocityTexture(pipeline: WgpuRenderEffectPipeline, texture: GPUTexture | null): void;
+//# sourceMappingURL=wgpuRenderEffectPipeline.d.ts.map

package/dist/wgpuRenderEffectPipeline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wgpuRenderEffectPipeline.d.ts","sourceRoot":"","sources":["../src/wgpuRenderEffectPipeline.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EACV,YAAY,EACZ,2BAA2B,EAC3B,wBAAwB,EACxB,eAAe,EAEhB,MAAM,iBAAiB,CAAC;AAgBzB,wBAAgB,6BAA6B,CAAC,KAAK,EAAE,eAAe,EAAE,QAAQ,EAAE,wBAAwB,GAAG,IAAI,CAiB9G;AAED,wBAAgB,8BAA8B,CAC5C,MAAM,EAAE,eAAe,EACvB,OAAO,GAAE,QAAQ,CAAC,2BAA2B,CAAM,GAClD,wBAAwB,CAE1B;AAED,wBAAgB,+BAA+B,CAAC,KAAK,EAAE,eAAe,EAAE,QAAQ,EAAE,wBAAwB,GAAG,IAAI,CAMhH;AAED,wBAAgB,2BAA2B,CACzC,KAAK,EAAE,eAAe,EACtB,QAAQ,EAAE,wBAAwB,EAClC,OAAO,EAAE,aAAa,CAAC,YAAY,CAAC,GACnC,IAAI,CAwCN;AAID,wBAAgB,kCAAkC,CAChD,QAAQ,EAAE,wBAAwB,EAClC,OAAO,EAAE,UAAU,GAAG,IAAI,GACzB,IAAI,CAEN"}

package/dist/wgpuRenderEffectPipeline.js

@@ -0,0 +1,106 @@
+import { drawWgpuFilterPass } from '@flighthq/filters-wgpu';
+import { createMatrix } from '@flighthq/geometry';
+import { acquireWgpuRenderTarget, beginWgpuRenderTarget, createWgpuRenderTarget, createWgpuRenderTargetPool, destroyWgpuRenderTarget, destroyWgpuRenderTargetPool, endWgpuRenderTarget, getWgpuRenderStateRuntime, releaseWgpuRenderTarget, resizeWgpuRenderTarget, } from '@flighthq/render-wgpu';
+import { getWgpuEffectPipeline } from './wgpuEffectProgramCache';
+import { getWgpuRenderEffectRunner } from './wgpuRenderEffectRegistry';
+// Opt-in post-process pipeline, the Wgpu mirror of effects-gl's renderEffectPipeline. The caller
+// opens the frame with renderWgpuBackground (creating the command encoder + canvas pass), then:
+//   beginWgpuRenderEffectPipeline → renders the scene into the pipeline's offscreen target
+//   ...draw the scene tree...
+//   endWgpuRenderEffectPipeline(effects) → pops back to the canvas, then runs the agnostic effect
+//     list through the per-state registry ping-ponging pooled targets, and presents to the canvas
+//   submitWgpuRenderPass → submits the encoder
+// The default render loop imports none of this. The effect list is per-frame data; only the scene
+// target and pool are retained. Depth/velocity G-buffers are not yet produced (follow-up); depth- and
+// velocity-driven recipes receive null and fall back to their color-only paths.
+export function beginWgpuRenderEffectPipeline(state, pipeline) {
+    const w = state.canvas.width;
+    const h = state.canvas.height;
+    const format = pipeline.options.format === 'rgba16f' ? 'rgba16float' : state.format;
+    if (pipeline.sceneTarget === null) {
+        pipeline.sceneTarget = createWgpuRenderTarget(state, w, h, format);
+    }
+    else {
+        resizeWgpuRenderTarget(state, pipeline.sceneTarget, w, h);
+    }
+    // Clear the scene target to the background colour (not transparent) so the background is part of the
+    // image the effects process and the replace-blend present composites — mirroring the Gl pipeline,
+    // where renderGlBackground draws into the scene target. Without this the present overwrites the bg.
+    const rgba = state.backgroundColorRgba;
+    const clearColor = rgba !== undefined && rgba.length >= 4 ? { r: rgba[0], g: rgba[1], b: rgba[2], a: rgba[3] } : undefined;
+    beginWgpuRenderTarget(state, pipeline.sceneTarget, state.renderTransform2D ?? createMatrix(), clearColor);
+}
+export function createWgpuRenderEffectPipeline(_state, options = {}) {
+    return { options: { ...options }, sceneTarget: null, pool: createWgpuRenderTargetPool(), velocityTexture: null };
+}
+export function destroyWgpuRenderEffectPipeline(state, pipeline) {
+    if (pipeline.sceneTarget) {
+        destroyWgpuRenderTarget(state, pipeline.sceneTarget);
+        pipeline.sceneTarget = null;
+    }
+    destroyWgpuRenderTargetPool(state, pipeline.pool);
+}
+export function endWgpuRenderEffectPipeline(state, pipeline, effects) {
+    const scene = pipeline.sceneTarget;
+    if (scene === null)
+        return;
+    // Pop the scene render target; restores the canvas pass (loadOp 'load').
+    endWgpuRenderTarget(state);
+    const format = scene.format;
+    const descriptor = { width: scene.width, height: scene.height, format };
+    let source = scene;
+    let scratchA = null;
+    let scratchB = null;
+    for (const effect of effects) {
+        const runner = getWgpuRenderEffectRunner(state, effect.kind);
+        if (runner === null)
+            continue;
+        if (scratchA === null)
+            scratchA = acquireWgpuRenderTarget(state, pipeline.pool, descriptor);
+        if (scratchB === null)
+            scratchB = acquireWgpuRenderTarget(state, pipeline.pool, descriptor);
+        const dest = source === scratchA ? scratchB : scratchA;
+        runner({
+            state,
+            source,
+            dest,
+            pool: pipeline.pool,
+            // Depth/velocity G-buffers are not yet produced for Wgpu; depth/velocity-driven recipes
+            // fall back to color-only when null. Wiring them is a follow-up (depth needs a sampleable
+            // depth attachment; velocity a separate pass), mirroring the Gl seam.
+            sceneDepthTexture: null,
+            sceneVelocityTexture: pipeline.velocityTexture,
+        }, effect);
+        source = dest;
+    }
+    presentWgpuRenderEffectResult(state, source);
+    if (scratchA !== null)
+        releaseWgpuRenderTarget(pipeline.pool, scratchA);
+    if (scratchB !== null)
+        releaseWgpuRenderTarget(pipeline.pool, scratchB);
+}
+// Sets the velocity G-buffer the pipeline feeds to velocity-driven effects this frame, or null to
+// clear it. The Wgpu mirror of setGlRenderEffectVelocityTexture.
+export function setWgpuRenderEffectVelocityTexture(pipeline, texture) {
+    pipeline.velocityTexture = texture;
+}
+// Presents the final effect result to the canvas. Draws source into the canvas color attachment
+// (dest null → runtime.canvasTextureView) with replace blend so it overwrites the canvas pixels.
+function presentWgpuRenderEffectResult(state, source) {
+    const runtime = getWgpuRenderStateRuntime(state);
+    if (runtime.commandEncoder === null)
+        return;
+    const pipeline = getWgpuEffectPipeline(state, 'effect.present', PRESENT_FRAGMENT_WGSL, 'replace');
+    drawWgpuFilterPass(state, source, null, pipeline, () => { });
+}
+const PRESENT_FRAGMENT_WGSL = /* wgsl */ `
+struct Uniforms { _u : 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 {
+  return textureSampleLevel(tex, smp, uv, 0.0);
+}`;
+//# sourceMappingURL=wgpuRenderEffectPipeline.js.map

package/dist/wgpuRenderEffectPipeline.js.map

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

package/dist/wgpuRenderEffectRegistrants.d.ts

@@ -0,0 +1,9 @@
+import type { WgpuRenderState } from '@flighthq/types';
+export declare function registerAntialiasingWgpuRenderEffects(state: WgpuRenderState): void;
+export declare function registerBloomWgpuRenderEffects(state: WgpuRenderState): void;
+export declare function registerBlurWgpuRenderEffects(state: WgpuRenderState): void;
+export declare function registerColorWgpuRenderEffects(state: WgpuRenderState): void;
+export declare function registerScreenSpaceWgpuRenderEffects(state: WgpuRenderState): void;
+export declare function registerStandardWgpuRenderEffects(state: WgpuRenderState): void;
+export declare function registerStylizeWgpuRenderEffects(state: WgpuRenderState): void;
+//# sourceMappingURL=wgpuRenderEffectRegistrants.d.ts.map

package/dist/wgpuRenderEffectRegistrants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wgpuRenderEffectRegistrants.d.ts","sourceRoot":"","sources":["../src/wgpuRenderEffectRegistrants.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAsDvD,wBAAgB,qCAAqC,CAAC,KAAK,EAAE,eAAe,GAAG,IAAI,CAIlF;AAID,wBAAgB,8BAA8B,CAAC,KAAK,EAAE,eAAe,GAAG,IAAI,CAQ3E;AAID,wBAAgB,6BAA6B,CAAC,KAAK,EAAE,eAAe,GAAG,IAAI,CAO1E;AAKD,wBAAgB,8BAA8B,CAAC,KAAK,EAAE,eAAe,GAAG,IAAI,CAc3E;AAID,wBAAgB,oCAAoC,CAAC,KAAK,EAAE,eAAe,GAAG,IAAI,CAMjF;AAKD,wBAAgB,iCAAiC,CAAC,KAAK,EAAE,eAAe,GAAG,IAAI,CAO9E;AAID,wBAAgB,gCAAgC,CAAC,KAAK,EAAE,eAAe,GAAG,IAAI,CAW7E"}

package/dist/wgpuRenderEffectRegistrants.js

@@ -0,0 +1,129 @@
+import { defaultWgpuBloomEffectRunner } from './wgpuBloomEffect';
+import { defaultWgpuBokehDepthOfFieldEffectRunner } from './wgpuBokehDepthOfFieldEffect';
+import { defaultWgpuBrightnessContrastEffectRunner } from './wgpuBrightnessContrastEffect';
+import { defaultWgpuCameraMotionBlurEffectRunner } from './wgpuCameraMotionBlurEffect';
+import { defaultWgpuChannelMixerEffectRunner } from './wgpuChannelMixerEffect';
+import { defaultWgpuChromaticAberrationEffectRunner } from './wgpuChromaticAberrationEffect';
+import { defaultWgpuColorGradeEffectRunner } from './wgpuColorGradeEffect';
+import { defaultWgpuCrtEffectRunner } from './wgpuCrtEffect';
+import { defaultWgpuDirectionalBlurEffectRunner } from './wgpuDirectionalBlurEffect';
+import { defaultWgpuDisplacementEffectRunner } from './wgpuDisplacementEffect';
+import { defaultWgpuDitherEffectRunner } from './wgpuDitherEffect';
+import { defaultWgpuExposureEffectRunner } from './wgpuExposureEffect';
+import { defaultWgpuFilmGrainEffectRunner } from './wgpuFilmGrainEffect';
+import { defaultWgpuFxaaEffectRunner } from './wgpuFxaaEffect';
+import { defaultWgpuGlitchEffectRunner } from './wgpuGlitchEffect';
+import { defaultWgpuGodRaysEffectRunner } from './wgpuGodRaysEffect';
+import { defaultWgpuGrayscaleEffectRunner } from './wgpuGrayscaleEffect';
+import { defaultWgpuHalftoneEffectRunner } from './wgpuHalftoneEffect';
+import { defaultWgpuHueSaturationEffectRunner } from './wgpuHueSaturationEffect';
+import { defaultWgpuInvertEffectRunner } from './wgpuInvertEffect';
+import { defaultWgpuKuwaharaEffectRunner } from './wgpuKuwaharaEffect';
+import { defaultWgpuLensDirtEffectRunner } from './wgpuLensDirtEffect';
+import { defaultWgpuLensDistortionEffectRunner } from './wgpuLensDistortionEffect';
+import { defaultWgpuLensFlareEffectRunner } from './wgpuLensFlareEffect';
+import { defaultWgpuLiftGammaGainEffectRunner } from './wgpuLiftGammaGainEffect';
+import { defaultWgpuLookupTableGradeEffectRunner } from './wgpuLookupTableGradeEffect';
+import { defaultWgpuMotionBlurEffectRunner } from './wgpuMotionBlurEffect';
+import { defaultWgpuOutlineEffectRunner } from './wgpuOutlineEffect';
+import { defaultWgpuPixelateEffectRunner } from './wgpuPixelateEffect';
+import { defaultWgpuPosterizeEffectRunner } from './wgpuPosterizeEffect';
+import { defaultWgpuRadialBlurEffectRunner } from './wgpuRadialBlurEffect';
+import { registerWgpuRenderEffect } from './wgpuRenderEffectRegistry';
+import { defaultWgpuScanlinesEffectRunner } from './wgpuScanlinesEffect';
+import { defaultWgpuScreenSpaceFogEffectRunner } from './wgpuScreenSpaceFogEffect';
+import { defaultWgpuSepiaEffectRunner } from './wgpuSepiaEffect';
+import { defaultWgpuSharpenEffectRunner } from './wgpuSharpenEffect';
+import { defaultWgpuSketchEffectRunner } from './wgpuSketchEffect';
+import { defaultWgpuSmaaEffectRunner } from './wgpuSmaaEffect';
+import { defaultWgpuSsaoEffectRunner } from './wgpuSsaoEffect';
+import { defaultWgpuSsrEffectRunner } from './wgpuSsrEffect';
+import { defaultWgpuTaaEffectRunner } from './wgpuTaaEffect';
+import { defaultWgpuTiltShiftEffectRunner } from './wgpuTiltShiftEffect';
+import { defaultWgpuToneMapEffectRunner } from './wgpuToneMapEffect';
+import { defaultWgpuVignetteEffectRunner } from './wgpuVignetteEffect';
+import { defaultWgpuWhiteBalanceEffectRunner } from './wgpuWhiteBalanceEffect';
+// Curated registrant helpers — each function registers a taxonomy band of default runners under their
+// canonical kind keys. The full-set helper composes all bands. Each helper is a named export so callers
+// can import only the band they need (the rest tree-shakes). The Wgpu mirror of the equivalent helpers
+// in effects-gl.
+// Antialiasing band: FxaaEffect, SmaaEffect, TaaEffect.
+export function registerAntialiasingWgpuRenderEffects(state) {
+    registerWgpuRenderEffect(state, 'FxaaEffect', defaultWgpuFxaaEffectRunner);
+    registerWgpuRenderEffect(state, 'SmaaEffect', defaultWgpuSmaaEffectRunner);
+    registerWgpuRenderEffect(state, 'TaaEffect', defaultWgpuTaaEffectRunner);
+}
+// Bloom / optical band: BloomEffect, ChromaticAberrationEffect, GodRaysEffect, LensDirtEffect,
+// LensDistortionEffect, LensFlareEffect, VignetteEffect.
+export function registerBloomWgpuRenderEffects(state) {
+    registerWgpuRenderEffect(state, 'BloomEffect', defaultWgpuBloomEffectRunner);
+    registerWgpuRenderEffect(state, 'ChromaticAberrationEffect', defaultWgpuChromaticAberrationEffectRunner);
+    registerWgpuRenderEffect(state, 'GodRaysEffect', defaultWgpuGodRaysEffectRunner);
+    registerWgpuRenderEffect(state, 'LensDirtEffect', defaultWgpuLensDirtEffectRunner);
+    registerWgpuRenderEffect(state, 'LensDistortionEffect', defaultWgpuLensDistortionEffectRunner);
+    registerWgpuRenderEffect(state, 'LensFlareEffect', defaultWgpuLensFlareEffectRunner);
+    registerWgpuRenderEffect(state, 'VignetteEffect', defaultWgpuVignetteEffectRunner);
+}
+// Blur band: BokehDepthOfFieldEffect, CameraMotionBlurEffect, DirectionalBlurEffect, MotionBlurEffect,
+// RadialBlurEffect, TiltShiftEffect.
+export function registerBlurWgpuRenderEffects(state) {
+    registerWgpuRenderEffect(state, 'BokehDepthOfFieldEffect', defaultWgpuBokehDepthOfFieldEffectRunner);
+    registerWgpuRenderEffect(state, 'CameraMotionBlurEffect', defaultWgpuCameraMotionBlurEffectRunner);
+    registerWgpuRenderEffect(state, 'DirectionalBlurEffect', defaultWgpuDirectionalBlurEffectRunner);
+    registerWgpuRenderEffect(state, 'MotionBlurEffect', defaultWgpuMotionBlurEffectRunner);
+    registerWgpuRenderEffect(state, 'RadialBlurEffect', defaultWgpuRadialBlurEffectRunner);
+    registerWgpuRenderEffect(state, 'TiltShiftEffect', defaultWgpuTiltShiftEffectRunner);
+}
+// Color / tone band: BrightnessContrastEffect, ChannelMixerEffect, ColorGradeEffect, ExposureEffect,
+// GrayscaleEffect, HueSaturationEffect, InvertEffect, LiftGammaGainEffect, LookupTableGradeEffect,
+// PosterizeEffect, SepiaEffect, ToneMapEffect, WhiteBalanceEffect.
+export function registerColorWgpuRenderEffects(state) {
+    registerWgpuRenderEffect(state, 'BrightnessContrastEffect', defaultWgpuBrightnessContrastEffectRunner);
+    registerWgpuRenderEffect(state, 'ChannelMixerEffect', defaultWgpuChannelMixerEffectRunner);
+    registerWgpuRenderEffect(state, 'ColorGradeEffect', defaultWgpuColorGradeEffectRunner);
+    registerWgpuRenderEffect(state, 'ExposureEffect', defaultWgpuExposureEffectRunner);
+    registerWgpuRenderEffect(state, 'GrayscaleEffect', defaultWgpuGrayscaleEffectRunner);
+    registerWgpuRenderEffect(state, 'HueSaturationEffect', defaultWgpuHueSaturationEffectRunner);
+    registerWgpuRenderEffect(state, 'InvertEffect', defaultWgpuInvertEffectRunner);
+    registerWgpuRenderEffect(state, 'LiftGammaGainEffect', defaultWgpuLiftGammaGainEffectRunner);
+    registerWgpuRenderEffect(state, 'LookupTableGradeEffect', defaultWgpuLookupTableGradeEffectRunner);
+    registerWgpuRenderEffect(state, 'PosterizeEffect', defaultWgpuPosterizeEffectRunner);
+    registerWgpuRenderEffect(state, 'SepiaEffect', defaultWgpuSepiaEffectRunner);
+    registerWgpuRenderEffect(state, 'ToneMapEffect', defaultWgpuToneMapEffectRunner);
+    registerWgpuRenderEffect(state, 'WhiteBalanceEffect', defaultWgpuWhiteBalanceEffectRunner);
+}
+// Screen-space / atmospheric band: DisplacementEffect, ScreenSpaceFogEffect, SharpenEffect,
+// SsaoEffect, SsrEffect.
+export function registerScreenSpaceWgpuRenderEffects(state) {
+    registerWgpuRenderEffect(state, 'DisplacementEffect', defaultWgpuDisplacementEffectRunner);
+    registerWgpuRenderEffect(state, 'ScreenSpaceFogEffect', defaultWgpuScreenSpaceFogEffectRunner);
+    registerWgpuRenderEffect(state, 'SharpenEffect', defaultWgpuSharpenEffectRunner);
+    registerWgpuRenderEffect(state, 'SsaoEffect', defaultWgpuSsaoEffectRunner);
+    registerWgpuRenderEffect(state, 'SsrEffect', defaultWgpuSsrEffectRunner);
+}
+// Full standard set — composes all taxonomy bands. Registers all 45 default runners under their
+// canonical kind keys. Import this when the full effect palette is needed; import individual band
+// helpers when only a subset of effects is used.
+export function registerStandardWgpuRenderEffects(state) {
+    registerAntialiasingWgpuRenderEffects(state);
+    registerBloomWgpuRenderEffects(state);
+    registerBlurWgpuRenderEffects(state);
+    registerColorWgpuRenderEffects(state);
+    registerScreenSpaceWgpuRenderEffects(state);
+    registerStylizeWgpuRenderEffects(state);
+}
+// Stylize band: CrtEffect, DitherEffect, FilmGrainEffect, GlitchEffect, HalftoneEffect,
+// KuwaharaEffect, OutlineEffect, PixelateEffect, ScanlinesEffect, SketchEffect.
+export function registerStylizeWgpuRenderEffects(state) {
+    registerWgpuRenderEffect(state, 'CrtEffect', defaultWgpuCrtEffectRunner);
+    registerWgpuRenderEffect(state, 'DitherEffect', defaultWgpuDitherEffectRunner);
+    registerWgpuRenderEffect(state, 'FilmGrainEffect', defaultWgpuFilmGrainEffectRunner);
+    registerWgpuRenderEffect(state, 'GlitchEffect', defaultWgpuGlitchEffectRunner);
+    registerWgpuRenderEffect(state, 'HalftoneEffect', defaultWgpuHalftoneEffectRunner);
+    registerWgpuRenderEffect(state, 'KuwaharaEffect', defaultWgpuKuwaharaEffectRunner);
+    registerWgpuRenderEffect(state, 'OutlineEffect', defaultWgpuOutlineEffectRunner);
+    registerWgpuRenderEffect(state, 'PixelateEffect', defaultWgpuPixelateEffectRunner);
+    registerWgpuRenderEffect(state, 'ScanlinesEffect', defaultWgpuScanlinesEffectRunner);
+    registerWgpuRenderEffect(state, 'SketchEffect', defaultWgpuSketchEffectRunner);
+}
+//# sourceMappingURL=wgpuRenderEffectRegistrants.js.map