bevy_spatial 0.11.0

A crate for tracking bevy entities in spatial indices.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

//! implementations to use [`kd_tree`] trees as a spatial datastructure in ``bevy_spatial``.

use bevy::prelude::*;
use kd_tree::{KdPoint, KdTree as BaseKdTree, KdTreeN};

use crate::{
    TComp,
    point::SpatialPoint,
    spatial_access::{SpatialAccess, UpdateSpatialAccess},
};

use std::marker::PhantomData;

use bevy::prelude::Resource;

#[cfg(all(feature = "kdtree_rayon", target_arch = "wasm32"))]
compile_error!(
    "bevy-spatial feature \"kdtree_rayon\" is incompatible with target_arch = \"wasm32\" builds. Disable default-features and enable kdtree"
);

macro_rules! kdtree_impl {
    ($pt:ty, $treename:ident) => {
        impl KdPoint for $pt {
            type Scalar = <$pt as SpatialPoint>::Scalar;

            type Dim = <$pt as SpatialPoint>::Dimension;

            fn at(&self, i: usize) -> Self::Scalar {
                <Self as SpatialPoint>::at(self, i)
            }
        }

        /// Resource for storing a ``KdTree``
        #[derive(Resource)]
        pub struct $treename<Comp> {
            /// The ``KdTree``
            pub tree: BaseKdTree<$pt>,
            component_type: PhantomData<Comp>,
        }

        impl<Comp> Default for $treename<Comp> {
            fn default() -> Self {
                Self {
                    tree: default(),
                    component_type: PhantomData,
                }
            }
        }

        impl<Comp> SpatialAccess for $treename<Comp>
        where
            Comp: TComp,
        {
            type Point = $pt;

            type Comp = Comp;
            type ResultT = (<$pt as SpatialPoint>::Vec, Option<Entity>);

            /// Get the nearest neighbour to a position.
            fn nearest_neighbour(&self, loc: <$pt as SpatialPoint>::Vec) -> Option<Self::ResultT> {
                let p: $pt = loc.into();
                let res = self.tree.nearest(&p);
                res.map(|point| (point.item.vec(), point.item.entity()))
            }

            /// Get the `k` neighbours to `loc`
            ///
            /// If `loc` is the location of a tracked entity, you might want to skip the first.
            fn k_nearest_neighbour(
                &self,
                loc: <$pt as SpatialPoint>::Vec,
                k: usize,
            ) -> Vec<Self::ResultT> {
                let p: $pt = loc.into();

                self.tree
                    .nearests(&p, k)
                    .iter()
                    .map(|e| (e.item.vec(), e.item.entity()))
                    .collect()
            }

            /// Get all entities within a certain distance (radius) of `loc`
            fn within_distance(
                &self,
                loc: <$pt as SpatialPoint>::Vec,
                distance: <$pt as SpatialPoint>::Scalar,
            ) -> Vec<Self::ResultT> {
                let distance: <$pt as KdPoint>::Scalar = distance.into();

                if self.tree.len() == 0 {
                    vec![]
                } else {
                    let p: $pt = loc.into();

                    self.tree
                        .within_radius(&p, distance)
                        .iter()
                        .map(|e| (e.vec(), e.entity()))
                        .collect()
                }
            }
        }
        impl<Comp: TComp> UpdateSpatialAccess for $treename<Comp> {
            fn update(
                &mut self,
                data: impl Iterator<Item = (Self::Point, bool)>,
                _: impl Iterator<Item = Entity>,
            ) {
                #[cfg(all(feature = "kdtree_rayon", not(target_arch = "wasm32")))]
                let tree =
                    KdTreeN::par_build_by_ordered_float(data.map(|(p, _)| p).collect::<Vec<_>>());
                #[cfg(any(not(feature = "kdtree_rayon"), target_arch = "wasm32"))]
                let tree =
                    KdTreeN::build_by_ordered_float(data.map(|(p, _)| p).collect::<Vec<_>>());
                self.tree = tree;
            }

            fn add(&mut self, _: Self::Point) {}

            fn remove_point(&mut self, _: Self::Point) -> bool {
                false
            }

            fn remove_entity(&mut self, _: Entity) -> bool {
                false
            }

            fn clear(&mut self) {
                self.tree = KdTreeN::default();
            }
        }
    };
}
kdtree_impl!(crate::point::Point2, KDTree2);
kdtree_impl!(crate::point::Point3, KDTree3);
kdtree_impl!(crate::point::Point3A, KDTree3A);
kdtree_impl!(crate::point::PointD2, KDTreeD2);
kdtree_impl!(crate::point::PointD3, KDTreeD3);