@flighthq/effects-wgpu 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,49 @@
+export * from './wgpuBloomEffect';
+export * from './wgpuBokehDepthOfFieldEffect';
+export * from './wgpuBrightnessContrastEffect';
+export * from './wgpuCameraMotionBlurEffect';
+export * from './wgpuChannelMixerEffect';
+export * from './wgpuChromaticAberrationEffect';
+export * from './wgpuColorGradeEffect';
+export * from './wgpuCrtEffect';
+export * from './wgpuDirectionalBlurEffect';
+export * from './wgpuDisplacementEffect';
+export * from './wgpuDitherEffect';
+export * from './wgpuEffectProgramCache';
+export * from './wgpuExposureEffect';
+export * from './wgpuFilmGrainEffect';
+export * from './wgpuFxaaEffect';
+export * from './wgpuGlitchEffect';
+export * from './wgpuGodRaysEffect';
+export * from './wgpuGrayscaleEffect';
+export * from './wgpuHalftoneEffect';
+export * from './wgpuHueSaturationEffect';
+export * from './wgpuInvertEffect';
+export * from './wgpuKuwaharaEffect';
+export * from './wgpuLensDirtEffect';
+export * from './wgpuLensDistortionEffect';
+export * from './wgpuLensFlareEffect';
+export * from './wgpuLiftGammaGainEffect';
+export * from './wgpuLookupTableGradeEffect';
+export * from './wgpuMotionBlurEffect';
+export * from './wgpuOutlineEffect';
+export * from './wgpuPixelateEffect';
+export * from './wgpuPosterizeEffect';
+export * from './wgpuRadialBlurEffect';
+export * from './wgpuRenderEffectPipeline';
+export * from './wgpuRenderEffectRegistrants';
+export * from './wgpuRenderEffectRegistry';
+export * from './wgpuScanlinesEffect';
+export * from './wgpuScreenSpaceFogEffect';
+export * from './wgpuSepiaEffect';
+export * from './wgpuSharpenEffect';
+export * from './wgpuSketchEffect';
+export * from './wgpuSmaaEffect';
+export * from './wgpuSsaoEffect';
+export * from './wgpuSsrEffect';
+export * from './wgpuTaaEffect';
+export * from './wgpuTiltShiftEffect';
+export * from './wgpuToneMapEffect';
+export * from './wgpuVignetteEffect';
+export * from './wgpuWhiteBalanceEffect';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,0BAA0B,CAAC;AACzC,cAAc,iCAAiC,CAAC;AAChD,cAAc,wBAAwB,CAAC;AACvC,cAAc,iBAAiB,CAAC;AAChC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,0BAA0B,CAAC;AACzC,cAAc,oBAAoB,CAAC;AACnC,cAAc,0BAA0B,CAAC;AACzC,cAAc,sBAAsB,CAAC;AACrC,cAAc,uBAAuB,CAAC;AACtC,cAAc,kBAAkB,CAAC;AACjC,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC;AACpC,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC;AACrC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,oBAAoB,CAAC;AACnC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,uBAAuB,CAAC;AACtC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,wBAAwB,CAAC;AACvC,cAAc,qBAAqB,CAAC;AACpC,cAAc,sBAAsB,CAAC;AACrC,cAAc,uBAAuB,CAAC;AACtC,cAAc,wBAAwB,CAAC;AACvC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,uBAAuB,CAAC;AACtC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,kBAAkB,CAAC;AACjC,cAAc,kBAAkB,CAAC;AACjC,cAAc,iBAAiB,CAAC;AAChC,cAAc,iBAAiB,CAAC;AAChC,cAAc,uBAAuB,CAAC;AACtC,cAAc,qBAAqB,CAAC;AACpC,cAAc,sBAAsB,CAAC;AACrC,cAAc,0BAA0B,CAAC"}

package/dist/index.js

