EffectCraft: An open-source motion graphics and compositing tool written by scratch in pure Rust
Radial Wipe: Feather in pixels on both edges of the wedge, as After Effects
vangel768d41ef72183f
diff --git a/crates/effects/src/lib.rs b/crates/effects/src/lib.rsindex ff10c99c9..d942ff13d 100644--- a/crates/effects/src/lib.rs+++ b/crates/effects/src/lib.rs@@ -85,7 +85,7 @@ use effectcraft_keyframe::Value;use effectcraft_project::build::Ids;use effectcraft_project::{GroupKind, ParamUi, PropGroup, Property};pub use effectcraft_raster::{AuxChannels, Image};-pub use misc::{INVERT_ALPHA, INVERT_CHANNELS, glow_ab_t, glow_operation, glow_sigma, venetian_cover, venetian_origin};+pub use misc::{INVERT_ALPHA, INVERT_CHANNELS, glow_ab_t, glow_operation, glow_sigma, radial_wipe_sigma, radial_wipe_wedge, venetian_cover, venetian_origin};pub use sim::particle_state;pub use sim3::{PgBlit, PgPlan, playground_plan, playground_state};pub use stylize2::strobe_on;diff --git a/crates/effects/src/misc.rs b/crates/effects/src/misc.rsindex 90306be08..fa92c998e 100644--- a/crates/effects/src/misc.rs+++ b/crates/effects/src/misc.rs@@ -532,22 +532,67 @@ fn linear_wipe(ctx: &EffectCtx, mut b: Buf) -> Buf {b}+/// Standard normal CDF Φ (Abramowitz & Stegun 7.1.26 erf, |error| < 1.5e-7).+fn norm_cdf(z: f64) -> f64 {+ let x = z.abs() / std::f64::consts::SQRT_2;+ let t = 1.0 / (1.0 + 0.327_591_1 * x);+ let poly = t * (0.254_829_592 + t * (-0.284_496_736 + t * (1.421_413_741 + t * (-1.453_152_027 + t * 1.061_405_429))));+ let erf = 1.0 - poly * (-x * x).exp();+ if z >= 0.0 { 0.5 * (1.0 + erf) } else { 0.5 * (1.0 - erf) }+}++/// Radial Wipe's wiped wedge relative to the Start Angle: (first ray, span), degrees clockwise+/// from up. Clockwise (0) wipes from the start angle on, Counterclockwise (1) back from it,+/// Both (2) half each way.+pub fn radial_wipe_wedge(wipe: u32, done: f64) -> (f64, f64) {+ let span = done.clamp(0.0, 1.0) * 360.0;+ match wipe {+ 1 => (-span, span),+ 2 => (-span / 2.0, span),+ _ => (0.0, span),+ }+}++/// Radial Wipe's feather: a Gaussian of σ = 0.4 × Feather pixels across both edges of the wedge+/// (After Effects 2026, Feather 20: the edge profile is the same width in pixels at every+/// radius, σ = 8.0 px, mean error 0.0002 over the frame).+pub fn radial_wipe_sigma(feather: f64) -> f64 {+ feather.max(0.0) * 0.4+}++/// Visible fraction of a pixel at `(ux, uy)` from the centre (y down) for a wiped wedge from+/// `ray0` (absolute degrees clockwise from up) over `span` degrees: the signed distance to the+/// wedge's nearer edge, through the feather's Gaussian.+pub fn radial_wipe_alpha(ux: f64, uy: f64, ray0: f64, span: f64, sigma: f64) -> f64 {+ let a = (ux.atan2(-uy).to_degrees() - ray0).rem_euclid(360.0);+ let wiped = a < span;+ let ray_dist = |deg: f64| {+ let (s, c) = deg.to_radians().sin_cos();+ // Ray direction (sin, −cos) in y-down pixels.+ let along = ux * s - uy * c;+ if along > 0.0 { (ux * c + uy * s).abs() } else { ux.hypot(uy) }+ };+ let d = ray_dist(ray0).min(ray_dist(ray0 + span));+ let sd = if wiped { -d } else { d };+ if sigma < 1e-3 {+ return if wiped { 0.0 } else { 1.0 };+ }+ norm_cdf(sd / sigma)+}+fn radial_wipe(ctx: &EffectCtx, mut b: Buf) -> Buf {- let done = ctx.params.f("completion") / 100.0;+ let done = (ctx.params.f("completion") / 100.0).clamp(0.0, 1.0);+ if done <= 0.0 {+ return b;+ }let start = ctx.params.f("startAngle");let c = b.to_px(ctx.params.v2("center"));- let dir = ctx.params.e("wipe");- let feather = (ctx.params.f("feather")).max(0.01);+ let (w0, span) = radial_wipe_wedge(ctx.params.e("wipe"), done);+ let sigma = radial_wipe_sigma(ctx.params.f("feather")) * b.scale;+ let full = done >= 1.0;b.img.rows_mut().for_each(|(y, row)| {for (x, px) in row.iter_mut().enumerate() {- let a = ((x as f64 + 0.5 - c.0).atan2(-(y as f64 + 0.5 - c.1)).to_degrees() - start).rem_euclid(360.0);- // Both: the wipe opens in both directions from the start angle at once.- let (a, edge) = match dir {- 1 => (360.0 - a, done * 360.0),- 2 => (a.min(360.0 - a), done * 180.0),- _ => (a, done * 360.0),- };- let k = ((a - edge) / feather + 0.5).clamp(0.0, 1.0) as f32;+ let k = if full { 0.0 } else { radial_wipe_alpha(x as f64 + 0.5 - c.0, y as f64 + 0.5 - c.1, start + w0, span, sigma) as f32 };for ch in px.iter_mut() {*ch *= k;}@@ -556,15 +601,6 @@ fn radial_wipe(ctx: &EffectCtx, mut b: Buf) -> Buf {b}-/// Standard normal CDF Φ (Abramowitz & Stegun 7.1.26 erf, |error| < 1.5e-7).-fn norm_cdf(z: f64) -> f64 {- let x = z.abs() / std::f64::consts::SQRT_2;- let t = 1.0 / (1.0 + 0.327_591_1 * x);- let poly = t * (0.254_829_592 + t * (-0.284_496_736 + t * (1.421_413_741 + t * (-1.453_152_027 + t * 1.061_405_429))));- let erf = 1.0 - poly * (-x * x).exp();- if z >= 0.0 { 0.5 * (1.0 + erf) } else { 0.5 * (1.0 - erf) }-}-/// Venetian Blinds: how much of a pixel at phase `d` (0..`width`) a band of `done × width`/// covers, its two edges softened by a Gaussian of σ = Feather / 2 (σ in the units of `width`)./// Fitted to After Effects 2026 (Completion 40, Direction 30, Width 50, Feather 5 on 960 × 540@@ -955,6 +991,54 @@ mod tests {assert_eq!(venetian_cover(3.0, 10.0, 0.5, 1e9), 0.5);}+ /// After Effects 2026, Radial Wipe Completion 40, Start Angle 30, Wipe Counterclockwise,+ /// Feather 20, centre (800, 500): visible fraction at pixel offsets from the centre on both+ /// edges (8-bit captures of dark steps, so ±0.05).+ #[test]+ fn radial_wipe_feather_matches_after_effects() {+ let img = effectcraft_raster::Image::filled(400, 300, [1.0, 1.0, 1.0, 1.0]);+ let vals = [+ ("completion", Value::Scalar(40.0)),+ ("startAngle", Value::Scalar(30.0)),+ ("center", Value::Vec2([200.0, 150.0])),+ ("wipe", Value::Enum(1)),+ ("feather", Value::Scalar(20.0)),+ ];+ let o = run_fx("ec.transition.radialwipe", &vals, img.clone(), 0.0, EffectEnv::default());+ let ae = [+ ((-50, 34), 0.922),+ ((-52, 30), 0.797),+ ((-54, 26), 0.609),+ ((-55, 24), 0.5),+ ((-56, 22), 0.406),+ ((-57, 19), 0.266),+ ((-58, 15), 0.125),+ ((-104, 60), 0.951),+ ((-108, 53), 0.732),+ ((-111, 45), 0.341),+ ((-114, 37), 0.062),+ ((22, -56), 0.156),+ ((26, -54), 0.312),+ ((30, -52), 0.531),+ ((34, -50), 0.729),+ ((37, -47), 0.875),+ ((53, -108), 0.177),+ ((67, -99), 0.875),+ ];+ for ((dx, dy), a) in ae {+ let got = o.img.get(200 + dx, 150 + dy)[3];+ assert!((got - a).abs() < 0.05, "offset ({dx}, {dy}): {got} vs AE {a}");+ }+ // 0 % leaves the layer, 100 % clears it, Feather 0 is a hard edge.+ let at = |c: f64, f: f64| {+ let v = [("completion", Value::Scalar(c)), ("feather", Value::Scalar(f))];+ run_fx("ec.transition.radialwipe", &v, img.clone(), 0.0, EffectEnv::default()).img+ };+ assert_eq!(at(0.0, 20.0), img);+ assert!(at(100.0, 20.0).data.iter().all(|p| p[3] == 0.0));+ assert!(at(50.0, 0.0).data.iter().all(|p| p[3] == 0.0 || p[3] == 1.0));+ }+#[test]fn glow_operation_and_arbitrary_map() {// Pixels addressed in layer space (Glow pads its buffer).diff --git a/crates/gpu/src/fx_generate.rs b/crates/gpu/src/fx_generate.rsindex 7f2678a57..b32151e33 100644--- a/crates/gpu/src/fx_generate.rs+++ b/crates/gpu/src/fx_generate.rs@@ -234,33 +234,23 @@ fn venetian(e: &mut Enc, ctx: &EffectCtx, b: GBuf) -> Option<GBuf> {}fn radial_wipe(e: &mut Enc, ctx: &EffectCtx, b: GBuf) -> Option<GBuf> {- let done = ctx.params.f("completion") / 100.0;+ let done = (ctx.params.f("completion") / 100.0).clamp(0.0, 1.0);+ if done <= 0.0 {+ return Some(b);+ }let start = ctx.params.f("startAngle");let c = b.to_px(ctx.params.v2("center"));- let dir = ctx.params.e("wipe");- let feather = ctx.params.f("feather").max(0.01);- let edge = if dir == 2 { done * 180.0 } else { done * 360.0 };- // Rotations: the start angle, and the start angle ± the edge (where the wipe's edge lies).- let rots = [start, start + edge, start - edge].map(|r| r.to_radians().sin_cos());- let mut data = Vec::with_capacity(9 * (b.img.width + b.img.height) as usize);- for x in 0..b.img.width {- let ux = x as f64 + 0.5 - c.0;- for (s, co) in rots {- data.extend(hl(ux * co));- data.push((ux * s) as f32);- }- }- for y in 0..b.img.height {- let uy = -(y as f64 + 0.5 - c.1);- for (s, co) in rots {- data.extend(hl(uy * s));- data.push((uy * co) as f32);- }- }+ let (w0, span) = effectcraft_effects::radial_wipe_wedge(ctx.params.e("wipe"), done);+ let sigma = effectcraft_effects::radial_wipe_sigma(ctx.params.f("feather")) * b.scale;+ let ray0 = start + w0;+ let (s0, c0) = ray0.to_radians().sin_cos();+ let (s1, c1) = (ray0 + span).to_radians().sin_cos();let mut p = Params::default();- p.u[0] = [9 * b.img.width, dir.min(2), 0, 0];- p.f[0] = [edge as f32, feather as f32, 0.0, 0.0];- run(e, "gen_radial_wipe", &p, b, None, Some(&data))+ p.u[0] = [(done >= 1.0) as u32, (sigma < 1e-3) as u32, 0, 0];+ p.f[0] = [c.0 as f32, c.1 as f32, sigma.max(1e-3) as f32, ray0.rem_euclid(360.0) as f32];+ p.f[1] = [s0 as f32, c0 as f32, s1 as f32, c1 as f32];+ p.f[2][0] = span as f32;+ run(e, "gen_radial_wipe", &p, b, None, None)}fn gradient_wipe(e: &mut Enc, ctx: &EffectCtx, b: GBuf) -> Option<GBuf> {diff --git a/crates/gpu/src/shaders/fx_generate.wgsl b/crates/gpu/src/shaders/fx_generate.wgslindex aa132217a..c4dbb878e 100644--- a/crates/gpu/src/shaders/fx_generate.wgsl+++ b/crates/gpu/src/shaders/fx_generate.wgsl@@ -281,20 +281,9 @@ fn gen_venetian(@builtin(global_invocation_id) gid: vec3<u32>) {textureStore(out, p, textureLoad(src, p, 0) * (1.0 - cover));}-// Angle (degrees, clockwise from up) of the pixel vector rotated by rotation `r` (0 = start,-// 1 = start + edge, 2 = start − edge), from the per-column / per-row tables of Radial Wipe.-fn gen_psi(r: u32, x: u32, y: u32) -> f32 {- let c = 9u * x + 3u * r;- let w = P.u[0].x + 9u * y + 3u * r;- // x' = ux·cos R − uy·sin R (cancels at the edge), y' = uy·cos R + ux·sin R.- let xr = (data[c] - data[w]) + (data[c + 1u] - data[w + 1u]);- let yr = data[w + 2u] + data[c + 2u];- return atan2(xr, yr) * GEN_DEG;-}--// Radial Wipe. data: per column 9 floats (for each rotation: ux·cos R (hi, lo), ux·sin R),-// per row 9 floats (uy·sin R (hi, lo), uy·cos R); u[0] = (row offset, wipe);-// f[0] = (edge, feather).+// Radial Wipe (effects::misc::radial_wipe_alpha). u[0] = (fully wiped, hard edge);+// f[0] = (centre x, centre y, σ, first ray in degrees); f[1] = (sin, cos) of both rays;+// f[2].x = span in degrees.@compute @workgroup_size(16, 16)fn gen_radial_wipe(@builtin(global_invocation_id) gid: vec3<u32>) {let dims = out_dims();@@ -302,30 +291,31 @@ fn gen_radial_wipe(@builtin(global_invocation_id) gid: vec3<u32>) {if (p.x >= dims.x || p.y >= dims.y) {return;}- let x = u32(p.x);- let y = u32(p.y);- let dir = P.u[0].y;- let edge = P.f[0].x;- var a = gen_psi(0u, x, y);- if (a < 0.0) {- a += 360.0;- }- var base: f32;- if (dir == 0u || (dir == 2u && a <= 180.0)) {- base = a - edge;- if (abs(base) < 90.0) {- base = gen_psi(1u, x, y);- }- } else {- base = (360.0 - a) - edge;- if (abs(base) < 90.0) {- base = -gen_psi(2u, x, y);+ var k = 0.0;+ if (P.u[0].x == 0u) {+ let ux = f32(p.x) + 0.5 - P.f[0].x;+ let uy = f32(p.y) + 0.5 - P.f[0].y;+ var a = atan2(ux, -uy) * GEN_DEG - P.f[0].w;+ a = a - 360.0 * floor(a / 360.0);+ let wiped = a < P.f[2].x;+ let d = min(gen_ray_dist(ux, uy, P.f[1].x, P.f[1].y), gen_ray_dist(ux, uy, P.f[1].z, P.f[1].w));+ if (P.u[0].y != 0u) {+ k = select(1.0, 0.0, wiped);+ } else {+ k = gen_norm_cdf(select(d, -d, wiped) / P.f[0].z);}}- let k = clamp(base / P.f[0].y + 0.5, 0.0, 1.0);textureStore(out, p, textureLoad(src, p, 0) * k);}+// Distance from (ux, uy) to the ray from the centre in direction (s, −c) (y down).+fn gen_ray_dist(ux: f32, uy: f32, s: f32, c: f32) -> f32 {+ if (ux * s - uy * c > 0.0) {+ return abs(ux * c + uy * s);+ }+ return length(vec2<f32>(ux, uy));+}+// Gradient Wipe: aux = the placed gradient layer. u[0].x = invert; f[0] = (done, softness).@compute @workgroup_size(16, 16)fn gen_gradient_wipe(@builtin(global_invocation_id) gid: vec3<u32>) {diff --git a/docs/effects-parity.md b/docs/effects-parity.mdindex f4da80ba7..bd89044bb 100644--- a/docs/effects-parity.md+++ b/docs/effects-parity.md@@ -45,7 +45,7 @@ corpus compares renders, each effect is assumed to differ somewhere, and users k| Stylize | 25 | 25 | Glow's halo (coverage of a dim layer's edge) and blur width match After Effects 2026 renders; glows above the threshold match too (each channel 8 × (value − threshold + 0.061), measured at three thresholds and two radii); Composite Original's labels are swapped against After Effects (EffectCraft's On Top adds the glow over the original, which After Effects calls Behind); Motion Tile output size (#369) || Text | 2 | 2 | — || Time | 8 | 8 | #535 (Pixel Motion Blur, Vector Detail) is closed |-| Transition | 17 | 17 | Venetian Blinds matches After Effects 2026 renders (band phase from the layer centre, Gaussian feather on both edges) except within ~6 px of the layer edge (up to 48/255) |+| Transition | 17 | 17 | Venetian Blinds matches After Effects 2026 renders (band phase from the layer centre, Gaussian feather on both edges) except within ~6 px of the layer edge (up to 48/255); Radial Wipe's Feather matches After Effects 2026 (a Gaussian of σ = 0.4 × Feather pixels on both edges of the wedge) || Utility | 9 | 7 | — |Third-party bundles in After Effects (Cineware, Mocha AE) are out of scope; Keylight is@@ -68,6 +68,7 @@ the GPU is performance, not parity.| 2026-10-19 | minor | Glow (colour channels): the glow covers the layer's blurred alpha, blur σ = 0.384 × radius, measured against After Effects 2026 renders (CPU and GPU) || 2026-10-19 | minor | Radial Blur repeats the edge instead of sampling transparency outside the layer, measured against After Effects 2026 renders (CPU and GPU) || 2026-10-19 | minor | Venetian Blinds: stripes measured from the layer centre, both band edges Gaussian (σ = Feather / 2), measured against After Effects 2026 (CPU and GPU) |+| 2026-10-19 | minor | Radial Wipe: Feather is in pixels on both edges of the wiped wedge (was degrees on the moving edge only), measured against After Effects 2026 (CPU and GPU) || 2026-10-12 | minor | Parameters 3,014 to 3,017 (effects.md); #303, #514, #526, #533–#536 marked closed instead of pending || 2026-10-12 | minor | Effect colour labels (26.5) added in Effect Controls || 2026-10-12 | minor | Tint's Swap Colors button and agent-drivable command (#963); undo/redo, instance targeting, animated layer-time edits and invalid-input tests |