665bfac0b339
fx_key.wgsl
// GPU effects (keying, matte and channel family): see src/fx_key.rs. Each entry point mirrors
// the CPU effect in effectcraft-effects operation for operation. Every name here is prefixed
// `fxk_` (the family files share one module).
// Correct the approximate quotient before bitwise/threshold operations.
fn fxk_div3(a: vec3<f32>, b: f32) -> vec3<f32> {
let q = a / b;
let r = fma(-q, vec3<f32>(b), a);
return fma(r, vec3<f32>(1.0 / b), q);
}
// util::unpremul: (straight colour, alpha); colour 0 when alpha ≤ 1e-6.
fn fxk_straight(px: vec4<f32>) -> vec3<f32> {
if (px.w > 1e-6) {
return fxk_div3(px.xyz, px.w);
}
return vec3<f32>(0.0);
}
fn fxk_premul(c: vec3<f32>, a: f32) -> vec4<f32> {
return vec4<f32>(c * a, a);
}
// Pixel `p` of the third image, copied into `data` as RGBA f32 rows of P.u[3].x pixels.
fn fxk_rows(p: vec2<i32>) -> vec4<f32> {
let i = (u32(p.y) * P.u[3].x + u32(p.x)) * 4u;
return vec4<f32>(data[i], data[i + 1u], data[i + 2u], data[i + 3u]);
}
// keying::to_lab.
fn fxk_cbrt(t: f32) -> f32 {
return sign(t) * pow(abs(t), 1.0 / 3.0);
}
fn fxk_lab_f(t: f32) -> f32 {
if (t > 0.008856) {
return fxk_cbrt(t);
}
return 7.787 * t + 16.0 / 116.0;
}
// keying::range_components.
fn fxk_range_components(space: u32, c: vec3<f32>) -> vec3<f32> {
if (space == 1u) {
let y = 0.299 * c.x + 0.587 * c.y + 0.114 * c.z;
let u = -0.14713 * c.x - 0.28886 * c.y + 0.436 * c.z;
let v = 0.615 * c.x - 0.51499 * c.y - 0.10001 * c.z;
return vec3<f32>(y * 255.0, u * 255.0 + 128.0, v * 255.0 + 128.0);
}
if (space == 2u) {
return c * 255.0;
}
let cl = clamp(c, vec3<f32>(0.0), vec3<f32>(1.0));
let l = vec3<f32>(srgb_to_linear(cl.x), srgb_to_linear(cl.y), srgb_to_linear(cl.z));
let x = (0.4124 * l.x + 0.3576 * l.y + 0.1805 * l.z) / 0.95047;
let yy = 0.2126 * l.x + 0.7152 * l.y + 0.0722 * l.z;
let z = (0.0193 * l.x + 0.1192 * l.y + 0.9505 * l.z) / 1.08883;
let fx = fxk_lab_f(x);
let fy = fxk_lab_f(yy);
let fz = fxk_lab_f(z);
return vec3<f32>((116.0 * fy - 16.0) * 2.55, 500.0 * (fx - fy) + 128.0, 200.0 * (fy - fz) + 128.0);
}
// keying::matte_levels.
// Luma Key / Extract luminance: Rec. 601, effects::LUMA_601 (checked by the test
// shader_constants_match_the_cpu).
fn fxk_key_luma(c: vec3<f32>) -> f32 {
return dot(c, vec3<f32>(0.299, 0.587, 0.114));
}
fn fxk_matte_levels(v: f32, in_b: f32, in_w: f32, gamma: f32, out_b: f32, out_w: f32) -> f32 {
var t = clamp((v - in_b / 255.0) / max((in_w - in_b) / 255.0, 1e-4), 0.0, 1.0);
t = powz(t, 1.0 / max(gamma, 0.01));
return clamp(out_b / 255.0 + t * (out_w - out_b) / 255.0, 0.0, 1.0);
}
// keying::secondary.
fn fxk_secondary(c: vec3<f32>, o1: u32, o2: u32, bal: f32) -> f32 {
var hi = c[o2];
var lo = c[o1];
if (c[o1] > c[o2]) {
hi = c[o1];
lo = c[o2];
}
return bal * hi + (1.0 - bal) * lo;
}
// channel::arithmetic's 8-bit quantisation.
fn fxk_q(v: f32) -> u32 {
return u32(round_away(clamp(v, 0.0, 1.0) * 255.0));
}
// channel2::extract.
fn fxk_extract(px: vec4<f32>, ch: u32, inv: bool) -> vec4<f32> {
let c = fxk_straight(px);
let a = max(px.w, 0.0);
var g: f32;
switch ch {
case 0u: {
if (inv) {
return fxk_premul(1.0 - c, a);
}
return px;
}
case 1u: { g = luminance(c) * a; }
case 2u: { g = c.x * a; }
case 3u: { g = c.y * a; }
case 4u: { g = c.z * a; }
default: { g = a; }
}
if (inv) {
g = 1.0 - g;
}
return vec4<f32>(g, g, g, 1.0);
}
// channel2::arith.
fn fxk_arith(op: u32, a: f32, b: f32) -> f32 {
switch op {
case 0u: { return b; }
case 1u: { return a + b; }
case 2u: { return a - b; }
case 3u: { return a * b; }
case 4u: { return abs(a - b); }
case 5u: { return f32(fxk_q(a) & fxk_q(b)) / 255.0; }
case 6u: { return f32(fxk_q(a) | fxk_q(b)) / 255.0; }
case 7u: { return f32(fxk_q(a) ^ fxk_q(b)) / 255.0; }
case 8u, 11u: { return max(a, b); }
case 9u, 10u: { return min(a, b); }
case 12u: { return a + b - a * b; }
case 13u: {
if (a < 0.5) {
return 2.0 * a * b;
}
return 1.0 - 2.0 * (1.0 - a) * (1.0 - b);
}
default: {
if (b < 0.5) {
return 2.0 * a * b;
}
return 1.0 - 2.0 * (1.0 - a) * (1.0 - b);
}
}
}
// channel2::overflow.
fn fxk_overflow(op: u32, v: f32, how: u32) -> f32 {
if (how == 0u) {
return clamp(v, 0.0, 1.0);
}
if (how == 1u) {
let m = 1.0001;
let r = v - m * floor(v / m);
return min(select(r, 0.0, r >= m || r < 0.0), 1.0);
}
if (op == 1u) {
return v * 0.5;
}
if (op == 2u) {
return (v + 1.0) * 0.5;
}
return clamp(v, 0.0, 1.0);
}
// Per-pixel keying / matte / channel operations. u[0].x = op (see src/fx_key.rs for each
// effect's parameter layout):
// 1 Color Key matte 2 Luma Key matte 3 Color Range matte 4 Extract matte
// 5 apply a matte (aux.x; u[0].y = 0 final, 2 matte view, 3 Difference Matte's matte view,
// 4 Difference Matte's output)
// 6 Difference Matte matte (src and aux blurred)
// 7 Spill Suppressor 8 Advanced Spill Suppressor (aux = 1×1 excess sums when u[1].w)
// 9 Color Difference Key 10 Unmult 11 route channels (u[1] = sources)
// 12 Remove Color Matting 13 Arithmetic 14 Solid Composite 15 Set Matte
// 16 Channel Combiner 17 Blend 18 Calculations 19 Compound Arithmetic
// 20 Set Channels: channel u[0].y of the value image from aux; 21 Set Channels: premultiply
// 22 Screen Key matte 23 Screen Key output 24 alpha plane 25 Key Cleaner output
// 26 Matte Choker ramp 27 util::set_alpha (aux.x = alpha, data = fill)
// 28 matte view (alpha as opaque grey)
// Refine Soft / Hard Matte: 29 guide pack (luminance, alpha, products); 30 guided-filter
// coefficients from the box means (f[0].x = eps); 31 refined alpha (src = boxed coefficients,
// aux = pack, data = edge band); 32 edge band (src.y − aux.y > 1e-3); 33 choke / contrast /
// invert; 34 View Edge Region; 35 decontamination (aux.x = refined alpha, data = colour estimate)
@compute @workgroup_size(16, 16)
fn fxk_point(@builtin(global_invocation_id) gid: vec3<u32>) {
let dims = out_dims();
let p = vec2<i32>(gid.xy);
if (p.x >= dims.x || p.y >= dims.y) {
return;
}
let px = textureLoad(src, p, 0);
let c = fxk_straight(px);
let a = max(px.w, 0.0);
let u0 = P.u[0];
let u1 = P.u[1];
let f0 = P.f[0];
var o = px;
switch u0.x {
case 1u: {
let k = f0.xyz;
let d = max(max(abs(c.x - k.x), abs(c.y - k.y)), abs(c.z - k.z));
o = vec4<f32>(select(1.0, 0.0, d <= f0.w));
}
case 2u: {
let l = fxk_key_luma(c);
let thr = f0.x;
let tol = f0.y;
var m: f32;
// As effects::keying::luma_key: Brighter / Darker cut hard at the threshold
// (Tolerance only shapes Similar / Dissimilar), as After Effects.
switch u0.y {
case 0u: { m = select(1.0, 0.0, l > thr); }
case 2u: { m = select(1.0, 0.0, abs(l - thr) <= tol); }
case 3u: { m = select(0.0, 1.0, abs(l - thr) <= tol); }
default: { m = select(1.0, 0.0, l < thr); }
}
o = vec4<f32>(m);
}
case 3u: {
let v = fxk_range_components(u0.y, c);
var out_d = 0.0;
for (var i = 0u; i < 3u; i++) {
out_d = max(max(out_d, P.f[0][i] - v[i]), v[i] - P.f[1][i]);
}
let fuzz = P.f[2].x;
var m = 1.0;
if (out_d <= 0.0) {
m = 0.0;
} else if (fuzz > 0.0) {
m = clamp(out_d / fuzz, 0.0, 1.0);
}
o = vec4<f32>(m);
}
case 4u: {
var v: f32;
switch u0.y {
case 1u: { v = c.x; }
case 2u: { v = c.y; }
case 3u: { v = c.z; }
case 4u: { v = a; }
default: { v = fxk_key_luma(c); }
}
v = 255.0 * v;
let bp = f0.x;
let wp = f0.y;
let bs = f0.z;
let ws = f0.w;
var k = 1.0;
if (v < bp) {
k = select(0.0, clamp(1.0 - (bp - v) / bs, 0.0, 1.0), bs > 0.0);
} else if (v > wp) {
k = select(0.0, clamp(1.0 - (v - wp) / ws, 0.0, 1.0), ws > 0.0);
}
if (u0.z != 0u) {
k = 1.0 - k;
}
o = vec4<f32>(k);
}
case 5u: {
let m = textureLoad(aux, p, 0).x;
switch u0.y {
case 2u: {
let k = clamp(m, 0.0, 1.0);
let v = px.w * k;
o = vec4<f32>(v, v, v, 1.0);
}
case 3u: {
let v = m * px.w;
o = vec4<f32>(v, v, v, px.w);
}
case 4u: { o = px * m; }
default: { o = px * clamp(m, 0.0, 1.0); }
}
}
case 6u: {
let q = textureLoad(aux, p, 0);
let oc = fxk_straight(q);
let oa = max(q.w, 0.0);
let d = max(max(max(abs(c.x - oc.x), abs(c.y - oc.y)), abs(c.z - oc.z)), abs(a - oa));
var m: f32;
if (d <= f0.x) {
m = 0.0;
} else if (f0.y <= 1e-6) {
m = 1.0;
} else {
m = clamp((d - f0.x) / f0.y, 0.0, 1.0);
}
o = vec4<f32>(m);
}
case 7u: {
if (px.w <= 0.0) {
textureStore(out, p, px);
return;
}
var s = px.xyz / px.w;
if (u0.y == 1u) {
let g = (s.x + s.y + s.z) / 3.0;
let dir = f0.xyz;
let proj = (s.x - g) * dir.x + (s.y - g) * dir.y + (s.z - g) * dir.z;
if (proj > 0.0) {
s = s - proj * dir * f0.w;
}
} else {
let spill = max(s[u1.x] - max(s[u1.y], s[u1.z]), 0.0);
s[u1.x] = s[u1.x] - spill * f0.w;
}
o = vec4<f32>(s * px.w, px.w);
}
case 8u: {
if (px.w <= 0.0) {
textureStore(out, p, px);
return;
}
var pi = u1.x;
var o1 = u1.y;
var o2 = u1.z;
if (u1.w != 0u) {
let ex = textureLoad(aux, vec2<i32>(0, 0), 0);
if (ex.y >= ex.x && ex.y >= ex.z) {
pi = 1u;
o1 = 0u;
o2 = 2u;
} else if (ex.z >= ex.x) {
pi = 2u;
o1 = 0u;
o2 = 1u;
} else {
pi = 0u;
o1 = 1u;
o2 = 2u;
}
}
var s = px.xyz / px.w;
let amt = f0.x;
let spill_range = f0.y;
let luma = f0.z;
let tol = f0.w;
let desat = P.f[1].x;
let neutral = P.f[1].y;
let key_hue = P.f[1].z;
var w = 1.0;
if (tol < 1.0) {
let h = rgb_to_hsl(s).x;
let d0 = abs(h - key_hue);
let d = min(d0, 1.0 - d0);
w = clamp(1.0 - d / max(tol * 0.5, 1e-4), 0.0, 1.0);
}
let mx = max(s[o1], s[o2]);
let avg = 0.5 * (s[o1] + s[o2]);
let lim = mx + (avg - mx) * spill_range;
let spill = max(s[pi] - lim, 0.0) * amt * w;
s[pi] = s[pi] - spill;
let lw = vec3<f32>(0.2126, 0.7152, 0.0722);
let back = spill * lw[pi] * luma + spill * neutral / 3.0;
s = s + back;
if (desat > 0.0 && spill > 0.0) {
let l = luminance(s);
let k = min(desat * min(spill * 4.0, 1.0), 1.0);
s = s + (vec3<f32>(l) - s) * k;
}
o = vec4<f32>(s * px.w, px.w);
}
case 9u: {
var cc = c;
if (u0.z != 0u) {
let cl = clamp(cc, vec3<f32>(0.0), vec3<f32>(1.0));
cc = vec3<f32>(srgb_to_linear(cl.x), srgb_to_linear(cl.y), srgb_to_linear(cl.z));
}
let pa = P.f[1];
let pb = P.f[3];
let ua = 1.0 - clamp((cc[u1.x] - cc[u1.y]) / f0.x, 0.0, 1.0);
let ub = 1.0 - clamp((cc[u1.x] - cc[u1.z]) / f0.y, 0.0, 1.0);
let ca = fxk_matte_levels(ua, pa.x, pa.y, pa.z, pa.w, P.f[2].x);
let cb = fxk_matte_levels(ub, pb.x, pb.y, pb.z, pb.w, P.f[2].y);
let um = max(ua, ub);
let cm = fxk_matte_levels(max(ca, cb), f0.z, f0.w, P.f[2].z, 0.0, 255.0);
var view = u0.y;
if (view == 8u) {
let right = p.x * 2 >= dims.x;
let bottom = p.y * 2 >= dims.y;
if (!right && !bottom) {
view = 2u;
} else if (right && !bottom) {
view = 4u;
} else if (!right && bottom) {
view = 6u;
} else {
view = 7u;
}
}
var g = -1.0;
switch view {
case 1u: { g = ua; }
case 2u: { g = ca; }
case 3u: { g = ub; }
case 4u: { g = cb; }
case 5u: { g = um; }
case 6u: { g = cm; }
default: {}
}
if (g >= 0.0) {
let m = g * a;
o = vec4<f32>(m, m, m, 1.0);
} else {
o = px * cm;
}
}
case 10u: {
let white = u0.y != 0u;
var d: f32;
var start: f32;
if (white) {
d = 1.0 - min(min(c.x, c.y), c.z);
start = 1.0 - f0.x;
} else {
d = max(max(c.x, c.y), c.z);
start = f0.x;
}
d = clamp(d, 0.0, 1.0);
let width = f0.y * (1.0 - start);
var m: f32;
if (width > 1e-6) {
m = clamp((d - start) / width, 0.0, 1.0);
} else {
m = select(0.0, 1.0, d > start);
}
if (m <= 1e-6) {
o = vec4<f32>(0.0);
} else {
let bg = select(0.0, 1.0, white);
var oc = c;
if (u0.z != 0u) {
oc = (c - bg * (1.0 - m)) / m;
}
if (u0.w != 0u) {
oc = clamp(oc, vec3<f32>(0.0), vec3<f32>(1.0));
}
o = fxk_premul(oc, a * m);
}
}
case 11u: {
let v = vec4<f32>(dst_pick(u1.x, c, a), dst_pick(u1.y, c, a), dst_pick(u1.z, c, a), dst_pick(u1.w, c, a));
o = fxk_premul(v.xyz, clamp(v.w, 0.0, 1.0));
}
case 12u: {
if (px.w <= 1e-6) {
o = vec4<f32>(0.0);
} else {
for (var i = 0; i < 3; i++) {
let s = px[i] / px.w;
var v = max(s - f0[i] * (1.0 - px.w), 0.0);
if (u0.y != 0u) {
v = min(v, px.w);
}
o[i] = v;
}
}
}
case 13u: {
if (px.w <= 0.0) {
textureStore(out, p, px);
return;
}
let s = fxk_div3(px.xyz, px.w);
var r = vec3<f32>(0.0);
for (var i = 0u; i < 3u; i++) {
let v = s[i];
let kv = f0[i];
let iv = fxk_q(v);
let ik = u32(round_away(kv * 255.0));
var x: f32;
switch u0.y {
case 0u: { x = f32(iv & ik) / 255.0; }
case 1u: { x = f32(iv | ik) / 255.0; }
case 2u: { x = f32(iv ^ ik) / 255.0; }
case 3u: { x = v + kv; }
case 4u: { x = v - kv; }
case 5u: { x = abs(v - kv); }
case 6u: { x = min(v, kv); }
case 7u: { x = max(v, kv); }
case 8u: { x = select(v, 0.0, v > kv); }
case 9u: { x = select(v, 0.0, v < kv); }
case 10u: { x = select(0.0, 1.0, v >= kv); }
case 11u: { x = v * kv; }
default: { x = 1.0 - (1.0 - v) * (1.0 - kv); }
}
if (u0.z != 0u) {
r[i] = clamp(x, 0.0, 1.0);
} else {
r[i] = max(x, 0.0);
}
}
o = vec4<f32>(r * px.w, px.w);
}
case 14u: {
var b = blend_pixel(u0.y, f0, px * P.f[1].x, 0.5);
b.w = clamp(b.w, 0.0, 1.0);
o = vec4<f32>(max(b.xyz, vec3<f32>(0.0)), b.w);
}
case 15u: {
var mc = c;
var ma = a;
if ((u0.z & 8u) == 0u) {
let q = textureLoad(aux, p, 0);
mc = fxk_straight(q);
ma = max(q.w, 0.0);
}
var m = dst_pick(u0.y, mc, ma);
if ((u0.z & 4u) != 0u) {
m = m * ma;
}
m = clamp(m, 0.0, 1.0);
let inv = (u0.z & 1u) != 0u;
if (inv) {
m = 1.0 - m;
}
let own_m = (u0.z & 8u) != 0u;
let is_alpha = (u0.z & 16u) != 0u;
var na = m;
if ((u0.z & 2u) != 0u && (!own_m || !is_alpha || inv)) {
na = a * m;
}
o = fxk_premul(c, clamp(na, 0.0, 1.0));
}
case 16u: {
let ch_from = u0.y;
let ch_to = u0.z;
let inv = (u0.w & 1u) != 0u;
let solid = (u0.w & 2u) != 0u;
let second = (u0.w & 4u) != 0u;
var sc = c;
var sa = a;
if (second) {
let q = textureLoad(aux, p, 0);
sc = fxk_straight(q);
sa = max(q.w, 0.0);
}
if (sa <= 0.0 && ch_from != 7u && !second) {
if (solid) {
o = fxk_premul(c, 1.0);
}
textureStore(out, p, o);
return;
}
var na = a;
var r: vec3<f32>;
if (ch_from <= 3u) {
switch ch_from {
case 0u: {
let hsl = rgb_to_hsl(sc);
r = vec3<f32>(hsl.x, hsl.z, hsl.y);
}
case 1u: { r = hsl_to_rgb(sc.x, sc.z, sc.y); }
case 2u: {
let y = 0.299 * sc.x + 0.587 * sc.y + 0.114 * sc.z;
r = vec3<f32>(y, 0.492 * (sc.z - y) + 0.5, 0.877 * (sc.x - y) + 0.5);
}
default: {
let y = sc.x;
let uu = sc.y - 0.5;
let vv = sc.z - 0.5;
let rr = y + vv / 0.877;
let bb = y + uu / 0.492;
let gg = (y - 0.299 * rr - 0.114 * bb) / 0.587;
r = vec3<f32>(rr, gg, bb);
}
}
if (inv) {
r = 1.0 - r;
}
} else {
var v: f32;
switch ch_from {
case 4u: { v = sc.x; }
case 5u: { v = sc.y; }
case 6u: { v = sc.z; }
case 7u: { v = sa; }
case 8u: { v = rgb_to_hsl(sc).z; }
case 9u: { v = rgb_to_hsl(sc).x; }
case 10u: { v = rgb_to_hsl(sc).y; }
case 11u: { v = luminance(sc); }
case 12u: { v = max(max(sc.x, sc.y), sc.z); }
default: { v = min(min(sc.x, sc.y), sc.z); }
}
if (inv) {
v = 1.0 - v;
}
switch ch_to {
case 0u: { r = vec3<f32>(v, 0.0, 0.0); }
case 1u: { r = vec3<f32>(0.0, v, 0.0); }
case 2u: { r = vec3<f32>(0.0, 0.0, v); }
case 3u: {
na = clamp(v, 0.0, 1.0);
r = vec3<f32>(1.0);
}
case 5u: { r = hsl_to_rgb(v, 1.0, 0.5); }
case 6u: { r = hsl_to_rgb(0.0, clamp(v, 0.0, 1.0), 0.5); }
case 8u: {
let hsl = rgb_to_hsl(c);
r = hsl_to_rgb(hsl.x, clamp(hsl.y * v, 0.0, 1.0), hsl.z);
}
default: { r = vec3<f32>(v); }
}
}
if (solid) {
na = 1.0;
}
o = fxk_premul(max(r, vec3<f32>(0.0)), na);
}
case 17u: {
let q = textureLoad(aux, p, 0);
var bl: vec4<f32>;
switch u0.y {
case 0u: { bl = q; }
case 1u, 2u: {
let oa = q.w;
if (px.w <= 0.0 || oa <= 0.0) {
bl = px;
} else {
let hsl = rgb_to_hsl(c);
let ohsl = rgb_to_hsl(fxk_straight(q));
var h2 = ohsl.x;
var s2 = ohsl.y;
if (u0.y == 2u) {
if (hsl.y > 1e-4) {
s2 = hsl.y;
} else {
h2 = 0.0;
s2 = 0.0;
}
}
let rgb = hsl_to_rgb(h2, s2, hsl.z);
bl = px + (fxk_premul(rgb, a) - px) * oa;
}
}
case 3u: { bl = vec4<f32>(min(px.xyz, q.xyz), px.w); }
default: { bl = max(px, q); }
}
o = bl + (px - bl) * f0.x;
}
case 18u: {
let flags = u1.x;
var r = fxk_extract(px, u0.y, (flags & 1u) != 0u);
if ((flags & 8u) != 0u) {
let s = fxk_extract(textureLoad(aux, p, 0), u0.z, (flags & 2u) != 0u) * f0.x;
r = blend_pixel(u0.w, r, s, 0.5);
}
if ((flags & 4u) != 0u && r.w > 1e-6) {
r = fxk_premul(fxk_straight(r), px.w);
}
r.w = clamp(r.w, 0.0, 1.0);
o = r;
}
case 19u: {
let q = textureLoad(aux, p, 0);
let oc = fxk_straight(q);
let oa = max(q.w, 0.0);
var rc = c;
var ra = a;
if (u0.z != 2u) {
for (var i = 0u; i < 3u; i++) {
rc[i] = fxk_overflow(u0.y, fxk_arith(u0.y, c[i], oc[i]), u0.w);
}
}
if (u0.z != 0u) {
ra = fxk_overflow(u0.y, fxk_arith(u0.y, a, oa), u0.w);
}
let res = fxk_premul(rc, ra);
o = res + (px - res) * f0.x;
}
case 20u: {
let q = textureLoad(aux, p, 0);
o = px;
o[u0.y] = dst_pick(u0.z, fxk_straight(q), max(q.w, 0.0));
}
case 21u: {
o = fxk_premul(px.xyz, clamp(px.w, 0.0, 1.0));
}
case 22u: {
let d = c[u1.x] - fxk_secondary(c, u1.y, u1.z, f0.z);
let t = clamp(d / f0.x * f0.y, 0.0, 1.0);
o = vec4<f32>(clamp((1.0 - t - f0.w) / max(P.f[1].x - f0.w, 1e-3), 0.0, 1.0));
}
case 23u: {
let k = clamp(textureLoad(aux, p, 0).x, 0.0, 1.0);
let alpha = a * k;
if (u0.y == 1u) {
o = vec4<f32>(alpha, alpha, alpha, 1.0);
} else if (u0.y == 2u) {
var v = 0.5;
if (alpha <= 1e-3) {
v = 0.0;
} else if (alpha >= 0.999) {
v = 1.0;
}
o = vec4<f32>(v, v, v, 1.0);
} else {
let screen = f0.xyz;
var fg = c;
if (!(u0.z != 0u || k <= 1e-4)) {
let s = 1.0 - k;
for (var i = 0; i < 3; i++) {
fg[i] = min(max(c[i] - s * screen[i], 0.0) / k, max(c[i], 1.0));
}
}
let spill = max(fg[u1.x] - fxk_secondary(fg, u1.y, u1.z, f0.w), 0.0);
fg[u1.x] = fg[u1.x] - spill * P.f[1].x;
o = fxk_premul(fg, alpha);
}
}
case 24u: {
o = vec4<f32>(px.w);
}
case 25u: {
var na = textureLoad(aux, p, 0).x;
if (u0.y != 0u) {
na = clamp((na - 0.5) * 1.5 + 0.5, 0.0, 1.0);
}
var cc = c;
let a0 = a;
if (P.u[3].y != 0u && a0 > 1e-4 && a0 < 0.999) {
let q = fxk_rows(p);
if (q.w > 1e-6) {
let ea = q.w;
if (ea > 1e-4) {
let t = f0.y * (1.0 - a0);
cc = cc + (q.xyz / ea - cc) * t;
}
}
}
na = clamp((na - 0.5) * f0.x + 0.5, 0.0, 1.0);
if (a0 <= 1e-6) {
na = 0.0;
}
o = fxk_premul(cc, na);
}
case 26u: {
o = vec4<f32>(clamp((px.x - f0.x) / f0.y + 0.5, 0.0, 1.0));
}
case 27u: {
let na = clamp(textureLoad(aux, p, 0).x, 0.0, 1.0);
var cc = c;
if (px.w <= 1e-4) {
cc = fxk_straight(fxk_rows(p));
}
o = fxk_premul(cc, na);
}
case 29u: {
let g = luminance(px.xyz);
o = vec4<f32>(g, px.w, g * px.w, g * g);
}
case 30u: {
let var_g = px.w - px.x * px.x;
let cov = px.z - px.x * px.y;
let ca = cov / (var_g + f0.x);
o = vec4<f32>(ca, px.y - ca * px.x, 0.0, 0.0);
}
case 31u: {
let q = textureLoad(aux, p, 0);
if (fxk_rows(p).x != 0.0) {
o = vec4<f32>(clamp(px.x * q.x + px.y, 0.0, 1.0));
} else {
o = vec4<f32>(q.y);
}
}
case 32u: {
o = vec4<f32>(select(0.0, 1.0, px.y - textureLoad(aux, p, 0).y > 1e-3));
}
case 33u: {
var v = px.x;
let choke = f0.x;
if (choke > 0.0) {
v = (v - choke) / (1.0 - choke);
} else if (choke < 0.0) {
v = v / (1.0 + choke);
}
if (abs(f0.y - 1.0) > 1e-6) {
v = (v - 0.5) * f0.y + 0.5;
}
v = clamp(v, 0.0, 1.0);
if (u0.y != 0u) {
v = 1.0 - v;
}
o = vec4<f32>(v);
}
case 34u: {
let v = px.x;
if (textureLoad(aux, p, 0).x != 0.0) {
o = vec4<f32>(0.5 + 0.5 * v, 0.5 * v, 0.5 * v, 1.0);
} else {
o = vec4<f32>(v, v, v, 1.0);
}
}
case 35u: {
let n = textureLoad(aux, p, 0).x;
let a0 = px.w;
var t = 0.0;
if (a0 > 1e-4 && a0 < 0.999) {
t = 1.0 - a0;
} else if (u0.w != 0u && n > 1e-4 && n < 0.999) {
t = 1.0 - n;
}
let strength = f0.x * t;
if (u0.y != 0u) {
let v = select(0.0, strength, u0.z != 0u);
o = vec4<f32>(v, v, v, 1.0);
} else if (P.u[3].y != 0u && strength > 0.0 && a0 > 1e-4) {
let q = fxk_rows(p);
if (q.w > 1e-4) {
let cc = c + (q.xyz / q.w - c) * strength;
o = fxk_premul(cc, a0);
}
}
}
case 28u: {
let v = clamp(px.w, 0.0, 1.0);
o = vec4<f32>(v, v, v, 1.0);
}
default: {}
}
textureStore(out, p, o);
}
// util::fit_layer: bilinear sample of the other layer (src) at the buffer coordinates in data
// (one per column, then one per row).
@compute @workgroup_size(16, 16)
fn fxk_fit(@builtin(global_invocation_id) gid: vec3<u32>) {
let dims = out_dims();
let p = vec2<i32>(gid.xy);
if (p.x >= dims.x || p.y >= dims.y) {
return;
}
let x = data[u32(p.x)];
let y = data[u32(dims.x) + u32(p.y)];
textureStore(out, p, sample_bilinear(src, x, y));
}
// Sum of 16×16 blocks; u[0].x = first pass: sum Advanced Spill Suppressor's per-channel excess
// of each primary over the other two (straight colour × alpha), else sum the values.
@compute @workgroup_size(16, 16)
fn fxk_reduce(@builtin(global_invocation_id) gid: vec3<u32>) {
let dims = out_dims();
let p = vec2<i32>(gid.xy);
if (p.x >= dims.x || p.y >= dims.y) {
return;
}
let sd = vec2<i32>(textureDimensions(src));
var acc = vec4<f32>(0.0);
for (var j = 0; j < 16; j++) {
for (var i = 0; i < 16; i++) {
let q = vec2<i32>(p.x * 16 + i, p.y * 16 + j);
if (q.x >= sd.x || q.y >= sd.y) {
continue;
}
let v = textureLoad(src, q, 0);
if (P.u[0].x != 0u) {
let c = fxk_straight(v);
let a = max(v.w, 0.0);
acc += vec4<f32>(
max(c.x - max(c.y, c.z), 0.0) * a,
max(c.y - max(c.x, c.z), 0.0) * a,
max(c.z - max(c.x, c.y), 0.0) * a,
0.0,
);
} else {
acc += v;
}
}
}
textureStore(out, p, acc);
}
No file is open. Choose one in the tree, or press Ctrl+O (⌘O on a Mac) to find one by name.
Syntax highlighting could not load. The unmodified read-only text remains available above.