Skip to content

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.rs
index 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");
+ }
}