use std::f32::consts::PI;
use euclid::default::{Point2D, Vector2D};
#[derive(Clone, Copy, Debug)]
pub struct FluidParams {
pub rest_density: f32,
pub particle_radius: f32,
pub smoothing_radius: f32,
pub solver_iters: u32,
pub viscosity: f32,
pub damping: f32,
pub relaxation_eps: f32,
pub gravity: Vector2D<f32>,
pub max_particles: usize,
}
impl Default for FluidParams {
fn default() -> Self {
Self {
rest_density: 1.0,
particle_radius: 7.0,
smoothing_radius: 40.0,
solver_iters: 3,
viscosity: 0.05,
damping: 0.99,
relaxation_eps: 100.0,
gravity: Vector2D::new(0.0, 520.0),
max_particles: 600,
}
}
}
#[derive(Clone, Copy, Debug)]
pub struct Basin {
pub min_x: f32,
pub max_x: f32,
pub floor_y: f32,
}
impl Basin {
fn clamp(&self, p: Point2D<f32>, r: f32) -> Point2D<f32> {
let lo = self.min_x + r;
let hi = self.max_x - r;
let x = if lo <= hi {
p.x.clamp(lo, hi)
} else {
0.5 * (self.min_x + self.max_x)
};
Point2D::new(x, p.y.min(self.floor_y - r))
}
}
#[derive(Clone, Copy, Debug)]
pub struct FluidContact {
pub center: Point2D<f32>,
pub shape: ContactShape,
}
#[derive(Clone, Copy, Debug)]
pub enum ContactShape {
Circle { radius: f32 },
Obb { half: (f32, f32), angle: f32 },
}
impl FluidContact {
pub fn circle(center: Point2D<f32>, radius: f32) -> Self {
Self {
center,
shape: ContactShape::Circle { radius },
}
}
pub fn obb(center: Point2D<f32>, half: (f32, f32), angle: f32) -> Self {
Self {
center,
shape: ContactShape::Obb { half, angle },
}
}
}
pub struct Fluid {
pos: Vec<Point2D<f32>>,
vel: Vec<Vector2D<f32>>,
pred: Vec<Point2D<f32>>,
lambda: Vec<f32>,
params: FluidParams,
basin: Basin,
}
impl Fluid {
pub fn new(params: FluidParams, basin: Basin) -> Self {
Self {
pos: Vec::new(),
vel: Vec::new(),
pred: Vec::new(),
lambda: Vec::new(),
params,
basin,
}
}
pub fn spawn_block(&mut self, origin: Point2D<f32>, cols: usize, rows: usize, spacing: f32) {
for row in 0..rows {
for col in 0..cols {
if self.pos.len() >= self.params.max_particles {
break;
}
let p = Point2D::new(
origin.x + col as f32 * spacing,
origin.y + row as f32 * spacing,
);
self.pos.push(p);
self.vel.push(Vector2D::zero());
self.pred.push(p);
self.lambda.push(0.0);
}
}
self.params.rest_density =
rest_density_for_spacing(spacing, self.params.smoothing_radius).max(1e-3);
}
pub fn particle_count(&self) -> usize {
self.pos.len()
}
pub fn params(&self) -> &FluidParams {
&self.params
}
pub fn positions(&self) -> impl Iterator<Item = Point2D<f32>> + '_ {
self.pos.iter().copied()
}
pub fn velocities(&self) -> impl Iterator<Item = Vector2D<f32>> + '_ {
self.vel.iter().copied()
}
pub fn max_speed(&self) -> f32 {
self.vel.iter().map(|v| v.length()).fold(0.0, f32::max)
}
pub fn step(&mut self, dt: f32) {
let n = self.pos.len();
if n == 0 || !dt.is_finite() || dt <= 0.0 {
return;
}
let h = self.params.smoothing_radius;
let rho0 = self.params.rest_density;
let eps = self.params.relaxation_eps;
let r = self.params.particle_radius;
let g = self.params.gravity;
for i in 0..n {
self.vel[i] += g * dt;
self.pred[i] = self.pos[i] + self.vel[i] * dt;
}
let mut deltas = vec![Vector2D::zero(); n];
for _ in 0..self.params.solver_iters {
for i in 0..n {
let mut rho = 0.0;
let mut grad_i = Vector2D::zero();
let mut sum_grad2 = 0.0;
for j in 0..n {
let rvec = self.pred[i] - self.pred[j];
rho += poly6(rvec.square_length(), h);
if i != j {
let grad_j = spiky_grad(rvec, h) / rho0;
grad_i += grad_j;
sum_grad2 += grad_j.square_length();
}
}
sum_grad2 += grad_i.square_length();
let c = rho / rho0 - 1.0;
self.lambda[i] = -c / (sum_grad2 + eps);
}
for i in 0..n {
let mut dp = Vector2D::zero();
for j in 0..n {
if i == j {
continue;
}
let rvec = self.pred[i] - self.pred[j];
dp += spiky_grad(rvec, h) * (self.lambda[i] + self.lambda[j]);
}
deltas[i] = dp / rho0;
}
for i in 0..n {
self.pred[i] = self.basin.clamp(self.pred[i] + deltas[i], r);
}
}
for i in 0..n {
self.vel[i] = (self.pred[i] - self.pos[i]) / dt;
self.pos[i] = self.pred[i];
}
if self.params.viscosity > 0.0 {
let mut dv = vec![Vector2D::zero(); n];
for i in 0..n {
for j in 0..n {
if i == j {
continue;
}
let w = poly6((self.pos[i] - self.pos[j]).square_length(), h);
dv[i] += (self.vel[j] - self.vel[i]) * w;
}
}
for i in 0..n {
self.vel[i] += dv[i] * self.params.viscosity;
}
}
if self.params.damping < 1.0 {
for i in 0..n {
self.vel[i] *= self.params.damping;
}
}
}
pub fn resolve_contacts(&mut self, contacts: &[FluidContact]) -> Vec<Vector2D<f32>> {
let mut reactions = vec![Vector2D::zero(); contacts.len()];
if contacts.is_empty() {
return reactions;
}
let pr = self.params.particle_radius;
for i in 0..self.pos.len() {
for (c, contact) in contacts.iter().enumerate() {
let push = match contact.shape {
ContactShape::Circle { radius } => {
let rmin = radius + pr;
let delta = self.pos[i] - contact.center;
let d = delta.length();
if d >= rmin {
continue;
}
let n = if d > 1.0e-4 {
delta / d
} else {
Vector2D::new(0.0, -1.0)
};
n * (rmin - d)
}
ContactShape::Obb { half, angle } => {
let rel = self.pos[i] - contact.center;
let (s, co) = angle.sin_cos();
let lx = rel.x * co + rel.y * s;
let ly = -rel.x * s + rel.y * co;
let (hx, hy) = (half.0 + pr, half.1 + pr);
if lx.abs() >= hx || ly.abs() >= hy {
continue;
}
let (px, py) = (hx - lx.abs(), hy - ly.abs());
let (plx, ply) = if px < py {
(px * lx.signum(), 0.0)
} else {
(0.0, py * ly.signum())
};
Vector2D::new(plx * co - ply * s, plx * s + ply * co)
}
};
self.pos[i] += push;
let plen = push.length();
if plen > 1.0e-6 {
let n = push / plen;
let vn = self.vel[i].dot(n);
if vn < 0.0 {
self.vel[i] -= n * vn;
}
}
reactions[c] -= push;
}
}
reactions
}
}
fn poly6(r2: f32, h: f32) -> f32 {
let h2 = h * h;
if r2 >= h2 {
return 0.0;
}
let c = 4.0 / (PI * h.powi(8));
let d = h2 - r2;
c * d * d * d
}
fn spiky_grad(rvec: Vector2D<f32>, h: f32) -> Vector2D<f32> {
let r = rvec.length();
if r >= h || r < 1.0e-6 {
return Vector2D::zero();
}
let c = -30.0 / (PI * h.powi(5));
let d = h - r;
rvec * (c * d * d / r)
}
fn rest_density_for_spacing(spacing: f32, h: f32) -> f32 {
let spacing = spacing.max(1.0e-3);
let reach = (h / spacing).ceil() as i32 + 1;
let mut rho = 0.0;
for gx in -reach..=reach {
for gy in -reach..=reach {
let r2 = (gx as f32 * spacing).powi(2) + (gy as f32 * spacing).powi(2);
rho += poly6(r2, h);
}
}
rho
}
#[cfg(test)]
mod tests {
use super::*;
fn pool() -> (Fluid, Basin) {
let basin = Basin {
min_x: -200.0,
max_x: 200.0,
floor_y: 200.0,
};
let mut fluid = Fluid::new(FluidParams::default(), basin);
fluid.spawn_block(Point2D::new(-104.0, -150.0), 14, 10, 16.0);
(fluid, basin)
}
#[test]
fn fluid_settles_in_the_basin_and_stays_finite() {
let (mut fluid, basin) = pool();
let n = fluid.particle_count();
assert_eq!(n, 140, "the block seeded 14×10 particles");
assert!(
fluid.params().rest_density > 0.0,
"rest density auto-set from the spawn"
);
for _ in 0..400 {
fluid.step(1.0 / 60.0);
}
assert_eq!(fluid.particle_count(), n, "particle count is conserved");
for p in fluid.positions() {
assert!(p.x.is_finite() && p.y.is_finite(), "no NaN/inf: {p:?}");
assert!(
p.x >= basin.min_x - 1.0 && p.x <= basin.max_x + 1.0,
"contained in x: {p:?}"
);
assert!(p.y <= basin.floor_y + 1.0, "stayed above the floor: {p:?}");
}
assert!(
fluid.max_speed() < 40.0,
"fluid settled (max speed {})",
fluid.max_speed()
);
let mean_y: f32 = fluid.positions().map(|p| p.y).sum::<f32>() / n as f32;
assert!(
mean_y > 0.0,
"the pool sank toward the floor (mean_y {mean_y})"
);
}
#[test]
fn empty_fluid_step_is_a_noop() {
let basin = Basin {
min_x: -100.0,
max_x: 100.0,
floor_y: 100.0,
};
let mut fluid = Fluid::new(FluidParams::default(), basin);
fluid.step(1.0 / 60.0);
assert_eq!(fluid.particle_count(), 0);
}
#[test]
fn contacts_push_particles_out_and_report_reaction() {
let basin = Basin {
min_x: -200.0,
max_x: 200.0,
floor_y: 200.0,
};
let mut fluid = Fluid::new(FluidParams::default(), basin);
fluid.spawn_block(Point2D::new(-30.0, -30.0), 5, 5, 14.0); let pr = fluid.params().particle_radius;
let radius = 30.0;
let center = Point2D::new(0.0, 0.0);
let contact = FluidContact::circle(center, radius);
let reactions = fluid.resolve_contacts(&[contact]);
for p in fluid.positions() {
let d = (p - center).length();
assert!(
d >= radius + pr - 0.5,
"particle pushed out of the contact (d {d})"
);
}
assert!(
reactions[0].length() > 0.0,
"non-zero reaction on the overlapped contact"
);
assert!(fluid.resolve_contacts(&[]).is_empty());
}
#[test]
fn obb_contact_pushes_particles_out_of_the_box() {
let basin = Basin {
min_x: -300.0,
max_x: 300.0,
floor_y: 300.0,
};
let mut fluid = Fluid::new(FluidParams::default(), basin);
fluid.spawn_block(Point2D::new(-40.0, -40.0), 6, 6, 14.0); let pr = fluid.params().particle_radius;
let half = (50.0, 30.0); let contact = FluidContact::obb(Point2D::new(0.0, 0.0), half, 0.0);
let reactions = fluid.resolve_contacts(&[contact]);
for p in fluid.positions() {
let inside = p.x.abs() < half.0 + pr - 0.5 && p.y.abs() < half.1 + pr - 0.5;
assert!(!inside, "particle pushed out of the box (was at {p:?})");
}
assert!(
reactions[0].length() > 0.0,
"non-zero reaction on the overlapped box"
);
}
}