EffectCraft: An open-source motion graphics and compositing tool written by scratch in pure Rust
Particles: tests for CC Particle Systems II and CC Mr. Mercury with a Birth Rate over time (#1373)
tylerjenningsw16cc290a476f
diff --git a/crates/effects/src/sim.rs b/crates/effects/src/sim.rsindex 8d7849019..ab2884451 100644--- a/crates/effects/src/sim.rs+++ b/crates/effects/src/sim.rs@@ -2224,4 +2224,110 @@ mod tests {assert!(births.iter().all(|&b| f64::from(b) / SPS < 0.5), "nothing born once the ramp reaches 0");}+ // ------------------------- CC Particle Systems II and CC Mr. Mercury's Birth Rate over time++ /// A stepped particle effect: its id, physics and simulation.+ struct System {+ id: &'static str,+ phys: fn(&EffectCtx) -> Phys,+ stepped: Stepped<'static>,+ }++ const SYSTEMS: [System; 2] =+ [System { id: "ec.sim.ccparticlesystems2", phys: ps2_phys, stepped: PS2 }, System { id: "ec.sim.ccmrmercury", phys: mercury_phys, stepped: MERCURY }];++ /// `id`'s parameters with Birth Rate `now` and Longevity 1 s.+ fn sys_params(id: &str, now: f64) -> crate::Params {+ let spec = crate::find(id).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)), ("longevity", num(1.0))] {+ assert!(p.values.contains_key(k), "{id}: no {k}");+ p.values.insert(k.to_string(), v);+ }+ p+ }++ /// The context at layer time `t` (`seed` keeps each test's simulations apart).+ fn sys_ctx<'a>(p: &'a crate::Params, t: f64, host: Option<&'a Rate>, seed: u32) -> EffectCtx<'a> {+ let env = EffectEnv { host: host.map(|h| h as &dyn crate::EffectHost), effect_index: host.map_or(0, |h| h.index), ..Default::default() };+ EffectCtx { params: p, time: t, layer_size: [100.0, 100.0], seed, adjustment: false, env }+ }++ /// The live particles (id, position, age) of `sys` at `t` through its simulation.+ fn sys_at(sys: &System, seed: u32, now: f64, t: f64, host: Option<&Rate>) -> Vec<(u32, [f32; 3], f32)> {+ let p = sys_params(sys.id, now);+ let ctx = sys_ctx(&p, t, host, seed);+ sys.stepped.state(&ctx, &(sys.phys)(&ctx)).parts.iter().map(|q| (q.id, q.p, q.age)).collect()+ }++ /// The same, simulated from layer time 0 with a cache of its own (the reference).+ fn sys_fresh(sys: &System, seed: u32, now: f64, t: f64, host: &Rate) -> Vec<(u32, [f32; 3], f32)> {+ let p = sys_params(sys.id, now);+ let ctx = sys_ctx(&p, t, Some(host), seed);+ let mut skip = sys.stepped.skip.to_vec();+ skip.push("birthRate");+ let key = params_key_except(&ctx, &Buf { img: Image::new(0, 0), offset: [0.0; 2], scale: 1.0 }, sys.stepped.salt, &skip);+ let st = simulate_rates(&SimCache::new(1), key, &(sys.phys)(&ctx), &rate_history(&ctx, "birthRate", sys.stepped.k));+ st.parts.iter().map(|q| (q.id, q.p, q.age)).collect()+ }++ /// What `sys` draws at `t`: CC Particle Systems II's particles, CC Mr. Mercury's blobs.+ fn sys_drawn(sys: &System, seed: u32, now: f64, t: f64, host: Option<&Rate>) -> usize {+ let p = sys_params(sys.id, now);+ let ctx = sys_ctx(&p, t, host, seed);+ match sys.id {+ "ec.sim.ccmrmercury" => mercury_blobs(&ctx, &Buf { img: Image::new(100, 100), offset: [0.0; 2], scale: 1.0 }).len(),+ id => particle_state(id, &ctx).unwrap().len(),+ }+ }++ /// #1373 for CC Particle Systems II and CC Mr. Mercury: a burst lives on after Birth Rate+ /// drops to 0 (what they draw too), moving and ageing, and is gone after its Longevity.+ #[test]+ fn particle_systems_ii_and_mr_mercury_keep_a_burst_after_birth_rate_drops() {+ let host = Rate { index: 1, rate: burst };+ for sys in &SYSTEMS {+ let born = crate::psim::births_at(steps_at(0.5), 40_000, |i| burst(i as f64 / SPS) * sys.stepped.k).unwrap().len();+ assert_eq!(sys_at(sys, 201, 3.0, 0.4, Some(&host)), sys_at(sys, 201, 3.0, 0.4, None), "{}: during the burst", sys.id);+ let late = sys_at(sys, 201, 0.0, 0.9, Some(&host));+ assert!(late.len() > born / 2 && late.iter().all(|q| (q.0 as usize) < born), "{}: {} live of {born}", sys.id, late.len());+ assert!(sys_drawn(sys, 201, 0.0, 0.9, Some(&host)) > 0, "{}: drawn", sys.id);+ assert_eq!(sys_drawn(sys, 201, 0.0, 0.9, None), 0, "{}: a constant 0 bore none", sys.id);+ let early = sys_at(sys, 201, 0.0, 0.7, Some(&host));+ let q0 = early.iter().find(|q| q.0 == late[0].0).unwrap();+ assert!(q0.1 != late[0].1 && late[0].2 > q0.2 + 0.19, "{}: {q0:?} -> {:?}", sys.id, late[0]);+ assert!(sys_at(sys, 201, 0.0, 1.8, Some(&host)).is_empty(), "{}: gone after Longevity", sys.id);+ }+ }++ /// Seeking matches a simulation from 0, and moving an earlier key (same current rate, same+ /// cache key) isn't served from the old history's checkpoints.+ #[test]+ fn particle_systems_ii_and_mr_mercury_seek_and_drop_stale_checkpoints() {+ let (long, short) = (Rate { index: 0, rate: burst }, Rate { index: 0, rate: short_burst });+ for sys in &SYSTEMS {+ for t in [1.4, 0.6, 0.9, 0.3, 0.9, 1.1] {+ let now = burst(t);+ assert_eq!(sys_at(sys, 202, now, t, Some(&long)), sys_fresh(sys, 202, now, t, &long), "{} at {t}", sys.id);+ }+ let b = sys_at(sys, 202, 0.0, 0.9, Some(&short));+ assert_eq!(b, sys_fresh(sys, 202, 0.0, 0.9, &short), "{}: the moved key", sys.id);+ assert!(!b.is_empty() && b.len() < sys_at(sys, 202, 0.0, 0.9, Some(&long)).len(), "{}", sys.id);+ }+ }++ /// A constant Birth Rate gives exactly the particles the constant-rate simulation did.+ #[test]+ fn particle_systems_ii_and_mr_mercury_are_unchanged_at_a_constant_rate() {+ let host = Rate { index: 0, rate: |_| 2.0 };+ for sys in &SYSTEMS {+ let p = sys_params(sys.id, 2.0);+ let ctx = sys_ctx(&p, 1.3, None, 203);+ let before = simulate(&SimCache::new(1), 1, 1.3, &(sys.phys)(&ctx));+ let before: Vec<_> = before.parts.iter().map(|q| (q.id, q.p, q.age)).collect();+ assert!(!before.is_empty());+ assert_eq!(sys_at(sys, 203, 2.0, 1.3, Some(&host)), before, "{}: keyed to a constant", sys.id);+ assert_eq!(sys_at(sys, 203, 2.0, 1.3, None), before, "{}: no host", sys.id);+ }+ }}