use rapier2d::prelude::*;
use crate::{Force, ForceContext, RepulsionRequest};
#[derive(Clone, Copy, Debug)]
pub struct NodeExclusion {
pub strength: f32,
pub cutoff: f32,
pub min_distance: f32,
}
impl Default for NodeExclusion {
fn default() -> Self {
Self {
strength: 220_000.0,
cutoff: 1_000.0,
min_distance: 8.0,
}
}
}
impl Force for NodeExclusion {
fn apply(&self, ctx: &mut ForceContext<'_>, _dt: f32) {
let nodes: Vec<(RigidBodyHandle, Vector)> = ctx
.bodies_by_node
.values()
.filter_map(|&handle| ctx.bodies.get(handle).map(|b| (handle, b.translation())))
.collect();
if let Some(solver) = ctx.repulsion_solver {
if nodes.len() >= ctx.gpu_repulsion_threshold {
let xs: Vec<f32> = nodes.iter().map(|(_, p)| p.x).collect();
let ys: Vec<f32> = nodes.iter().map(|(_, p)| p.y).collect();
let request = RepulsionRequest {
strength: self.strength,
cutoff: self.cutoff,
min_distance: self.min_distance,
};
match solver(&xs, &ys, request) {
Ok(forces) => {
let (fx, fy) = forces.components();
for (idx, (handle, _)) in nodes.iter().enumerate() {
if let Some(body) = ctx.bodies.get_mut(*handle) {
body.add_force(Vector::new(fx[idx], fy[idx]), true);
}
}
return;
}
Err(error) => tracing::warn!(
?error,
nodes = nodes.len(),
"staged repulsion failed; falling back to NodeExclusion's CPU law"
),
}
}
}
let cutoff2 = self.cutoff * self.cutoff;
let mut forces = vec![Vector::ZERO; nodes.len()];
for i in 0..nodes.len() {
let pos_i = nodes[i].1;
let mut force_i = Vector::ZERO;
for j in 0..nodes.len() {
if j == i {
continue;
}
let delta = pos_i - nodes[j].1;
if delta.length_squared() > cutoff2 {
continue;
}
let dist = delta.length().max(self.min_distance);
force_i += delta / dist * (self.strength / (dist * dist));
}
forces[i] = force_i;
}
for (idx, (handle, _)) in nodes.iter().enumerate() {
if let Some(body) = ctx.bodies.get_mut(*handle) {
body.add_force(forces[idx], true);
}
}
}
}
#[derive(Clone, Copy, Debug)]
pub struct EdgeSpring {
pub stiffness: f32,
pub rest_length: f32,
}
impl Default for EdgeSpring {
fn default() -> Self {
Self {
stiffness: 10.0,
rest_length: 170.0,
}
}
}
impl Force for EdgeSpring {
fn apply(&self, ctx: &mut ForceContext<'_>, _dt: f32) {
for &(a, b) in ctx.edges {
if a == b {
continue; }
let (Some(&ha), Some(&hb)) = (ctx.bodies_by_node.get(&a), ctx.bodies_by_node.get(&b))
else {
continue; };
let (Some(pa), Some(pb)) = (
ctx.bodies.get(ha).map(|x| x.translation()),
ctx.bodies.get(hb).map(|x| x.translation()),
) else {
continue;
};
let delta = pb - pa;
let dist = delta.length();
if dist < 1e-3 {
continue;
}
let pull = delta / dist * (self.stiffness * (dist - self.rest_length));
if let Some(body) = ctx.bodies.get_mut(ha) {
body.add_force(pull, true);
}
if let Some(body) = ctx.bodies.get_mut(hb) {
body.add_force(-pull, true);
}
}
}
}
#[derive(Clone, Copy, Debug)]
pub struct Boundary {
pub strength: f32,
}
impl Default for Boundary {
fn default() -> Self {
Self { strength: 0.08 }
}
}
impl Force for Boundary {
fn apply(&self, ctx: &mut ForceContext<'_>, _dt: f32) {
let handles: Vec<RigidBodyHandle> = ctx.bodies_by_node.values().copied().collect();
for handle in handles {
let Some(pos) = ctx.bodies.get(handle).map(|b| b.translation()) else {
continue;
};
if let Some(body) = ctx.bodies.get_mut(handle) {
body.add_force(-pos * self.strength, true);
}
}
}
}