@@ -0,0 +1,49 @@
+export * from './wgpuBloomEffect';
+export * from './wgpuBokehDepthOfFieldEffect';
+export * from './wgpuBrightnessContrastEffect';
+export * from './wgpuCameraMotionBlurEffect';
+export * from './wgpuChannelMixerEffect';
+export * from './wgpuChromaticAberrationEffect';
+export * from './wgpuColorGradeEffect';
+export * from './wgpuCrtEffect';
+export * from './wgpuDirectionalBlurEffect';
+export * from './wgpuDisplacementEffect';
+export * from './wgpuDitherEffect';
+export * from './wgpuEffectProgramCache';
+export * from './wgpuExposureEffect';
+export * from './wgpuFilmGrainEffect';
+export * from './wgpuFxaaEffect';
+export * from './wgpuGlitchEffect';
+export * from './wgpuGodRaysEffect';
+export * from './wgpuGrayscaleEffect';
+export * from './wgpuHalftoneEffect';
+export * from './wgpuHueSaturationEffect';
+export * from './wgpuInvertEffect';
+export * from './wgpuKuwaharaEffect';
+export * from './wgpuLensDirtEffect';
+export * from './wgpuLensDistortionEffect';
+export * from './wgpuLensFlareEffect';
+export * from './wgpuLiftGammaGainEffect';
+export * from './wgpuLookupTableGradeEffect';
+export * from './wgpuMotionBlurEffect';
+export * from './wgpuOutlineEffect';
+export * from './wgpuPixelateEffect';
+export * from './wgpuPosterizeEffect';
+export * from './wgpuRadialBlurEffect';
+export * from './wgpuRenderEffectPipeline';
+export * from './wgpuRenderEffectRegistrants';
+export * from './wgpuRenderEffectRegistry';
+export * from './wgpuScanlinesEffect';
+export * from './wgpuScreenSpaceFogEffect';
+export * from './wgpuSepiaEffect';
+export * from './wgpuSharpenEffect';
+export * from './wgpuSketchEffect';
+export * from './wgpuSmaaEffect';
+export * from './wgpuSsaoEffect';
+export * from './wgpuSsrEffect';
+export * from './wgpuTaaEffect';
+export * from './wgpuTiltShiftEffect';
+export * from './wgpuToneMapEffect';
+export * from './wgpuVignetteEffect';
+export * from './wgpuWhiteBalanceEffect';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,0BAA0B,CAAC;AACzC,cAAc,iCAAiC,CAAC;AAChD,cAAc,wBAAwB,CAAC;AACvC,cAAc,iBAAiB,CAAC;AAChC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,0BAA0B,CAAC;AACzC,cAAc,oBAAoB,CAAC;AACnC,cAAc,0BAA0B,CAAC;AACzC,cAAc,sBAAsB,CAAC;AACrC,cAAc,uBAAuB,CAAC;AACtC,cAAc,kBAAkB,CAAC;AACjC,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC;AACpC,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC;AACrC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,oBAAoB,CAAC;AACnC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,uBAAuB,CAAC;AACtC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,wBAAwB,CAAC;AACvC,cAAc,qBAAqB,CAAC;AACpC,cAAc,sBAAsB,CAAC;AACrC,cAAc,uBAAuB,CAAC;AACtC,cAAc,wBAAwB,CAAC;AACvC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,uBAAuB,CAAC;AACtC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,kBAAkB,CAAC;AACjC,cAAc,kBAAkB,CAAC;AACjC,cAAc,iBAAiB,CAAC;AAChC,cAAc,iBAAiB,CAAC;AAChC,cAAc,uBAAuB,CAAC;AACtC,cAAc,qBAAqB,CAAC;AACpC,cAAc,sBAAsB,CAAC;AACrC,cAAc,0BAA0B,CAAC"}

package/dist/wgpuBloomEffect.d.ts

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

package/dist/wgpuBloomEffect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wgpuBloomEffect.d.ts","sourceRoot":"","sources":["../src/wgpuBloomEffect.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EACV,WAAW,EACX,sBAAsB,EACtB,eAAe,EACf,gBAAgB,EAChB,oBAAoB,EACrB,MAAM,iBAAiB,CAAC;AASzB,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,eAAe,EACtB,MAAM,EAAE,QAAQ,CAAC,gBAAgB,CAAC,EAClC,IAAI,EAAE,QAAQ,CAAC,gBAAgB,CAAC,EAChC,IAAI,EAAE,oBAAoB,EAC1B,MAAM,EAAE,QAAQ,CAAC,WAAW,CAAC,GAC5B,IAAI,CAgCN;AAED,eAAO,MAAM,4BAA4B,EAAE,sBAE1C,CAAC"}

package/dist/wgpuBloomEffect.js

