use crate::data::graph::{Direction, EdgeIndex, Graph, NodeIndex};
use crate::geometry::ColliderHandle;
pub type ColliderGraphIndex = NodeIndex;
pub type RigidBodyGraphIndex = NodeIndex;
pub type TemporaryInteractionIndex = EdgeIndex;
#[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
pub struct InteractionGraph<T> {
pub(crate) graph: Graph<ColliderHandle, T>,
}
impl<T> InteractionGraph<T> {
pub fn new() -> Self {
InteractionGraph {
graph: Graph::with_capacity(10, 10),
}
}
pub fn raw_graph(&self) -> &Graph<ColliderHandle, T> {
&self.graph
}
pub(crate) fn invalid_graph_index() -> ColliderGraphIndex {
ColliderGraphIndex::new(crate::INVALID_U32)
}
pub(crate) fn is_graph_index_valid(index: ColliderGraphIndex) -> bool {
index.index() != crate::INVALID_USIZE
}
pub(crate) fn add_edge(
&mut self,
index1: ColliderGraphIndex,
index2: ColliderGraphIndex,
interaction: T,
) -> TemporaryInteractionIndex {
self.graph.add_edge(index1, index2, interaction)
}
pub(crate) fn remove_edge(
&mut self,
index1: ColliderGraphIndex,
index2: ColliderGraphIndex,
) -> Option<T> {
let id = self.graph.find_edge(index1, index2)?;
self.graph.remove_edge(id)
}
#[must_use = "The graph index of the collision object returned by this method has been changed to `id`."]
pub(crate) fn remove_node(&mut self, id: ColliderGraphIndex) -> Option<ColliderHandle> {
let _ = self.graph.remove_node(id);
self.graph.node_weight(id).cloned()
}
pub fn interaction_pairs(&self) -> impl Iterator<Item = (ColliderHandle, ColliderHandle, &T)> {
self.graph.raw_edges().iter().map(move |edge| {
(
self.graph[edge.source()],
self.graph[edge.target()],
&edge.weight,
)
})
}
pub fn interaction_pair(
&self,
id1: ColliderGraphIndex,
id2: ColliderGraphIndex,
) -> Option<(ColliderHandle, ColliderHandle, &T)> {
self.graph.find_edge(id1, id2).and_then(|edge| {
let endpoints = self.graph.edge_endpoints(edge)?;
let h1 = self.graph.node_weight(endpoints.0)?;
let h2 = self.graph.node_weight(endpoints.1)?;
let weight = self.graph.edge_weight(edge)?;
Some((*h1, *h2, weight))
})
}
pub fn interaction_pair_mut(
&mut self,
id1: ColliderGraphIndex,
id2: ColliderGraphIndex,
) -> Option<(ColliderHandle, ColliderHandle, &mut T)> {
let edge = self.graph.find_edge(id1, id2)?;
let endpoints = self.graph.edge_endpoints(edge)?;
let h1 = *self.graph.node_weight(endpoints.0)?;
let h2 = *self.graph.node_weight(endpoints.1)?;
let weight = self.graph.edge_weight_mut(edge)?;
Some((h1, h2, weight))
}
pub fn interactions_with(
&self,
id: ColliderGraphIndex,
) -> impl Iterator<Item = (ColliderHandle, ColliderHandle, &T)> {
self.graph.edges(id).filter_map(move |e| {
let endpoints = self.graph.edge_endpoints(e.id()).unwrap();
Some((self.graph[endpoints.0], self.graph[endpoints.1], e.weight()))
})
}
pub fn index_interaction(
&self,
id: TemporaryInteractionIndex,
) -> Option<(ColliderHandle, ColliderHandle, &T)> {
if let (Some(e), Some(endpoints)) =
(self.graph.edge_weight(id), self.graph.edge_endpoints(id))
{
Some((self.graph[endpoints.0], self.graph[endpoints.1], e))
} else {
None
}
}
pub fn interactions_with_mut(
&mut self,
id: ColliderGraphIndex,
) -> impl Iterator<
Item = (
ColliderHandle,
ColliderHandle,
TemporaryInteractionIndex,
&mut T,
),
> {
let incoming_edge = self.graph.first_edge(id, Direction::Incoming);
let outgoing_edge = self.graph.first_edge(id, Direction::Outgoing);
InteractionsWithMut {
graph: &mut self.graph,
incoming_edge,
outgoing_edge,
}
}
}
pub struct InteractionsWithMut<'a, T> {
graph: &'a mut Graph<ColliderHandle, T>,
incoming_edge: Option<EdgeIndex>,
outgoing_edge: Option<EdgeIndex>,
}
impl<'a, T> Iterator for InteractionsWithMut<'a, T> {
type Item = (
ColliderHandle,
ColliderHandle,
TemporaryInteractionIndex,
&'a mut T,
);
#[inline]
fn next(
&mut self,
) -> Option<(
ColliderHandle,
ColliderHandle,
TemporaryInteractionIndex,
&'a mut T,
)> {
if let Some(edge) = self.incoming_edge {
self.incoming_edge = self.graph.next_edge(edge, Direction::Incoming);
let endpoints = self.graph.edge_endpoints(edge).unwrap();
let (co1, co2) = (self.graph[endpoints.0], self.graph[endpoints.1]);
let interaction = &mut self.graph[edge];
return Some((co1, co2, edge, unsafe { std::mem::transmute(interaction) }));
}
let edge = self.outgoing_edge?;
self.outgoing_edge = self.graph.next_edge(edge, Direction::Outgoing);
let endpoints = self.graph.edge_endpoints(edge).unwrap();
let (co1, co2) = (self.graph[endpoints.0], self.graph[endpoints.1]);
let interaction = &mut self.graph[edge];
Some((co1, co2, edge, unsafe { std::mem::transmute(interaction) }))
}
}