@flighthq/effects-wgpu 0.1.0

package/dist/wgpuTiltShiftEffect.js

@@ -0,0 +1,51 @@
+import { drawWgpuFilterPass } from '@flighthq/filters-wgpu';
+import { getWgpuEffectPipeline } from './wgpuEffectProgramCache';
+// Tilt-shift: keep a horizontal focus band sharp and blur above and below it. The band is centered at
+// `center` on Y with height `width`; blur strength ramps with distance outside the band. Blur is
+// approximated by averaging a few neighbor taps using the pixel size from the resolution uniform.
+export function applyTiltShiftEffectToWgpu(state, source, dest, effect) {
+    const center = effect.center ?? 0.5;
+    const width = effect.width ?? 0.3;
+    const blur = effect.blur ?? 4;
+    const pipeline = getWgpuEffectPipeline(state, 'lens.tiltShift', TILT_SHIFT_FRAGMENT_WGSL, 'replace');
+    drawWgpuFilterPass(state, source, dest, pipeline, (f32) => {
+        f32[0] = center;
+        f32[1] = width;
+        f32[2] = blur;
+        f32[4] = source.width;
+        f32[5] = source.height;
+    });
+}
+export const defaultWgpuTiltShiftEffectRunner = (ctx, effect) => {
+    applyTiltShiftEffectToWgpu(ctx.state, ctx.source, ctx.dest, effect);
+};
+// Slot layout: [0]=center, [1]=width, [2]=blur, [3]=pad, [4..5]=resolution (vec2 aligned to 16 bytes).
+const TILT_SHIFT_FRAGMENT_WGSL = /* wgsl */ `
+struct Uniforms {
+  u_center : f32,
+  u_width : f32,
+  u_blur : 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;
+  let dist = abs(uv.y - uni.u_center);
+  let edge = uni.u_width * 0.5;
+  let amount = smoothstep(edge, edge + uni.u_width, dist);
+  let radius = amount * uni.u_blur;
+  var sum = vec4f(0.0);
+  var total = 0.0;
+  for (var i = -3; i <= 3; i = i + 1) {
+    let offset = vec2f(0.0, f32(i)) * radius * texel;
+    sum = sum + textureSampleLevel(tex, smp, uv + offset, 0.0);
+    total = total + 1.0;
+  }
+  return sum / total;
+}`;
+//# sourceMappingURL=wgpuTiltShiftEffect.js.map

package/dist/wgpuTiltShiftEffect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wgpuTiltShiftEffect.js","sourceRoot":"","sources":["../src/wgpuTiltShiftEffect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAG5D,OAAO,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AAEjE,sGAAsG;AACtG,iGAAiG;AACjG,kGAAkG;AAClG,MAAM,UAAU,0BAA0B,CACxC,KAAsB,EACtB,MAAkC,EAClC,IAAgC,EAChC,MAAiC;IAEjC,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,IAAI,GAAG,CAAC;IACpC,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,IAAI,GAAG,CAAC;IAClC,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,IAAI,CAAC,CAAC;IAC9B,MAAM,QAAQ,GAAG,qBAAqB,CAAC,KAAK,EAAE,gBAAgB,EAAE,wBAAwB,EAAE,SAAS,CAAC,CAAC;IACrG,kBAAkB,CAAC,KAAK,EAAE,MAA0B,EAAE,IAAwB,EAAE,QAAQ,EAAE,CAAC,GAAG,EAAE,EAAE;QAChG,GAAG,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC;QAChB,GAAG,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC;QACf,GAAG,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;QACd,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,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,uGAAuG;AACvG,MAAM,wBAAwB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2B1C,CAAC"}

package/dist/wgpuToneMapEffect.d.ts

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

package/dist/wgpuToneMapEffect.d.ts.map

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

package/dist/wgpuToneMapEffect.js

