use crate::core::{Mesh, Object3D, ObjectId, ObjectKind};
use crate::math::Color;
use crate::scene::Scene;
use super::sand::{Downwind, Saltation};
use super::{Heightfield, ParticleSystem, Rng};
#[derive(Debug, Clone)]
pub struct SnowCover {
pub field: Heightfield,
pub angle_of_repose: f32,
pub sweeps: usize,
pub spread: f32,
pub thin: f32,
pub color: Color,
pub saltation: Saltation,
rng: Rng,
object: Option<ObjectId>,
drawn_version: u64,
}
impl SnowCover {
pub fn new(field: Heightfield) -> Self {
Self {
field,
angle_of_repose: 50f32.to_radians(),
sweeps: 4,
spread: 0.2,
thin: 0.012,
color: Color::from_hex(0xf2f5fa),
saltation: Saltation {
slab: 0.004,
hop: 2,
on_sand: 0.55,
on_bare: 0.3,
shadow: 15f32.to_radians(),
},
rng: Rng::new(0x5e0),
object: None,
drawn_version: u64::MAX,
}
}
pub fn absorb(&mut self, flakes: &mut ParticleSystem) {
self.take_up(flakes);
self.settle();
}
pub fn take_up(&mut self, flakes: &mut ParticleSystem) {
for l in flakes.take_landed() {
self.field
.deposit_spread(l.position.x, l.position.z, l.volume, self.spread);
}
}
pub fn settle(&mut self) {
self.field.relax(self.angle_of_repose, self.sweeps);
}
pub fn settle_within(&mut self, budget: usize) {
self.field
.relax_within(self.angle_of_repose, self.sweeps, budget);
}
pub fn object(&self) -> Object3D {
let mut look = super::surface::SurfaceLook::snow(self.color);
look.coverage = self.thin > 0.0;
let mut o = Object3D::mesh(Mesh::new(self.mesh(), look.material()));
o.cast_shadow = true;
o.receive_shadow = true;
o.name = "snow".into();
o
}
pub fn drift(&mut self, downwind: Downwind, slabs: usize) {
self.carry(downwind, slabs);
self.settle();
}
pub(crate) fn carry(&mut self, downwind: Downwind, slabs: usize) {
self.field
.saltate(downwind, slabs, &self.saltation, &mut self.rng, false);
}
fn mesh(&self) -> crate::core::BufferGeometry {
let thin = self.thin;
self.field.mesh_with_coverage(|d| {
if thin > 0.0 {
let t = (d / thin).clamp(0.0, 1.0);
t * t * (3.0 - 2.0 * t)
} else {
1.0
}
})
}
pub fn bind(&mut self, object: ObjectId) {
self.object = Some(object);
self.drawn_version = u64::MAX;
}
pub fn add_to(&mut self, scene: &mut Scene) -> ObjectId {
let id = scene.add(self.object());
self.object = Some(id);
self.drawn_version = self.field.version;
id
}
pub fn sync(&mut self, scene: &mut Scene) {
let Some(id) = self.object else { return };
if self.drawn_version == self.field.version {
return;
}
if let Some(object) = scene.get_mut(id)
&& let ObjectKind::Mesh(mesh) = &mut object.kind
{
mesh.geometry = std::sync::Arc::new(self.mesh());
}
self.drawn_version = self.field.version;
}
}