Moved indexing into bevy_hierarchy

Ensures access to plugin system without modifying the ECS crate.

Author: bushrat011899

crates/bevy_ecs/src/lib.rs

@@ -10,7 +10,6 @@ pub mod change_detection;
 pub mod component;
 pub mod entity;
 pub mod event;
-pub mod indexing;
 pub mod query;
 #[cfg(feature = "bevy_reflect")]
 pub mod reflect;

crates/bevy_ecs/src/indexing.rs renamed to crates/bevy_hierarchy/src/indexing.rs

@@ -1,38 +1,34 @@
-//! Provides an [`Index`] system parameter, allowing a user to lookup an [`Entity`]
-//! based on the value of one of its [`Components`][`Component`].
+use std::{hash::Hash, marker::PhantomData};
+
+use bevy_app::{App, Plugin, Update};
 
-use crate as bevy_ecs;
 use bevy_ecs::{
     component::{Component, Tick},
     prelude::{Changed, Entity, Query, Ref, RemovedComponents, ResMut},
     query::ReadOnlyWorldQuery,
-    system::{SystemChangeTick, SystemParam},
+    system::{Resource, SystemChangeTick, SystemParam},
 };
 
-use bevy_ecs_macros::Resource;
-
 use bevy_utils::{default, EntityHashMap, EntityHashSet, HashMap};
 
-use std::{hash::Hash, marker::PhantomData};
-
-/// Describes how to transform a [`Component`] `Input` into an `Index` suitable for an [`Index`].
+/// Describes how to transform an `Input` into an `Index` suitable for an [`Index`].
 pub trait Indexer {
-    /// The input [`Component`] to index against.
-    type Input: Component;
+    /// The input to index against.
+    type Input;
 
-    /// A type suitable for indexing the [`Component`] `Input`
-    type Index: Hash + Eq + Clone + Sync + Send + 'static;
+    /// A type suitable for indexing the `Input`
+    type Index;
 
     /// Generate an `Index` from the provided `Input`
     fn index(input: &Self::Input) -> Self::Index;
 }
 
-/// A basic [`Indexer`] which directly uses the [`Component`] `T`'s value.
+/// A basic [`Indexer`] which directly uses `T`'s value.
 pub struct SimpleIndexer<T>(PhantomData<T>);
 
 impl<T> Indexer for SimpleIndexer<T>
 where