@@ -0,0 +1,57 @@
+import { drawWgpuFilterPass } from '@flighthq/filters-wgpu';
+import { getWgpuEffectPipeline } from './wgpuEffectProgramCache';
+// Tone map: compress HDR to displayable range via the selected operator. Single-pass reference recipe,
+// the Wgpu mirror of effects-gl's applyToneMapEffectToGl. The operator selects a tonemap body
+// that is compiled into the fragment once per state, keyed by operator name.
+export function applyToneMapEffectToWgpu(state, source, dest, effect) {
+    const operator = effect.operator ?? 'aces';
+    const exposure = effect.exposure ?? 1;
+    const white = effect.white ?? 1;
+    const pipeline = getWgpuEffectPipeline(state, `toneMap.${operator}`, buildToneMapFragment(operator), 'replace');
+    drawWgpuFilterPass(state, source, dest, pipeline, (f32) => {
+        f32[0] = exposure;
+        f32[1] = white;
+    });
+}
+export const defaultWgpuToneMapEffectRunner = (ctx, effect) => {
+    applyToneMapEffectToWgpu(ctx.state, ctx.source, ctx.dest, effect);
+};
+function buildToneMapFragment(operator) {
+    return TONEMAP_FRAGMENT_HEAD + (TONEMAP_OPERATORS[operator] ?? TONEMAP_OPERATORS.aces) + TONEMAP_FRAGMENT_TAIL;
+}
+// Slots [0]=exposure, [1]=white; the operator body is spliced between head and tail. The struct's two
+// scalars pad to a 16-byte boundary.
+const TONEMAP_FRAGMENT_HEAD = /* wgsl */ `
+struct Uniforms { u_exposure : f32, u_white : 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;
+
+fn tonemap(x : vec3f) -> vec3f {`;
+const TONEMAP_FRAGMENT_TAIL = /* wgsl */ `}
+
+@fragment
+fn fs_main(@location(0) uv : vec2f) -> @location(0) vec4f {
+  let c = textureSampleLevel(tex, smp, uv, 0.0);
+  let mapped = tonemap(c.rgb * uni.u_exposure);
+  return vec4f(clamp(mapped, vec3f(0.0), vec3f(1.0)), c.a);
+}`;
+const TONEMAP_OPERATORS = {
+    aces: `
+  let a = x * (2.51 * x + 0.03);
+  let b = x * (2.43 * x + 0.59) + 0.14;
+  return a / b;`,
+    reinhard: `
+  return x / (1.0 + x / (uni.u_white * uni.u_white));`,
+    filmic: `
+  let X = max(vec3f(0.0), x - 0.004);
+  return (X * (6.2 * X + 0.5)) / (X * (6.2 * X + 1.7) + 0.06);`,
+    uncharted2: `
+  let A = 0.15; let B = 0.50; let C = 0.10; let D = 0.20; let E = 0.02; let F = 0.30;
+  let v = ((x * (A * x + C * B) + D * E) / (x * (A * x + B) + D * F)) - E / F;
+  return v;`,
+    agx: `
+  let v = clamp((x - 0.004) / (1.0 + x), vec3f(0.0), vec3f(1.0));
+  return pow(v, vec3f(0.8));`,
+};
+//# sourceMappingURL=wgpuToneMapEffect.js.map

