use std::collections::HashMap;
use euclid::default::{Box2D, Point2D};
use crate::NodeKey;
use crate::{NODE_BODY_RADIUS, NodeCollider, SceneBodyId};
#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub struct RectSelection {
pub nodes: Vec<NodeKey>,
pub edges: Vec<(NodeKey, NodeKey)>,
}
#[derive(Clone, Debug, PartialEq)]
pub struct SceneBodyView {
pub id: SceneBodyId,
pub position: Point2D<f32>,
pub rotation: f32,
pub collider: NodeCollider,
pub sprite: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct LayoutSnapshot {
pub positions: Vec<(NodeKey, Point2D<f32>)>,
pub scene: Vec<SceneBodyView>,
pub fluid: Vec<Point2D<f32>>,
pub fluid_radius: f32,
pub generation: u64,
}
#[derive(Clone, Debug)]
pub struct LayoutView {
positions: HashMap<NodeKey, Point2D<f32>>,
edges: Vec<(NodeKey, NodeKey)>,
radius: f32,
radii: HashMap<NodeKey, f32>,
scene: Vec<SceneBodyView>,
fluid: Vec<Point2D<f32>>,
fluid_radius: f32,
}
impl Default for LayoutView {
fn default() -> Self {
Self::new()
}
}
impl LayoutView {
pub fn new() -> Self {
Self {
positions: HashMap::new(),
edges: Vec::new(),
radius: NODE_BODY_RADIUS,
radii: HashMap::new(),
scene: Vec::new(),
fluid: Vec::new(),
fluid_radius: 0.0,
}
}
pub fn from_parts(
positions: impl IntoIterator<Item = (NodeKey, Point2D<f32>)>,
edges: impl IntoIterator<Item = (NodeKey, NodeKey)>,
radius: f32,
) -> Self {
Self {
positions: positions.into_iter().collect(),
edges: edges.into_iter().collect(),
radius,
radii: HashMap::new(),
scene: Vec::new(),
fluid: Vec::new(),
fluid_radius: 0.0,
}
}
fn radius_of(&self, node: NodeKey) -> f32 {
self.radii.get(&node).copied().unwrap_or(self.radius)
}
pub fn set_radii(&mut self, radii: impl IntoIterator<Item = (NodeKey, f32)>) {
self.radii.clear();
self.radii.extend(radii);
}
pub fn apply_snapshot(&mut self, snapshot: &LayoutSnapshot) {
self.positions.clear();
self.positions.extend(snapshot.positions.iter().copied());
self.scene.clear();
self.scene.extend(snapshot.scene.iter().cloned());
self.fluid.clear();
self.fluid.extend(snapshot.fluid.iter().copied());
self.fluid_radius = snapshot.fluid_radius;
}
pub fn set_edges(&mut self, edges: impl IntoIterator<Item = (NodeKey, NodeKey)>) {
self.edges.clear();
self.edges.extend(edges);
}
pub fn set_position(&mut self, node: NodeKey, position: Point2D<f32>) {
self.positions.insert(node, position);
}
pub fn len(&self) -> usize {
self.positions.len()
}
pub fn is_empty(&self) -> bool {
self.positions.is_empty()
}
pub fn position_of(&self, node: NodeKey) -> Option<Point2D<f32>> {
self.positions.get(&node).copied()
}
pub fn positions(&self) -> impl Iterator<Item = (NodeKey, Point2D<f32>)> + '_ {
self.positions.iter().map(|(&k, &p)| (k, p))
}
pub fn scene_bodies(&self) -> impl Iterator<Item = SceneBodyView> + '_ {
self.scene.iter().cloned()
}
pub fn fluid_particles(&self) -> impl Iterator<Item = Point2D<f32>> + '_ {
self.fluid.iter().copied()
}
pub fn fluid_radius(&self) -> f32 {
self.fluid_radius
}
pub fn hit_test(&self, point: Point2D<f32>) -> Option<NodeKey> {
let mut best: Option<(NodeKey, f32)> = None;
for (&node, ¢er) in &self.positions {
let r = self.radius_of(node);
let d2 = (point - center).square_length();
if d2 <= r * r && best.map_or(true, |(_, bd)| d2 < bd) {
best = Some((node, d2));
}
}
best.map(|(node, _)| node)
}
pub fn cull_aabb(&self, region: Box2D<f32>) -> Vec<NodeKey> {
self.positions()
.filter(|(node, center)| {
let r = self.radius_of(*node);
region.inflate(r, r).contains(*center)
})
.map(|(node, _)| node)
.collect()
}
pub fn edge_segments(
&self,
) -> impl Iterator<Item = (NodeKey, NodeKey, Point2D<f32>, Point2D<f32>)> + '_ {
self.edges.iter().filter_map(move |&(a, b)| {
let pa = self.position_of(a)?;
let pb = self.position_of(b)?;
Some((a, b, pa, pb))
})
}
pub fn edge_hit_test(&self, point: Point2D<f32>, tolerance: f32) -> Option<(NodeKey, NodeKey)> {
let mut best: Option<((NodeKey, NodeKey), f32)> = None;
for (a, b, pa, pb) in self.edge_segments() {
let d = point_segment_distance(point, pa, pb);
if d <= tolerance && best.map_or(true, |(_, bd)| d < bd) {
best = Some(((a, b), d));
}
}
best.map(|(edge, _)| edge)
}
pub fn rect_select(&self, region: Box2D<f32>) -> RectSelection {
let nodes = self
.positions()
.filter(|(_, p)| region.contains(*p))
.map(|(node, _)| node)
.collect();
let edges = self
.edge_segments()
.filter(|&(_, _, pa, pb)| segment_intersects_box(pa, pb, region))
.map(|(a, b, _, _)| (a, b))
.collect();
RectSelection { nodes, edges }
}
}
pub(crate) fn point_segment_distance(p: Point2D<f32>, a: Point2D<f32>, b: Point2D<f32>) -> f32 {
let ab = b - a;
let len2 = ab.square_length();
if len2 <= f32::EPSILON {
return (p - a).length();
}
let t = ((p - a).dot(ab) / len2).clamp(0.0, 1.0);
let proj = a + ab * t;
(p - proj).length()
}
pub(crate) fn segment_intersects_box(a: Point2D<f32>, b: Point2D<f32>, r: Box2D<f32>) -> bool {
let dx = b.x - a.x;
let dy = b.y - a.y;
let p = [-dx, dx, -dy, dy];
let q = [a.x - r.min.x, r.max.x - a.x, a.y - r.min.y, r.max.y - a.y];
let mut u1 = 0.0_f32;
let mut u2 = 1.0_f32;
for i in 0..4 {
if p[i].abs() < f32::EPSILON {
if q[i] < 0.0 {
return false;
}
} else {
let t = q[i] / p[i];
if p[i] < 0.0 {
if t > u2 {
return false;
}
if t > u1 {
u1 = t;
}
} else {
if t < u1 {
return false;
}
if t < u2 {
u2 = t;
}
}
}
}
u1 <= u2
}
#[cfg(test)]
mod tests {
use euclid::default::{Box2D, Point2D};
use crate::{NodeKey, Simulation};
fn sim_with_edge() -> (Simulation, NodeKey, NodeKey) {
let a = NodeKey::new(0);
let b = NodeKey::new(1);
let mut sim = Simulation::new();
sim.sync_nodes([(a, Point2D::new(0.0, 0.0)), (b, Point2D::new(100.0, 0.0))]);
sim.sync_edges([(a, b)]);
sim.refresh_spatial_index();
(sim, a, b)
}
#[test]
fn view_node_picks_and_cull_match_the_simulation() {
let (sim, a, b) = sim_with_edge();
let view = sim.view();
assert_eq!(
view.hit_test(Point2D::new(0.0, 0.0)),
sim.hit_test(Point2D::new(0.0, 0.0))
);
assert_eq!(view.hit_test(Point2D::new(0.0, 0.0)), Some(a));
assert_eq!(view.hit_test(Point2D::new(100.0, 0.0)), Some(b));
assert!(view.hit_test(Point2D::new(5000.0, 5000.0)).is_none());
let region = Box2D::new(Point2D::new(-30.0, -30.0), Point2D::new(30.0, 30.0));
let mut from_view = view.cull_aabb(region);
let mut from_sim = sim.cull_aabb(region);
from_view.sort();
from_sim.sort();
assert_eq!(from_view, from_sim);
assert_eq!(from_view, vec![a]);
}
#[test]
fn view_edge_picks_match_the_simulation() {
let (sim, a, b) = sim_with_edge();
let view = sim.view();
assert_eq!(
view.edge_hit_test(Point2D::new(50.0, 0.0), 5.0),
Some((a, b))
);
assert_eq!(
view.edge_hit_test(Point2D::new(50.0, 0.0), 5.0),
sim.edge_hit_test(Point2D::new(50.0, 0.0), 5.0)
);
assert!(view.edge_hit_test(Point2D::new(50.0, 50.0), 5.0).is_none());
let near_origin = view.rect_select(Box2D::new(
Point2D::new(-10.0, -10.0),
Point2D::new(10.0, 10.0),
));
assert_eq!(near_origin.nodes, vec![a]);
assert_eq!(near_origin.edges, vec![(a, b)]);
}
#[test]
fn snapshot_round_trips_and_drag_override_sticks() {
let (sim, a, _b) = sim_with_edge();
let snapshot = sim.snapshot(7);
assert_eq!(snapshot.generation, 7);
assert_eq!(snapshot.positions.len(), 2);
let mut view = crate::LayoutView::new();
view.apply_snapshot(&snapshot);
assert_eq!(view.len(), 2);
assert!((view.position_of(a).unwrap() - Point2D::new(0.0, 0.0)).length() < 0.5);
view.set_position(a, Point2D::new(250.0, 250.0));
assert_eq!(view.position_of(a), Some(Point2D::new(250.0, 250.0)));
view.apply_snapshot(&snapshot);
assert!((view.position_of(a).unwrap() - Point2D::new(0.0, 0.0)).length() < 0.5);
}
#[test]
fn per_node_radius_grows_the_pick_and_cull() {
let (sim, a, b) = sim_with_edge(); let mut view = sim.view();
let near_a = Point2D::new(40.0, 0.0);
assert!(view.hit_test(near_a).is_none());
view.set_radii([(a, 60.0)]);
assert_eq!(view.hit_test(near_a), Some(a));
assert!(view.hit_test(Point2D::new(100.0, 30.0)).is_none());
let window = Box2D::new(Point2D::new(45.0, -10.0), Point2D::new(55.0, 10.0));
assert!(view.cull_aabb(window).contains(&a));
view.set_radii([(b, 60.0)]);
assert!(view.hit_test(Point2D::new(0.0, 40.0)).is_none());
}
}