@@ -0,0 +1,72 @@
+import { computeBloomBlurRadius, computeBloomIntensity, computeBloomThreshold } from '@flighthq/effects';
+import { applyGaussianBlurFilterToWgpu, createWgpuDualSourcePipeline, drawWgpuDualSourcePass, drawWgpuFilterPass, } from '@flighthq/filters-wgpu';
+import { acquireWgpuRenderTarget, releaseWgpuRenderTarget } from '@flighthq/render-wgpu';
+import { getWgpuEffectPipeline } from './wgpuEffectProgramCache';
+// Bloom: bright-pass → blur the bright branch (reusing the Tier-1 gaussian blur filter) → additively
+// composite back. The multi-pass reference recipe — it acquires intermediate targets from the pool and
+// releases them, branches, and reuses a filter, which is what makes it an effect and not a filter.
+// The Wgpu mirror of effects-gl's applyBloomEffectToGl; identical parameters come from the
+// shared computeBloomThreshold / computeBloomIntensity / computeBloomBlurRadius.
+export function applyBloomEffectToWgpu(state, source, dest, pool, effect) {
+    const threshold = computeBloomThreshold(effect);
+    const intensity = computeBloomIntensity(effect);
+    const radius = computeBloomBlurRadius(effect);
+    const descriptor = { width: source.width, height: source.height, format: source.format };
+    const bright = acquireWgpuRenderTarget(state, pool, descriptor);
+    const blurred = acquireWgpuRenderTarget(state, pool, descriptor);
+    const temp = acquireWgpuRenderTarget(state, pool, descriptor);
+    const brightPipeline = getWgpuEffectPipeline(state, 'bloom.bright', BLOOM_BRIGHT_FRAGMENT_WGSL, 'replace');
+    drawWgpuFilterPass(state, source, bright, brightPipeline, (f32) => {
+        f32[0] = threshold;
+    });
+    applyGaussianBlurFilterToWgpu(state, bright, blurred, temp, { blurX: radius, blurY: radius });
+    const compositePipeline = getBloomCompositePipeline(state);
+    drawWgpuDualSourcePass(state, source, blurred, dest, compositePipeline, (f32) => {
+        f32[0] = intensity;
+    });
+    releaseWgpuRenderTarget(pool, bright);
+    releaseWgpuRenderTarget(pool, blurred);
+    releaseWgpuRenderTarget(pool, temp);
+}
+export const defaultWgpuBloomEffectRunner = (ctx, effect) => {
+    applyBloomEffectToWgpu(ctx.state, ctx.source, ctx.dest, ctx.pool, effect);
+};
+// The composite pipeline reads two textures (scene = group 1, blurred = group 2) so it uses the
+// dual-source filter primitive; cached per state alongside the single-source pipelines.
+function getBloomCompositePipeline(state) {
+    let pipeline = _compositePipelines.get(state);
+    if (pipeline === undefined) {
+        pipeline = createWgpuDualSourcePipeline(state, BLOOM_COMPOSITE_FRAGMENT_WGSL, 'replace');
+        _compositePipelines.set(state, pipeline);
+    }
+    return pipeline;
+}
+const _compositePipelines = new WeakMap();
+const BLOOM_BRIGHT_FRAGMENT_WGSL = /* wgsl */ `
+struct Uniforms { u_threshold : 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));
+  let k = step(uni.u_threshold, l);
+  return vec4f(c.rgb * k, c.a);
+}`;
+const BLOOM_COMPOSITE_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 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;
+
+@fragment
+fn fs_main(@location(0) uv : vec2f) -> @location(0) vec4f {
+  let scene = textureSampleLevel(tex0, smp0, uv, 0.0);
+  let bloom = textureSampleLevel(tex1, smp1, uv, 0.0);
+  return vec4f(scene.rgb + bloom.rgb * uni.u_intensity, scene.a);
+}`;
+//# sourceMappingURL=wgpuBloomEffect.js.map

package/dist/wgpuBloomEffect.js.map

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

package/dist/wgpuBokehDepthOfFieldEffect.d.ts

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

package/dist/wgpuBokehDepthOfFieldEffect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wgpuBokehDepthOfFieldEffect.d.ts","sourceRoot":"","sources":["../src/wgpuBokehDepthOfFieldEffect.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,uBAAuB,EACvB,sBAAsB,EACtB,eAAe,EACf,gBAAgB,EACjB,MAAM,iBAAiB,CAAC;AAUzB,wBAAgB,kCAAkC,CAChD,KAAK,EAAE,eAAe,EACtB,MAAM,EAAE,QAAQ,CAAC,gBAAgB,CAAC,EAClC,IAAI,EAAE,QAAQ,CAAC,gBAAgB,CAAC,EAChC,MAAM,EAAE,QAAQ,CAAC,uBAAuB,CAAC,GACxC,IAAI,CAUN;AAED,eAAO,MAAM,wCAAwC,EAAE,sBAEtD,CAAC"}

package/dist/wgpuBokehDepthOfFieldEffect.js

@@ -0,0 +1,51 @@
+import { drawWgpuFilterPass } from '@flighthq/filters-wgpu';
+import { getWgpuEffectPipeline } from './wgpuEffectProgramCache';
+// Bokeh depth-of-field: a disc-shaped blur. The real DoF computes a per-pixel circle of confusion from a
+// sampleable depth texture (focusDistance/focusRange) and scales the disc radius by it — but Wgpu does
+// not produce a scene depth texture yet (ctx.sceneDepthTexture is null), so there is no second source to
+// bind here. This recipe always falls back to a uniform disc blur of radius maxBlur. When the depth seam
+// lands it can take a depth source as group 2 and recover the true circle of confusion, matching
+// effects-gl's applyBokehDepthOfFieldEffectToGl.
+export function applyBokehDepthOfFieldEffectToWgpu(state, source, dest, effect) {
+    const maxBlur = effect.maxBlur ?? 4;
+    const width = source.width;
+    const height = source.height;
+    const pipeline = getWgpuEffectPipeline(state, 'lens.bokehDoF', BOKEH_DOF_FRAGMENT_WGSL, 'replace');
+    drawWgpuFilterPass(state, source, dest, pipeline, (f32) => {
+        f32[0] = maxBlur;
+        f32[2] = width;
+        f32[3] = height;
+    });
+}
+export const defaultWgpuBokehDepthOfFieldEffectRunner = (ctx, effect) => {
+    applyBokehDepthOfFieldEffectToWgpu(ctx.state, ctx.source, ctx.dest, effect);
+};
+// Slot layout: [0]=maxBlur, [1]=pad, [2..3]=resolution (vec2 aligned to 8 bytes). With no depth source
+// the circle of confusion is fixed at 1.0, so the disc samples the full maxBlur radius everywhere.
+const BOKEH_DOF_FRAGMENT_WGSL = /* wgsl */ `
+struct Uniforms {
+  u_maxBlur : 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) uv : vec2f) -> @location(0) vec4f {
+  let texel = vec2f(1.0) / uni.u_resolution;
+  // No depth texture in WebGPU yet: circle of confusion is fixed, so the disc uses the full radius.
+  let blur = uni.u_maxBlur;
+  var sum = vec4f(0.0);
+  var total = 0.0;
+  for (var i = 0; i < 16; i = i + 1) {
+    let ang = f32(i) * 0.39269908; // golden-ish angular step over the disc
+    let rad = (f32(i % 4) + 1.0) * 0.25;
+    let offset = vec2f(cos(ang), sin(ang)) * rad * blur * texel;
+    sum = sum + textureSampleLevel(tex, smp, uv + offset, 0.0);
+    total = total + 1.0;
+  }
+  return sum / total;
+}`;
+//# sourceMappingURL=wgpuBokehDepthOfFieldEffect.js.map

package/dist/wgpuBokehDepthOfFieldEffect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wgpuBokehDepthOfFieldEffect.js","sourceRoot":"","sources":["../src/wgpuBokehDepthOfFieldEffect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAQ5D,OAAO,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AAEjE,yGAAyG;AACzG,uGAAuG;AACvG,yGAAyG;AACzG,yGAAyG;AACzG,iGAAiG;AACjG,iDAAiD;AACjD,MAAM,UAAU,kCAAkC,CAChD,KAAsB,EACtB,MAAkC,EAClC,IAAgC,EAChC,MAAyC;IAEzC,MAAM,OAAO,GAAG,MAAM,CAAC,OAAO,IAAI,CAAC,CAAC;IACpC,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC;IAC3B,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;IAC7B,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,OAAO,CAAC;QACjB,GAAG,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC;QACf,GAAG,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC;IAClB,CAAC,CAAC,CAAC;AACL,CAAC;AAED,MAAM,CAAC,MAAM,wCAAwC,GAA2B,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE;IAC9F,kCAAkC,CAAC,GAAG,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,IAAI,EAAE,MAAiC,CAAC,CAAC;AACzG,CAAC,CAAC;AAEF,uGAAuG;AACvG,mGAAmG;AACnG,MAAM,uBAAuB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;EAyBzC,CAAC"}

package/dist/wgpuBrightnessContrastEffect.d.ts

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

package/dist/wgpuBrightnessContrastEffect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wgpuBrightnessContrastEffect.d.ts","sourceRoot":"","sources":["../src/wgpuBrightnessContrastEffect.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,wBAAwB,EACxB,sBAAsB,EACtB,eAAe,EACf,gBAAgB,EACjB,MAAM,iBAAiB,CAAC;AAKzB,wBAAgB,mCAAmC,CACjD,KAAK,EAAE,eAAe,EACtB,MAAM,EAAE,QAAQ,CAAC,gBAAgB,CAAC,EAClC,IAAI,EAAE,QAAQ,CAAC,gBAAgB,CAAC,EAChC,MAAM,EAAE,QAAQ,CAAC,wBAAwB,CAAC,GACzC,IAAI,CAaN;AAED,eAAO,MAAM,yCAAyC,EAAE,sBAEvD,CAAC"}

package/dist/wgpuBrightnessContrastEffect.js

@@ -0,0 +1,29 @@
+import { drawWgpuFilterPass } from '@flighthq/filters-wgpu';
+import { getWgpuEffectPipeline } from './wgpuEffectProgramCache';
+// Brightness/contrast: shift then scale about mid-grey.
+export function applyBrightnessContrastEffectToWgpu(state, source, dest, effect) {
+    const brightness = effect.brightness ?? 0;
+    const contrast = effect.contrast ?? 1;
+    const pipeline = getWgpuEffectPipeline(state, 'colorGrade.brightnessContrast', BRIGHTNESS_CONTRAST_FRAGMENT_WGSL, 'replace');
+    drawWgpuFilterPass(state, source, dest, pipeline, (f32) => {
+        f32[0] = brightness;
+        f32[1] = contrast;
+    });
+}
+export const defaultWgpuBrightnessContrastEffectRunner = (ctx, effect) => {
+    applyBrightnessContrastEffectToWgpu(ctx.state, ctx.source, ctx.dest, effect);
+};
+// Slot layout: [0]=brightness, [1]=contrast.
+const BRIGHTNESS_CONTRAST_FRAGMENT_WGSL = /* wgsl */ `
+struct Uniforms { u_brightness : f32, u_contrast : f32, _pad0 : f32, _pad1 : 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 = (c.rgb + uni.u_brightness - 0.5) * uni.u_contrast + 0.5;
+  return vec4f(clamp(rgb, vec3f(0.0), vec3f(1.0)), c.a);
+}`;
+//# sourceMappingURL=wgpuBrightnessContrastEffect.js.map

package/dist/wgpuBrightnessContrastEffect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wgpuBrightnessContrastEffect.js","sourceRoot":"","sources":["../src/wgpuBrightnessContrastEffect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAQ5D,OAAO,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AAEjE,wDAAwD;AACxD,MAAM,UAAU,mCAAmC,CACjD,KAAsB,EACtB,MAAkC,EAClC,IAAgC,EAChC,MAA0C;IAE1C,MAAM,UAAU,GAAG,MAAM,CAAC,UAAU,IAAI,CAAC,CAAC;IAC1C,MAAM,QAAQ,GAAG,MAAM,CAAC,QAAQ,IAAI,CAAC,CAAC;IACtC,MAAM,QAAQ,GAAG,qBAAqB,CACpC,KAAK,EACL,+BAA+B,EAC/B,iCAAiC,EACjC,SAAS,CACV,CAAC;IACF,kBAAkB,CAAC,KAAK,EAAE,MAA0B,EAAE,IAAwB,EAAE,QAAQ,EAAE,CAAC,GAAG,EAAE,EAAE;QAChG,GAAG,CAAC,CAAC,CAAC,GAAG,UAAU,CAAC;QACpB,GAAG,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC;IACpB,CAAC,CAAC,CAAC;AACL,CAAC;AAED,MAAM,CAAC,MAAM,yCAAyC,GAA2B,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE;IAC/F,mCAAmC,CAAC,GAAG,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,IAAI,EAAE,MAAkC,CAAC,CAAC;AAC3G,CAAC,CAAC;AAEF,6CAA6C;AAC7C,MAAM,iCAAiC,GAAG,UAAU,CAAC;;;;;;;;;;;EAWnD,CAAC"}

package/dist/wgpuCameraMotionBlurEffect.d.ts

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

package/dist/wgpuCameraMotionBlurEffect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wgpuCameraMotionBlurEffect.d.ts","sourceRoot":"","sources":["../src/wgpuCameraMotionBlurEffect.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,sBAAsB,EACtB,sBAAsB,EACtB,eAAe,EACf,gBAAgB,EACjB,MAAM,iBAAiB,CAAC;AASzB,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,CAQN;AAED,eAAO,MAAM,uCAAuC,EAAE,sBAErD,CAAC"}

package/dist/wgpuCameraMotionBlurEffect.js

@@ -0,0 +1,49 @@
+import { drawWgpuFilterPass } from '@flighthq/filters-wgpu';
+import { getWgpuEffectPipeline } from './wgpuEffectProgramCache';
+// Camera motion blur: a real single-pass radial/zoom blur scaled by intensity — smears each sample
+// toward the screen center. A legitimate 2D effect on its own, the Wgpu mirror of effects-gl's
+// applyCameraMotionBlurEffectToGl. Two richer variants are 2D-native follow-ups, not 3D-gated:
+// feeding the actual camera/root transform delta as the smear vector (global velocity), and per-object
+// motion blur reading ctx.sceneVelocityTexture (per-node prev-transform delta).
+export function applyCameraMotionBlurEffectToWgpu(state, source, dest, effect) {
+    const intensity = effect.intensity ?? 0.5;
+    const samples = effect.samples ?? 16;
+    const pipeline = getWgpuEffectPipeline(state, 'motion.cameraMotionBlur', CAMERA_MOTION_BLUR_FRAGMENT_WGSL, 'replace');
+    drawWgpuFilterPass(state, source, dest, pipeline, (f32) => {
+        f32[0] = intensity;
+        f32[1] = samples;
+    });
+}
+export const defaultWgpuCameraMotionBlurEffectRunner = (ctx, effect) => {
+    applyCameraMotionBlurEffectToWgpu(ctx.state, ctx.source, ctx.dest, effect);
+};
+// Slot layout: [0]=intensity, [1]=samples. SAMPLES caps the loop; min(u_samples, 16.0) gates the taps.
+const CAMERA_MOTION_BLUR_FRAGMENT_WGSL = /* wgsl */ `
+struct Uniforms {
+  u_intensity : f32,
+  u_samples : f32,
+  _pad0 : f32,
+  _pad1 : 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 = vec2f(0.5) - 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_intensity);
+    sum = sum + textureSampleLevel(tex, smp, p, 0.0);
+    taken = taken + 1.0;
+  }
+  return sum / max(taken, 1.0);
+}`;
+//# sourceMappingURL=wgpuCameraMotionBlurEffect.js.map

package/dist/wgpuCameraMotionBlurEffect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wgpuCameraMotionBlurEffect.js","sourceRoot":"","sources":["../src/wgpuCameraMotionBlurEffect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAQ5D,OAAO,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AAEjE,mGAAmG;AACnG,+FAA+F;AAC/F,+FAA+F;AAC/F,uGAAuG;AACvG,gFAAgF;AAChF,MAAM,UAAU,iCAAiC,CAC/C,KAAsB,EACtB,MAAkC,EAClC,IAAgC,EAChC,MAAwC;IAExC,MAAM,SAAS,GAAG,MAAM,CAAC,SAAS,IAAI,GAAG,CAAC;IAC1C,MAAM,OAAO,GAAG,MAAM,CAAC,OAAO,IAAI,EAAE,CAAC;IACrC,MAAM,QAAQ,GAAG,qBAAqB,CAAC,KAAK,EAAE,yBAAyB,EAAE,gCAAgC,EAAE,SAAS,CAAC,CAAC;IACtH,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,OAAO,CAAC;IACnB,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,uGAAuG;AACvG,MAAM,gCAAgC,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2BlD,CAAC"}

package/dist/wgpuChannelMixerEffect.d.ts

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

package/dist/wgpuChannelMixerEffect.d.ts.map

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

package/dist/wgpuChannelMixerEffect.js

@@ -0,0 +1,34 @@
+import { drawWgpuFilterPass } from '@flighthq/filters-wgpu';
+import { getWgpuEffectPipeline } from './wgpuEffectProgramCache';
+// Channel mixer: apply a 3x4 row-major RGB->RGB matrix plus per-row offset. The matrix is uploaded as
+// three vec4f rows (r/g/b), each 16-byte aligned, so the std140 layout maps a row directly onto a slot.
+export function applyChannelMixerEffectToWgpu(state, source, dest, effect) {
+    const matrix = new Float32Array(12);
+    for (let i = 0; i < 12; i++)
+        matrix[i] = effect.matrix[i] ?? IDENTITY_CHANNEL_MIXER[i];
+    const pipeline = getWgpuEffectPipeline(state, 'colorGrade.channelMixer', CHANNEL_MIXER_FRAGMENT_WGSL, 'replace');
+    drawWgpuFilterPass(state, source, dest, pipeline, (f32) => {
+        for (let i = 0; i < 12; i++)
+            f32[i] = matrix[i];
+    });
+}
+export const defaultWgpuChannelMixerEffectRunner = (ctx, effect) => {
+    applyChannelMixerEffectToWgpu(ctx.state, ctx.source, ctx.dest, effect);
+};
+const IDENTITY_CHANNEL_MIXER = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0];
+// Slot layout: three vec4f rows, each 16-byte aligned — [0..3]=row r, [4..7]=row g, [8..11]=row b.
+const CHANNEL_MIXER_FRAGMENT_WGSL = /* wgsl */ `
+struct Uniforms { u_row_r : vec4f, u_row_g : vec4f, u_row_b : 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;
+
+@fragment
+fn fs_main(@location(0) uv : vec2f) -> @location(0) vec4f {
+  let c = textureSampleLevel(tex, smp, uv, 0.0);
+  let r = uni.u_row_r.x * c.r + uni.u_row_r.y * c.g + uni.u_row_r.z * c.b + uni.u_row_r.w;
+  let g = uni.u_row_g.x * c.r + uni.u_row_g.y * c.g + uni.u_row_g.z * c.b + uni.u_row_g.w;
+  let b = uni.u_row_b.x * c.r + uni.u_row_b.y * c.g + uni.u_row_b.z * c.b + uni.u_row_b.w;
+  return vec4f(clamp(vec3f(r, g, b), vec3f(0.0), vec3f(1.0)), c.a);
+}`;
+//# sourceMappingURL=wgpuChannelMixerEffect.js.map

package/dist/wgpuChannelMixerEffect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wgpuChannelMixerEffect.js","sourceRoot":"","sources":["../src/wgpuChannelMixerEffect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAG5D,OAAO,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AAEjE,sGAAsG;AACtG,wGAAwG;AACxG,MAAM,UAAU,6BAA6B,CAC3C,KAAsB,EACtB,MAAkC,EAClC,IAAgC,EAChC,MAAoC;IAEpC,MAAM,MAAM,GAAG,IAAI,YAAY,CAAC,EAAE,CAAC,CAAC;IACpC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,EAAE;QAAE,MAAM,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,sBAAsB,CAAC,CAAC,CAAC,CAAC;IACvF,MAAM,QAAQ,GAAG,qBAAqB,CAAC,KAAK,EAAE,yBAAyB,EAAE,2BAA2B,EAAE,SAAS,CAAC,CAAC;IACjH,kBAAkB,CAAC,KAAK,EAAE,MAA0B,EAAE,IAAwB,EAAE,QAAQ,EAAE,CAAC,GAAG,EAAE,EAAE;QAChG,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,EAAE;YAAE,GAAG,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;IAClD,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,MAAM,sBAAsB,GAAsB,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;AAEvF,mGAAmG;AACnG,MAAM,2BAA2B,GAAG,UAAU,CAAC;;;;;;;;;;;;;EAa7C,CAAC"}

package/dist/wgpuChromaticAberrationEffect.d.ts

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

package/dist/wgpuChromaticAberrationEffect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wgpuChromaticAberrationEffect.d.ts","sourceRoot":"","sources":["../src/wgpuChromaticAberrationEffect.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,yBAAyB,EACzB,sBAAsB,EACtB,eAAe,EACf,gBAAgB,EACjB,MAAM,iBAAiB,CAAC;AAOzB,wBAAgB,oCAAoC,CAClD,KAAK,EAAE,eAAe,EACtB,MAAM,EAAE,QAAQ,CAAC,gBAAgB,CAAC,EAClC,IAAI,EAAE,QAAQ,CAAC,gBAAgB,CAAC,EAChC,MAAM,EAAE,QAAQ,CAAC,yBAAyB,CAAC,GAC1C,IAAI,CAaN;AAED,eAAO,MAAM,0CAA0C,EAAE,sBAExD,CAAC"}

package/dist/wgpuChromaticAberrationEffect.js

@@ -0,0 +1,40 @@
+import { drawWgpuFilterPass } from '@flighthq/filters-wgpu';
+import { getWgpuEffectPipeline } from './wgpuEffectProgramCache';
+// Chromatic aberration: sample the R/G/B channels at progressively larger offsets so colors fringe
+// apart. When radial, the offset scales with distance from the optical center (true lens behavior);
+// otherwise it is a uniform horizontal split.
+export function applyChromaticAberrationEffectToWgpu(state, source, dest, effect) {
+    const intensity = effect.intensity ?? 0.005;
+    const radial = effect.radial ?? true;
+    const pipeline = getWgpuEffectPipeline(state, 'lens.chromaticAberration', CHROMATIC_ABERRATION_FRAGMENT_WGSL, 'replace');
+    drawWgpuFilterPass(state, source, dest, pipeline, (f32) => {
+        f32[0] = intensity;
+        f32[1] = radial ? 1 : 0;
+    });
+}
+export const defaultWgpuChromaticAberrationEffectRunner = (ctx, effect) => {
+    applyChromaticAberrationEffectToWgpu(ctx.state, ctx.source, ctx.dest, effect);
+};
+// Slot layout: [0]=intensity, [1]=radial flag (1.0/0.0).
+const CHROMATIC_ABERRATION_FRAGMENT_WGSL = /* wgsl */ `
+struct Uniforms {
+  u_intensity : f32,
+  u_radial : 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);
+  let scale = mix(1.0, length(centered) * 2.0, uni.u_radial);
+  let dir = mix(vec2f(1.0, 0.0), normalize(centered + vec2f(1e-5)), uni.u_radial);
+  let offset = dir * uni.u_intensity * scale;
+  let r = textureSampleLevel(tex, smp, uv + offset, 0.0).r;
+  let g = textureSampleLevel(tex, smp, uv, 0.0).g;
+  let b = textureSampleLevel(tex, smp, uv - offset, 0.0).b;
+  let a = textureSampleLevel(tex, smp, uv, 0.0).a;
+  return vec4f(r, g, b, a);
+}`;
+//# sourceMappingURL=wgpuChromaticAberrationEffect.js.map

package/dist/wgpuChromaticAberrationEffect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wgpuChromaticAberrationEffect.js","sourceRoot":"","sources":["../src/wgpuChromaticAberrationEffect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAQ5D,OAAO,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AAEjE,mGAAmG;AACnG,oGAAoG;AACpG,8CAA8C;AAC9C,MAAM,UAAU,oCAAoC,CAClD,KAAsB,EACtB,MAAkC,EAClC,IAAgC,EAChC,MAA2C;IAE3C,MAAM,SAAS,GAAG,MAAM,CAAC,SAAS,IAAI,KAAK,CAAC;IAC5C,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,IAAI,IAAI,CAAC;IACrC,MAAM,QAAQ,GAAG,qBAAqB,CACpC,KAAK,EACL,0BAA0B,EAC1B,kCAAkC,EAClC,SAAS,CACV,CAAC;IACF,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,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAC1B,CAAC,CAAC,CAAC;AACL,CAAC;AAED,MAAM,CAAC,MAAM,0CAA0C,GAA2B,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE;IAChG,oCAAoC,CAAC,GAAG,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,IAAI,EAAE,MAAmC,CAAC,CAAC;AAC7G,CAAC,CAAC;AAEF,yDAAyD;AACzD,MAAM,kCAAkC,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;EAoBpD,CAAC"}

package/dist/wgpuColorGradeEffect.d.ts

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

package/dist/wgpuColorGradeEffect.d.ts.map

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

package/dist/wgpuColorGradeEffect.js

@@ -0,0 +1,52 @@
+import { drawWgpuFilterPass } from '@flighthq/filters-wgpu';
+import { getWgpuEffectPipeline } from './wgpuEffectProgramCache';
+// Color grade: combined exposure, brightness, contrast, saturation, and temperature/tint shift.
+export function applyColorGradeEffectToWgpu(state, source, dest, effect) {
+    const exposure = Math.pow(2, effect.exposure ?? 0);
+    const contrast = effect.contrast ?? 1;
+    const saturation = effect.saturation ?? 1;
+    const temperature = effect.temperature ?? 0;
+    const tint = effect.tint ?? 0;
+    const brightness = effect.brightness ?? 0;
+    const pipeline = getWgpuEffectPipeline(state, 'colorGrade.colorGrade', COLOR_GRADE_FRAGMENT_WGSL, 'replace');
+    drawWgpuFilterPass(state, source, dest, pipeline, (f32) => {
+        f32[0] = exposure;
+        f32[1] = contrast;
+        f32[2] = saturation;
+        f32[3] = temperature;
+        f32[4] = tint;
+        f32[5] = brightness;
+    });
+}
+export const defaultWgpuColorGradeEffectRunner = (ctx, effect) => {
+    applyColorGradeEffectToWgpu(ctx.state, ctx.source, ctx.dest, effect);
+};
+// Slot layout: [0]=exposure, [1]=contrast, [2]=saturation, [3]=temperature, [4]=tint, [5]=brightness.
+const COLOR_GRADE_FRAGMENT_WGSL = /* wgsl */ `
+struct Uniforms {
+  u_exposure : f32,
+  u_contrast : f32,
+  u_saturation : f32,
+  u_temperature : f32,
+  u_tint : f32,
+  u_brightness : f32,
+  _pad0 : f32,
+  _pad1 : 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);
+  var rgb = c.rgb * uni.u_exposure + uni.u_brightness;
+  rgb.r += uni.u_temperature * 0.5;
+  rgb.b -= uni.u_temperature * 0.5;
+  rgb.g += uni.u_tint * 0.5;
+  let l = dot(rgb, vec3f(0.2126, 0.7152, 0.0722));
+  rgb = mix(vec3f(l), rgb, uni.u_saturation);
+  rgb = (rgb - 0.5) * uni.u_contrast + 0.5;
+  return vec4f(clamp(rgb, vec3f(0.0), vec3f(1.0)), c.a);
+}`;
+//# sourceMappingURL=wgpuColorGradeEffect.js.map

package/dist/wgpuColorGradeEffect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wgpuColorGradeEffect.js","sourceRoot":"","sources":["../src/wgpuColorGradeEffect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAG5D,OAAO,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AAEjE,gGAAgG;AAChG,MAAM,UAAU,2BAA2B,CACzC,KAAsB,EACtB,MAAkC,EAClC,IAAgC,EAChC,MAAkC;IAElC,MAAM,QAAQ,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,MAAM,CAAC,QAAQ,IAAI,CAAC,CAAC,CAAC;IACnD,MAAM,QAAQ,GAAG,MAAM,CAAC,QAAQ,IAAI,CAAC,CAAC;IACtC,MAAM,UAAU,GAAG,MAAM,CAAC,UAAU,IAAI,CAAC,CAAC;IAC1C,MAAM,WAAW,GAAG,MAAM,CAAC,WAAW,IAAI,CAAC,CAAC;IAC5C,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,IAAI,CAAC,CAAC;IAC9B,MAAM,UAAU,GAAG,MAAM,CAAC,UAAU,IAAI,CAAC,CAAC;IAC1C,MAAM,QAAQ,GAAG,qBAAqB,CAAC,KAAK,EAAE,uBAAuB,EAAE,yBAAyB,EAAE,SAAS,CAAC,CAAC;IAC7G,kBAAkB,CAAC,KAAK,EAAE,MAA0B,EAAE,IAAwB,EAAE,QAAQ,EAAE,CAAC,GAAG,EAAE,EAAE;QAChG,GAAG,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC;QAClB,GAAG,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC;QAClB,GAAG,CAAC,CAAC,CAAC,GAAG,UAAU,CAAC;QACpB,GAAG,CAAC,CAAC,CAAC,GAAG,WAAW,CAAC;QACrB,GAAG,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;QACd,GAAG,CAAC,CAAC,CAAC,GAAG,UAAU,CAAC;IACtB,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,sGAAsG;AACtG,MAAM,yBAAyB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;EA0B3C,CAAC"}

package/dist/wgpuCrtEffect.d.ts

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

package/dist/wgpuCrtEffect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wgpuCrtEffect.d.ts","sourceRoot":"","sources":["../src/wgpuCrtEffect.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,sBAAsB,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAM5G,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,eAAe,EACtB,MAAM,EAAE,QAAQ,CAAC,gBAAgB,CAAC,EAClC,IAAI,EAAE,QAAQ,CAAC,gBAAgB,CAAC,EAChC,MAAM,EAAE,QAAQ,CAAC,SAAS,CAAC,GAC1B,IAAI,CAcN;AAED,eAAO,MAAM,0BAA0B,EAAE,sBAExC,CAAC"}

package/dist/wgpuCrtEffect.js

@@ -0,0 +1,60 @@
+import { drawWgpuFilterPass } from '@flighthq/filters-wgpu';
+import { getWgpuEffectPipeline } from './wgpuEffectProgramCache';
+// CRT: barrel-distort the uv (curvature), darken alternating scanlines, vignette the edges, and split
+// the channels outward (chromatic aberration) for a tube-monitor look.
+export function applyCrtEffectToWgpu(state, source, dest, effect) {
+    const curvature = effect.curvature ?? 0.1;
+    const scanlineIntensity = effect.scanlineIntensity ?? 0.3;
+    const vignette = effect.vignette ?? 0.3;
+    const aberration = effect.aberration ?? 0.005;
+    const pipeline = getWgpuEffectPipeline(state, 'stylization.crt', CRT_FRAGMENT_WGSL, 'replace');
+    drawWgpuFilterPass(state, source, dest, pipeline, (f32) => {
+        f32[0] = curvature;
+        f32[1] = scanlineIntensity;
+        f32[2] = vignette;
+        f32[3] = aberration;
+        f32[4] = source.width;
+        f32[5] = source.height;
+    });
+}
+export const defaultWgpuCrtEffectRunner = (ctx, effect) => {
+    applyCrtEffectToWgpu(ctx.state, ctx.source, ctx.dest, effect);
+};
+// Slot layout: [0]=curvature, [1]=scanlineIntensity, [2]=vignette, [3]=aberration, [4..5]=resolution.
+const CRT_FRAGMENT_WGSL = /* wgsl */ `
+struct Uniforms {
+  u_curvature : f32,
+  u_scanlineIntensity : f32,
+  u_vignette : f32,
+  u_aberration : 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 barrel(uv : vec2f) -> vec2f {
+  var c = uv * 2.0 - 1.0;
+  c += c * uni.u_curvature * dot(c, c);
+  return c * 0.5 + 0.5;
+}
+
+@fragment
+fn fs_main(@location(0) uvIn : vec2f) -> @location(0) vec4f {
+  let uv = barrel(uvIn);
+  if (uv.x < 0.0 || uv.x > 1.0 || uv.y < 0.0 || uv.y > 1.0) {
+    return vec4f(0.0, 0.0, 0.0, 1.0);
+  }
+  let off = vec2f(uni.u_aberration, 0.0);
+  let r = textureSampleLevel(tex, smp, uv + off, 0.0).r;
+  let g = textureSampleLevel(tex, smp, uv, 0.0).g;
+  let b = textureSampleLevel(tex, smp, uv - off, 0.0).b;
+  let a = textureSampleLevel(tex, smp, uv, 0.0).a;
+  var col = vec3f(r, g, b);
+  let line = sin(uv.y * uni.u_resolution.y * 3.14159265) * 0.5 + 0.5;
+  col *= 1.0 - uni.u_scanlineIntensity * (1.0 - line);
+  let vc = uv * 2.0 - 1.0;
+  col *= 1.0 - uni.u_vignette * dot(vc, vc);
+  return vec4f(col, a);
+}`;
+//# sourceMappingURL=wgpuCrtEffect.js.map