package/dist/wgpuToneMapEffect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wgpuToneMapEffect.js","sourceRoot":"","sources":["../src/wgpuToneMapEffect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAG5D,OAAO,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AAEjE,uGAAuG;AACvG,8FAA8F;AAC9F,6EAA6E;AAC7E,MAAM,UAAU,wBAAwB,CACtC,KAAsB,EACtB,MAAkC,EAClC,IAAgC,EAChC,MAA+B;IAE/B,MAAM,QAAQ,GAAG,MAAM,CAAC,QAAQ,IAAI,MAAM,CAAC;IAC3C,MAAM,QAAQ,GAAG,MAAM,CAAC,QAAQ,IAAI,CAAC,CAAC;IACtC,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,IAAI,CAAC,CAAC;IAChC,MAAM,QAAQ,GAAG,qBAAqB,CAAC,KAAK,EAAE,WAAW,QAAQ,EAAE,EAAE,oBAAoB,CAAC,QAAQ,CAAC,EAAE,SAAS,CAAC,CAAC;IAChH,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,KAAK,CAAC;IACjB,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,QAAgB;IAC5C,OAAO,qBAAqB,GAAG,CAAC,iBAAiB,CAAC,QAAQ,CAAC,IAAI,iBAAiB,CAAC,IAAI,CAAC,GAAG,qBAAqB,CAAC;AACjH,CAAC;AAED,sGAAsG;AACtG,qCAAqC;AACrC,MAAM,qBAAqB,GAAG,UAAU,CAAC;;;;;;iCAMR,CAAC;AAElC,MAAM,qBAAqB,GAAG,UAAU,CAAC;;;;;;;EAOvC,CAAC;AAEH,MAAM,iBAAiB,GAA2B;IAChD,IAAI,EAAE;;;gBAGQ;IACd,QAAQ,EAAE;sDAC0C;IACpD,MAAM,EAAE;;+DAEqD;IAC7D,UAAU,EAAE;;;YAGF;IACV,GAAG,EAAE;;6BAEsB;CAC5B,CAAC"}

package/dist/wgpuVignetteEffect.d.ts

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

package/dist/wgpuVignetteEffect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wgpuVignetteEffect.d.ts","sourceRoot":"","sources":["../src/wgpuVignetteEffect.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,sBAAsB,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AASjH,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,CAmBN;AAED,eAAO,MAAM,+BAA+B,EAAE,sBAE7C,CAAC"}

package/dist/wgpuVignetteEffect.js

@@ -0,0 +1,54 @@
+import { drawWgpuFilterPass } from '@flighthq/filters-wgpu';
+import { getWgpuEffectPipeline } from './wgpuEffectProgramCache';
+// Vignette: darken toward the edges. Pixels inside `radius` stay full bright; beyond it, brightness
+// falls off over `softness` and the color is blended toward the (unpacked) vignette color by intensity.
+// Single-pass reference recipe, the Wgpu mirror of effects-gl's applyVignetteEffectToGl. The
+// fragment works in centered coordinates (uv - 0.5) so radial math measures distance from the center;
+// the packed RGBA color int is unpacked to normalized components in JS before upload.
+export function applyVignetteEffectToWgpu(state, source, dest, effect) {
+    const intensity = effect.intensity ?? 1;
+    const radius = effect.radius ?? 0.75;
+    const softness = effect.softness ?? 0.45;
+    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, 'lens.vignette', VIGNETTE_FRAGMENT_WGSL, 'replace');
+    drawWgpuFilterPass(state, source, dest, pipeline, (f32) => {
+        f32[0] = intensity;
+        f32[1] = radius;
+        f32[2] = softness;
+        f32[4] = r;
+        f32[5] = g;
+        f32[6] = b;
+        f32[7] = a;
+    });
+}
+export const defaultWgpuVignetteEffectRunner = (ctx, effect) => {
+    applyVignetteEffectToWgpu(ctx.state, ctx.source, ctx.dest, effect);
+};
+// Slot layout: [0]=intensity, [1]=radius, [2]=softness, [3]=pad, [4..7]=color rgba. The std140-style
+// struct aligns the vec4 color to a 16-byte boundary, so the JS writes skip slot [3].
+const VIGNETTE_FRAGMENT_WGSL = /* wgsl */ `
+struct Uniforms {
+  u_intensity : f32,
+  u_radius : f32,
+  u_softness : f32,
+  _pad0 : f32,
+  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;
+
+@fragment
+fn fs_main(@location(0) uv : vec2f) -> @location(0) vec4f {
+  let c = textureSampleLevel(tex, smp, uv, 0.0);
+  let centered = uv - vec2f(0.5);
+  let dist = length(centered) * 1.41421356;
+  let vig = smoothstep(uni.u_radius, uni.u_radius - uni.u_softness, dist);
+  let darken = (1.0 - vig) * uni.u_intensity * uni.u_color.a;
+  return vec4f(mix(c.rgb, uni.u_color.rgb, darken), c.a);
+}`;
+//# sourceMappingURL=wgpuVignetteEffect.js.map

