EffectCraft: An open-source motion graphics and compositing tool written by scratch in pure Rust
CC Particle World: Birth Rate decides the births of its own time, so a burst lives on (#1373)
tylerjenningswbb0e2b57db22
diff --git a/crates/effects/src/sim.rs b/crates/effects/src/sim.rsindex 2c7b97d14..8bb3c2ea7 100644--- a/crates/effects/src/sim.rs+++ b/crates/effects/src/sim.rs@@ -784,6 +784,14 @@ pub(crate) struct PState {pub parts: Vec<Particle>,pub carry: f64,pub next_id: u32,+ /// The birth rates of the steps so far (see [`rates_hash`]): a checkpoint is only resumed+ /// from with the same history.+ pub hist: u64,+}++/// `hist` after one more step at `rate` particles per second.+fn rates_hash(hist: u64, rate: f64) -> u64 {+ (hist ^ rate.to_bits()).wrapping_mul(0x0100_0000_01b3).rotate_left(5)}/// Physics configuration (world units; y down).@@ -862,6 +870,12 @@ impl Phys {}pub(crate) fn step(&self, st: &mut PState, step: u64) {+ self.step_at_rate(st, step, self.rate);+ }++ /// One step with `rate` particles per second born during it (rather than [`Phys::rate`]):+ /// the rate only decides the births, particles already alive move and age as ever.+ pub(crate) fn step_at_rate(&self, st: &mut PState, step: u64, rate: f64) {let dt = (1.0 / SPS) as f32;let t = step as f32 * dt;let mut drag = self.resistance;@@ -919,7 +933,8 @@ impl Phys {q.age += dt;});st.parts.retain(|q| q.age < q.life);- st.carry += self.rate / SPS;+ st.hist = rates_hash(st.hist, rate);+ st.carry += rate / SPS;let n = st.carry.floor() as u32;st.carry -= n as f64;for _ in 0..n {@@ -966,31 +981,73 @@ impl Phys {}/// The state at layer time `ctx.time` from the host's particle backend (GPU particles), or-/// `None` (simulate on the CPU).-fn accelerated(ctx: &EffectCtx, key: u64, phys: &Phys) -> Option<std::sync::Arc<PState>> {+/// `None` (simulate on the CPU). `rates`: the birth rate of each step, when it changes over time+/// (else [`Phys::rate`]).+fn accelerated(ctx: &EffectCtx, key: u64, phys: &Phys, rates: Option<&[f64]>) -> Option<std::sync::Arc<PState>> {let backend = ctx.env.host?.particles()?;let steps = steps_at(ctx.time);- let births = crate::psim::births(phys.rate, steps, phys.max)?;+ let births = match rates {+ Some(r) => crate::psim::births_at(steps, phys.max, |i| r.get(i as usize).copied().unwrap_or(0.0))?,+ None => crate::psim::births(phys.rate, steps, phys.max)?,+ };let req = crate::psim::SimRequest { key, steps, births: &births, system: crate::psim::ParticleSystem::Engine(phys.desc()) };let parts = backend.simulate(&req)?;Some(std::sync::Arc::new(PState {parts: parts.into_iter().map(|q| Particle { p: q.p, v: q.v, age: q.age, life: q.life, rnd: q.rnd, id: q.id }).collect(),carry: 0.0,next_id: births.len() as u32,+ hist: 0,}))}+/// The birth rate (particles per second) of each step up to layer time `ctx.time`: parameter+/// `id` × `k`, sampled where the step starts (a keyframed or expression-driven Birth Rate only+/// decides the births of its own time, #1373). Without a host that evaluates the effect at+/// other times, the current value for every step.+fn rate_history(ctx: &EffectCtx, id: &str, k: f64) -> Vec<f64> {+ let now = ctx.params.f(id);+ let host = ctx.env.host;+ (0..steps_at(ctx.time))+ .map(|i| {+ let v = host.and_then(|h| h.param_at(ctx.env.effect_index, id, i as f64 / SPS)).map_or(now, |v| v.as_f64());+ if v.is_finite() { v.max(0.0) * k } else { 0.0 }+ })+ .collect()+}++/// Run a particle system through `rates` (one birth rate per step, see [`rate_history`]) with+/// `cache`, resuming only from checkpoints reached with the same rates.+fn simulate_rates(cache: &SimCache<PState>, key: u64, phys: &Phys, rates: &[f64]) -> std::sync::Arc<PState> {+ // `hist` of the state after each number of steps.+ let mut prefix = Vec::with_capacity(rates.len() + 1);+ prefix.push(0u64);+ for r in rates {+ prefix.push(rates_hash(prefix.last().copied().unwrap_or(0), *r));+ }+ let rate = |i: u64| rates.get(i as usize).copied().unwrap_or(0.0);+ cache.run_where(key, rates.len() as u64, PState::default, |st, i| phys.step_at_rate(st, i, rate(i)), |s, st| prefix.get(s as usize) == Some(&st.hist))+}++/// CC Particle World's particles at `ctx.time`, born at the Birth Rate of their own time.+fn pw_state(ctx: &EffectCtx, phys: &Phys) -> std::sync::Arc<PState> {+ let rates = rate_history(ctx, "birthRate", PW_RATE);+ // Every parameter but Birth Rate (its history is checked through `PState::hist`).+ let key = params_key_except(ctx, &Buf { img: Image::new(0, 0), offset: [0.0; 2], scale: 1.0 }, 1, &[PW_EFFECT_CAMERA, "birthRate"]);+ accelerated(ctx, key, phys, Some(&rates)).unwrap_or_else(|| simulate_rates(&PW_CACHE, key, phys, &rates))+}+/// The live particles of a stepped particle effect (`ec.sim.ccparticleworld`,/// `ec.sim.ccparticlesystems2`) at `ctx.time`: from the host's particle backend when it has/// one (GPU particles), else from the CPU simulation. For comparing the two.pub fn particle_state(id: &str, ctx: &EffectCtx) -> Option<Vec<crate::psim::SimParticle>> {- let (phys, cache, salt) = match id {- "ec.sim.ccparticleworld" => (pw_phys(ctx), &PW_CACHE, 1),- "ec.sim.ccparticlesystems2" => (ps2_phys(ctx), &PS2_CACHE, 2),+ let st = match id {+ "ec.sim.ccparticleworld" => pw_state(ctx, &pw_phys(ctx)),+ "ec.sim.ccparticlesystems2" => {+ let (phys, key) = (ps2_phys(ctx), sim_key(ctx, 2));+ accelerated(ctx, key, &phys, None).unwrap_or_else(|| simulate(&PS2_CACHE, key, ctx.time, &phys))+ }_ => return None,};- let key = sim_key(ctx, salt);- let st = accelerated(ctx, key, &phys).unwrap_or_else(|| simulate(cache, key, ctx.time, &phys));Some(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())}@@ -1042,11 +1099,14 @@ fn type_sprite(kind: u32, x: f32, y: f32, r: f32, c: [f32; 4], vx: f32, vy: f32,static PW_CACHE: SimCache<PState> = SimCache::new(6);+/// Particles per second per unit of CC Particle World's Birth Rate.+const PW_RATE: f64 = 120.0;+/// CC Particle World's physics.fn pw_phys(ctx: &EffectCtx) -> Phys {let pr = ctx.params;Phys {- rate: pr.f("birthRate").max(0.0) * 120.0,+ rate: pr.f("birthRate").max(0.0) * PW_RATE,life: pr.f("longevity").max(0.0) as f32,producer: [pr.f("producer/producerX") as f32, pr.f("producer/producerY") as f32, pr.f("producer/producerZ") as f32],radius: [pr.f("producer/radiusX").max(0.0) as f32, pr.f("producer/radiusY").max(0.0) as f32, pr.f("producer/radiusZ").max(0.0) as f32],@@ -1167,8 +1227,7 @@ fn particle_world_plan(ctx: &EffectCtx, b: &Buf) -> Option<SpritePlan> {if phys.rate <= 0.0 && ctx.time <= 0.0 {return None;}- let key = sim_key(ctx, 1);- let st = accelerated(ctx, key, &phys).unwrap_or_else(|| simulate(&PW_CACHE, key, ctx.time, &phys));+ let st = pw_state(ctx, &phys);let kind = pr.e("particle/particleType");let birth = pr.color("particle/birthColor");let death = pr.color("particle/deathColor");@@ -1242,7 +1301,7 @@ fn particle_systems2_plan(ctx: &EffectCtx, b: &Buf) -> SpritePlan {let unit = lh.max(1.0);let phys = ps2_phys(ctx);let key = sim_key(ctx, 2);- let st = accelerated(ctx, key, &phys).unwrap_or_else(|| simulate(&PS2_CACHE, key, ctx.time, &phys));+ let st = accelerated(ctx, key, &phys, None).unwrap_or_else(|| simulate(&PS2_CACHE, key, ctx.time, &phys));let kind = pr.e("particle/particleType");let birth = pr.color("particle/birthColor");let death = pr.color("particle/deathColor");@@ -1969,4 +2028,5 @@ mod tests {let sum = |i: &Image| i.data.iter().map(|p| p[0]).sum::<f32>() / i.data.len() as f32;assert!((sum(&full.img) - sum(&half.img)).abs() < 0.05, "{} {}", sum(&full.img), sum(&half.img));}+}diff --git a/crates/gpu/src/particles.rs b/crates/gpu/src/particles.rsindex 7934dee0c..837746547 100644--- a/crates/gpu/src/particles.rs+++ b/crates/gpu/src/particles.rs@@ -23,10 +23,25 @@ struct Checkpoint {key: u64,steps: u64,n: u32,+ /// The birth steps of its particles (see [`born`]).+ born: u64,buf: wgpu::Buffer,used: u64,}+/// The particles born in the first `steps` steps of `births` (ascending birth steps) and a hash+/// of their birth steps: a checkpoint is only resumed from when the request's births before it+/// are the same (a keyframed Birth Rate isn't part of the system key, #1373).+fn born(births: &[u32], steps: u64) -> (u32, u64) {+ let mut h = 0xcbf2_9ce4_8422_2325u64;+ let mut n = 0u32;+ for &b in births.iter().take_while(|&&b| u64::from(b) < steps) {+ h = (h ^ u64::from(b)).wrapping_mul(0x0100_0000_01b3);+ n += 1;+ }+ (n, h)+}+#[derive(Default)]pub(crate) struct Checkpoints {list: Vec<Checkpoint>,@@ -141,7 +156,7 @@ pub(crate) fn simulate(g: &GpuContext, req: &SimRequest) -> Option<Vec<SimParticlet mut c = g.particle_states.lock().ok()?;c.clock += 1;let now = c.clock;- match c.list.iter_mut().filter(|k| k.key == req.key && k.steps <= req.steps).max_by_key(|k| k.steps) {+ match c.list.iter_mut().filter(|k| k.key == req.key && k.steps <= req.steps && born(req.births, k.steps) == (k.n, k.born)).max_by_key(|k| k.steps) {Some(k) => {k.used = now;(k.steps, Some(k.buf.clone()), k.n)@@ -232,7 +247,8 @@ fn keep_checkpoint(g: &GpuContext, req: &SimRequest, n: u32, next: wgpu::Buffer)if let Ok(mut c) = g.particle_states.lock() {let now = c.clock;c.list.retain(|k| !(k.key == req.key && k.steps == req.steps));- c.list.push(Checkpoint { key: req.key, steps: req.steps, n, buf: next, used: now });+ let (_, h) = born(req.births, req.steps);+ c.list.push(Checkpoint { key: req.key, steps: req.steps, n, born: h, buf: next, used: now });while c.list.len() > CHECKPOINTS {let Some(i) = c.list.iter().enumerate().min_by_key(|(_, k)| k.used).map(|(i, _)| i) else { break };c.list.remove(i);