665bfac0b339
fx_gen2.wgsl
// GPU effects, generators of part C: see src/fx_gen2.rs. Every entry point is prefixed `fg2_`.
// Geometry computed on the CPU (bolts, strokes, glyphs, audio marks, waves) arrives as item
// tables in `data` — tile offsets, item indices, items (as fx_sim's tiled raster) — and is
// rasterised here with the CPU's coverage functions; closed-form generators run per pixel.
fn fg2_inside(p: vec2<i32>) -> bool {
let d = out_dims();
return p.x < d.x && p.y < d.y;
}
// util::unpremul (colour 0 below alpha 1e-6).
fn fg2_unpremul(p: vec4<f32>) -> vec3<f32> {
if (p.w > 1e-6) {
return p.xyz / p.w;
}
return vec3<f32>(0.0);
}
// util::smoothstep.
fn fg2_smoothstep(e0: f32, e1: f32, x: f32) -> f32 {
if (abs(e1 - e0) < 1e-9) {
return select(1.0, 0.0, x < e0);
}
let t = clamp((x - e0) / (e1 - e0), 0.0, 1.0);
return t * t * (3.0 - 2.0 * t);
}
// Premultiplied "over": `s` on top of `d`.
fn fg2_over(d: vec4<f32>, s: vec4<f32>) -> vec4<f32> {
return s + d * (1.0 - s.w);
}
// The tile's item range: (first index slot, end slot).
fn fg2_tile(p: vec2<i32>, tiles_x: u32) -> vec2<u32> {
let tile = u32(p.y / 16) * tiles_x + u32(p.x / 16);
return vec2<u32>(u32(data[tile]), u32(data[tile + 1u]));
}
// Whether pixel `p` lies in the integer bounds stored at the end of item `at` (stride `stride`).
fn fg2_in_bounds(p: vec2<i32>, at: u32, stride: u32) -> bool {
let bb = at + stride - 4u;
return !(f32(p.x) < data[bb] || f32(p.y) < data[bb + 1u] || f32(p.x) > data[bb + 2u] || f32(p.y) > data[bb + 3u]);
}
// ---------------------------------------------------------------- segments (generate3::raster_segs)
// Items: (ax, ay, bx, by, radius, value, bounds). Up to four coverages per pixel (x, y, z, w),
// variant k with radius max(r · f[k].x + f[k].y, f[k].z) and hardness f[k].w, max-combined;
// bit k of u[1].x selects Advanced Lightning's linear core (clamp(r − d + 0.5, 0, 1)) instead.
// u[0] = (items at, stride, tiles x, variants).
@compute @workgroup_size(16, 16)
fn fg2_segs(@builtin(global_invocation_id) gid: vec3<u32>) {
let p = vec2<i32>(gid.xy);
if (!fg2_inside(p)) {
return;
}
let stride = P.u[0].y;
let nv = P.u[0].w;
let rg = fg2_tile(p, P.u[0].z);
let px = f32(p.x) + 0.5;
let py = f32(p.y) + 0.5;
var o = vec4<f32>(0.0);
for (var k = rg.x; k < rg.y; k++) {
let at = P.u[0].x + u32(data[k]) * stride;
if (!fg2_in_bounds(p, at, stride)) {
continue;
}
let ax = data[at];
let ay = data[at + 1u];
let dx = data[at + 2u] - ax;
let dy = data[at + 3u] - ay;
let r = data[at + 4u];
let v = data[at + 5u];
let l2 = dx * dx + dy * dy;
var t = 0.0;
if (l2 > 1e-12) {
t = clamp(((px - ax) * dx + (py - ay) * dy) / l2, 0.0, 1.0);
}
let ex = px - ax - dx * t;
let ey = py - ay - dy * t;
let d = sqrt(ex * ex + ey * ey);
for (var j = 0u; j < nv; j++) {
let vf = P.f[j];
let rk = max(r * vf.x + vf.y, vf.z);
var c = 0.0;
if (((P.u[1].x >> j) & 1u) != 0u) {
c = clamp(rk - d + 0.5, 0.0, 1.0) * v;
} else {
let inner = rk * clamp(vf.w, 0.0, 1.0) - 0.5;
let outer = rk + 0.5;
if (d >= outer) {
continue;
}
if (d <= inner) {
c = v;
} else {
c = (1.0 - fg2_smoothstep(inner, outer, d)) * v;
}
}
if (c > o[j]) {
o[j] = c;
}
}
}
textureStore(out, p, o);
}
// ---------------------------------------------------------------- convex polygons (generate3::raster_convex)
// Items: (vertex count, 16 vertex pairs, bounds); coverage = union, 4 × 4 samples per pixel.
// u[0] = (items at, stride, tiles x).
fn fg2_in_poly(at: u32, x: f32, y: f32) -> bool {
let n = u32(data[at]);
var sgn = 0.0;
for (var i = 0u; i < n; i++) {
let j = (i + 1u) % n;
let ax = data[at + 1u + 2u * i];
let ay = data[at + 2u + 2u * i];
let bx = data[at + 1u + 2u * j];
let by = data[at + 2u + 2u * j];
let c = (bx - ax) * (y - ay) - (by - ay) * (x - ax);
if (abs(c) < 1e-12) {
continue;
}
if (sgn == 0.0) {
sgn = sign(c);
} else if (sign(c) != sgn) {
return false;
}
}
return true;
}
@compute @workgroup_size(16, 16)
fn fg2_convex(@builtin(global_invocation_id) gid: vec3<u32>) {
let p = vec2<i32>(gid.xy);
if (!fg2_inside(p)) {
return;
}
let stride = P.u[0].y;
let rg = fg2_tile(p, P.u[0].z);
var o = 0.0;
for (var k = rg.x; k < rg.y; k++) {
let at = P.u[0].x + u32(data[k]) * stride;
if (!fg2_in_bounds(p, at, stride)) {
continue;
}
var hit = 0;
for (var sy = 0; sy < 4; sy++) {
for (var sx = 0; sx < 4; sx++) {
if (fg2_in_poly(at, f32(p.x) + (f32(sx) + 0.5) / 4.0, f32(p.y) + (f32(sy) + 0.5) / 4.0)) {
hit += 1;
}
}
}
o = max(o, f32(hit) / 16.0);
}
textureStore(out, p, vec4<f32>(o, 0.0, 0.0, 0.0));
}
// ---------------------------------------------------------------- painting
// generate3::paint (style 0 on the layer, 1 on transparency, 2 reveal) and Vegas' Composite
// Under (3). aux = coverage (x); u[0].x = style; f[0] = colour; f[1].x = opacity.
@compute @workgroup_size(16, 16)
fn fg2_paint(@builtin(global_invocation_id) gid: vec3<u32>) {
let p = vec2<i32>(gid.xy);
if (!fg2_inside(p)) {
return;
}
let px = textureLoad(src, p, 0);
let c = textureLoad(aux, p, 0).x;
let col = P.f[0];
var o: vec4<f32>;
if (P.u[0].x == 3u) {
let a = c * col.w;
o = fg2_over(vec4<f32>(col.xyz * a, a), px);
} else {
let a = clamp(c * P.f[1].x * col.w, 0.0, 1.0);
let s = vec4<f32>(col.xyz * a, a);
switch P.u[0].x {
case 1u: {
o = s;
}
case 2u: {
o = px * a;
}
default: {
o = fg2_over(px, s);
}
}
}
textureStore(out, p, o);
}
// generate3::draw_marks: aux = (core, halo); u[0].x = composite; f[0] = inside, f[1] = outside.
@compute @workgroup_size(16, 16)
fn fg2_marks(@builtin(global_invocation_id) gid: vec3<u32>) {
let p = vec2<i32>(gid.xy);
if (!fg2_inside(p)) {
return;
}
let cv = textureLoad(aux, p, 0);
let c = cv.x;
let a = max(c, cv.y);
var base = vec4<f32>(0.0);
if (P.u[0].x != 0u) {
base = textureLoad(src, p, 0);
}
if (a <= 0.0) {
textureStore(out, p, base);
return;
}
let t = c / a;
let col = P.f[1].xyz + (P.f[0].xyz - P.f[1].xyz) * t;
textureStore(out, p, fg2_over(base, vec4<f32>(col * a, a)));
}
// (src.x, aux.x) into (x, y), src.y into z: a coverage next to its blurred copy.
@compute @workgroup_size(16, 16)
fn fg2_pair(@builtin(global_invocation_id) gid: vec3<u32>) {
let p = vec2<i32>(gid.xy);
if (!fg2_inside(p)) {
return;
}
let s = textureLoad(src, p, 0);
textureStore(out, p, vec4<f32>(s.x, textureLoad(aux, p, 0).x, s.y, 0.0));
}
// textfx::lightning's composite: aux = (outer, glow, core); u[0].x = blending mode;
// f[0] = outside colour, f[1] = inside colour.
@compute @workgroup_size(16, 16)
fn fg2_bolt(@builtin(global_invocation_id) gid: vec3<u32>) {
let p = vec2<i32>(gid.xy);
if (!fg2_inside(p)) {
return;
}
let px = textureLoad(src, p, 0);
let m = textureLoad(aux, p, 0);
let o = max(m.x, m.y * 0.8);
let c = m.z;
let a = min(max(o, c), 1.0);
if (a <= 0.0) {
textureStore(out, p, px);
return;
}
let t = c / a;
let oc = P.f[0].xyz;
let colr = oc + (P.f[1].xyz - oc) * t;
var r: vec4<f32>;
switch P.u[0].x {
case 1u: {
r = vec4<f32>(px.xyz + colr * a, min(px.w + a * (1.0 - px.w), 1.0));
}
case 2u: {
let s = vec4<f32>(colr * a, a);
r = px + s - px * s;
}
default: {
r = fg2_over(px, vec4<f32>(colr * a, a));
}
}
textureStore(out, p, r);
}
// generate2::advanced_lightning's composite: aux = (core, blurred core); u[0] = (composite, glow);
// f[0] = (core opacity, glow opacity); f[1] = core colour, f[2] = glow colour.
@compute @workgroup_size(16, 16)
fn fg2_adv_bolt(@builtin(global_invocation_id) gid: vec3<u32>) {
let p = vec2<i32>(gid.xy);
if (!fg2_inside(p)) {
return;
}
let px = textureLoad(src, p, 0);
let m = textureLoad(aux, p, 0);
let cv = m.x * P.f[0].x;
var g = 0.0;
if (P.u[0].y != 0u) {
g = min(m.y * 3.0, 1.0);
}
let gv = g * P.f[0].y;
let l = P.f[1].xyz * cv + P.f[2].xyz * gv;
let la = min(max(cv, gv), 1.0);
if (P.u[0].x != 0u) {
let k = clamp(la, 0.0, 1.0);
textureStore(out, p, vec4<f32>(px.xyz + l, clamp(px.w + k * (1.0 - px.w), 0.0, 1.0)));
} else {
textureStore(out, p, vec4<f32>(l, la));
}
}
// textfx::text_px over the previous pass: aux = (fill, outer, inner) coverages.
// u[0] = (display, keep the layer, stroked, inner ring); f[0] = fill, f[1] = stroke colour;
// f[2].x = opacity.
fn fg2_tint(c: vec4<f32>, a0: f32) -> vec4<f32> {
let a = clamp(a0 * c.w, 0.0, 1.0);
return vec4<f32>(c.xyz * a, a);
}
@compute @workgroup_size(16, 16)
fn fg2_text(@builtin(global_invocation_id) gid: vec3<u32>) {
let p = vec2<i32>(gid.xy);
if (!fg2_inside(p)) {
return;
}
let cov = textureLoad(aux, p, 0);
let op = P.f[2].x;
let f = cov.x * op;
var ring = 0.0;
if (P.u[0].z != 0u) {
var inner = 0.0;
if (P.u[0].w != 0u) {
inner = cov.z;
}
ring = max(cov.y - inner, 0.0);
}
let s = ring * op;
var o = vec4<f32>(0.0);
if (P.u[0].y != 0u) {
o = textureLoad(src, p, 0);
}
let fill = fg2_tint(P.f[0], f);
let stroke = fg2_tint(P.f[1], s);
switch P.u[0].x {
case 1u: {
o = fg2_over(o, stroke);
}
case 2u: {
o = fg2_over(fg2_over(o, stroke), fill);
}
case 3u: {
o = fg2_over(fg2_over(o, fill), stroke);
}
default: {
o = fg2_over(o, fill);
}
}
textureStore(out, p, o);
}
// ---------------------------------------------------------------- Radio Waves (generate2::radio_waves)
// data: waves (stride 13: cx, cy, radius, half width, rotation, fade, colour rgba, opacity,
// outline offset, outline vertices), then outline vertices (x, y relative to the centre).
// aux = the contour's signed distance (x) when u[0].y. u[0] = (waves, contour, profile);
// f[0] = (anti-aliasing, anchor x, anchor y).
fn fg2_rw_profile(kind: u32, u0: f32) -> f32 {
let u = clamp(u0, -1.0, 1.0);
switch kind {
case 1u: {
return (1.0 - u) * 0.5;
}
case 2u: {
return (1.0 + u) * 0.5;
}
case 3u: {
return 1.0 - abs(u);
}
case 4u: {
return cos(u * 1.5707963267948966);
}
case 5u: {
if (u < 0.0) {
return 1.0 + u;
}
return 1.0;
}
case 6u: {
if (u > 0.0) {
return 1.0 - u;
}
return 1.0;
}
default: {
return 1.0;
}
}
}
// generate2::outline_dist.
fn fg2_outline_dist(off: u32, n: u32, dx: f32, dy: f32) -> f32 {
let r = sqrt(dx * dx + dy * dy);
if (r < 1e-9) {
var m = 3.0e38;
for (var k = 0u; k < n; k++) {
let x = data[off + 2u * k];
let y = data[off + 2u * k + 1u];
m = min(m, sqrt(x * x + y * y));
}
return m;
}
let dir = vec2<f32>(dx / r, dy / r);
var best = 3.0e38;
for (var k = 0u; k < n; k++) {
let j = (k + 1u) % n;
let p0 = vec2<f32>(data[off + 2u * k], data[off + 2u * k + 1u]);
let p1 = vec2<f32>(data[off + 2u * j], data[off + 2u * j + 1u]);
let e = p1 - p0;
let den = dir.x * e.y - dir.y * e.x;
if (abs(den) < 1e-12) {
continue;
}
let t = (p0.x * e.y - p0.y * e.x) / den;
let q = vec2<f32>(dir.x * t - p0.x, dir.y * t - p0.y);
let el2 = max(e.x * e.x + e.y * e.y, 1e-12);
let s = (q.x * e.x + q.y * e.y) / el2;
if (t <= 0.0 || s < -1e-5 || s > 1.0 + 1e-5) {
continue;
}
best = min(best, abs(r - t) * abs(den) / sqrt(el2));
}
return best;
}
// util::point_in_poly (even-odd).
fn fg2_point_in_poly(off: u32, n: u32, x: f32, y: f32) -> bool {
if (n < 3u) {
return false;
}
var inside = false;
var j = n - 1u;
for (var i = 0u; i < n; i++) {
let ax = data[off + 2u * i];
let ay = data[off + 2u * i + 1u];
let bx = data[off + 2u * j];
let by = data[off + 2u * j + 1u];
if ((ay > y) != (by > y) && x < (bx - ax) * (y - ay) / (by - ay) + ax) {
inside = !inside;
}
j = i;
}
return inside;
}
@compute @workgroup_size(16, 16)
fn fg2_radio(@builtin(global_invocation_id) gid: vec3<u32>) {
let p = vec2<i32>(gid.xy);
if (!fg2_inside(p)) {
return;
}
var o = textureLoad(src, p, 0);
let aa = P.f[0].x;
for (var w = 0u; w < P.u[0].x; w++) {
let at = w * 13u;
let dx = f32(p.x) + 0.5 - data[at];
let dy = f32(p.y) + 0.5 - data[at + 1u];
let radius = data[at + 2u];
let hw = data[at + 3u];
let n = u32(data[at + 12u]);
var d: f32;
if (P.u[0].y != 0u) {
let rot = data[at + 4u];
let s = sin(-rot);
let c = cos(-rot);
let rx = dx * c - dy * s;
let ry = dx * s + dy * c;
d = sample_bilinear_clamped(aux, P.f[0].y + rx, P.f[0].z + ry).x - radius;
} else if (n > 0u) {
let off = u32(data[at + 11u]);
let ud = fg2_outline_dist(off, n, dx, dy);
d = select(ud, -ud, fg2_point_in_poly(off, n, dx, dy));
} else {
d = sqrt(dx * dx + dy * dy) - radius;
}
let ad = abs(d);
let cov = clamp((hw - ad) / aa + 0.5, 0.0, 1.0);
if (cov <= 0.0) {
continue;
}
let u = clamp(d / hw, -1.0, 1.0);
let col = vec4<f32>(data[at + 6u], data[at + 7u], data[at + 8u], data[at + 9u]);
let a = cov * fg2_rw_profile(P.u[0].z, u) * data[at + 5u] * data[at + 10u] * col.w;
o = fg2_over(o, vec4<f32>(col.xyz * a, a));
}
textureStore(out, p, o);
}
// ---------------------------------------------------------------- Beam (generate2::beam)
// u[0] = (3D perspective, composite, length > 0); f[0] = (sx, sy, dx, dy); f[1] = (t0, t1,
// start thickness, end thickness); f[2] = (softness, |d|², ...); f[3] = inside, f[4] = outside.
@compute @workgroup_size(16, 16)
fn fg2_beam(@builtin(global_invocation_id) gid: vec3<u32>) {
let p = vec2<i32>(gid.xy);
if (!fg2_inside(p)) {
return;
}
let px = textureLoad(src, p, 0);
let s = P.f[0].xy;
let d = P.f[0].zw;
let t0 = P.f[1].x;
let t1 = P.f[1].y;
let soft = P.f[2].x;
let vx = f32(p.x) + 0.5 - s.x;
let vy = f32(p.y) + 0.5 - s.y;
let tc = clamp((vx * d.x + vy * d.y) / P.f[2].y, t0, t1);
let ex = vx - d.x * tc;
let ey = vy - d.y * tc;
let dist = sqrt(ex * ex + ey * ey);
var tk = tc;
if (!(P.u[0].x != 0u || t1 - t0 < 1e-9)) {
tk = (tc - t0) / (t1 - t0);
}
let hw = max((P.f[1].z + (P.f[1].w - P.f[1].z) * tk) * 0.5, 0.25);
let tt = dist / hw;
var a = 0.0;
if (P.u[0].z == 0u) {
a = 0.0;
} else if (soft > 1e-3) {
a = 1.0 - fg2_smoothstep(1.0 - soft, 1.0, tt);
} else {
a = clamp(hw - dist + 0.5, 0.0, 1.0);
}
let cc = P.f[3].xyz + (P.f[4].xyz - P.f[3].xyz) * fg2_smoothstep(0.0, 1.0, tt);
let g = vec4<f32>(cc * a, a);
if (P.u[0].y != 0u) {
textureStore(out, p, fg2_over(px, g));
} else {
textureStore(out, p, g);
}
}
// ---------------------------------------------------------------- Lens Flare (generate2::lens_flare)
// data: ghosts (t, r, colour rgb, k, ring); u[0] = ghosts; f[0] = (fx, fy, cx, cy);
// f[1] = (diagonal, core k, rays, halo r); f[2] = (brightness, blend).
@compute @workgroup_size(16, 16)
fn fg2_flare(@builtin(global_invocation_id) gid: vec3<u32>) {
let p = vec2<i32>(gid.xy);
if (!fg2_inside(p)) {
return;
}
let px = textureLoad(src, p, 0);
let f = P.f[0].xy;
let c = P.f[0].zw;
let diag = P.f[1].x;
let dx = f32(p.x) + 0.5 - f.x;
let dy = f32(p.y) + 0.5 - f.y;
let r = sqrt(dx * dx + dy * dy) / diag;
let th = atan2(dy, dx);
let ck = r / P.f[1].y;
let core = 1.5 * exp(-(ck * ck)) + 0.25 * exp(-r / 0.12);
let streak = powz(abs(cos(P.f[1].z * 0.5 * th)), 40.0) * exp(-r / 0.3) * 0.35;
let hk = (r - P.f[1].w) / 0.012;
let halo = exp(-(hk * hk)) * 0.12;
let base = core + streak;
var l = vec3<f32>(base, base * 0.95, base * 0.85);
l += vec3<f32>(halo * 0.6, halo * 0.8, halo);
for (var i = 0u; i < P.u[0].x; i++) {
let at = i * 7u;
let gt = data[at];
let gr = data[at + 1u];
let gx = f.x + (c.x - f.x) * gt;
let gy = f.y + (c.y - f.y) * gt;
let ex = f32(p.x) + 0.5 - gx;
let ey = f32(p.y) + 0.5 - gy;
let d = sqrt(ex * ex + ey * ey) / diag;
var v: f32;
if (data[at + 6u] != 0.0) {
let q = (d - gr) / (gr * 0.12);
v = exp(-(q * q));
} else {
v = fg2_smoothstep(gr, gr * 0.8, d);
}
l += vec3<f32>(data[at + 2u], data[at + 3u], data[at + 4u]) * data[at + 5u] * v;
}
l = l * P.f[2].x;
let la = min(max(max(l.x, l.y), l.z), 1.0);
let k = clamp(la, 0.0, 1.0);
let o = vec4<f32>(px.xyz + l, clamp(px.w + k * (1.0 - px.w), 0.0, 1.0));
textureStore(out, p, o + (px - o) * P.f[2].y);
}
// ---------------------------------------------------------------- CC Glue Gun (generate3::glue_gun)
// data: beads (x, y, radius); u[0] = (beads, glue only); f[0] = (light x, y, z, strength);
// f[1].x = strength weight (clamp(strength, 0, 1) max 0.3).
@compute @workgroup_size(16, 16)
fn fg2_glue(@builtin(global_invocation_id) gid: vec3<u32>) {
let p = vec2<i32>(gid.xy);
if (!fg2_inside(p)) {
return;
}
let px = textureLoad(src, p, 0);
let glue_only = P.u[0].y != 0u;
let fx = f32(p.x) + 0.5;
let fy = f32(p.y) + 0.5;
var best_h = 0.0;
var best_d = vec2<f32>(0.0);
var best_r = 1.0;
for (var i = 0u; i < P.u[0].x; i++) {
let r = data[i * 3u + 2u];
let dx = (fx - data[i * 3u]) / r;
let dy = (fy - data[i * 3u + 1u]) / r;
let d2 = dx * dx + dy * dy;
if (d2 < 1.0) {
let hgt = sqrt(1.0 - d2);
if (hgt > best_h) {
best_h = hgt;
best_d = vec2<f32>(dx, dy);
best_r = r;
}
}
}
if (best_h <= 0.0) {
textureStore(out, p, select(px, vec4<f32>(0.0), glue_only));
return;
}
let nrm = vec3<f32>(best_d, best_h);
let ndl = max(dot(nrm, P.f[0].xyz), 0.0);
let spec = powz(ndl, 24.0);
let strength = P.f[0].w;
let s = sample_bilinear_clamped(src, fx - nrm.x * best_r * 0.5 * strength, fy - nrm.y * best_r * 0.5 * strength);
let edge = fg2_smoothstep(0.0, 0.15, best_h);
let shade = 0.65 + 0.35 * ndl;
let g = vec4<f32>(s.xyz * shade + vec3<f32>(spec), max(s.w, 0.6));
let gp = vec4<f32>(min(g.xyz, vec3<f32>(g.w + spec)), min(g.w, 1.0));
var base = px;
if (glue_only) {
base = vec4<f32>(0.0);
}
var o = base + (gp - base) * (edge * P.f[1].x);
o.w = clamp(o.w, 0.0, 1.0);
textureStore(out, p, o);
}
// ---------------------------------------------------------------- CC Threads (generate3::threads)
// u[0] = (overlaps); f[0] = (cx, cy, sin, cos); f[1] = (thread width, height, coverage,
// shadowing); f[2].x = texture.
@compute @workgroup_size(16, 16)
fn fg2_threads(@builtin(global_invocation_id) gid: vec3<u32>) {
let p = vec2<i32>(gid.xy);
if (!fg2_inside(p)) {
return;
}
let c = P.f[0].xy;
let sn = P.f[0].z;
let cs = P.f[0].w;
let tw = P.f[1].x;
let th = P.f[1].y;
let coverage = P.f[1].z;
let shadow = P.f[1].w;
let tex_amt = P.f[2].x;
let overlaps = i32(P.u[0].x);
let dx = f32(p.x) + 0.5 - c.x;
let dy = f32(p.y) + 0.5 - c.y;
let u = dx * cs + dy * sn;
let v = -dx * sn + dy * cs;
let ci = i32(floor(u / tw));
let cj = i32(floor(v / th));
let fu = u / tw - f32(ci);
let fv = v / th - f32(cj);
let in_h = abs(fv - 0.5) < coverage * 0.5;
let in_v = abs(fu - 0.5) < coverage * 0.5;
let h_top = imod(ci + cj, 2 * overlaps) < overlaps;
var horizontal: bool;
if (in_h && in_v) {
horizontal = h_top;
} else if (in_h) {
horizontal = true;
} else if (in_v) {
horizontal = false;
} else {
textureStore(out, p, vec4<f32>(0.0));
return;
}
var su = u;
var sv = (f32(cj) + 0.5) * th;
if (!horizontal) {
su = (f32(ci) + 0.5) * tw;
sv = v;
}
let s = sample_bilinear_clamped(src, c.x + su * cs - sv * sn, c.y + su * sn + sv * cs);
let half_cov = max(coverage * 0.5, 1e-6);
var across = (fu - 0.5) / half_cov;
var along = fv;
if (horizontal) {
across = (fv - 0.5) / half_cov;
along = fu;
}
let profile = sqrt(max(1.0 - across * across, 0.0));
let dive = 1.0 - abs(along - 0.5) * 2.0;
let under = select(1.0, 0.0, horizontal == h_top);
let shade = 1.0 - shadow * (1.0 - profile) * 0.8 - shadow * 0.25 * (1.0 - dive) * under;
var fib = 1.0;
if (tex_amt > 0.0) {
let seed = bitcast<u32>(ci) ^ (bitcast<u32>(cj) << 8u);
fib = 1.0 - tex_amt * 0.3 * hash_noise(u32(max(along * 64.0, 0.0)), u32(max(across * 8.0 + 8.0, 0.0)), seed);
}
let k = max(shade * fib, 0.0);
textureStore(out, p, vec4<f32>(s.xyz * k, s.w));
}
// ---------------------------------------------------------------- Paint Bucket / Eyedropper Fill (generate3)
// Paint Bucket's fill: aux = coverage (x); u[0] = (mode); f[0] = colour; f[1].x = opacity.
@compute @workgroup_size(16, 16)
fn fg2_bucket(@builtin(global_invocation_id) gid: vec3<u32>) {
let p = vec2<i32>(gid.xy);
if (!fg2_inside(p)) {
return;
}
let px = textureLoad(src, p, 0);
let c = textureLoad(aux, p, 0).x;
let col = P.f[0];
let mode = P.u[0].x;
let k = clamp(c * P.f[1].x * col.w, 0.0, 1.0);
if (k <= 0.0) {
textureStore(out, p, select(px, vec4<f32>(0.0), mode == 9u));
return;
}
let dc = fg2_unpremul(px);
let da = select(max(px.w, 0.0), px.w, px.w > 1e-6);
let fc = col.xyz;
var mixed = fc;
switch mode {
case 1u: {
mixed = dc + fc;
}
case 2u: {
mixed = dc * fc;
}
case 3u: {
mixed = vec3<f32>(1.0) - (vec3<f32>(1.0) - dc) * (vec3<f32>(1.0) - fc);
}
case 4u, 5u, 6u, 7u: {
let d = rgb_to_hsl(dc);
let f = rgb_to_hsl(fc);
switch mode {
case 4u: {
mixed = hsl_to_rgb(f.x, d.y, d.z);
}
case 5u: {
mixed = hsl_to_rgb(d.x, f.y, d.z);
}
case 6u: {
mixed = hsl_to_rgb(f.x, f.y, d.z);
}
default: {
mixed = hsl_to_rgb(d.x, d.y, f.z);
}
}
}
default: {}
}
var o: vec4<f32>;
switch mode {
case 8u: {
o = fg2_over(vec4<f32>(fc * k, k), px);
}
case 9u: {
o = vec4<f32>(fc * k, k);
}
case 0u: {
o = fg2_over(px, vec4<f32>(fc * k, k));
}
default: {
if (da <= 1e-6) {
o = px;
} else {
let c3 = dc + (mixed - dc) * k;
o = vec4<f32>(c3 * da, da);
}
}
}
textureStore(out, p, o);
}
// Paint Bucket's coverage from the region (x): u[0].x = 0 antialias (aux = the blurred region),
// 1 = view threshold, 2 = stroke ring (aux = the eroded region, src = the dilated one).
@compute @workgroup_size(16, 16)
fn fg2_bucket_cov(@builtin(global_invocation_id) gid: vec3<u32>) {
let p = vec2<i32>(gid.xy);
if (!fg2_inside(p)) {
return;
}
let a = textureLoad(src, p, 0).x;
let b = textureLoad(aux, p, 0).x;
switch P.u[0].x {
case 0u: {
// src = the region, aux = its blur.
textureStore(out, p, vec4<f32>(select(b, max(b, 0.5), a > 0.0), 0.0, 0.0, 0.0));
}
case 1u: {
textureStore(out, p, vec4<f32>(a, a, a, 1.0));
}
default: {
textureStore(out, p, vec4<f32>(max(a - b, 0.0), 0.0, 0.0, 0.0));
}
}
}
// Eyedropper Fill: u[0].x = keep alpha; f[0] = fill (straight, alpha); f[1].x = blend.
@compute @workgroup_size(16, 16)
fn fg2_eyedropper(@builtin(global_invocation_id) gid: vec3<u32>) {
let p = vec2<i32>(gid.xy);
if (!fg2_inside(p)) {
return;
}
let px = textureLoad(src, p, 0);
let a = select(P.f[0].w, px.w, P.u[0].x != 0u);
let f = vec4<f32>(P.f[0].xyz * a, a);
textureStore(out, p, f + (px - f) * P.f[1].x);
}
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.