Filter entities sent for deletion

rmf_site_editor/src/site/deletion.rs

@@ -24,7 +24,10 @@ use crate::{
     },
     AppState, Issue,
 };
-use bevy::{ecs::system::SystemParam, prelude::*};
+use bevy::{
+    ecs::system::{BoxedSystem, SystemParam, SystemState},
+    prelude::*,
+};
 use rmf_site_format::{ConstraintDependents, Edge, MeshConstraint, Path, Point};
 use std::collections::HashSet;
 
@@ -48,7 +51,7 @@ impl PreventDeletion {
 
 /// This is an event used to delete site elements. Deleting the element is
 /// recursive, so all its children will be deleted along with it.
-#[derive(Debug, Clone, Copy, Event)]
+#[derive(Debug, Clone, Copy, Eq, Event, Hash, PartialEq)]
 pub struct Delete {
     pub element: Entity,
     /// If this is true, all dependents of the element or any of its children
@@ -105,6 +108,7 @@ impl Plugin for DeletionPlugin {
         )
         .add_systems(First, apply_deferred.in_set(SiteUpdateSet::DeletionFlush))
         .add_event::<Delete>()
+        .init_resource::<DeletionFilters>()
         .add_systems(
             First,
             handle_deletion_requests
@@ -114,14 +118,69 @@ impl Plugin for DeletionPlugin {
     }
 }
 
-fn handle_deletion_requests(mut deletions: EventReader<Delete>, mut params: DeletionParams) {
+#[derive(Deref, DerefMut)]
+pub struct DeletionBox(pub BoxedSystem<HashSet<Delete>, HashSet<Delete>>);
+
+#[derive(Default, Resource)]
+pub struct DeletionFilters {
+    boxed_systems: Vec<DeletionBox>,
+    pending_insertion: Vec<DeletionBox>,
+}
+
+impl DeletionFilters {
+    pub fn insert(&mut self, filter: DeletionBox) {
+        self.pending_insertion.push(filter);
+    }
+
+    fn insert_boxes(&mut self, world: &mut World) {
+        for mut inserted in self.pending_insertion.drain(..) {
+            inserted.initialize(world);
+            self.boxed_systems.push(inserted);
+        }
+    }
+
+    fn run_boxes(
+        &mut self,
+        mut pending_delete: HashSet<Delete>,
+        world: &mut World,
+    ) -> HashSet<Delete> {
+        for boxed_system in self.boxed_systems.iter_mut() {
+            pending_delete = boxed_system.0.run(pending_delete, world);
+        }
+        pending_delete
+    }
+}
+
+fn handle_deletion_requests(
+    world: &mut World,
+    state: &mut SystemState<(EventReader<Delete>, DeletionParams)>,
+) {
+    let (mut deletions, _) = state.get_mut(world);
+    if deletions.is_empty() {
+        return;
+    }
+    let mut pending_delete: HashSet<Delete> = HashSet::new();
     for delete in deletions.read() {
+        pending_delete.insert(*delete);
+    }
+
+    pending_delete =
+        world.resource_scope::<DeletionFilters, _>(move |world, mut deletion_filters| {
+            deletion_filters.insert_boxes(world);
+            // Run through all boxed systems to filter out entities that should not
+            // be sent to delete
+            deletion_filters.run_boxes(pending_delete, world)
+        });
+
+    let (_, mut params) = state.get_mut(world);
+    for delete in pending_delete.iter() {
         if delete.and_dependents {
             recursive_dependent_delete(delete.element, &mut params);
         } else {
             cautious_delete(delete.element, &mut params);
         }
     }
+    state.apply(world);
 }
 
 fn cautious_delete(element: Entity, params: &mut DeletionParams) {