use std::collections::HashMap;
use rapier2d::prelude::*;
use crate::scene_spec::SceneBodyId;
use crate::{NODE_GROUP, NodeKey, SCENE_GROUP, Simulation};
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub struct Kinds(pub u16);
impl Kinds {
pub const NONE: Kinds = Kinds(0);
pub fn intersects(self, other: Kinds) -> bool {
self.0 & other.0 != 0
}
}
const KIND_SHIFT: u32 = 16;
fn kind_bits(kinds: Kinds) -> Group {
Group::from_bits_truncate((kinds.0 as u32) << KIND_SHIFT)
}
fn kind_band() -> Group {
Group::from_bits_truncate(0xFFFF << KIND_SHIFT)
}
pub(crate) fn node_mask(kinds: Kinds, tangible: bool) -> InteractionGroups {
let memberships = NODE_GROUP | kind_bits(kinds);
let mut filter = NODE_GROUP | kind_band();
if tangible {
filter |= SCENE_GROUP;
}
InteractionGroups::new(memberships, filter, InteractionTestMode::And)
}
pub(crate) fn sieve_mask(blocks: Kinds) -> InteractionGroups {
let bits = kind_bits(blocks);
InteractionGroups::new(
SCENE_GROUP | bits,
SCENE_GROUP | bits,
InteractionTestMode::And,
)
}
#[derive(Default)]
pub(crate) struct Sift {
pub(crate) node_kinds: HashMap<NodeKey, Kinds>,
pub(crate) sieves: HashMap<SceneBodyId, Kinds>,
}
impl Simulation {
pub fn set_node_kinds(&mut self, node: NodeKey, kinds: Kinds) {
self.sift.node_kinds.insert(node, kinds);
let tangible = self.node_is_tangible(node);
self.remask_node(node, tangible);
}
pub fn node_kinds(&self, node: NodeKey) -> Kinds {
self.sift
.node_kinds
.get(&node)
.copied()
.unwrap_or(Kinds::NONE)
}
pub fn set_scene_sieve(&mut self, id: SceneBodyId, blocks: Kinds) {
if blocks == Kinds::NONE {
self.sift.sieves.remove(&id);
} else {
self.sift.sieves.insert(id, blocks);
}
let Some(handle) = self.scene_bodies.get(&id).map(|(h, _)| *h) else {
return;
};
let groups = if blocks == Kinds::NONE {
crate::scene_groups()
} else {
sieve_mask(blocks)
};
let colliders: Vec<ColliderHandle> = self
.bodies
.get(handle)
.map(|body| body.colliders().to_vec())
.unwrap_or_default();
for collider in colliders {
if let Some(collider) = self.colliders.get_mut(collider) {
collider.set_collision_groups(groups);
}
}
}
pub fn scene_sieve(&self, id: SceneBodyId) -> Kinds {
self.sift.sieves.get(&id).copied().unwrap_or(Kinds::NONE)
}
pub(crate) fn node_is_tangible(&self, node: NodeKey) -> bool {
self.bodies_by_node
.get(&node)
.and_then(|&handle| self.bodies.get(handle))
.and_then(|body| body.colliders().first())
.and_then(|&ch| self.colliders.get(ch))
.map(|c| c.collision_groups().filter.contains(SCENE_GROUP))
.unwrap_or(self.nodes_tangible)
}
pub(crate) fn remask_node(&mut self, node: NodeKey, tangible: bool) {
let kinds = self.node_kinds(node);
let Some(&handle) = self.bodies_by_node.get(&node) else {
return;
};
let groups = node_mask(kinds, tangible);
let colliders: Vec<ColliderHandle> = self
.bodies
.get(handle)
.map(|body| body.colliders().to_vec())
.unwrap_or_default();
for collider in colliders {
if let Some(collider) = self.colliders.get_mut(collider) {
collider.set_collision_groups(groups);
}
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn the_pairwise_test_is_kinds_intersect_blocks() {
let a = Kinds(0b01);
let b = Kinds(0b10);
let sieve = sieve_mask(Kinds(0b01));
for tangible in [false, true] {
let blocked = node_mask(a, tangible);
let passed = node_mask(b, tangible);
assert!(blocked.test(sieve), "blocked kind must meet the sieve");
assert!(!passed.test(sieve), "other kinds must pass through");
}
}
#[test]
fn kinds_do_not_disturb_the_existing_axes() {
let plain = node_mask(Kinds::NONE, false);
let kinded = node_mask(Kinds(0xFFFF), false);
assert!(plain.test(kinded));
let scene = crate::scene_groups();
assert!(!node_mask(Kinds(0b1), false).test(scene));
assert!(node_mask(Kinds(0b1), true).test(scene));
assert!(!node_mask(Kinds::NONE, true).test(sieve_mask(Kinds(0xFFFF))));
}
}