665bfac0b339
fx_transition.wgsl
// GPU effects, transitions and perspective: see src/fx_transition.rs. Block Dissolve, the CC
// transitions (Glass Wipe, Grid Wipe, Image Wipe, Jaws, Line Sweep, Radial ScaleWipe, Scale
// Wipe, Twister, WarpoMatic), Radial Shadow, CC Bender, CC Blobbylize, CC Cylinder, CC Sphere,
// CC Spotlight, CC Environment and 3D Glasses, each mirroring the CPU effect operation for
// operation. Coordinates are pixel centres relative to the effect's centre where it has one.
fn ftr_inside(p: vec2<i32>) -> bool {
let d = out_dims();
return p.x < d.x && p.y < d.y;
}
fn ftr_centre(p: vec2<i32>) -> vec2<f32> {
return vec2<f32>(f32(p.x) + 0.5, f32(p.y) + 0.5);
}
// util::smoothstep.
fn ftr_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);
}
// util::unpremul's colour.
fn ftr_unpremul(p: vec4<f32>) -> vec3<f32> {
if (p.w > 1e-6) {
return p.xyz / p.w;
}
return vec3<f32>(0.0);
}
// The third image, copied into `data` as RGBA f32 rows: P.u[3] = (row stride, width, height).
fn ftr_row(x: i32, y: i32) -> vec4<f32> {
if (x < 0 || y < 0 || x >= i32(P.u[3].y) || y >= i32(P.u[3].z)) {
return vec4<f32>(0.0);
}
let i = (u32(y) * P.u[3].x + u32(x)) * 4u;
return vec4<f32>(data[i], data[i + 1u], data[i + 2u], data[i + 3u]);
}
fn ftr_row_clamped(x: i32, y: i32) -> vec4<f32> {
return ftr_row(clamp(x, 0, i32(P.u[3].y) - 1), clamp(y, 0, i32(P.u[3].z) - 1));
}
// Image::sample_bilinear on the third image.
fn ftr_row_bilinear(x: f32, y: f32) -> vec4<f32> {
let fx = x - 0.5;
let fy = y - 0.5;
let x0 = floor(fx);
let y0 = floor(fy);
let tx = fx - x0;
let ty = fy - y0;
let xi = i32(x0);
let yi = i32(y0);
let a = ftr_row(xi, yi);
let b = ftr_row(xi + 1, yi);
let c = ftr_row(xi, yi + 1);
let d = ftr_row(xi + 1, yi + 1);
let top = a + (b - a) * tx;
let bot = c + (d - c) * tx;
return top + (bot - top) * ty;
}
// Image::sample_bilinear_clamped on the third image.
fn ftr_row_bilinear_clamped(x: f32, y: f32) -> vec4<f32> {
let fx = x - 0.5;
let fy = y - 0.5;
let x0 = floor(fx);
let y0 = floor(fy);
let tx = fx - x0;
let ty = fy - y0;
let xi = i32(x0);
let yi = i32(y0);
let a = ftr_row_clamped(xi, yi);
let b = ftr_row_clamped(xi + 1, yi);
let c = ftr_row_clamped(xi, yi + 1);
let d = ftr_row_clamped(xi + 1, yi + 1);
let top = a + (b - a) * tx;
let bot = c + (d - c) * tx;
return top + (bot - top) * ty;
}
// Central differences of the aux plane (x), edges clamped (transition2::grad).
fn ftr_grad(p: vec2<i32>) -> vec2<f32> {
let gx = (tex_get_clamped(aux, p.x + 1, p.y).x - tex_get_clamped(aux, p.x - 1, p.y).x) * 0.5;
let gy = (tex_get_clamped(aux, p.x, p.y + 1).x - tex_get_clamped(aux, p.x, p.y - 1).x) * 0.5;
return vec2<f32>(gx, gy);
}
// transition2::wipe_t.
fn ftr_wipe_t(g: f32, c: f32, w0: f32) -> f32 {
let w = max(w0, 1e-3);
let edge = c * (1.0 + 2.0 * w) - w;
return 1.0 - ftr_smoothstep(edge - w, edge + w, g);
}
// ---------------------------------------------------------------- planes
// A plane (x) from the source: u[0].x = util::Src index (Red, Green, Blue, Alpha, Luminance,
// Hue, Lightness, Saturation, Full, Half, Off) times alpha except for Alpha itself
// (transition2::prop_plane, CC Blobbylize); 11 = CC Environment's relief.
@compute @workgroup_size(16, 16)
fn ftr_plane(@builtin(global_invocation_id) gid: vec3<u32>) {
let p = vec2<i32>(gid.xy);
if (!ftr_inside(p)) {
return;
}
let px = textureLoad(src, p, 0);
let c = ftr_unpremul(px);
let a = max(px.w, 0.0);
var v: f32;
switch P.u[0].x {
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).x;
}
case 6u: {
v = rgb_to_hsl(c).z;
}
case 7u: {
v = rgb_to_hsl(c).y;
}
case 8u: {
v = 1.0;
}
case 9u: {
v = 0.5;
}
case 11u: {
v = luminance(c) * 0.5 + 0.5;
}
default: {
v = 0.0;
}
}
if (P.u[0].x != 3u) {
v *= a;
}
textureStore(out, p, vec4<f32>(v, 0.0, 0.0, 0.0));
}
// src × aux.x (Image::mul_mask).
@compute @workgroup_size(16, 16)
fn ftr_mul(@builtin(global_invocation_id) gid: vec3<u32>) {
let p = vec2<i32>(gid.xy);
if (!ftr_inside(p)) {
return;
}
textureStore(out, p, textureLoad(src, p, 0) * textureLoad(aux, p, 0).x);
}
// aux + src × (1 − aux.a): src composited under aux.
@compute @workgroup_size(16, 16)
fn ftr_under(@builtin(global_invocation_id) gid: vec3<u32>) {
let p = vec2<i32>(gid.xy);
if (!ftr_inside(p)) {
return;
}
let o = textureLoad(aux, p, 0);
textureStore(out, p, o + textureLoad(src, p, 0) * (1.0 - o.w));
}
// ---------------------------------------------------------------- Block Dissolve (transition::block_dissolve)
// The kept-block mask (x). u[0] = (sub-samples per axis, seed, column table length);
// f[0].x = completion; data = block columns (width × n, u32) then block rows (height × n).
@compute @workgroup_size(16, 16)
fn ftr_blocks(@builtin(global_invocation_id) gid: vec3<u32>) {
let p = vec2<i32>(gid.xy);
if (!ftr_inside(p)) {
return;
}
let n = P.u[0].x;
var hits = 0u;
for (var j = 0u; j < n; j++) {
let by = bitcast<u32>(data[P.u[0].z + u32(p.y) * n + j]);
for (var i = 0u; i < n; i++) {
let bx = bitcast<u32>(data[u32(p.x) * n + i]);
if (hash_noise(bx, by, P.u[0].y) >= P.f[0].x) {
hits += 1u;
}
}
}
textureStore(out, p, vec4<f32>(f32(hits) / f32(n * n), 0.0, 0.0, 0.0));
}
// ---------------------------------------------------------------- CC Grid Wipe (transition::grid_wipe)
// u[0] = (shape, reverse); f[0] = (cx, cy, sin, cos); f[1] = (cell size, max distance,
// completion, border).
fn ftr_metric(shape: u32, d: vec2<f32>) -> f32 {
switch shape {
case 0u: {
return abs(d.x);
}
case 2u: {
return max(abs(d.x), abs(d.y));
}
default: {
return length(d);
}
}
}
@compute @workgroup_size(16, 16)
fn ftr_grid(@builtin(global_invocation_id) gid: vec3<u32>) {
let p = vec2<i32>(gid.xy);
if (!ftr_inside(p)) {
return;
}
let px = textureLoad(src, p, 0);
// CPU-generated coverage preserves exact f64 tile and hard-edge decisions.
let k = data[gid.y * u32(out_dims().x) + gid.x];
textureStore(out, p, px * k);
}
// ---------------------------------------------------------------- CC Radial ScaleWipe / CC Scale Wipe (transition.rs)
// Radial: u[0].x = reverse; f[0] = (cx, cy, max distance, completion).
@compute @workgroup_size(16, 16)
fn ftr_radial_scale(@builtin(global_invocation_id) gid: vec3<u32>) {
let p = vec2<i32>(gid.xy);
if (!ftr_inside(p)) {
return;
}
let c = P.f[0].xy;
let maxd = P.f[0].z;
let done = P.f[0].w;
let d = ftr_centre(p) - c;
let r = length(d);
var o = vec4<f32>(0.0);
if (P.u[0].x != 0u) {
let lim = (1.0 - done) * maxd;
if (!(r >= lim || lim <= 1e-9)) {
let k = maxd / lim;
o = sample_bilinear(src, c.x + d.x * k, c.y + d.y * k);
}
} else {
let hole = done * maxd;
if (!(r <= hole || maxd - hole <= 1e-9)) {
let rs = (r - hole) * maxd / (maxd - hole);
o = sample_bilinear(src, c.x + d.x / r * rs, c.y + d.y / r * rs);
}
}
textureStore(out, p, o);
}
// Scale Wipe: f[0] = (cx, cy, direction x, direction y); f[1].x = stretch.
@compute @workgroup_size(16, 16)
fn ftr_scale(@builtin(global_invocation_id) gid: vec3<u32>) {
let p = vec2<i32>(gid.xy);
if (!ftr_inside(p)) {
return;
}
let f = ftr_centre(p);
let dir = P.f[0].zw;
let u = dot(f - P.f[0].xy, dir);
var q = f;
if (u > 0.0) {
let back = u - u / (1.0 + P.f[1].x);
q = f - dir * back;
}
textureStore(out, p, sample_bilinear_clamped(src, q.x, q.y));
}
// ---------------------------------------------------------------- CC Glass Wipe (transition2::glass_wipe)
// aux = the gradient plane (x); data = the layer to reveal (rows). u[0].x = has reveal;
// f[0] = (completion, band half-width, displacement).
@compute @workgroup_size(16, 16)
fn ftr_glass(@builtin(global_invocation_id) gid: vec3<u32>) {
let p = vec2<i32>(gid.xy);
if (!ftr_inside(p)) {
return;
}
let t = ftr_wipe_t(textureLoad(aux, p, 0).x, P.f[0].x, P.f[0].y);
let band = 4.0 * t * (1.0 - t);
let g = ftr_grad(p);
let f = ftr_centre(p);
let o = g * P.f[0].z * band * 10.0;
var a = textureLoad(src, p, 0);
var r = vec4<f32>(0.0);
if (band > 1e-4) {
a = sample_bilinear(src, f.x + o.x, f.y + o.y);
if (P.u[0].x != 0u) {
r = ftr_row_bilinear(f.x - o.x, f.y - o.y);
}
} else if (P.u[0].x != 0u) {
r = ftr_row(p.x, p.y);
}
textureStore(out, p, a + (r - a) * t);
}
// ---------------------------------------------------------------- CC Image Wipe (transition2::image_wipe)
// aux = the gradient plane (x). u[0].x = inverse; f[0] = (completion, band half-width).
@compute @workgroup_size(16, 16)
fn ftr_image_wipe(@builtin(global_invocation_id) gid: vec3<u32>) {
let p = vec2<i32>(gid.xy);
if (!ftr_inside(p)) {
return;
}
var g = textureLoad(aux, p, 0).x;
if (P.u[0].x != 0u) {
g = 1.0 - g;
}
let k = 1.0 - ftr_wipe_t(g, P.f[0].x, P.f[0].y);
textureStore(out, p, textureLoad(src, p, 0) * k);
}
// ---------------------------------------------------------------- CC Jaws (transition2::jaws)
// u[0].x = shape; f[0] = (cx, cy, sin, cos); f[1] = (tooth width, amplitude, travel).
@compute @workgroup_size(16, 16)
fn ftr_jaws(@builtin(global_invocation_id) gid: vec3<u32>) {
let p = vec2<i32>(gid.xy);
if (!ftr_inside(p)) {
return;
}
let c = P.f[0].xy;
let sn = P.f[0].z;
let cs = P.f[0].w;
let width = P.f[1].x;
let amp = P.f[1].y;
let dd = P.f[1].z;
let d = ftr_centre(p) - c;
let u = d.x * cs + d.y * sn;
let v = -d.x * sn + d.y * cs;
let ph = fract_euclid(u / width);
var f: f32;
switch P.u[0].x {
case 0u: {
f = amp * (1.0 - 4.0 * abs(ph - 0.5));
}
case 1u: {
f = amp * clamp((1.0 - 4.0 * abs(ph - 0.5)) * 2.0, -1.0, 1.0);
}
case 2u: {
f = select(-amp, amp, ph < 0.5);
}
default: {
f = amp * sin(ph * 6.283185307179586);
}
}
var vs = 0.0;
var hit = true;
if (v + dd < f) {
vs = v + dd;
} else if (v - dd >= f) {
vs = v - dd;
} else {
hit = false;
}
var o = vec4<f32>(0.0);
if (hit) {
o = sample_bilinear(src, u * cs - vs * sn + c.x, u * sn + vs * cs + c.y);
}
textureStore(out, p, o);
}
// ---------------------------------------------------------------- CC Line Sweep (transition2::line_sweep)
// u[0] = (flip, slant ≥ 0); f[0] = (sin, cos, v0, u0); f[1] = (thickness, |slant|, strips,
// total travel); f[2].x = completion.
@compute @workgroup_size(16, 16)
fn ftr_line_sweep(@builtin(global_invocation_id) gid: vec3<u32>) {
let p = vec2<i32>(gid.xy);
if (!ftr_inside(p)) {
return;
}
let f = ftr_centre(p);
let sn = P.f[0].x;
let cs = P.f[0].y;
let u = f.x * cs + f.y * sn;
let v = -f.x * sn + f.y * cs;
let nstr = P.f[1].z;
var k = floor((v - P.f[0].z) / P.f[1].x);
if (P.u[0].x != 0u) {
k = nstr - 1.0 - k;
}
let stagger = select(nstr - 1.0 - k, k, P.u[0].y != 0u);
let front = P.f[0].w + P.f[2].x * P.f[1].w - P.f[1].y * stagger;
textureStore(out, p, select(textureLoad(src, p, 0), vec4<f32>(0.0), u < front));
}
// ---------------------------------------------------------------- CC Twister (transition2::twister)
// aux = the backside layer (u[0].x = has one); u[0].y = shading; f[0] = (cx, cy, sin, cos);
// f[1] = (half diagonal, completion).
@compute @workgroup_size(16, 16)
fn ftr_twister(@builtin(global_invocation_id) gid: vec3<u32>) {
let p = vec2<i32>(gid.xy);
if (!ftr_inside(p)) {
return;
}
let c = P.f[0].xy;
let sn = P.f[0].z;
let cs = P.f[0].w;
let d = ftr_centre(p) - c;
let u = d.x * cs + d.y * sn;
let v = -d.x * sn + d.y * cs;
let s01 = clamp((u / P.f[1].x) * 0.5 + 0.5, 0.0, 1.0);
let th = 3.141592653589793 * clamp(P.f[1].y * 2.0 - s01, 0.0, 1.0);
let k = cos(th);
if (abs(k) < 1e-4) {
textureStore(out, p, vec4<f32>(0.0));
return;
}
let vs = v / k;
var o: vec4<f32>;
if (k > 0.0 || P.u[0].x == 0u) {
o = sample_bilinear(src, u * cs - vs * sn + c.x, u * sn + vs * cs + c.y);
} else {
o = sample_bilinear(aux, u * cs + vs * sn + c.x, u * sn - vs * cs + c.y);
}
if (P.u[0].y != 0u) {
let l = 0.4 + 0.6 * abs(k);
o = vec4<f32>(o.xyz * l, o.w);
}
textureStore(out, p, o);
}
// ---------------------------------------------------------------- CC WarpoMatic (transition2::warpomatic)
// Reactor "Contrast Differences": src = the plane, aux = its wide mean.
@compute @workgroup_size(16, 16)
fn ftr_react_contrast(@builtin(global_invocation_id) gid: vec3<u32>) {
let p = vec2<i32>(gid.xy);
if (!ftr_inside(p)) {
return;
}
let a = textureLoad(src, p, 0).x;
let b = textureLoad(aux, p, 0).x;
textureStore(out, p, vec4<f32>(min(abs(a - b) * 4.0, 1.0), 0.0, 0.0, 0.0));
}
// Reactor "Local Differences": aux = the plane; its gradient magnitude.
@compute @workgroup_size(16, 16)
fn ftr_react_local(@builtin(global_invocation_id) gid: vec3<u32>) {
let p = vec2<i32>(gid.xy);
if (!ftr_inside(p)) {
return;
}
let g = ftr_grad(p);
textureStore(out, p, vec4<f32>(min(sqrt(g.x * g.x + g.y * g.y) * 8.0, 1.0), 0.0, 0.0, 0.0));
}
// aux = the reactor plane (x); data = the layer to reveal (rows). u[0] = (warp direction,
// has reveal); f[0] = (completion, blend span, warp amount).
@compute @workgroup_size(16, 16)
fn ftr_warpo(@builtin(global_invocation_id) gid: vec3<u32>) {
let p = vec2<i32>(gid.xy);
if (!ftr_inside(p)) {
return;
}
let q = ftr_wipe_t(textureLoad(aux, p, 0).x, P.f[0].x, P.f[0].y);
let g = ftr_grad(p);
let f = ftr_centre(p);
let amt = P.f[0].z;
let o = g * amt * q;
var i = g * amt * (1.0 - q);
if (P.u[0].x == 1u) {
i = -i;
} else if (P.u[0].x == 2u) {
i = vec2<f32>(-i.y, i.x);
}
var a = vec4<f32>(0.0);
if (q < 1.0) {
a = sample_bilinear(src, f.x + o.x, f.y + o.y);
}
var inc = vec4<f32>(0.0);
if (P.u[0].y != 0u && q > 0.0) {
inc = ftr_row_bilinear(f.x + i.x, f.y + i.y);
}
textureStore(out, p, a + (inc - a) * q);
}
// ---------------------------------------------------------------- Radial Shadow (perspective::radial_shadow)
// The shadow before its blur. u[0].x = glass edge; f[0] = (light x, y, projection k,
// opacity × colour alpha); f[1] = (colour, colour influence).
@compute @workgroup_size(16, 16)
fn ftr_rshadow(@builtin(global_invocation_id) gid: vec3<u32>) {
let p = vec2<i32>(gid.xy);
if (!ftr_inside(p)) {
return;
}
let l = P.f[0].xy;
let q = ftr_centre(p);
let s = sample_bilinear(src, l.x + (q.x - l.x) / P.f[0].z, l.y + (q.y - l.y) / P.f[0].z);
let sc = ftr_unpremul(s);
let sa = max(s.w, 0.0);
var a = sa;
if (P.u[0].x != 0u) {
a = clamp(sa * (1.0 - sa) * 4.0, 0.0, 1.0);
}
a *= P.f[0].w;
let col = P.f[1].xyz;
let c = col + (sc - col) * P.f[1].w;
textureStore(out, p, vec4<f32>(c * a, a));
}
// ---------------------------------------------------------------- CC Bender (distort3::cc_bender)
// u[0].x = style; f[0] = (base x, y, axis x, y); f[1] = (axis length, normal x, y, amount ×
// reference).
@compute @workgroup_size(16, 16)
fn ftr_bender(@builtin(global_invocation_id) gid: vec3<u32>) {
let p = vec2<i32>(gid.xy);
if (!ftr_inside(p)) {
return;
}
let f = ftr_centre(p);
let r = f - P.f[0].xy;
let t = clamp(dot(r, P.f[0].zw) / P.f[1].x, 0.0, 1.0);
let pi = 3.141592653589793;
var b: f32;
switch P.u[0].x {
case 1u: {
b = 0.5 * sin(pi * t) * t;
}
case 2u: {
b = 0.5 * t;
}
case 3u: {
b = 0.25 * (1.0 - cos(pi * t)) - 0.1 * sin(2.0 * pi * t);
}
default: {
b = 0.5 * t * t;
}
}
let d = P.f[1].w * b;
textureStore(out, p, sample_bilinear(src, f.x - P.f[1].y * d, f.y - P.f[1].z * d));
}
// ---------------------------------------------------------------- CC Blobbylize (distort3::cc_blobbylize)
// aux = the Softness-blurred blob plane (x). f[0] = (cut away, intensity, ambient,
// matte slope); f[1] = (diffuse, specular, shininess, metal); f[2] = (light x, y,
// point light height, point); f[3] = distant light direction; f[4] = light colour;
// f[5] = (matte depth, RGB depth, light slope, matte antialias width);
// f[6].x = displacement clamp.
@compute @workgroup_size(16, 16)
fn ftr_blob(@builtin(global_invocation_id) gid: vec3<u32>) {
let p = vec2<i32>(gid.xy);
if (!ftr_inside(p)) {
return;
}
let cut = P.f[0].x;
if (cut >= 1.0) {
// Endpoint guard: an opaque source can reach h = 1.0, where the gradient antialias
// would otherwise leave a half-covered pixel at Cut Away 100.
textureStore(out, p, vec4<f32>(0.0));
return;
}
let hv = textureLoad(aux, p, 0).x;
let g = ftr_grad(p);
let grad = length(g);
var m = 0.0;
if (grad > 1e-9) {
let aa = max(P.f[5].w * grad, 5e-4);
m = clamp(0.5 + (hv - cut) / aa, 0.0, 1.0);
} else if (hv > cut) {
m = 1.0;
}
if (m <= 0.0) {
textureStore(out, p, vec4<f32>(0.0));
return;
}
let f = ftr_centre(p);
// Softness-scaled bevel warp of the source matte (normal z = 1).
let na = normalize(vec3<f32>(-g.x * P.f[0].w, -g.y * P.f[0].w, 1.0));
let sa = sample_bilinear(src, f.x + na.x * P.f[5].x, f.y + na.y * P.f[5].x);
let alpha = max(sa.w, 0.0) * m;
if (alpha <= 0.0) {
textureStore(out, p, vec4<f32>(0.0));
return;
}
// Height-field refraction of the colour (normal z = height), independent of Softness.
let hz = max(hv, 1e-3);
let d = -g * P.f[5].y / hz;
let lim = P.f[6].x;
let disp = vec2<f32>(clamp(d.x, -lim, lim), clamp(d.y, -lim, lim));
let srgb = sample_bilinear(src, f.x + disp.x, f.y + disp.y);
let c = ftr_unpremul(srgb);
let n = normalize(vec3<f32>(-g.x * P.f[5].z, -g.y * P.f[5].z, 1.0));
var l = P.f[3].xyz;
if (P.f[2].w != 0.0) {
l = normalize(vec3<f32>(P.f[2].x - f.x, P.f[2].y - f.y, P.f[2].z));
}
let intensity = P.f[0].y;
let ndl = max(dot(n, l), 0.0);
let h3 = normalize(vec3<f32>(l.x, l.y, l.z + 1.0));
let sp = powz(max(dot(n, h3), 0.0), P.f[1].z) * P.f[1].y;
let lc = P.f[4].xyz;
let metal = P.f[1].w;
let lit = (P.f[0].z + P.f[1].x * ndl * intensity) * lc;
let spec_col = (1.0 - metal) * lc + metal * c * lc;
let o = c * lit + (sp * intensity) * spec_col;
textureStore(out, p, vec4<f32>(o * alpha, alpha));
}
// 0.5 + atan2(x, z) / 2π, kept on the side of the ±π seam that the sign of `x` puts it on (a
// GPU's approximate atan2 can land just across it, which wraps to the opposite edge of the
// texture). x = ±0 takes the CPU's −π (its zero is negative there).
fn ftr_lon_u(x: f32, z: f32) -> f32 {
let u = 0.5 + atan2(x, z) / 6.283185307179586;
if (x <= 0.0) {
return clamp(u, 0.0, 0.5);
}
return clamp(u, 0.5, 0.99999994);
}
// ---------------------------------------------------------------- CC Cylinder / CC Sphere (perspective.rs)
// Shading (perspective::Shading): f[3] = (light direction, intensity); f[4] = (light colour,
// ambient); f[5] = (diffuse, specular, shininess); f[6] = half vector. The layer rectangle in
// f[1] = (x0, y0, width, height).
fn ftr_shade(px: vec4<f32>, n: vec3<f32>) -> vec4<f32> {
let c = ftr_unpremul(px);
let a = max(px.w, 0.0);
if (a <= 0.0) {
return vec4<f32>(0.0);
}
let nl = max(dot(n, P.f[3].xyz), 0.0);
var spec = 0.0;
if (nl > 0.0) {
spec = powz(max(dot(n, P.f[6].xyz), 0.0), P.f[5].z) * P.f[5].y;
}
let lc = P.f[4].xyz * P.f[3].w;
let o = c * (P.f[4].w + P.f[5].x * nl * lc) + spec * lc;
return vec4<f32>(o * a, a);
}
// perspective::texel: the layer as a texture at (u, v), wrapping horizontally.
fn ftr_texel(u0: f32, v: f32) -> vec4<f32> {
let u = fract_euclid(u0);
if (v < 0.0 || v > 1.0) {
return vec4<f32>(0.0);
}
let r = P.f[1];
return sample_bilinear_clamped(src, r.x + u * r.z, r.y + v * r.w);
}
fn ftr_over(top: vec4<f32>, bottom: vec4<f32>) -> vec4<f32> {
return top + bottom * (1.0 - top.w);
}
fn ftr_faces(mode: u32, front: vec4<f32>, back: vec4<f32>) -> vec4<f32> {
if (mode == 1u) {
return front;
}
if (mode == 2u) {
return back;
}
return ftr_over(front, back);
}
// Cylinder: u[0].x = render, u[0].y = axis rotation enabled;
// f[0] = (cx, cy, radius, layer height); f[2].x = legacy texture spin;
// f[7..10] = rows of the local-to-view rotation matrix.
fn ftr_cylinder_face(d: vec2<f32>, z: f32, back: bool) -> vec4<f32> {
let m0 = P.f[7].xyz;
let m1 = P.f[8].xyz;
let m2 = P.f[9].xyz;
let q = vec3<f32>(d, z);
let local = vec3<f32>(m0.x * q.x + m1.x * q.y + m2.x * q.z,
m0.y * q.x + m1.y * q.y + m2.y * q.z,
m0.z * q.x + m1.z * q.y + m2.z * q.z);
let u = (atan2(local.x, local.z) + P.f[2].x) / 6.283185307179586 + 0.5;
let v = local.y / P.f[0].w + 0.5;
let flip = select(1.0, -1.0, back);
let n = vec3<f32>(local.x / P.f[0].z * flip, 0.0, local.z / P.f[0].z * flip);
return ftr_shade(ftr_texel(u, v), vec3<f32>(dot(m0, n), dot(m1, n), dot(m2, n)));
}
@compute @workgroup_size(16, 16)
fn ftr_cylinder(@builtin(global_invocation_id) gid: vec3<u32>) {
let p = vec2<i32>(gid.xy);
if (!ftr_inside(p)) {
return;
}
let d = ftr_centre(p) - P.f[0].xy;
if (P.u[0].y == 0u) {
// Original path is unchanged for old projects and default parameters.
let v = d.y / P.f[0].w + 0.5;
let s = d.x / P.f[0].z;
if (abs(s) >= 1.0) {
textureStore(out, p, vec4<f32>(0.0));
return;
}
let tau = 6.283185307179586;
let th = asin_p(s);
let cz = cos(th);
let spin = P.f[2].x;
let front = ftr_shade(ftr_texel((th + spin) / tau + 0.5, v), vec3<f32>(s, 0.0, cz));
let back = ftr_shade(ftr_texel((3.141592653589793 - th + spin) / tau + 0.5, v), vec3<f32>(-s, 0.0, cz));
textureStore(out, p, ftr_faces(P.u[0].x, front, back));
return;
}
let axis = vec3<f32>(P.f[7].y, P.f[8].y, P.f[9].y);
let a = 1.0 - axis.z * axis.z;
let da = dot(d, axis.xy);
let bq = -da * axis.z;
let disc = bq * bq - a * (dot(d, d) - da * da - P.f[0].z * P.f[0].z);
if (a <= 1e-10 || !(disc > 0.0)) {
textureStore(out, p, vec4<f32>(0.0));
return;
}
let root = sqrt(disc);
let front = ftr_cylinder_face(d, (-bq + root) / a, false);
let back = ftr_cylinder_face(d, (-bq - root) / a, true);
textureStore(out, p, ftr_faces(P.u[0].x, front, back));
}
// Sphere: u[0].x = render; f[0] = (cx, cy, radius); f[7..10] = the rotation matrix rows.
fn ftr_sphere_tex(q: vec3<f32>) -> vec4<f32> {
let m0 = P.f[7].xyz;
let m1 = P.f[8].xyz;
let m2 = P.f[9].xyz;
let t = m0 * q.x + m1 * q.y + m2 * q.z;
let lat = asin_p(clamp(t.y, -1.0, 1.0));
return ftr_texel(ftr_lon_u(t.x, t.z), lat / 3.141592653589793 + 0.5);
}
@compute @workgroup_size(16, 16)
fn ftr_sphere(@builtin(global_invocation_id) gid: vec3<u32>) {
let p = vec2<i32>(gid.xy);
if (!ftr_inside(p)) {
return;
}
let sxy = (ftr_centre(p) - P.f[0].xy) / P.f[0].z;
let d2 = sxy.x * sxy.x + sxy.y * sxy.y;
if (d2 >= 1.0) {
textureStore(out, p, vec4<f32>(0.0));
return;
}
let z = sqrt(1.0 - d2);
let front = ftr_shade(ftr_sphere_tex(vec3<f32>(sxy, z)), vec3<f32>(sxy, z));
let back = ftr_shade(ftr_sphere_tex(vec3<f32>(sxy, -z)), vec3<f32>(-sxy, z));
textureStore(out, p, ftr_faces(P.u[0].x, front, back));
}
// ---------------------------------------------------------------- CC Spotlight (perspective::spotlight)
// u[0].x = light only; f[0] = (from x, y, height, intensity); f[1] = (axis, inner angle);
// f[2] = (colour, cone angle).
@compute @workgroup_size(16, 16)
fn ftr_spot(@builtin(global_invocation_id) gid: vec3<u32>) {
let p = vec2<i32>(gid.xy);
if (!ftr_inside(p)) {
return;
}
let d = ftr_centre(p) - P.f[0].xy;
let v = normalize(vec3<f32>(d, -P.f[0].z));
let axis = P.f[1].xyz;
// acos(v · axis), well conditioned near the axis.
let ang = atan2(length(cross(v, axis)), dot(v, axis));
let m = (1.0 - ftr_smoothstep(P.f[1].w, P.f[2].w, ang)) * P.f[0].w;
let px = textureLoad(src, p, 0);
if (P.u[0].x != 0u) {
let a = clamp(m, 0.0, 1.0);
textureStore(out, p, vec4<f32>(P.f[2].xyz * a, a));
} else {
textureStore(out, p, vec4<f32>(px.xyz * (m * P.f[2].xyz), px.w));
}
}
// ---------------------------------------------------------------- CC Environment (perspective2::cc_environment)
// aux = the relief height map (x); data = the environment image (rows). u[0].x = mapping;
// f[0] = (1 / buffer scale, height, environment scale); f[1] = (environment offset, size).
fn ftr_env_uv(mapping: u32, r: vec3<f32>) -> vec2<f32> {
if (mapping == 1u) {
let m = 2.0 * max(sqrt(r.x * r.x + r.y * r.y + (r.z + 1.0) * (r.z + 1.0)), 1e-9);
return vec2<f32>(0.5 + r.x / m, 0.5 + r.y / m);
}
if (mapping == 2u) {
let ax = abs(r.x);
let ay = abs(r.y);
let az = abs(r.z);
var cr: vec4<f32>;
if (ax >= ay && ax >= az) {
if (r.x > 0.0) {
cr = vec4<f32>(2.0, 1.0, -r.z / ax, r.y / ax);
} else {
cr = vec4<f32>(0.0, 1.0, r.z / ax, r.y / ax);
}
} else if (ay >= az) {
if (r.y < 0.0) {
cr = vec4<f32>(1.0, 0.0, r.x / ay, -r.z / ay);
} else {
cr = vec4<f32>(1.0, 2.0, r.x / ay, r.z / ay);
}
} else if (r.z > 0.0) {
cr = vec4<f32>(1.0, 1.0, r.x / az, r.y / az);
} else {
cr = vec4<f32>(1.0, 3.0, r.x / az, -r.y / az);
}
return vec2<f32>((cr.x + (cr.z + 1.0) * 0.5) / 3.0, (cr.y + (cr.w + 1.0) * 0.5) / 4.0);
}
let lat = asin_p(clamp(r.y, -1.0, 1.0));
return vec2<f32>(ftr_lon_u(r.x, r.z), 0.5 + lat / 3.141592653589793);
}
@compute @workgroup_size(16, 16)
fn ftr_env(@builtin(global_invocation_id) gid: vec3<u32>) {
let p = vec2<i32>(gid.xy);
if (!ftr_inside(p)) {
return;
}
let a = textureLoad(src, p, 0).w;
if (a <= 0.0) {
textureStore(out, p, vec4<f32>(0.0));
return;
}
let g = ftr_grad(p) * P.f[0].x;
let height = P.f[0].y;
let n = normalize(vec3<f32>(-g.x * height, -g.y * height, 1.0));
let d = -n.z;
let r = vec3<f32>(-2.0 * d * n.x, -2.0 * d * n.y, -(-1.0 - 2.0 * d * n.z));
let uv = ftr_env_uv(P.u[0].x, r);
let es = P.f[0].z;
let ex = fract_euclid(uv.x) * P.f[1].z * es + P.f[1].x;
let ey = clamp(uv.y, 0.0, 1.0) * P.f[1].w * es + P.f[1].y;
let env = ftr_row_bilinear_clamped(ex, ey);
let ec = env.xyz * (1.0 / max(env.w, 1e-3));
textureStore(out, p, vec4<f32>(ec * a, a));
}
// ---------------------------------------------------------------- 3D Glasses (perspective2::glasses_3d)
// Translate by f[0].xy (perspective2::shift).
@compute @workgroup_size(16, 16)
fn ftr_shift(@builtin(global_invocation_id) gid: vec3<u32>) {
let p = vec2<i32>(gid.xy);
if (!ftr_inside(p)) {
return;
}
let f = ftr_centre(p) - P.f[0].xy;
textureStore(out, p, sample_bilinear(src, f.x, f.y));
}
// src = left view, aux = right view. u[0].x = 3D view; f[0] = (width, height, balance).
@compute @workgroup_size(16, 16)
fn ftr_glasses(@builtin(global_invocation_id) gid: vec3<u32>) {
let p = vec2<i32>(gid.xy);
if (!ftr_inside(p)) {
return;
}
let f = ftr_centre(p);
let w = P.f[0].x;
let h = P.f[0].y;
let k = P.f[0].z;
let view = P.u[0].x;
var o: vec4<f32>;
if (view == 0u) {
if (f.x < w * 0.5) {
o = sample_bilinear(src, f.x * 2.0, f.y);
} else {
o = sample_bilinear(aux, (f.x - w * 0.5) * 2.0, f.y);
}
} else if (view == 1u) {
if (f.y < h * 0.5) {
o = sample_bilinear(src, f.x, f.y * 2.0);
} else {
o = sample_bilinear(aux, f.x, (f.y - h * 0.5) * 2.0);
}
} else if (view == 2u) {
if (p.y % 2 == 0) {
o = textureLoad(src, p, 0);
} else {
o = textureLoad(aux, p, 0);
}
} else {
let lp = textureLoad(src, p, 0);
let rp = textureLoad(aux, p, 0);
let lc = ftr_unpremul(lp);
let rc = ftr_unpremul(rp);
let a = max(max(lp.w, 0.0), max(rp.w, 0.0));
let ll = luminance(lc);
let rl = luminance(rc);
var c: vec3<f32>;
switch view {
case 3u: {
c = vec3<f32>(ll, rl, 0.0);
}
case 4u: {
c = vec3<f32>(ll, 0.0, rl);
}
case 5u: {
c = vec3<f32>(lc.x + (ll - lc.x) * k, rc.y, rc.z);
}
case 6u: {
c = vec3<f32>(ll * (1.0 - 0.5 * k) + lc.x * 0.5 * k, rl, 0.0);
}
case 7u: {
c = vec3<f32>(ll * (1.0 - 0.5 * k) + lc.x * 0.5 * k, 0.0, rl);
}
default: {
c = abs(lc - rc);
}
}
o = vec4<f32>(c * a, a);
}
textureStore(out, p, o);
}
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.