EffectCraft: An open-source motion graphics and compositing tool written by scratch in pure Rust
Effects: Write-on draws a stroke along the animated brush, honouring Stroke Length and Brush Spacing (#536)
Claude9b7f8cf005a9
diff --git a/crates/effects/src/generate3.rs b/crates/effects/src/generate3.rsindex 926846a9b..eaa924119 100644--- a/crates/effects/src/generate3.rs+++ b/crates/effects/src/generate3.rs@@ -15,7 +15,7 @@ use effectcraft_raster::{Image, Px};use rayon::prelude::*;use crate::util::{Plane, gauss_plane, hash1, layer_or_self, morph_frac, poly_length, premul, smoothstep, unpremul};-use crate::{Buf, EffectCtx, EffectSpec, col, num, p, popup, slider};+use crate::{Buf, EffectCtx, EffectSpec, Params, col, num, p, popup, slider};fn spec(id: &'static str, name: &'static str, params: Vec<crate::ParamSpec>, render: crate::RenderFn) -> EffectSpec {EffectSpec { id, name, category: "Generate", params, render, gpu: false, float: true }@@ -1074,23 +1074,66 @@ fn vegas_plan(ctx: &EffectCtx, b: &Buf) -> PaintPlan {// ---------------------------------------------------------------- Write-on / Glue Gun-/// Brush dab history: only the brush position at the current time is known to an effect-/// (parameter histories are not passed in), so the stroke is drawn as the dabs laid along-/// the current position — a single dab when the brush is static. Deterministic.+/// Write-on draws a stroke along the animated Brush Position, as in After Effects: a dab every+/// Brush Spacing seconds from the layer's start up to now, each one lasting Stroke Length+/// seconds (0: for ever). The dabs' positions come from the host's parameters at their times;+/// with Paint Time Properties ▸ Opacity or Brush Time Properties ▸ Size each dab keeps its own+/// opacity or size, else the current ones apply to every dab. (Colour and hardness are one per+/// stroke: the current ones.) Without a host (or dabs) the current dab draws. Deterministic.fn write_on(ctx: &EffectCtx, mut b: Buf) -> Buf {let plan = write_on_plan(ctx, &b);draw_paint(&mut b, &plan);b}+/// The most dabs one Write-on frame draws; longer strokes lay them further apart, joined.+const WRITE_ON_MAX_DABS: i64 = 4096;+fn write_on_plan(ctx: &EffectCtx, b: &Buf) -> PaintPlan {let pr = ctx.params;- let q = b.to_px(pr.v2("brushPosition"));- let r = (pr.f("brushSize") * b.scale * 0.5).max(0.05);+ let own_opacity = pr.e("paintTimeProperties") == 1;+ let own_size = matches!(pr.e("brushTimeProperties"), 1 | 3);+ let opacity = |p: &Params| (p.f("brushOpacity") / 100.0).clamp(0.0, 1.0) as f32;+ let radius = |p: &Params| (p.f("brushSize") * b.scale * 0.5).max(0.05);+ let dab = |p: &Params| {+ let q = b.to_px(p.v2("brushPosition"));+ ([q.0, q.1], radius(if own_size { p } else { pr }), if own_opacity { opacity(p) } else { 1.0 })+ };+ let mut segs = vec![];+ let t = ctx.time;+ let spacing = pr.f("brushSpacing").max(0.001);+ let life = pr.f("strokeLength").max(0.0);+ if let Some(host) = ctx.env.host+ && t.is_finite()+ && t >= 0.0+ {+ let start = if life > 0.0 { (t - life).max(0.0) } else { 0.0 };+ let k0 = (start / spacing - 1e-9).ceil().max(0.0) as i64;+ let k1 = (t / spacing + 1e-9).floor().max(0.0) as i64;+ let n = k1.saturating_sub(k0).saturating_add(1);+ let stride = (n / WRITE_ON_MAX_DABS).saturating_add(1).max(1);+ let mut prev: Option<[f64; 2]> = None;+ let mut k = k0;+ while k <= k1 {+ let tk = k as f64 * spacing;+ let at = if (tk - t).abs() < 1e-9 { Some(dab(pr)) } else { host.params_at(tk).map(|p| dab(&p)) };+ if let Some((q, r, v)) = at {+ // Dabs laid further apart than the brush spacing are joined into a line.+ let a = if stride > 1 { prev.unwrap_or(q) } else { q };+ segs.push(Seg { a, b: q, r, v });+ prev = Some(q);+ }+ k = k.saturating_add(stride);+ }+ }+ if segs.is_empty() {+ let (q, r, v) = dab(pr);+ segs.push(Seg { a: q, b: q, r, v });+ }PaintPlan {- cov: Coverage::Segs { segs: vec![Seg { a: [q.0, q.1], b: [q.0, q.1], r, v: 1.0 }], hardness: pr.f("brushHardness") / 100.0 },+ cov: Coverage::Segs { segs, hardness: pr.f("brushHardness") / 100.0 },color: pr.color("color"),- opacity: (pr.f("brushOpacity") / 100.0) as f32,+ opacity: if own_opacity { 1.0 } else { opacity(pr) },style: pr.e("paintStyle"),}}@@ -2204,6 +2247,75 @@ mod tests {assert_eq!(g.img.get(0, 0), src.get(0, 0));}+ /// #536: an animated Brush Position draws a stroke that stays (Stroke Length 0), expires+ /// after Stroke Length, and lays its dabs Brush Spacing seconds apart.+ #[test]+ fn write_on_accumulates_a_stroke_along_the_animated_brush() {+ // Brush Position from [8, 16] at 0 s to [56, 16] at 1 s; red, hard, 6 px.+ struct Brush(Vec<(&'static str, Value)>);+ impl Brush {+ fn at(&self, t: f64) -> Vec<(&'static str, Value)> {+ let mut v = self.0.clone();+ v.push(("brushPosition", Value::Vec2([8.0 + 48.0 * t.clamp(0.0, 1.0), 16.0])));+ v+ }+ }+ impl EffectHost for Brush {+ fn layer(&self, _: u64, _: bool) -> Option<LayerPixels> {+ None+ }+ fn audio(&self, _: u64, _: f64, _: usize, _: u32) -> Option<Vec<f32>> {+ None+ }+ fn params_at(&self, t: f64) -> Option<Params> {+ let s = crate::find("ec.generate.writeon").unwrap();+ let mut p = Params { values: s.params.iter().map(|p| (p.id.to_string(), p.default.clone())).collect() };+ for (k, v) in self.at(t) {+ p.values.insert(k.to_string(), v);+ }+ Some(p)+ }+ }+ let render = |extra: &[(&'static str, Value)], t: f64| {+ let mut set = vec![("color", col(1.0, 0.0, 0.0)), ("brushSize", num(6.0)), ("brushHardness", num(100.0)), ("brushSpacing", num(0.05))];+ set.extend(extra.iter().cloned());+ let host = Brush(set);+ let env = EffectEnv { host: Some(&host), ..Default::default() };+ let at = host.at(t);+ run_env("ec.generate.writeon", &at, Image::new(64, 32), t, env).img+ };+ let on = |img: &Image, x: i64| img.get(x, 16)[3] > 0.9;+ let half = render(&[], 0.5);+ assert!(on(&half, 8) && on(&half, 20) && on(&half, 32) && !on(&half, 44) && !on(&half, 56));+ let end = render(&[], 1.0);+ assert!([8, 20, 32, 44, 56].iter().all(|x| on(&end, *x)));+ // Stroke Length 0.25 s: only the last quarter second's trail.+ let trail = render(&[("strokeLength", num(0.25))], 1.0);+ assert!(!on(&trail, 8) && !on(&trail, 32) && on(&trail, 48) && on(&trail, 56));+ // Brush Spacing 0.5 s: three separate marks.+ let spaced = render(&[("brushSpacing", num(0.5))], 1.0);+ assert!(on(&spaced, 8) && on(&spaced, 32) && on(&spaced, 56) && !on(&spaced, 20) && !on(&spaced, 44));+ // Paint Time Properties ▸ Opacity: each dab keeps the opacity it was laid with.+ struct Fade;+ impl EffectHost for Fade {+ fn layer(&self, _: u64, _: bool) -> Option<LayerPixels> {+ None+ }+ fn audio(&self, _: u64, _: f64, _: usize, _: u32) -> Option<Vec<f32>> {+ None+ }+ fn params_at(&self, t: f64) -> Option<Params> {+ let mut p = Brush(vec![("brushHardness", num(100.0)), ("brushSpacing", num(0.05)), ("paintTimeProperties", Value::Enum(1))]).params_at(t)?;+ p.values.insert("brushOpacity".into(), num(if t < 0.5 { 100.0 } else { 20.0 }));+ Some(p)+ }+ }+ let p1 = Fade.params_at(1.0).unwrap();+ let set: Vec<(&str, Value)> = p1.values.iter().map(|(k, v)| (k.as_str(), v.clone())).collect();+ let faded = run_env("ec.generate.writeon", &set, Image::new(64, 32), 1.0, EffectEnv { host: Some(&Fade), ..Default::default() }).img;+ assert!(faded.get(8, 16)[3] > 0.9 && (faded.get(56, 16)[3] - 0.2).abs() < 0.05, "{:?} {:?}", faded.get(8, 16), faded.get(56, 16));+ }+#[test]fn paint_bucket_fills_enclosed_region_only() {let mut img = Image::filled(32, 32, [1.0, 1.0, 1.0, 1.0]);