package/dist/wgpuVignetteEffect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wgpuVignetteEffect.js","sourceRoot":"","sources":["../src/wgpuVignetteEffect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAG5D,OAAO,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AAEjE,oGAAoG;AACpG,wGAAwG;AACxG,6FAA6F;AAC7F,sGAAsG;AACtG,sFAAsF;AACtF,MAAM,UAAU,yBAAyB,CACvC,KAAsB,EACtB,MAAkC,EAClC,IAAgC,EAChC,MAAgC;IAEhC,MAAM,SAAS,GAAG,MAAM,CAAC,SAAS,IAAI,CAAC,CAAC;IACxC,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,IAAI,IAAI,CAAC;IACrC,MAAM,QAAQ,GAAG,MAAM,CAAC,QAAQ,IAAI,IAAI,CAAC;IACzC,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,eAAe,EAAE,sBAAsB,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,SAAS,CAAC;QACnB,GAAG,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC;QAChB,GAAG,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC;QAClB,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,+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,qGAAqG;AACrG,sFAAsF;AACtF,MAAM,sBAAsB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;EAoBxC,CAAC"}

package/dist/wgpuWhiteBalanceEffect.d.ts

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

package/dist/wgpuWhiteBalanceEffect.d.ts.map

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

package/dist/wgpuWhiteBalanceEffect.js

@@ -0,0 +1,32 @@
+import { drawWgpuFilterPass } from '@flighthq/filters-wgpu';
+import { getWgpuEffectPipeline } from './wgpuEffectProgramCache';
+// White balance: warm/cool temperature and magenta/green tint channel shift.
+export function applyWhiteBalanceEffectToWgpu(state, source, dest, effect) {
+    const temperature = effect.temperature ?? 0;
+    const tint = effect.tint ?? 0;
+    const pipeline = getWgpuEffectPipeline(state, 'colorGrade.whiteBalance', WHITE_BALANCE_FRAGMENT_WGSL, 'replace');
+    drawWgpuFilterPass(state, source, dest, pipeline, (f32) => {
+        f32[0] = temperature;
+        f32[1] = tint;
+    });
+}
+export const defaultWgpuWhiteBalanceEffectRunner = (ctx, effect) => {
+    applyWhiteBalanceEffectToWgpu(ctx.state, ctx.source, ctx.dest, effect);
+};
+// Slot layout: [0]=temperature, [1]=tint.
+const WHITE_BALANCE_FRAGMENT_WGSL = /* wgsl */ `
+struct Uniforms { u_temperature : f32, u_tint : 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;
+  rgb.r += uni.u_temperature * 0.5;
+  rgb.b -= uni.u_temperature * 0.5;
+  rgb.g += uni.u_tint * 0.5;
+  return vec4f(clamp(rgb, vec3f(0.0), vec3f(1.0)), c.a);
+}`;
+//# sourceMappingURL=wgpuWhiteBalanceEffect.js.map

