5a24289898fd
mask.wgsl
// Mask evaluation (`lightcraft_pipeline::masks`): one component shape → `c`, then combined into
// the mask's alpha plane. Bindings: img (rgb, pre-exposure), log_l, aux (shape data), c, alpha.
// Position of output pixel (x, y) in long-edge units: P[4..10] = affine (a, b, c, d, e, f).
fn pos(x: u32, y: u32) -> vec2<f32> {
let px = f32(x) + 0.5;
let py = f32(y) + 0.5;
return vec2<f32>(pf(4u) * px + pf(6u) * py + pf(8u), pf(5u) * px + pf(7u) * py + pf(9u));
}
// P: w, h, kind, invert, affine[6], then per kind:
// 0 linear: a.xy, d.xy, |d|² 1 radial: centre.xy, cos, sin, rx, ry, feather, invert
// 2 luminance range: lo, hi, lo feather, hi feather, ev
// 3 colour range: tol, gain, sample count (OkLab triples in aux)
// 4 brush: stroke count (stroke records + dabs in aux)
// `masks::chromaticity` of pixel i.
fn chroma_at(i: u32) -> vec3<f32> {
let c = vec3<f32>(img[3u * i], img[3u * i + 1u], img[3u * i + 2u]);
return c / max(lum2020(c), 1e-6);
}
// `masks::auto_similarity`.
fn auto_similarity(l: f32, ch: vec3<f32>, rl: f32, rch: vec3<f32>) -> f32 {
let dl = (l - rl) / AUTO_TOL_EV;
let dc = length(ch - rch) / AUTO_TOL_CHROMA;
return 1.0 - sstep(0.5, 1.0, sqrt(dl * dl + dc * dc));
}
@compute @workgroup_size(16, 16)
fn shape(@builtin(global_invocation_id) g: vec3<u32>) {
let w = pu(0u);
let h = pu(1u);
if (g.x >= w || g.y >= h) {
return;
}
let i = g.y * w + g.x;
let kind = pu(2u);
var v = 0.0;
if (kind == 0u) {
let p = pos(g.x, g.y);
let a = vec2<f32>(pf(10u), pf(11u));
let d = vec2<f32>(pf(12u), pf(13u));
let t = dot(p - a, d) / pf(14u);
v = 1.0 - sstep(0.0, 1.0, t);
} else if (kind == 1u) {
let p = pos(g.x, g.y);
let d = p - vec2<f32>(pf(10u), pf(11u));
let co = pf(12u);
let s = pf(13u);
let x = d.x * co - d.y * s;
let y = d.x * s + d.y * co;
let qx = x / pf(14u);
let qy = y / pf(15u);
let r = sqrt(qx * qx + qy * qy);
let f = pf(16u);
v = 1.0 - sstep(1.0 - max(f, 0.01), 1.0, r);
if (pu(17u) != 0u) {
v = 1.0 - v;
}
} else if (kind == 2u) {
let lo = pf(10u);
let hi = pf(11u);
let y = clamp((log_l[i] + pf(14u) + 8.0) / 12.0, 0.0, 1.0);
v = sstep(lo - pf(12u), lo, y) * (1.0 - sstep(hi, hi + pf(13u), y));
} else if (kind == 3u) {
let tol = pf(10u);
let gain = pf(11u);
let c = vec3<f32>(img[3u * i], img[3u * i + 1u], img[3u * i + 2u]) * gain;
let lab = oklab(c / (1.0 + c));
var best = 3.402823e38;
for (var k = 0u; k < pu(12u); k++) {
let s = vec3<f32>(aux[3u * k], aux[3u * k + 1u], aux[3u * k + 2u]);
let da = lab.y - s.y;
let db = lab.z - s.z;
let dl = lab.x - s.x;
best = min(best, sqrt(da * da + db * db + 0.25 * (dl * dl)));
}
v = 1.0 - sstep(tol * 0.5, tol, best);
} else if (kind == 4u) {
// stroke record: dab offset, dab count, r, hard, flow, density, erase, bbox x0 y0 x1 y1, auto
let px = f32(g.x) + 0.5;
let py = f32(g.y) + 0.5;
let lp = log_l[i];
let chp = chroma_at(i);
for (var k = 0u; k < pu(10u); k++) {
let o = 12u * k;
let auto_mask = aux[o + 11u] != 0.0;
if (px < aux[o + 7u] || py < aux[o + 8u] || px > aux[o + 9u] || py > aux[o + 10u]) {
continue;
}
let off = u32(aux[o]);
let cnt = u32(aux[o + 1u]);
let r = aux[o + 2u];
let hard = aux[o + 3u];
let flow = aux[o + 4u];
var keep = 1.0;
for (var j = 0u; j < cnt; j++) {
let dx = px - aux[off + 2u * j];
let dy = py - aux[off + 2u * j + 1u];
let dd = sqrt(dx * dx + dy * dy);
if (dd > r) {
continue;
}
var a = 1.0;
if (dd > hard) {
a = 1.0 - sstep(hard, r, dd);
}
if (auto_mask) {
let rx = min(u32(max(floor(aux[off + 2u * j]), 0.0)), w - 1u);
let ry = min(u32(max(floor(aux[off + 2u * j + 1u]), 0.0)), h - 1u);
let ri = ry * w + rx;
a *= auto_similarity(lp, chp, log_l[ri], chroma_at(ri));
}
keep *= 1.0 - a * flow;
}
let sa = min(1.0 - keep, aux[o + 5u]);
if (aux[o + 6u] != 0.0) {
v = v * (1.0 - sa);
} else {
v = max(v, sa);
}
}
}
if (pu(3u) != 0u) {
v = 1.0 - v;
}
c[i] = v;
}
// Combine `c` into mask plane P[2]: P[3] = 0 copy, 1 add (max), 2 subtract, 3 intersect.
@compute @workgroup_size(256)
fn combine(@builtin(global_invocation_id) g: vec3<u32>, @builtin(num_workgroups) nw: vec3<u32>) {
let i = lin_index(g, nw);
let n = pu(0u);
if (i >= n) {
return;
}
let j = pu(2u) * n + i;
let op = pu(3u);
let a = alpha[j];
let v = c[i];
if (op == 0u) {
alpha[j] = v;
} else if (op == 1u) {
alpha[j] = max(a, v);
} else if (op == 2u) {
alpha[j] = a * (1.0 - v);
} else {
alpha[j] = a * v;
}
}
// Finish mask plane P[2]: P[3] = invert, P[4] = amount (applied when ≠ 1).
@compute @workgroup_size(256)
fn finalize(@builtin(global_invocation_id) g: vec3<u32>, @builtin(num_workgroups) nw: vec3<u32>) {
let i = lin_index(g, nw);
let n = pu(0u);
if (i >= n) {
return;
}
let j = pu(2u) * n + i;
var a = alpha[j];
if (pu(3u) != 0u) {
a = 1.0 - a;
}
let amt = pf(4u);
if (abs(amt - 1.0) > 1e-6) {
a = a * amt;
}
alpha[j] = a;
}
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.