use crate::core::ObjectId;
use crate::math::Vector3;
use crate::scene::Scene;
use super::sand::{Downwind, SandBed};
use super::snow::SnowCover;
use super::{Heightfield, ParticleEffect, ParticleSystem, Weather};
#[derive(Debug, Clone)]
pub enum Layer {
Snow(SnowCover),
Sand(SandBed),
}
impl Layer {
pub fn field(&self) -> &Heightfield {
match self {
Layer::Snow(s) => &s.field,
Layer::Sand(s) => &s.field,
}
}
pub fn field_mut(&mut self) -> &mut Heightfield {
match self {
Layer::Snow(s) => &mut s.field,
Layer::Sand(s) => &mut s.field,
}
}
fn take_up(&mut self, system: &mut ParticleSystem) {
match self {
Layer::Snow(s) => s.take_up(system),
Layer::Sand(s) => s.take_up(system),
}
}
fn settle_some(&mut self) {
let f = self.field();
let budget = 8 * f.nx * f.nz;
match self {
Layer::Snow(s) => s.settle_within(budget),
Layer::Sand(s) => s.settle_within(budget),
}
}
fn sync(&mut self, scene: &mut Scene) {
match self {
Layer::Snow(s) => s.sync(scene),
Layer::Sand(s) => s.sync(scene),
}
}
}
#[derive(Debug, Clone)]
struct Effect {
fx: ParticleEffect,
anchors: Vec<Vector3>,
settles_on: Option<ObjectId>,
light: Option<DrivenLight>,
}
#[derive(Debug, Clone)]
struct DrivenLight {
object: ObjectId,
intensity: f32,
mean: f32,
at: Option<Vector3>,
}
#[derive(Debug, Clone)]
struct LayerEntry {
layer: Layer,
object: ObjectId,
base_from: Option<f32>,
wind: Option<(Downwind, f32)>,
carried: f32,
since_settled: f32,
since_drawn: f32,
}
const LAYER_INTERVAL: f32 = 1.0 / 15.0;
const SNOW_REDRAW: f32 = 0.25;
#[derive(Debug, Clone, Default)]
pub struct ParticleAnimator {
effects: Vec<Effect>,
layers: Vec<LayerEntry>,
weather: Vec<(ObjectId, Weather)>,
time: f32,
}
impl ParticleAnimator {
pub fn new() -> Self {
Self::default()
}
pub fn add(&mut self, scene: &mut Scene, system: ParticleSystem) -> ObjectId {
let anchors = system.emitters.iter().map(|e| e.position).collect();
let fx = ParticleEffect::add_to(scene, system);
let id = fx.object;
self.effects.push(Effect {
fx,
anchors,
settles_on: None,
light: None,
});
id
}
pub fn track(&mut self, object: ObjectId, system: ParticleSystem) {
let anchors = system.emitters.iter().map(|e| e.position).collect();
self.effects.push(Effect {
fx: ParticleEffect {
system,
object,
caster: None,
},
anchors,
settles_on: None,
light: None,
});
}
pub fn track_snow(&mut self, object: ObjectId, mut cover: SnowCover, base_from: Option<f32>) {
cover.bind(object);
self.layers.push(LayerEntry {
layer: Layer::Snow(cover),
object,
base_from,
wind: None,
carried: 0.0,
since_settled: 0.0,
since_drawn: LAYER_INTERVAL,
});
}
pub fn track_sand(&mut self, object: ObjectId, mut bed: SandBed, base_from: Option<f32>) {
bed.bind(object);
self.layers.push(LayerEntry {
layer: Layer::Sand(bed),
object,
base_from,
wind: None,
carried: 0.0,
since_settled: 0.0,
since_drawn: LAYER_INTERVAL,
});
}
pub fn add_snow(
&mut self,
scene: &mut Scene,
mut cover: SnowCover,
base_from: Option<f32>,
) -> ObjectId {
let object = cover.add_to(scene);
self.layers.push(LayerEntry {
layer: Layer::Snow(cover),
object,
base_from,
wind: None,
carried: 0.0,
since_settled: 0.0,
since_drawn: LAYER_INTERVAL,
});
object
}
pub fn add_sand(
&mut self,
scene: &mut Scene,
mut bed: SandBed,
base_from: Option<f32>,
) -> ObjectId {
let object = bed.add_to(scene);
self.layers.push(LayerEntry {
layer: Layer::Sand(bed),
object,
base_from,
wind: None,
carried: 0.0,
since_settled: 0.0,
since_drawn: LAYER_INTERVAL,
});
object
}
pub fn settle(&mut self, system: ObjectId, layer: ObjectId) {
if let Some(e) = self.effects.iter_mut().find(|e| e.fx.object == system) {
e.settles_on = Some(layer);
}
}
pub fn light_with(&mut self, system: ObjectId, light: ObjectId, intensity: f32) {
if let Some(e) = self.effects.iter_mut().find(|e| e.fx.object == system) {
e.light = Some(DrivenLight {
object: light,
intensity,
mean: 0.0,
at: None,
});
}
}
pub fn set_layer_wind(&mut self, layer: ObjectId, wind: Option<(Downwind, f32)>) {
if let Some(l) = self.layers.iter_mut().find(|l| l.object == layer) {
l.wind = wind;
}
}
pub fn system(&self, id: ObjectId) -> Option<&ParticleSystem> {
self.effects
.iter()
.find(|e| e.fx.object == id)
.map(|e| &e.fx.system)
}
pub fn system_mut(&mut self, id: ObjectId) -> Option<&mut ParticleSystem> {
self.effects
.iter_mut()
.find(|e| e.fx.object == id)
.map(|e| &mut e.fx.system)
}
pub fn layer(&self, id: ObjectId) -> Option<&Layer> {
self.layers
.iter()
.find(|l| l.object == id)
.map(|l| &l.layer)
}
pub fn layer_mut(&mut self, id: ObjectId) -> Option<&mut Layer> {
self.layers
.iter_mut()
.find(|l| l.object == id)
.map(|l| &mut l.layer)
}
pub fn untrack(&mut self, id: ObjectId) {
self.effects.retain(|e| e.fx.object != id);
self.layers.retain(|l| l.object != id);
self.weather.retain(|w| w.0 != id);
}
pub fn add_weather(&mut self, scene: &mut Scene, weather: Weather) -> ObjectId {
let id = scene.add(weather.object());
self.weather.push((id, weather));
id
}
pub fn track_weather(&mut self, object: ObjectId, weather: Weather) {
self.weather.push((object, weather));
}
pub fn weather_mut(&mut self, id: ObjectId) -> Option<&mut Weather> {
self.weather
.iter_mut()
.find(|w| w.0 == id)
.map(|w| &mut w.1)
}
pub fn update(&mut self, scene: &mut Scene, dt: f32, eye: Option<Vector3>) {
scene.update_world();
if self.layers.iter().any(|l| l.base_from.is_some()) {
let ours: Vec<ObjectId> = self
.effects
.iter()
.map(|e| e.fx.object)
.chain(self.layers.iter().map(|l| l.object))
.chain(self.weather.iter().map(|w| w.0))
.collect();
let solids: Vec<ObjectId> = scene
.arena
.get(scene.root)
.map(|r| {
r.children
.iter()
.copied()
.filter(|c| !ours.contains(c))
.collect()
})
.unwrap_or_default();
for l in &mut self.layers {
if let Some(from) = l.base_from.take() {
l.layer
.field_mut()
.base_from_scene(&scene.arena, &solids, from);
}
}
}
self.time += dt;
let centre = eye.unwrap_or(Vector3::ZERO);
for (id, w) in &self.weather {
w.update(scene, *id, self.time, centre);
}
for e in &mut self.effects {
if e.fx.system.look.casts_shadow
&& e.fx.caster.is_none()
&& scene.get(e.fx.object).is_some()
{
e.fx.caster = Some(scene.add_to(e.fx.object, super::render::caster_object()));
}
if let Some(o) = scene.get(e.fx.object) {
let m = o.matrix_world;
for (emitter, anchor) in e.fx.system.emitters.iter_mut().zip(&e.anchors) {
emitter.position = anchor.apply_matrix4(&m);
}
}
let layer = e
.settles_on
.and_then(|id| self.layers.iter_mut().find(|l| l.object == id));
match layer {
Some(l) => {
e.fx.system.step(dt, Some(l.layer.field()));
l.layer.take_up(&mut e.fx.system);
}
None => e.fx.system.step(dt, None),
}
e.fx.sync(scene, eye);
if let Some(dl) = &mut e.light {
drive_light(dl, &e.fx.system, scene, dt);
}
}
for l in &mut self.layers {
if let Some((downwind, rate)) = l.wind {
l.carried += rate * dt;
let slabs = l.carried.floor();
l.carried -= slabs;
if slabs > 0.0 {
match &mut l.layer {
Layer::Sand(bed) => bed.carry(downwind, slabs as usize),
Layer::Snow(cover) => cover.carry(downwind, slabs as usize),
}
}
}
if let Layer::Sand(bed) = &mut l.layer {
bed.advance(scene, dt);
}
l.since_settled += dt;
l.since_drawn += dt;
if l.since_settled >= LAYER_INTERVAL {
l.since_settled = 0.0;
l.layer.settle_some();
}
let redraw = match l.layer {
Layer::Snow(_) => SNOW_REDRAW,
Layer::Sand(_) => LAYER_INTERVAL,
};
if l.since_drawn >= redraw {
l.since_drawn = 0.0;
l.layer.sync(scene);
}
}
}
}
fn glow(system: &ParticleSystem) -> (f32, Vector3) {
let ps = &system.particles;
let (mut total, mut centre) = (0.0f32, Vector3::ZERO);
for (i, &position) in ps.position.iter().enumerate() {
let t = system.life_fraction(i);
let mut w = system.color_over_life.at(t)[3].max(0.0);
if let Some(k) = &system.temperature_over_life {
w *= (k.at(t) / 1500.0).powi(4);
}
total += w;
centre = centre + position * w;
}
(
total,
if total > 0.0 {
centre * (1.0 / total)
} else {
Vector3::ZERO
},
)
}
fn drive_light(dl: &mut DrivenLight, system: &ParticleSystem, scene: &mut Scene, dt: f32) {
let (now, centre) = glow(system);
let k = (dt / 1.5).min(1.0);
dl.mean = if dl.mean <= 0.0 {
now
} else {
dl.mean + (now - dl.mean) * k
};
let level = if dl.mean > 1e-6 {
(now / dl.mean).clamp(0.0, 2.0)
} else {
0.0
};
let at = match dl.at {
Some(p) => p + (centre - p) * (dt * 6.0).min(1.0),
None => centre,
};
dl.at = Some(at);
if let Some(o) = scene.get_mut(dl.object) {
if now > 0.0 {
o.position = at;
}
let i = dl.intensity * level;
match &mut o.kind {
crate::core::ObjectKind::Light(crate::lights::Light::Point(l)) => l.intensity = i,
crate::core::ObjectKind::Light(crate::lights::Light::Spot(l)) => l.intensity = i,
_ => {}
}
}
}