package/dist/wgpuWhiteBalanceEffect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wgpuWhiteBalanceEffect.js","sourceRoot":"","sources":["../src/wgpuWhiteBalanceEffect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAG5D,OAAO,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AAEjE,6EAA6E;AAC7E,MAAM,UAAU,6BAA6B,CAC3C,KAAsB,EACtB,MAAkC,EAClC,IAAgC,EAChC,MAAoC;IAEpC,MAAM,WAAW,GAAG,MAAM,CAAC,WAAW,IAAI,CAAC,CAAC;IAC5C,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,IAAI,CAAC,CAAC;IAC9B,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,GAAG,CAAC,CAAC,CAAC,GAAG,WAAW,CAAC;QACrB,GAAG,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;IAChB,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,0CAA0C;AAC1C,MAAM,2BAA2B,GAAG,UAAU,CAAC;;;;;;;;;;;;;;EAc7C,CAAC"}

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@flighthq/effects-wgpu",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src/**/*.test.ts",
+    "!dist/**/*.test.js",
+    "!dist/**/*.test.d.ts",
+    "!dist/**/*.test.js.map",
+    "!dist/**/*.test.d.ts.map"
+  ],
+  "scripts": {
+    "build": "tsc -b",
+    "clean": "tsc -b --clean",
+    "test": "vitest run --config vitest.config.ts",
+    "test:watch": "vitest --watch --config vitest.config.ts",
+    "prepack": "npm run clean && npm run clean:dist && npm run build",
+    "clean:dist": "tsx ../../scripts/clean-package-dist.ts"
+  },
+  "dependencies": {
+    "@flighthq/effects": "0.1.0",
+    "@flighthq/filters": "0.1.0",
+    "@flighthq/filters-wgpu": "0.1.0",
+    "@flighthq/geometry": "0.1.0",
+    "@flighthq/render-wgpu": "0.1.0",
+    "@flighthq/types": "0.1.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.3.0"
+  },
+  "description": "WebGPU shader recipes for render effects (substrate-agnostic post-process pipeline)",
+  "sideEffects": false
+}

package/src/wgpuBloomEffect.test.ts

@@ -0,0 +1,13 @@
+import { applyBloomEffectToWgpu, defaultWgpuBloomEffectRunner } from './wgpuBloomEffect';
+
+describe('applyBloomEffectToWgpu', () => {
+  it('is a function', () => {
+    expect(typeof applyBloomEffectToWgpu).toBe('function');
+  });
+});
+
+describe('defaultWgpuBloomEffectRunner', () => {
+  it('is a function', () => {
+    expect(typeof defaultWgpuBloomEffectRunner).toBe('function');
+  });
+});

package/src/wgpuBokehDepthOfFieldEffect.test.ts

@@ -0,0 +1,16 @@
+import {
+  applyBokehDepthOfFieldEffectToWgpu,
+  defaultWgpuBokehDepthOfFieldEffectRunner,
+} from './wgpuBokehDepthOfFieldEffect';
+
+describe('applyBokehDepthOfFieldEffectToWgpu', () => {
+  it('is a function', () => {
+    expect(typeof applyBokehDepthOfFieldEffectToWgpu).toBe('function');
+  });
+});
+
+describe('defaultWgpuBokehDepthOfFieldEffectRunner', () => {
+  it('is a function', () => {
+    expect(typeof defaultWgpuBokehDepthOfFieldEffectRunner).toBe('function');
+  });
+});

package/src/wgpuBrightnessContrastEffect.test.ts

@@ -0,0 +1,16 @@
+import {
+  applyBrightnessContrastEffectToWgpu,
+  defaultWgpuBrightnessContrastEffectRunner,
+} from './wgpuBrightnessContrastEffect';
+
+describe('applyBrightnessContrastEffectToWgpu', () => {
+  it('is a function', () => {
+    expect(typeof applyBrightnessContrastEffectToWgpu).toBe('function');
+  });
+});
+
+describe('defaultWgpuBrightnessContrastEffectRunner', () => {
+  it('is a function', () => {
+    expect(typeof defaultWgpuBrightnessContrastEffectRunner).toBe('function');
+  });
+});

package/src/wgpuCameraMotionBlurEffect.test.ts

@@ -0,0 +1,16 @@
+import {
+  applyCameraMotionBlurEffectToWgpu,
+  defaultWgpuCameraMotionBlurEffectRunner,
+} from './wgpuCameraMotionBlurEffect';
+
+describe('applyCameraMotionBlurEffectToWgpu', () => {
+  it('is a function', () => {
+    expect(typeof applyCameraMotionBlurEffectToWgpu).toBe('function');
+  });
+});
+
+describe('defaultWgpuCameraMotionBlurEffectRunner', () => {
+  it('is a function', () => {
+    expect(typeof defaultWgpuCameraMotionBlurEffectRunner).toBe('function');
+  });
+});

