use crate::NodeKey;
use rapier2d::prelude::*;
use crate::{NODE_BODY_DENSITY, Simulation};
#[derive(Clone, Debug, PartialEq)]
pub enum NodeCollider {
Ball { radius: f32 },
Square { half: f32 },
RoundedSquare { half: f32, border: f32 },
Hull {
points: Vec<(f32, f32)>,
fallback: f32,
},
}
impl NodeCollider {
pub(crate) fn to_shared_shape(&self) -> SharedShape {
match self {
NodeCollider::Ball { radius } => SharedShape::ball(radius.max(1.0)),
NodeCollider::Square { half } => {
let h = half.max(1.0);
SharedShape::cuboid(h, h)
}
NodeCollider::RoundedSquare { half, border } => {
let b = border.clamp(0.1, half - 0.1).max(0.1);
let h = (half - b).max(1.0);
SharedShape::round_cuboid(h, h, b)
}
NodeCollider::Hull { points, fallback } => {
if points.len() < 3 {
SharedShape::ball(fallback.max(1.0))
} else {
let pts: Vec<Vector> = points.iter().map(|&(x, y)| Vector::new(x, y)).collect();
SharedShape::convex_hull(&pts)
.unwrap_or_else(|| SharedShape::ball(fallback.max(1.0)))
}
}
}
}
}
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct NodeMaterial {
pub restitution: f32,
pub friction: f32,
pub density: f32,
pub gravity_scale: f32,
}
impl Default for NodeMaterial {
fn default() -> Self {
Self {
restitution: 0.0,
friction: 0.0,
density: NODE_BODY_DENSITY,
gravity_scale: 0.0,
}
}
}
impl Simulation {
pub fn set_node_colliders(
&mut self,
colliders: impl IntoIterator<Item = (NodeKey, NodeCollider)>,
) {
for (node, collider) in colliders {
let Some(&body_handle) = self.bodies_by_node.get(&node) else {
continue;
};
let collider_handles: Vec<ColliderHandle> = self
.bodies
.get(body_handle)
.map(|body| body.colliders().to_vec())
.unwrap_or_default();
let shape = collider.to_shared_shape();
for handle in collider_handles {
if let Some(c) = self.colliders.get_mut(handle) {
c.set_shape(shape.clone());
}
}
}
}
pub fn set_node_materials(
&mut self,
materials: impl IntoIterator<Item = (NodeKey, NodeMaterial)>,
) {
for (node, material) in materials {
self.node_materials.insert(node, material);
let Some(&body_handle) = self.bodies_by_node.get(&node) else {
continue;
};
let collider_handles: Vec<ColliderHandle> = self
.bodies
.get(body_handle)
.map(|body| body.colliders().to_vec())
.unwrap_or_default();
for handle in collider_handles {
if let Some(c) = self.colliders.get_mut(handle) {
c.set_restitution(material.restitution);
c.set_friction(material.friction);
c.set_density(material.density);
}
}
if let Some(body) = self.bodies.get_mut(body_handle) {
body.recompute_mass_properties_from_colliders(&self.colliders);
body.set_gravity_scale(material.gravity_scale, true);
}
}
}
pub fn node_material(&self, node: NodeKey) -> Option<NodeMaterial> {
let &handle = self.bodies_by_node.get(&node)?;
let body = self.bodies.get(handle)?;
let collider = self.colliders.get(*body.colliders().first()?)?;
Some(NodeMaterial {
restitution: collider.restitution(),
friction: collider.friction(),
density: collider.density(),
gravity_scale: body.gravity_scale(),
})
}
}