-    T: Component + Hash + Eq + Clone,
+    T: Clone,
 {
     type Input = T;
 
@@ -45,7 +41,7 @@ where
 
 /// Stored data required for an [`Index`].
 #[derive(Resource)]
-pub struct IndexBacking<T, F = (), I = SimpleIndexer<T>>
+struct IndexBacking<T, F = (), I = SimpleIndexer<T>>
 where
     I: Indexer,
 {
@@ -75,10 +71,16 @@ where
 impl<T, F, I> IndexBacking<T, F, I>
 where
     I: Indexer<Input = T>,
+    I::Index: Hash + Clone + Eq,
 {
     fn update(&mut self, entity: Entity, value: Option<&T>) -> Option<I::Index> {
         let value = value.map(|value| I::index(value));
 
+        if self.reverse.get(&entity) == value.as_ref() {
+            // Return early since the value is already up-to-date
+            return None;
+        }
+
         let old = if let Some(ref value) = value {
             self.reverse.insert(entity, value.clone())
         } else {
@@ -102,13 +104,33 @@ where
         old
     }
 
+    fn insert(&mut self, entity: Entity, value: &T) -> Option<I::Index> {
+        self.update(entity, Some(value))
+    }
+
+    fn remove_by_entity(&mut self, entity: Entity) -> Option<I::Index> {
+        self.update(entity, None)
+    }
+
     fn get(&self, value: &T) -> impl Iterator<Item = Entity> + '_ {
+        self.get_by_index(&I::index(value))
+    }
+
+    fn get_by_index(&self, index: &I::Index) -> impl Iterator<Item = Entity> + '_ {
         self.forward
-            .get(&I::index(value))
+            .get(index)
             .unwrap_or(&self.empty)
             .iter()
             .copied()
     }
+
+    fn iter(
+        &mut self,
+    ) -> impl Iterator<Item = (&I::Index, impl Iterator<Item = Entity> + '_)> + '_ {
+        self.forward
+            .iter()
+            .map(|(index, entities)| (index, entities.iter().copied()))
+    }
 }
 
 /// Allows for lookup of an [`Entity`] based on the [`Component`] `T`'s value.
@@ -121,64 +143,92 @@ where
     T: Component,
     I: Indexer + 'static,
     F: ReadOnlyWorldQuery + 'static,
+    I::Index: Send + Sync + 'static,
 {
     changed: Query<'w, 's, (Entity, Ref<'static, T>), (Changed<T>, F)>,
     removed: RemovedComponents<'w, 's, T>,
     index: ResMut<'w, IndexBacking<T, F, I>>,
-    this_run: SystemChangeTick,
+    change_tick: SystemChangeTick,
 }
 
 impl<'w, 's, T, F, I> Index<'w, 's, T, F, I>
 where
     T: Component,
     I: Indexer<Input = T> + 'static,
     F: ReadOnlyWorldQuery + 'static,
+    I::Index: Hash + Clone + Eq + Send + Sync + 'static,
 {
     fn update_index_internal(&mut self) {
-        let this_run = self.this_run.this_run();
+        let this_run = self.change_tick.this_run();
 
         // Remove old entires
         for entity in self.removed.read() {
-            self.index.update(entity, None);
+            self.index.remove_by_entity(entity);
         }
 
         // Update new and existing entries
         for (entity, component) in self.changed.iter() {
-            self.index.update(entity, Some(component.as_ref()));
+            self.index.insert(entity, component.as_ref());
         }
 
         self.index.last_this_run = Some(this_run);
     }
 
     /// System to keep [`Index`] coarsely updated every frame
-    pub fn update_index(mut index: Index<T, F, I>) {
+    fn update_index(mut index: Index<T, F, I>) {
         index.update_index_internal();
     }
 
     fn ensure_updated(&mut self) {
-        let this_run = self.this_run.this_run();
+        let this_run = self.change_tick.this_run();
 
         if self.index.last_this_run != Some(this_run) {
             self.update_index_internal();
         }
     }
 
-    /// Get
+    /// Get all [entities](`Entity`) with a [`Component`] of `value`.
     pub fn get(&mut self, value: &T) -> impl Iterator<Item = Entity> + '_ {
         self.ensure_updated();
 
         self.index.get(value)
     }
 
+    /// Get all [entities](`Entity`) with an `index`.
+    pub fn get_by_index(&mut self, index: &I::Index) -> impl Iterator<Item = Entity> + '_ {
+        self.ensure_updated();
+
+        self.index.get_by_index(index)
+    }
+
     /// Iterate over [entities](`Entity`) grouped by their [Index](`Indexer::Index`)
     pub fn iter(
         &mut self,
     ) -> impl Iterator<Item = (&I::Index, impl Iterator<Item = Entity> + '_)> + '_ {
         self.ensure_updated();
 
-        self.index
-            .forward
-            .iter()
-            .map(|(index, entities)| (index, entities.iter().copied()))
+        self.index.iter()
+    }
+}
+
+/// Starts indexing the [`Component`] `T`. This provides access to the [`Index`] system parameter.
+pub struct IndexPlugin<T, F = (), I = SimpleIndexer<T>>(PhantomData<fn(T, F, I)>);
+
+impl<T, F, I> Default for IndexPlugin<T, F, I> {
+    fn default() -> Self {
+        Self(PhantomData)
+    }
+}
+
+impl<T, I, F> Plugin for IndexPlugin<T, F, I>
+where
+    T: Component,
+    I: Indexer<Input = T> + 'static,
+    F: ReadOnlyWorldQuery + 'static,
+    I::Index: Hash + Clone + Eq + Send + Sync + 'static,
+{
+    fn build(&self, app: &mut App) {
+        app.init_resource::<IndexBacking<T, F, I>>()
+            .add_systems(Update, Index::<T, F, I>::update_index);
     }
 }

crates/bevy_hierarchy/src/lib.rs

@@ -10,6 +10,9 @@ pub use components::*;
 mod hierarchy;
 pub use hierarchy::*;
 
+mod indexing;
+pub use indexing::*;
+
 mod child_builder;
 pub use child_builder::*;
 

examples/ecs/indexing.rs

@@ -2,32 +2,10 @@
 #![allow(clippy::type_complexity)]
 
 use bevy::{
-    ecs::{indexing::*, query::ReadOnlyWorldQuery},
+    hierarchy::{Index, IndexPlugin},
     prelude::*,
 };
-use std::{hash::Hash, marker::PhantomData};
-
-pub struct IndexPlugin<T, F = (), I = SimpleIndexer<T>>(PhantomData<fn(T, F, I)>);
-
-impl<T, F, I> Default for IndexPlugin<T, F, I> {
-    fn default() -> Self {
-        Self(PhantomData)
-    }
-}
-
-impl<T, I, F> Plugin for IndexPlugin<T, F, I>
-where
-    T: Component,
-    I: Indexer<Input = T> + 'static,
-    F: ReadOnlyWorldQuery + 'static,
-{
-    fn build(&self, app: &mut App) {
-        app.init_resource::<IndexBacking<T, F, I>>()
-            .add_systems(Update, Index::<T, F, I>::update_index);
-    }
-}
-
-// Usage
+use std::hash::Hash;
 
 #[derive(Component, Hash, Clone, PartialEq, Eq, Debug)]
 struct Player(usize);