package/src/wgpuChannelMixerEffect.test.ts

@@ -0,0 +1,13 @@
+import { applyChannelMixerEffectToWgpu, defaultWgpuChannelMixerEffectRunner } from './wgpuChannelMixerEffect';
+
+describe('applyChannelMixerEffectToWgpu', () => {
+  it('is a function', () => {
+    expect(typeof applyChannelMixerEffectToWgpu).toBe('function');
+  });
+});
+
+describe('defaultWgpuChannelMixerEffectRunner', () => {
+  it('is a function', () => {
+    expect(typeof defaultWgpuChannelMixerEffectRunner).toBe('function');
+  });
+});

package/src/wgpuChromaticAberrationEffect.test.ts

@@ -0,0 +1,16 @@
+import {
+  applyChromaticAberrationEffectToWgpu,
+  defaultWgpuChromaticAberrationEffectRunner,
+} from './wgpuChromaticAberrationEffect';
+
+describe('applyChromaticAberrationEffectToWgpu', () => {
+  it('is a function', () => {
+    expect(typeof applyChromaticAberrationEffectToWgpu).toBe('function');
+  });
+});
+
+describe('defaultWgpuChromaticAberrationEffectRunner', () => {
+  it('is a function', () => {
+    expect(typeof defaultWgpuChromaticAberrationEffectRunner).toBe('function');
+  });
+});

package/src/wgpuColorGradeEffect.test.ts

@@ -0,0 +1,13 @@
+import { applyColorGradeEffectToWgpu, defaultWgpuColorGradeEffectRunner } from './wgpuColorGradeEffect';
+
+describe('applyColorGradeEffectToWgpu', () => {
+  it('is a function', () => {
+    expect(typeof applyColorGradeEffectToWgpu).toBe('function');
+  });
+});
+
+describe('defaultWgpuColorGradeEffectRunner', () => {
+  it('is a function', () => {
+    expect(typeof defaultWgpuColorGradeEffectRunner).toBe('function');
+  });
+});

package/src/wgpuCrtEffect.test.ts

@@ -0,0 +1,13 @@
+import { applyCrtEffectToWgpu, defaultWgpuCrtEffectRunner } from './wgpuCrtEffect';
+
+describe('applyCrtEffectToWgpu', () => {
+  it('is a function', () => {
+    expect(typeof applyCrtEffectToWgpu).toBe('function');
+  });
+});
+
+describe('defaultWgpuCrtEffectRunner', () => {
+  it('is a function', () => {
+    expect(typeof defaultWgpuCrtEffectRunner).toBe('function');
+  });
+});

package/src/wgpuDirectionalBlurEffect.test.ts

@@ -0,0 +1,13 @@
+import { applyDirectionalBlurEffectToWgpu, defaultWgpuDirectionalBlurEffectRunner } from './wgpuDirectionalBlurEffect';
+
+describe('applyDirectionalBlurEffectToWgpu', () => {
+  it('is a function', () => {
+    expect(typeof applyDirectionalBlurEffectToWgpu).toBe('function');
+  });
+});
+
+describe('defaultWgpuDirectionalBlurEffectRunner', () => {
+  it('is a function', () => {
+    expect(typeof defaultWgpuDirectionalBlurEffectRunner).toBe('function');
+  });
+});

package/src/wgpuDisplacementEffect.test.ts

@@ -0,0 +1,13 @@
+import { applyDisplacementEffectToWgpu, defaultWgpuDisplacementEffectRunner } from './wgpuDisplacementEffect';
+
+describe('applyDisplacementEffectToWgpu', () => {
+  it('is a function', () => {
+    expect(typeof applyDisplacementEffectToWgpu).toBe('function');
+  });
+});
+
+describe('defaultWgpuDisplacementEffectRunner', () => {
+  it('is a function', () => {
+    expect(typeof defaultWgpuDisplacementEffectRunner).toBe('function');
+  });
+});

