EffectCraft: An open-source motion graphics and compositing tool written by scratch in pure Rust
CC Particle World: tests for a Birth Rate that changes over time (#1373)
tylerjenningswd5a1268ead73
diff --git a/crates/effects/src/sim.rs b/crates/effects/src/sim.rsindex 8bb3c2ea7..15544eb81 100644--- a/crates/effects/src/sim.rs+++ b/crates/effects/src/sim.rs@@ -2029,4 +2029,159 @@ mod tests {assert!((sum(&full.img) - sum(&half.img)).abs() < 0.05, "{} {}", sum(&full.img), sum(&half.img));}+ // ---------------------------------------------------------- Birth Rate over time (#1373)++ /// A host that evaluates effect `index`'s Birth Rate at other layer times as `rate(t)`.+ struct Rate {+ index: usize,+ rate: fn(f64) -> f64,+ }+ impl crate::EffectHost for Rate {+ fn layer(&self, _: u64, _: bool) -> Option<crate::LayerPixels> {+ None+ }+ fn audio(&self, _: u64, _: f64, _: usize, _: u32) -> Option<Vec<f32>> {+ None+ }+ fn param_at(&self, effect_index: usize, id: &str, t: f64) -> Option<Value> {+ (effect_index == self.index && id == "birthRate").then(|| num((self.rate)(t)))+ }+ }++ /// Birth Rate 3 until 0.5 s, then 0 (the issue's one-shot burst).+ fn burst(t: f64) -> f64 {+ if t < 0.5 { 3.0 } else { 0.0 }+ }++ /// The same burst, cut at 0.25 s (an earlier key moved).+ fn short_burst(t: f64) -> f64 {+ if t < 0.25 { 3.0 } else { 0.0 }+ }++ /// Birth Rate falling linearly from 3 at 0 s to 0 at 0.5 s.+ fn falling(t: f64) -> f64 {+ (3.0 * (1.0 - t / 0.5)).max(0.0)+ }++ /// CC Particle World's parameters: random seed `seed`, Birth Rate `now` (its value at the+ /// rendered time), Longevity 1 s.+ fn pw_params(seed: f64, now: f64) -> crate::Params {+ let spec = crate::find("ec.sim.ccparticleworld").unwrap();+ let mut p = crate::Params { values: spec.params.iter().map(|ps| (ps.id.to_string(), crate::default_value(ps, [100.0, 100.0]))).collect() };+ for (k, v) in [("birthRate", num(now)), ("extras/randomSeed", num(seed)), ("longevity", num(1.0))] {+ p.values.insert(k.to_string(), v);+ }+ p+ }++ fn pw_ctx<'a>(p: &'a crate::Params, t: f64, host: Option<&'a Rate>, index: usize) -> EffectCtx<'a> {+ let env = EffectEnv { host: host.map(|h| h as &dyn crate::EffectHost), effect_index: index, ..Default::default() };+ EffectCtx { params: p, time: t, layer_size: [100.0, 100.0], seed: 1, adjustment: false, env }+ }++ /// The live particles at layer time `t` with Birth Rate `now` there and `host`'s history.+ fn pw_at(seed: f64, now: f64, t: f64, host: Option<&Rate>) -> Vec<crate::psim::SimParticle> {+ let p = pw_params(seed, now);+ particle_state("ec.sim.ccparticleworld", &pw_ctx(&p, t, host, host.map_or(0, |h| h.index))).unwrap()+ }++ /// The same, simulated from layer time 0 with a cache of its own (the reference).+ fn pw_fresh(seed: f64, now: f64, t: f64, host: &Rate) -> Vec<crate::psim::SimParticle> {+ let p = pw_params(seed, now);+ let ctx = pw_ctx(&p, t, Some(host), host.index);+ let key = params_key_except(&ctx, &Buf { img: Image::new(0, 0), offset: [0.0; 2], scale: 1.0 }, 1, &[PW_EFFECT_CAMERA, "birthRate"]);+ let st = simulate_rates(&SimCache::new(1), key, &pw_phys(&ctx), &rate_history(&ctx, "birthRate", PW_RATE));+ st.parts.iter().map(|q| crate::psim::SimParticle { p: q.p, v: q.v, age: q.age, life: q.life, rnd: q.rnd, id: q.id }).collect()+ }++ /// Particles born in the first `t` seconds of `rate`.+ fn born_by(rate: fn(f64) -> f64, t: f64) -> usize {+ crate::psim::births_at(steps_at(t), 40_000, |i| rate(i as f64 / SPS) * PW_RATE).unwrap().len()+ }++ /// #1373: Birth Rate only decides the births of its own time. After a burst stops, the+ /// particles born in it live on (moving and ageing) until their Longevity runs out, rather+ /// than vanishing because the rate is now 0.+ #[test]+ fn a_burst_lives_on_after_birth_rate_drops_to_zero() {+ let host = Rate { index: 2, rate: burst };+ // During the burst: as a constant Birth Rate of 3.+ assert_eq!(pw_at(101.0, 3.0, 0.4, Some(&host)), pw_at(101.0, 3.0, 0.4, None));+ // After it: the burst's particles, none newer.+ let late = pw_at(101.0, 0.0, 0.9, Some(&host));+ let n = born_by(burst, 0.5);+ assert!(late.len() > n / 2 && late.iter().all(|q| (q.id as usize) < n), "{} live of {n} born", late.len());+ assert!(pw_at(101.0, 0.0, 0.9, None).is_empty(), "a constant Birth Rate of 0 never bore any");+ // They keep moving.+ let early = pw_at(101.0, 0.0, 0.7, Some(&host));+ let q0 = early.iter().find(|q| q.id == late[0].id).unwrap();+ assert!(q0.p != late[0].p && late[0].age > q0.age + 0.19, "{q0:?} -> {:?}", late[0]);+ // Longevity 1 s (± 20 %): all gone by 1.8 s.+ assert!(pw_at(101.0, 0.0, 1.8, Some(&host)).is_empty());+ // The effect asks for its own index: another effect's history isn't its own.+ let p = pw_params(101.0, 0.0);+ assert!(particle_state("ec.sim.ccparticleworld", &pw_ctx(&p, 0.9, Some(&host), 0)).unwrap().is_empty());+ }++ /// A Birth Rate ramping down isn't simulated as if its current value had always applied.+ #[test]+ fn a_ramped_birth_rate_bears_what_each_moment_asked_for() {+ let host = Rate { index: 0, rate: falling };+ let ramped = pw_at(102.0, falling(0.25), 0.25, Some(&host));+ let constant = pw_at(102.0, falling(0.25), 0.25, None);+ assert_eq!(ramped.len(), born_by(falling, 0.25), "every particle born so far is alive");+ assert_eq!(constant.len(), born_by(|_| 1.5, 0.25));+ assert!(ramped.len() > constant.len() + 10, "{} vs {}", ramped.len(), constant.len());+ }++ /// Seeking backward, forward and to the same time again gives the state simulated from 0.+ #[test]+ fn seeking_through_a_birth_rate_history_matches_simulating_from_zero() {+ let host = Rate { index: 0, rate: burst };+ for t in [1.4, 0.6, 0.9, 0.3, 0.9, 1.1] {+ let now = burst(t);+ assert_eq!(pw_at(103.0, now, t, Some(&host)), pw_fresh(103.0, now, t, &host), "at {t}");+ }+ }++ /// The simulation cache key leaves Birth Rate out (so an animated rate keeps its checkpoints),+ /// but a checkpoint is only resumed with the history that reached it: after an earlier key+ /// moves, the same current rate (0) gives the new history's particles.+ #[test]+ fn an_earlier_birth_rate_change_is_not_served_from_stale_checkpoints() {+ let (long, short) = (Rate { index: 0, rate: burst }, Rate { index: 0, rate: short_burst });+ let a = pw_at(104.0, 0.0, 0.9, Some(&long));+ let b = pw_at(104.0, 0.0, 0.9, Some(&short));+ assert_eq!(b, pw_fresh(104.0, 0.0, 0.9, &short));+ assert!(b.len() < a.len() && !b.is_empty(), "{} vs {}", b.len(), a.len());+ assert_eq!(pw_at(104.0, 0.0, 1.0, Some(&long)), pw_fresh(104.0, 0.0, 1.0, &long));+ }++ /// A constant Birth Rate gives exactly the particles it did before the history was sampled.+ #[test]+ fn a_constant_birth_rate_is_unchanged() {+ let host = Rate { index: 0, rate: |_| 2.0 };+ let p = pw_params(105.0, 2.0);+ let ctx = pw_ctx(&p, 1.3, None, 0);+ let phys = pw_phys(&ctx);+ let before = simulate(&SimCache::new(1), sim_key(&ctx, 1), 1.3, &phys);+ let now = pw_at(105.0, 2.0, 1.3, Some(&host));+ assert_eq!(now.len(), before.parts.len());+ assert!(now.iter().zip(&before.parts).all(|(a, b)| a.id == b.id && a.p == b.p && a.v == b.v && a.age == b.age));+ assert_eq!(crate::psim::births_at(78, 40_000, |_| phys.rate), crate::psim::births(phys.rate, 78, 40_000));+ }++ /// The GPU's birth schedule for a rate history is the CPU's: the ids born are the ids the+ /// CPU simulation numbers.+ #[test]+ fn the_birth_schedule_follows_the_rate_history() {+ let host = Rate { index: 0, rate: falling };+ let p = pw_params(106.0, 0.0);+ let ctx = pw_ctx(&p, 0.7, Some(&host), 0);+ let rates = rate_history(&ctx, "birthRate", PW_RATE);+ let st = simulate_rates(&SimCache::new(1), 9, &pw_phys(&ctx), &rates);+ let births = crate::psim::births_at(rates.len() as u64, 40_000, |i| rates[i as usize]).unwrap();+ assert_eq!(st.next_id as usize, births.len());+ assert!(births.iter().all(|&b| f64::from(b) / SPS < 0.5), "nothing born once the ramp reaches 0");+ }}