665bfac0b339
fx_pixel2.wgsl
// GPU effects, pixel ports (part C): see src/fx_pixel2.rs. Every entry point is prefixed
// `fp2_` and mirrors the CPU effect operation for operation; positions are pixel centres
// relative to the effect's centre or anchor so f32 keeps its precision.
fn fp2_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 fp2_unpremul(p: vec4<f32>) -> vec3<f32> {
if (p.w > 1e-6) {
return p.xyz / p.w;
}
return vec3<f32>(0.0);
}
// util::smoothstep.
fn fp2_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);
}
// ---------------------------------------------------------------- CC Cross Blur (blur2::cross_blur)
// src = horizontal blur, aux = vertical blur; u[0].x = transfer mode.
@compute @workgroup_size(16, 16)
fn fp2_cross(@builtin(global_invocation_id) gid: vec3<u32>) {
let p = vec2<i32>(gid.xy);
if (!fp2_inside(p)) {
return;
}
let a = textureLoad(src, p, 0);
let v = textureLoad(aux, p, 0);
var o: vec4<f32>;
switch P.u[0].x {
case 1u: {
o = a + v;
}
case 2u: {
o = a + v - a * v;
}
case 3u: {
o = max(a, v);
}
default: {
o = (a + v) * 0.5;
}
}
o.w = clamp(o.w, 0.0, 1.0);
textureStore(out, p, o);
}
// ---------------------------------------------------------------- CC Radial Blur (blur3::cc_radial_blur)
// u[0].x = type; f[0] = (cx, cy, zoom, arc); f[1].x = quality.
@compute @workgroup_size(16, 16)
fn fp2_radial(@builtin(global_invocation_id) gid: vec3<u32>) {
let p = vec2<i32>(gid.xy);
if (!fp2_inside(p)) {
return;
}
let kind = P.u[0].x;
let c = P.f[0].xy;
let zoom = P.f[0].z;
let arc = P.f[0].w;
let dx = f32(p.x) + 0.5 - c.x;
let dy = f32(p.y) + 0.5 - c.y;
let r = sqrt(dx * dx + dy * dy);
var span = r * abs(zoom);
if (kind >= 3u) {
span = r * abs(arc);
}
let n = u32(clamp(ceil(span * P.f[1].x / 50.0), 1.0, 256.0));
if (n <= 1u) {
textureStore(out, p, textureLoad(src, p, 0));
return;
}
var acc = vec4<f32>(0.0);
var wsum = 0.0;
for (var i = 0u; i < n; i++) {
let t = f32(i) / f32(n - 1u);
var s = vec2<f32>(0.0);
var w = 1.0;
switch kind {
case 0u: {
let k = 1.0 - zoom * t;
s = vec2<f32>(c.x + dx * k, c.y + dy * k);
}
case 1u: {
let k = 1.0 - zoom * t;
s = vec2<f32>(c.x + dx * k, c.y + dy * k);
w = (1.0 - t) + 0.05;
}
case 2u: {
let k = 1.0 + zoom * (t - 0.5);
s = vec2<f32>(c.x + dx * k, c.y + dy * k);
}
default: {
let a = arc * (t - 0.5);
let sn = sin(a);
let co = cos(a);
if (kind == 4u) {
w = (1.0 - abs(2.0 * t - 1.0)) + 0.05;
}
s = vec2<f32>(c.x + dx * co - dy * sn, c.y + dx * sn + dy * co);
}
}
acc += sample_bilinear(src, s.x, s.y) * w;
wsum += w;
}
textureStore(out, p, acc / wsum);
}
// ---------------------------------------------------------------- util::gauss_plane
// One box pass (edges repeated) summing each window directly: the CPU's planes accumulate
// in f64, so a running f32 sum would lose the small values (normalised blurs divide them).
// u[0] = (radius, vertical).
@compute @workgroup_size(16, 16)
fn fp2_box(@builtin(global_invocation_id) gid: vec3<u32>) {
let p = vec2<i32>(gid.xy);
if (!fp2_inside(p)) {
return;
}
let r = i32(P.u[0].x);
var acc = vec4<f32>(0.0);
for (var i = -r; i <= r; i++) {
if (P.u[0].y != 0u) {
acc += tex_get_clamped(src, p.x, p.y + i);
} else {
acc += tex_get_clamped(src, p.x + i, p.y);
}
}
textureStore(out, p, acc * (1.0 / f32(2 * r + 1)));
}
// ---------------------------------------------------------------- planes
// One value per pixel into x. u[0] = (kind, property): kind 0 = luminance of the premultiplied
// pixel (blur2::plum); 1 = CC Glass / Plastic height (stylize3::height_field: the property of
// the straight colour times alpha, alpha itself); 2 = CC Mr. Smoothie's flow property (straight);
// 3 = x clamped to [f[0].x, f[0].y] (CC Plastic's cut).
@compute @workgroup_size(16, 16)
fn fp2_plane(@builtin(global_invocation_id) gid: vec3<u32>) {
let p = vec2<i32>(gid.xy);
if (!fp2_inside(p)) {
return;
}
let px = textureLoad(src, p, 0);
let prop = P.u[0].y;
var v = 0.0;
if (P.u[0].x == 0u) {
v = luminance(px.xyz);
} else if (P.u[0].x == 3u) {
v = clamp(px.x, P.f[0].x, P.f[0].y);
} else {
let c = fp2_unpremul(px);
let a = px.w;
switch prop {
case 0u: {
v = c.x;
}
case 1u: {
v = c.y;
}
case 2u: {
v = c.z;
}
case 3u: {
v = a;
}
case 4u: {
v = luminance(c);
}
case 5u: {
v = rgb_to_hsl(c).z;
}
case 6u: {
v = rgb_to_hsl(c).x;
}
default: {
v = rgb_to_hsl(c).y;
}
}
if (P.u[0].x == 1u && prop != 3u) {
v = v * a;
}
}
textureStore(out, p, vec4<f32>(v, 0.0, 0.0, 0.0));
}
// ---------------------------------------------------------------- CC Vector Blur (blur2::vector_blur)
// aux = softened luminance map (x). u[0].x = type; f[0] = (amount, angle offset).
fn fp2_map(x: i32, y: i32) -> f32 {
return tex_get_clamped(aux, x, y).x;
}
@compute @workgroup_size(16, 16)
fn fp2_vector(@builtin(global_invocation_id) gid: vec3<u32>) {
let p = vec2<i32>(gid.xy);
if (!fp2_inside(p)) {
return;
}
let d = vec2<i32>(textureDimensions(aux));
let x = p.x;
let y = p.y;
let gx = (fp2_map(min(x + 1, d.x - 1), y) - fp2_map(max(x - 1, 0), y)) * 0.5;
let gy = (fp2_map(x, min(y + 1, d.y - 1)) - fp2_map(x, max(y - 1, 0))) * 0.5;
let mag = sqrt(gx * gx + gy * gy);
let m = fp2_map(x, y);
let kind = P.u[0].x;
let amount = P.f[0].x;
let off = P.f[0].y;
var ang = 0.0;
var len = amount;
if (kind <= 2u) {
if (mag < 1e-6) {
textureStore(out, p, textureLoad(src, p, 0));
return;
}
let g = atan2(gy, gx);
var base = g + 1.5707963267948966;
if (kind == 2u) {
base = g;
}
if (kind != 1u) {
len = amount * min(mag * 10.0, 1.0);
}
ang = base + off;
} else {
ang = m * 6.283185307179586 + off;
if (kind != 3u) {
len = amount * m;
}
}
if (len < 0.5) {
textureStore(out, p, textureLoad(src, p, 0));
return;
}
let dx = cos(ang) * len;
let dy = sin(ang) * len;
let n = u32(clamp(ceil(len * 2.0), 2.0, 48.0));
var acc = vec4<f32>(0.0);
for (var i = 0u; i < n; i++) {
let t = f32(i) / f32(n - 1u) - 0.5;
acc += sample_bilinear_clamped(src, f32(x) + 0.5 + dx * t, f32(y) + 0.5 + dy * t) / f32(n);
}
textureStore(out, p, acc);
}
// ---------------------------------------------------------------- per-pixel colour effects
// u[0].x = effect: 0 Cineon Converter, 1 HDR Compander, 2 HDR Highlight Compression,
// 3 CC Overbrights, 4 Color Link (alpha), 5 Color Link (blend), 6 CC Composite.
// utility::Cineon::log_to_lin; c = (offset, knee, white, gamma), r = (internal black, white).
// Version 1 takes the saved Gamma, where 1.7 gives linear output.
fn fp2_log_to_lin(v: f32, c: vec4<f32>, r: vec2<f32>, version_2: bool) -> f32 {
let code = v * 1023.0;
let exposure = pow(10.0, (code - c.z) * 0.002 / 0.6);
var lin: f32;
if (version_2) {
let root_offset = pow(c.x, 1.0 / max(c.w, 0.001));
lin = max((pow(exposure, 1.0 / max(c.w, 0.001)) - root_offset) / max(1.0 - root_offset, 1e-6), 0.0);
} else {
lin = powz(max((exposure - c.x) / max(1.0 - c.x, 1e-6), 0.0), 1.7 / max(c.w, 0.01));
}
let k = c.y;
if (k < 1.0 && lin > k) {
let w = 1.0 - k;
lin = k + w * (1.0 - exp(-(lin - k) / w));
}
return r.x + (r.y - r.x) * lin;
}
// utility::Cineon::lin_to_log.
fn fp2_lin_to_log(v: f32, c: vec4<f32>, r: vec2<f32>, version_2: bool) -> f32 {
let d = r.y - r.x;
var lin = (v - r.x) / select(d, 1e-6, abs(d) < 1e-6);
let k = c.y;
if (k < 1.0 && lin > k) {
let w = 1.0 - k;
lin = k - w * log(max(1.0 - (lin - k) / w, 1e-6));
}
var exposure: f32;
if (version_2) {
let root_offset = pow(c.x, 1.0 / max(c.w, 0.001));
exposure = powz(max(lin, 0.0) * (1.0 - root_offset) + root_offset, max(c.w, 0.001));
} else {
exposure = powz(max(lin, 0.0), max(c.w, 0.01) / 1.7) * (1.0 - c.x) + c.x;
}
let code = c.z + log(max(exposure, 1e-9)) * 0.4342944819032518 * 0.6 / 0.002;
return code / 1023.0;
}
// utility2::spow.
fn fp2_spow(v: f32, e: f32) -> f32 {
return sign(v) * powz(abs(v), e);
}
fn fp2_cineon(v: f32) -> f32 {
let c = P.f[0];
let r = P.f[1].xy;
let version_2 = P.u[0].z != 0u;
switch P.u[0].y {
case 0u: {
return fp2_lin_to_log(v, c, r, version_2);
}
case 1u: {
return fp2_log_to_lin(v, c, r, version_2);
}
default: {
if (version_2) {
// Default points keep the input code; custom points pass through Gamma 1 first.
var code = v;
if (c.x != P.f[2].x || c.z != 685.0 || r.x != 0.0 || r.y != 1.0) {
let unit = vec4<f32>(c.xyz, 1.0);
code = fp2_lin_to_log(fp2_log_to_lin(v, unit, r, true), P.f[2], vec2<f32>(0.0, 1.0), false);
}
return powz(max(code, 0.0), 1.0 / max(c.w, 0.001));
}
return fp2_lin_to_log(fp2_log_to_lin(v, c, r, false), P.f[2], vec2<f32>(0.0, 1.0), false);
}
}
}
@compute @workgroup_size(16, 16)
fn fp2_point(@builtin(global_invocation_id) gid: vec3<u32>) {
let p = vec2<i32>(gid.xy);
if (!fp2_inside(p)) {
return;
}
let px = textureLoad(src, p, 0);
var o = px;
switch P.u[0].x {
// f[0], f[1], f[2]: see fp2_cineon; u[0].y = conversion type, z = version 2.
case 0u: {
if (px.w > 0.0) {
let c = px.xyz / px.w;
o = vec4<f32>(vec3<f32>(fp2_cineon(c.x), fp2_cineon(c.y), fp2_cineon(c.z)) * px.w, px.w);
}
}
// u[0].y = expand; f[0] = (gain, gamma).
case 1u: {
if (px.w > 0.0) {
let c = fp2_unpremul(px);
let g = P.f[0].x;
let e = P.f[0].y;
var r = vec3<f32>(0.0);
if (P.u[0].y != 0u) {
r = vec3<f32>(fp2_spow(c.x, e), fp2_spow(c.y, e), fp2_spow(c.z, e)) * g;
} else {
r = vec3<f32>(fp2_spow(c.x / g, 1.0 / e), fp2_spow(c.y / g, 1.0 / e), fp2_spow(c.z / g, 1.0 / e));
}
o = vec4<f32>(r * px.w, px.w);
}
}
// utility::hdr_compress_pixel; f[0].x = blend t (Amount / 100).
case 2u: {
if (px.w > 0.0) {
let c = px.xyz / px.w;
let t = P.f[0].x;
let y = max(0.30 * c.x + 0.59 * c.y + 0.11 * c.z, 0.0);
let comp = min(c * (1.0 / (1.0 + y)), vec3<f32>(1.0));
let g = 0.4;
let mixed = vec3<f32>(
(1.0 - t) * fp2_spow(c.x, g) + t * fp2_spow(comp.x, g),
(1.0 - t) * fp2_spow(c.y, g) + t * fp2_spow(comp.y, g),
(1.0 - t) * fp2_spow(c.z, g) + t * fp2_spow(comp.z, g),
);
let r = vec3<f32>(fp2_spow(mixed.x, 1.0 / g), fp2_spow(mixed.y, 1.0 / g), fp2_spow(mixed.z, 1.0 / g));
o = vec4<f32>(r * px.w, px.w);
}
}
// u[0].y = channel; f[0] = highlight colour.
case 3u: {
if (px.w > 0.0) {
let c = fp2_unpremul(px);
var v = max(max(c.x, c.y), c.z);
switch P.u[0].y {
case 1u: {
v = c.x;
}
case 2u: {
v = c.y;
}
case 3u: {
v = c.z;
}
case 4u: {
v = px.w;
}
case 5u: {
v = luminance(c);
}
default: {}
}
var r = vec3<f32>(v * 0.35);
if (v > 1.0) {
r = P.f[0].xyz;
} else if (v < 0.0) {
r = vec3<f32>(1.0) - P.f[0].xyz;
}
o = vec4<f32>(r * px.w, px.w);
}
}
// f[0] = (sampled alpha, opacity); u[0].y = stencil.
case 4u: {
let c = fp2_unpremul(px);
let a0 = select(max(px.w, 0.0), px.w, px.w > 1e-6);
var na = a0 + (P.f[0].x - a0) * P.f[0].y;
if (P.u[0].y != 0u) {
na = min(na, a0);
}
let a = clamp(na, 0.0, 1.0);
o = vec4<f32>(c * a, a);
}
// f[0] = premultiplied sampled colour; u[0] = (stencil, mode).
case 5u: {
o = blend_pixel(P.u[0].z, px, P.f[0], 0.5);
o.w = clamp(o.w, 0.0, 1.0);
if (P.u[0].y != 0u) {
o = vec4<f32>(fp2_unpremul(o) * px.w, px.w);
}
}
// u[0] = (_, composite original, mode, rgb only); f[0].x = opacity.
default: {
var source = px;
if (P.u[1].x != 0u) { source = textureLoad(aux, p, 0); }
let orig = source * P.f[0].x;
if (P.u[0].y == 1u) {
o = blend_pixel(P.u[0].z, orig, px, 0.5);
} else {
o = blend_pixel(P.u[0].z, px, orig, 0.5);
}
o.w = clamp(o.w, 0.0, 1.0);
if (P.u[0].w != 0u) {
o = vec4<f32>(fp2_unpremul(o) * px.w, px.w);
}
}
}
textureStore(out, p, o);
}
// ---------------------------------------------------------------- CC Block Load (stylize3::block_load)
// Mean colour of every s×s block: one invocation per block (the CPU's summation order).
// u[0].x = s.
@compute @workgroup_size(16, 16)
fn fp2_block_means(@builtin(global_invocation_id) gid: vec3<u32>) {
let p = vec2<i32>(gid.xy);
if (!fp2_inside(p)) {
return;
}
let s = i32(P.u[0].x);
let d = vec2<i32>(textureDimensions(src));
var acc = vec4<f32>(0.0);
var n = 0.0;
for (var y = p.y * s; y < min((p.y + 1) * s, d.y); y++) {
for (var x = p.x * s; x < min((p.x + 1) * s, d.x); x++) {
acc += textureLoad(src, vec2<i32>(x, y), 0);
n += 1.0;
}
}
if (n > 0.0) {
acc = acc / n;
}
textureStore(out, p, acc);
}
// stylize3::block_at on grid `t` (block size `s`).
fn fp2_block_at(t: texture_2d<f32>, s: u32, x: i32, y: i32, bilinear: bool) -> vec4<f32> {
let g = vec2<i32>(textureDimensions(t));
if (!bilinear || s == 1u) {
return textureLoad(t, vec2<i32>(min(x / i32(s), g.x - 1), min(y / i32(s), g.y - 1)), 0);
}
let fx = (f32(x) + 0.5) / f32(s) - 0.5;
let fy = (f32(y) + 0.5) / f32(s) - 0.5;
let x0 = floor(fx);
let y0 = floor(fy);
let tx = fx - x0;
let ty = fy - y0;
let xa = clamp(i32(x0), 0, g.x - 1);
let xb = clamp(i32(x0 + 1.0), 0, g.x - 1);
let ya = clamp(i32(y0), 0, g.y - 1);
let yb = clamp(i32(y0 + 1.0), 0, g.y - 1);
let a = textureLoad(t, vec2<i32>(xa, ya), 0);
let b = textureLoad(t, vec2<i32>(xb, ya), 0);
let c = textureLoad(t, vec2<i32>(xa, yb), 0);
let e = textureLoad(t, vec2<i32>(xb, yb), 0);
let top = a + (b - a) * tx;
let bot = c + (e - c) * tx;
return top + (bot - top) * ty;
}
// src = the new level's grid, aux = the previous level's grid (or the new one).
// u[0] = (new block size, old block size, flags: 1 scanlines, 2 smoothing, 4 bilinear,
// 8 previous level exists, 16 start cleared); f[0] = (frac, rows of the new level).
@compute @workgroup_size(16, 16)
fn fp2_block_load(@builtin(global_invocation_id) gid: vec3<u32>) {
let p = vec2<i32>(gid.xy);
if (!fp2_inside(p)) {
return;
}
let s_new = P.u[0].x;
let flags = P.u[0].z;
let scan = (flags & 1u) != 0u;
let smoothing = (flags & 2u) != 0u;
let bilinear = (flags & 4u) != 0u;
let frac = P.f[0].x;
let soft = select(0.0, 1.5, smoothing);
var t = 0.0;
if (scan) {
let front = frac * (P.f[0].y + soft) - soft * 0.5;
let r = f32(p.y / i32(s_new)) + 0.5;
if (soft > 0.0) {
t = fp2_smoothstep(r - soft * 0.5, r + soft * 0.5, front);
} else if (r < front) {
t = 1.0;
}
} else if (smoothing) {
t = frac;
}
var n = vec4<f32>(0.0);
if (t > 0.0) {
n = fp2_block_at(src, s_new, p.x, p.y, bilinear);
}
var prev = vec4<f32>(0.0);
if ((flags & 8u) != 0u) {
prev = fp2_block_at(aux, P.u[0].y, p.x, p.y, bilinear);
} else if ((flags & 16u) == 0u) {
prev = fp2_block_at(src, s_new, p.x, p.y, bilinear);
}
var o = prev;
if (t >= 1.0) {
o = n;
} else if (t > 0.0) {
o = prev + (n - prev) * t;
}
textureStore(out, p, o);
}
// ---------------------------------------------------------------- CC Burn Film (stylize3::burn_film)
// u[0].x = seed + 17; f[0] = (cx, cy, diagonal, feature size); f[1] = (threshold, band).
@compute @workgroup_size(16, 16)
fn fp2_burn(@builtin(global_invocation_id) gid: vec3<u32>) {
let p = vec2<i32>(gid.xy);
if (!fp2_inside(p)) {
return;
}
let px = textureLoad(src, p, 0);
let fx = f32(p.x) + 0.5;
let fy = f32(p.y) + 0.5;
let dx = fx - P.f[0].x;
let dy = fy - P.f[0].y;
let d = sqrt(dx * dx + dy * dy) / P.f[0].z;
let n = fxs_fbm(fx / P.f[0].w, fy / P.f[0].w, 0.0, P.u[0].x, 4.0);
let f = n * 0.65 + (1.0 - min(d, 1.0)) * 0.35;
let th = P.f[1].x;
let band = P.f[1].y;
var o = px;
if (f > th + band) {
o = vec4<f32>(0.0);
} else if (f > th - band * 2.0) {
let c = fp2_unpremul(px);
let k = fp2_smoothstep(th - band * 2.0, th, f);
let hot = fp2_smoothstep(th, th + band, f);
let chr = 1.0 - k * 0.85;
var r = c * chr;
r = vec3<f32>(r.x + (1.0 - r.x) * hot * 0.9, r.y + (0.45 - r.y) * hot * 0.9, r.z * (1.0 - hot));
let na = px.w * (1.0 - hot * 0.6);
o = vec4<f32>(r * na, na);
}
textureStore(out, p, o);
}
// ---------------------------------------------------------------- CC Glass / CC Plastic (stylize3)
// aux = height field (x). u[0] = (glass, point light); f[0] = (height scale k, displacement,
// height != 0, light height); f[1] = (intensity, ambient, diffuse, specular);
// f[2] = (shininess, metal, light x, light y); f[3] = light colour; f[4] = distant direction.
fn fp2_h(x: i32, y: i32) -> f32 {
return tex_get_clamped(aux, x, y).x;
}
// stylize3::BumpLight::shade.
fn fp2_shade(c: vec3<f32>, n: vec3<f32>, l: vec3<f32>) -> vec3<f32> {
let intensity = P.f[1].x;
let ambient = P.f[1].y;
let diffuse = P.f[1].z;
let specular = P.f[1].w;
let ndl = max(dot(n, l), 0.0);
let flat_z = max(l.z, 0.0);
let base = ambient + diffuse * flat_z;
var lit = 1.0;
if (base > 1e-4) {
lit = (ambient + diffuse * ndl) / base;
}
lit = 1.0 + (lit - 1.0) * intensity;
let hv = vec3<f32>(l.x, l.y, l.z + 1.0);
let hl = max(sqrt(hv.x * hv.x + hv.y * hv.y + hv.z * hv.z), 1e-6);
let ndh = max((n.x * hv.x + n.y * hv.y + n.z * hv.z) / hl, 0.0);
let spec = specular * intensity * powz(ndh, P.f[2].x);
let lc = P.f[3].xyz;
let metal = P.f[2].y;
let hl_col = lc * (1.0 - metal) + c * lc * metal;
return c * lit * (vec3<f32>(1.0) + (lc - vec3<f32>(1.0)) * min(intensity, 1.0)) + spec * hl_col;
}
@compute @workgroup_size(16, 16)
fn fp2_bump(@builtin(global_invocation_id) gid: vec3<u32>) {
let p = vec2<i32>(gid.xy);
if (!fp2_inside(p)) {
return;
}
let px = textureLoad(src, p, 0);
let glass = P.u[0].x != 0u;
if (px.w <= 0.0) {
textureStore(out, p, select(px, vec4<f32>(0.0), glass));
return;
}
let k = P.f[0].x;
let gx = (fp2_h(p.x + 1, p.y) - fp2_h(p.x - 1, p.y)) * 0.5 * k;
let gy = (fp2_h(p.x, p.y + 1) - fp2_h(p.x, p.y - 1)) * 0.5 * k;
let ln = sqrt(gx * gx + gy * gy + 1.0);
let n = vec3<f32>(-gx / ln, -gy / ln, 1.0 / ln);
let fx = f32(p.x) + 0.5;
let fy = f32(p.y) + 0.5;
var l = P.f[4].xyz;
if (P.u[0].y != 0u) {
let v = vec3<f32>(P.f[2].z - fx, P.f[2].w - fy, max(P.f[0].w, 1.0));
let vl = max(sqrt(v.x * v.x + v.y * v.y + v.z * v.z), 1e-6);
l = v / vl;
}
var c = fp2_unpremul(px);
if (glass) {
let disp = P.f[0].y;
if (disp != 0.0 && P.f[0].z != 0.0) {
let s = sample_bilinear_clamped(src, fx + n.x * disp, fy + n.y * disp);
if (s.w > 0.0) {
c = fp2_unpremul(s);
}
}
}
let o = fp2_shade(c, n, l);
textureStore(out, p, vec4<f32>(o * px.w, px.w));
}
// ---------------------------------------------------------------- CC HexTile (stylize3::hextile)
// u[0].x = render mode; f[0] = (cx, cy, radius, smearing); f[1] = (sin, cos).
@compute @workgroup_size(16, 16)
fn fp2_hextile(@builtin(global_invocation_id) gid: vec3<u32>) {
let p = vec2<i32>(gid.xy);
if (!fp2_inside(p)) {
return;
}
// Cell membership and reflection were decided in the CPU effect's f64 geometry.
let i = (gid.y * u32(out_dims().x) + gid.x) * 2u;
textureStore(out, p, sample_bilinear_clamped(src, data[i], data[i + 1u]));
}
// ---------------------------------------------------------------- CC Mr. Smoothie (stylize3::smoothie)
// aux = flow plane (x). f[0] = (ax, ay, bx, by); f[1] = (phase, loops).
fn fp2_pal(i: f32) -> vec4<f32> {
let t = i / 255.0;
let a = P.f[0].xy;
let b = P.f[0].zw;
let s = sample_bilinear_clamped(src, a.x + (b.x - a.x) * t, a.y + (b.y - a.y) * t);
return vec4<f32>(fp2_unpremul(s), 1.0);
}
@compute @workgroup_size(16, 16)
fn fp2_smoothie(@builtin(global_invocation_id) gid: vec3<u32>) {
let p = vec2<i32>(gid.xy);
if (!fp2_inside(p)) {
return;
}
let px = textureLoad(src, p, 0);
if (px.w <= 0.0) {
textureStore(out, p, px);
return;
}
let v = textureLoad(aux, p, 0).x;
var t = fract_euclid(v * P.f[1].y + P.f[1].x);
if (t < 0.5) {
t = t * 2.0;
} else {
t = 2.0 - t * 2.0;
}
let f = t * 255.0;
let i = min(floor(f), 254.0);
let a = fp2_pal(i);
let b = fp2_pal(i + 1.0);
let c = a + (b - a) * (f - i);
textureStore(out, p, vec4<f32>(c.xyz * px.w, px.w));
}
// ---------------------------------------------------------------- Inner/Outer Key (keying2)
// T = (straight colour, trimap) from src = the layer and aux = the trimap (x).
@compute @workgroup_size(16, 16)
fn fp2_io_prep(@builtin(global_invocation_id) gid: vec3<u32>) {
let p = vec2<i32>(gid.xy);
if (!fp2_inside(p)) {
return;
}
textureStore(out, p, vec4<f32>(fp2_unpremul(textureLoad(src, p, 0)), textureLoad(aux, p, 0).x));
}
// A known region (u[0].x: 0 foreground, 1 background) of T: (colour × known, known).
@compute @workgroup_size(16, 16)
fn fp2_io_known(@builtin(global_invocation_id) gid: vec3<u32>) {
let p = vec2<i32>(gid.xy);
if (!fp2_inside(p)) {
return;
}
let t = textureLoad(src, p, 0);
var m = select(0.0, 1.0, t.w > 0.75);
if (P.u[0].x == 1u) {
m = select(0.0, 1.0, t.w < 0.25);
}
textureStore(out, p, vec4<f32>(t.xyz * m, m));
}
// src = blurred foreground, aux = blurred background, data = T's rows (row length u[0].x):
// the estimated matte with the decontaminated colours (colour, alpha).
@compute @workgroup_size(16, 16)
fn fp2_io_est(@builtin(global_invocation_id) gid: vec3<u32>) {
let p = vec2<i32>(gid.xy);
if (!fp2_inside(p)) {
return;
}
let at = (u32(p.y) * P.u[0].x + u32(p.x)) * 4u;
let c = vec3<f32>(data[at], data[at + 1u], data[at + 2u]);
let tri = data[at + 3u];
var a = tri;
if (!(tri > 0.25 && tri < 0.75)) {
textureStore(out, p, vec4<f32>(c, a));
return;
}
let fs = textureLoad(src, p, 0);
let bs = textureLoad(aux, p, 0);
let fc = fs.xyz / max(fs.w, 1e-6);
let bc = bs.xyz / max(bs.w, 1e-6);
let d = fc - bc;
let dd = d.x * d.x + d.y * d.y + d.z * d.z;
if (dd < 1e-6) {
a = 0.5;
} else {
a = clamp(((c.x - bc.x) * d.x + (c.y - bc.y) * d.y + (c.z - bc.z) * d.z) / dd, 0.0, 1.0);
}
var col = c;
if (a > 0.02) {
col = clamp((c - (1.0 - a) * bc) / a, vec3<f32>(0.0), vec3<f32>(1.0));
}
textureStore(out, p, vec4<f32>(col, a));
}
// The matte (src.x, or src.w with u[0].y) after the Cleanup strokes: data = targets (u[0].x of
// them) then each stroke's coverage plane (negative = untouched).
@compute @workgroup_size(16, 16)
fn fp2_io_strokes(@builtin(global_invocation_id) gid: vec3<u32>) {
let p = vec2<i32>(gid.xy);
if (!fp2_inside(p)) {
return;
}
let s = textureLoad(src, p, 0);
var a = select(s.x, s.w, P.u[0].y != 0u);
let n = P.u[0].x;
let d = out_dims();
let plane = u32(d.x * d.y);
let i = u32(p.y * d.x + p.x);
for (var k = 0u; k < n; k++) {
let c = data[n + k * plane + i];
if (c >= 0.0) {
a += (data[k] - a) * c;
}
}
textureStore(out, p, vec4<f32>(a, 0.0, 0.0, 0.0));
}
// src = the layer, aux = the final matte (x), data = estimated colours' rows (row length u[0].x,
// colours used when u[0].y). u[0].z = invert; f[0] = (threshold, blend with original).
@compute @workgroup_size(16, 16)
fn fp2_io_final(@builtin(global_invocation_id) gid: vec3<u32>) {
let p = vec2<i32>(gid.xy);
if (!fp2_inside(p)) {
return;
}
let px = textureLoad(src, p, 0);
var m = textureLoad(aux, p, 0).x;
let thr = P.f[0].x;
if (thr > 0.0 && m < thr) {
m = 0.0;
}
if (P.u[0].z != 0u) {
m = 1.0 - m;
}
var c = fp2_unpremul(px);
if (P.u[0].y != 0u) {
let at = (u32(p.y) * P.u[0].x + u32(p.x)) * 4u;
c = vec3<f32>(data[at], data[at + 1u], data[at + 2u]);
}
let a = max(px.w, 0.0);
let keyed = vec4<f32>(c * (a * m), a * m);
textureStore(out, p, keyed + (px - keyed) * P.f[0].y);
}
// ---------------------------------------------------------------- CC Simple Wire Removal (keying2::wire_removal)
// u[0].x = style; f[0] = (ax, ay, nx, ny); f[1] = (hw thickness, soft width, mirror, segment length).
fn fp2_wire_pos(base: vec2<f32>, nrm: vec2<f32>, s: f32) -> vec4<f32> {
return sample_bilinear_clamped(src, base.x + nrm.x * s, base.y + nrm.y * s);
}
@compute @workgroup_size(16, 16)
fn fp2_wire(@builtin(global_invocation_id) gid: vec3<u32>) {
let p = vec2<i32>(gid.xy);
if (!fp2_inside(p)) {
return;
}
let px = textureLoad(src, p, 0);
let a = P.f[0].xy;
let nrm = P.f[0].zw;
let hw = P.f[1].x;
let soft_w = P.f[1].y;
let mirror = P.f[1].z;
let fx = f32(p.x) + 0.5;
let fy = f32(p.y) + 0.5;
let q = vec2<f32>(fx - a.x, fy - a.y);
let d = q.x * nrm.x + q.y * nrm.y;
let ad = abs(d);
// The wire is the segment A to B: the tangent is the normal turned back by 90 degrees.
let along = q.x * nrm.y - q.y * nrm.x;
if (along < 0.0 || along > P.f[1].w || ad > hw + soft_w) {
textureStore(out, p, px);
return;
}
let base = vec2<f32>(fx - d * nrm.x, fy - d * nrm.y);
let edge = hw + 1.0;
var repl: vec4<f32>;
switch P.u[0].x {
case 0u: {
let t = clamp((d + edge) / (2.0 * edge), 0.0, 1.0);
let l = fp2_wire_pos(base, nrm, -edge);
repl = l + (fp2_wire_pos(base, nrm, edge) - l) * t;
}
case 1u, 2u: {
var s = d - 2.0 * (hw - ad) - 1.0;
if (d >= 0.0) {
s = d + 2.0 * (hw - ad) + 1.0;
}
let sh = fp2_wire_pos(base, nrm, s);
repl = sh;
if (mirror > 0.0) {
repl = sh + (fp2_wire_pos(base, nrm, -s) - sh) * (mirror * 0.5);
}
}
default: {
var sx = 0.0;
if (abs(nrm.x) > 1e-6) {
sx = (hw - ad + 1.0) / abs(nrm.x);
}
let dir = select(-1.0, 1.0, d * nrm.x >= 0.0);
let sh = sample_bilinear_clamped(src, fx + dir * sx, fy);
let mi = sample_bilinear_clamped(src, fx - dir * sx, fy);
repl = sh;
if (mirror > 0.0) {
repl = sh + (mi - sh) * (mirror * 0.5);
}
}
}
var k = 1.0;
if (ad > hw) {
k = 1.0 - fp2_smoothstep(hw, hw + soft_w, ad);
}
textureStore(out, p, px + (repl - px) * k);
}
// ---------------------------------------------------------------- Basic 3D (obsolete::basic_3d)
// u[0] = (specular, wireframe); f[0] = (cx, cy, focal, distance); f[1] = ux; f[2] = uy;
// f[3] = normal; f[4] = light; f[5] = (hw width, hw height).
@compute @workgroup_size(16, 16)
fn fp2_basic3d(@builtin(global_invocation_id) gid: vec3<u32>) {
let p = vec2<i32>(gid.xy);
if (!fp2_inside(p)) {
return;
}
let cx = P.f[0].x;
let cy = P.f[0].y;
let f = P.f[0].z;
let dist = P.f[0].w;
let ux = P.f[1].xyz;
let uy = P.f[2].xyz;
let n = P.f[3].xyz;
let d = vec3<f32>(f32(p.x) + 0.5 - cx, f32(p.y) + 0.5 - cy, f);
let denom = dot(d, n);
if (abs(denom) < 1e-9) {
textureStore(out, p, vec4<f32>(0.0));
return;
}
// Eye at (0, 0, -f), plane through (0, 0, dist).
let t = (dist + f) * n.z / denom;
if (t <= 0.0) {
textureStore(out, p, vec4<f32>(0.0));
return;
}
let hit = vec3<f32>(d.x * t, d.y * t, -f + d.z * t - dist);
let u = dot(hit, ux);
let v = dot(hit, uy);
var c = sample_bilinear(src, cx + u, cy + v);
if (P.u[0].x != 0u && c.w > 0.0) {
let dv = d / sqrt(dot(d, d));
let k = 2.0 * dot(dv, n);
let r = dv - k * n;
let s = powz(max(-dot(r, P.f[4].xyz), 0.0), 40.0);
let a = c.w;
c = vec4<f32>(c.xyz + s * a * max(vec3<f32>(1.0) - c.xyz / max(a, 1e-6), vec3<f32>(0.0)), a);
}
if (P.u[0].y != 0u) {
let hw = P.f[5].x;
let hh = P.f[5].y;
let e = min(abs(abs(u) - hw), abs(abs(v) - hh));
if (e < 0.75 && abs(u) <= hw + 0.75 && abs(v) <= hh + 0.75) {
c = vec4<f32>(1.0);
}
}
textureStore(out, p, c);
}
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.