package/src/wgpuDitherEffect.test.ts

@@ -0,0 +1,13 @@
+import { applyDitherEffectToWgpu, defaultWgpuDitherEffectRunner } from './wgpuDitherEffect';
+
+describe('applyDitherEffectToWgpu', () => {
+  it('is a function', () => {
+    expect(typeof applyDitherEffectToWgpu).toBe('function');
+  });
+});
+
+describe('defaultWgpuDitherEffectRunner', () => {
+  it('is a function', () => {
+    expect(typeof defaultWgpuDitherEffectRunner).toBe('function');
+  });
+});

package/src/wgpuEffectProgramCache.test.ts

@@ -0,0 +1,7 @@
+import { getWgpuEffectPipeline } from './wgpuEffectProgramCache';
+
+describe('getWgpuEffectPipeline', () => {
+  it('is a function', () => {
+    expect(typeof getWgpuEffectPipeline).toBe('function');
+  });
+});

package/src/wgpuExposureEffect.test.ts

@@ -0,0 +1,13 @@
+import { applyExposureEffectToWgpu, defaultWgpuExposureEffectRunner } from './wgpuExposureEffect';
+
+describe('applyExposureEffectToWgpu', () => {
+  it('is a function', () => {
+    expect(typeof applyExposureEffectToWgpu).toBe('function');
+  });
+});
+
+describe('defaultWgpuExposureEffectRunner', () => {
+  it('is a function', () => {
+    expect(typeof defaultWgpuExposureEffectRunner).toBe('function');
+  });
+});

package/src/wgpuFilmGrainEffect.test.ts

@@ -0,0 +1,13 @@
+import { applyFilmGrainEffectToWgpu, defaultWgpuFilmGrainEffectRunner } from './wgpuFilmGrainEffect';
+
+describe('applyFilmGrainEffectToWgpu', () => {
+  it('is a function', () => {
+    expect(typeof applyFilmGrainEffectToWgpu).toBe('function');
+  });
+});
+
+describe('defaultWgpuFilmGrainEffectRunner', () => {
+  it('is a function', () => {
+    expect(typeof defaultWgpuFilmGrainEffectRunner).toBe('function');
+  });
+});

package/src/wgpuFxaaEffect.test.ts

@@ -0,0 +1,13 @@
+import { applyFxaaEffectToWgpu, defaultWgpuFxaaEffectRunner } from './wgpuFxaaEffect';
+
+describe('applyFxaaEffectToWgpu', () => {
+  it('is a function', () => {
+    expect(typeof applyFxaaEffectToWgpu).toBe('function');
+  });
+});
+
+describe('defaultWgpuFxaaEffectRunner', () => {
+  it('is a function', () => {
+    expect(typeof defaultWgpuFxaaEffectRunner).toBe('function');
+  });
+});

package/src/wgpuGlitchEffect.test.ts

@@ -0,0 +1,13 @@
+import { applyGlitchEffectToWgpu, defaultWgpuGlitchEffectRunner } from './wgpuGlitchEffect';
+
+describe('applyGlitchEffectToWgpu', () => {
+  it('is a function', () => {
+    expect(typeof applyGlitchEffectToWgpu).toBe('function');
+  });
+});
+
+describe('defaultWgpuGlitchEffectRunner', () => {
+  it('is a function', () => {
+    expect(typeof defaultWgpuGlitchEffectRunner).toBe('function');
+  });
+});

package/src/wgpuGodRaysEffect.test.ts

@@ -0,0 +1,13 @@
+import { applyGodRaysEffectToWgpu, defaultWgpuGodRaysEffectRunner } from './wgpuGodRaysEffect';
+
+describe('applyGodRaysEffectToWgpu', () => {
+  it('is a function', () => {
+    expect(typeof applyGodRaysEffectToWgpu).toBe('function');
+  });
+});
+
+describe('defaultWgpuGodRaysEffectRunner', () => {
+  it('is a function', () => {
+    expect(typeof defaultWgpuGodRaysEffectRunner).toBe('function');
+  });
+});

package/src/wgpuGrayscaleEffect.test.ts

@@ -0,0 +1,13 @@
+import { applyGrayscaleEffectToWgpu, defaultWgpuGrayscaleEffectRunner } from './wgpuGrayscaleEffect';
+
+describe('applyGrayscaleEffectToWgpu', () => {
+  it('is a function', () => {
+    expect(typeof applyGrayscaleEffectToWgpu).toBe('function');
+  });
+});
+
+describe('defaultWgpuGrayscaleEffectRunner', () => {
+  it('is a function', () => {
+    expect(typeof defaultWgpuGrayscaleEffectRunner).toBe('function');
+  });
+});

package/src/wgpuHalftoneEffect.test.ts

@@ -0,0 +1,13 @@
+import { applyHalftoneEffectToWgpu, defaultWgpuHalftoneEffectRunner } from './wgpuHalftoneEffect';
+
+describe('applyHalftoneEffectToWgpu', () => {
+  it('is a function', () => {
+    expect(typeof applyHalftoneEffectToWgpu).toBe('function');
+  });
+});
+
+describe('defaultWgpuHalftoneEffectRunner', () => {
+  it('is a function', () => {
+    expect(typeof defaultWgpuHalftoneEffectRunner).toBe('function');
+  });
+});

package/src/wgpuHueSaturationEffect.test.ts

@@ -0,0 +1,13 @@
+import { applyHueSaturationEffectToWgpu, defaultWgpuHueSaturationEffectRunner } from './wgpuHueSaturationEffect';
+
+describe('applyHueSaturationEffectToWgpu', () => {
+  it('is a function', () => {
+    expect(typeof applyHueSaturationEffectToWgpu).toBe('function');
+  });
+});
+
+describe('defaultWgpuHueSaturationEffectRunner', () => {
+  it('is a function', () => {
+    expect(typeof defaultWgpuHueSaturationEffectRunner).toBe('function');
+  });
+});

package/src/wgpuInvertEffect.test.ts

@@ -0,0 +1,13 @@
+import { applyInvertEffectToWgpu, defaultWgpuInvertEffectRunner } from './wgpuInvertEffect';
+
+describe('applyInvertEffectToWgpu', () => {
+  it('is a function', () => {
+    expect(typeof applyInvertEffectToWgpu).toBe('function');
+  });
+});
+
+describe('defaultWgpuInvertEffectRunner', () => {
+  it('is a function', () => {
+    expect(typeof defaultWgpuInvertEffectRunner).toBe('function');
+  });
+});

package/src/wgpuKuwaharaEffect.test.ts

@@ -0,0 +1,13 @@
+import { applyKuwaharaEffectToWgpu, defaultWgpuKuwaharaEffectRunner } from './wgpuKuwaharaEffect';
+
+describe('applyKuwaharaEffectToWgpu', () => {
+  it('is a function', () => {
+    expect(typeof applyKuwaharaEffectToWgpu).toBe('function');
+  });
+});
+
+describe('defaultWgpuKuwaharaEffectRunner', () => {
+  it('is a function', () => {
+    expect(typeof defaultWgpuKuwaharaEffectRunner).toBe('function');
+  });
+});

package/src/wgpuLensDirtEffect.test.ts

@@ -0,0 +1,13 @@
+import { applyLensDirtEffectToWgpu, defaultWgpuLensDirtEffectRunner } from './wgpuLensDirtEffect';
+
+describe('applyLensDirtEffectToWgpu', () => {
+  it('is a function', () => {
+    expect(typeof applyLensDirtEffectToWgpu).toBe('function');
+  });
+});
+
+describe('defaultWgpuLensDirtEffectRunner', () => {
+  it('is a function', () => {
+    expect(typeof defaultWgpuLensDirtEffectRunner).toBe('function');
+  });
+});