Removal

jamescarterbell · jamescarterbell · commit b64736f6f72f · 2025-12-23T15:14:31.000-05:00
diff --git a/crates/bevy_sprite/src/lib.rs b/crates/bevy_sprite/src/lib.rs
@@ -1,6 +1,5 @@
 #![expect(missing_docs, reason = "Not all docs are written yet, see #3492.")]
 #![cfg_attr(docsrs, feature(doc_cfg))]
-#![forbid(unsafe_code)]
 #![doc(
     html_logo_url = "https://bevy.org/assets/icon.png",
     html_favicon_url = "https://bevy.org/assets/icon.png"
diff --git a/crates/bevy_sprite/src/tilemap/commands.rs b/crates/bevy_sprite/src/tilemap/commands.rs
@@ -1,7 +1,16 @@
 use std::marker::PhantomData;
 
-use crate::tilemap::{TileData, TileStorage, Tilemap};
-use bevy_ecs::{entity::Entity, hierarchy::ChildOf, system::{Command, Commands}, world::World};
+use crate::{
+    tilemap::{TileData, TileStorage, Tilemap},
+    TileStorages,
+};
+use bevy_ecs::{
+    change_detection::DetectChangesMut,
+    entity::Entity,
+    hierarchy::ChildOf,
+    system::{Command, Commands},
+    world::World,
+};
 use bevy_math::{IVec2, Vec2, Vec3};
 use bevy_transform::components::Transform;
 
@@ -13,7 +22,7 @@ pub trait CommandsTilemapExt {
         maybe_tile: Option<T>,
     );
 
-    fn remove_tile<T: TileData>(&mut self, tilemap_id: Entity, tile_position: IVec2);
+    fn remove_tile(&mut self, tilemap_id: Entity, tile_position: IVec2);
 }
 
 impl CommandsTilemapExt for Commands<'_, '_> {
@@ -23,11 +32,24 @@ impl CommandsTilemapExt for Commands<'_, '_> {
         tile_position: IVec2,
         maybe_tile: Option<T>,
     ) {
-        self.queue(move |world: &mut World| {SetTile {tilemap_id, tile_position, maybe_tile }.apply(world);});
+        self.queue(move |world: &mut World| {
+            SetTile {
+                tilemap_id,
+                tile_position,
+                maybe_tile,
+            }
+            .apply(world);
+        });
     }
 
-    fn remove_tile<T: TileData>(&mut self, tilemap_id: Entity, tile_position: IVec2) {
-        self.queue(move |world: &mut World| {RemoveTile::<T> {tilemap_id, tile_position, _t: PhantomData::default() }.apply(world);});
+    fn remove_tile(&mut self, tilemap_id: Entity, tile_position: IVec2) {
+        self.queue(move |world: &mut World| {
+            RemoveTile {
+                tilemap_id,
+                tile_position,
+            }
+            .apply(world);
+        });
     }
 }
 
@@ -44,107 +66,115 @@ pub struct SetTileResult<T: TileData> {
 
 impl<T: TileData> Default for SetTileResult<T> {
     fn default() -> Self {
-        Self { replaced_tile: Default::default(), chunk_id: Default::default() }
+        Self {
+            replaced_tile: Default::default(),
+            chunk_id: Default::default(),
+        }
     }
 }
 
 impl<T: TileData> Command<SetTileResult<T>> for SetTile<T> {
     fn apply(self, world: &mut World) -> SetTileResult<T> {
-            let Ok(mut tilemap_entity) = world.get_entity_mut(self.tilemap_id) else {
-                tracing::warn!("Could not find Tilemap Entity {:?}", self.tilemap_id);
-                return Default::default();
-            };
-
-            let Some(tilemap) = tilemap_entity.get::<Tilemap>() else {
-                tracing::warn!("Could not find Tilemap on Entity {:?}", self.tilemap_id);
-                return Default::default();
-            };
+        let Ok(mut tilemap_entity) = world.get_entity_mut(self.tilemap_id) else {
+            tracing::warn!("Could not find Tilemap Entity {:?}", self.tilemap_id);
+            return Default::default();
+        };
 
-            let chunk_position = tilemap.tile_chunk_position(self.tile_position);
-            let tile_relative_position = tilemap.tile_relative_position(self.tile_position);
+        let Some(tilemap) = tilemap_entity.get::<Tilemap>() else {
+            tracing::warn!("Could not find Tilemap on Entity {:?}", self.tilemap_id);
+            return Default::default();
+        };
 
-            if let Some(tile_storage_id) = tilemap.chunks.get(&chunk_position).cloned() {
-                let replaced_tile = tilemap_entity.world_scope(move |w| {
-                    let Ok(mut tilestorage_entity) = w.get_entity_mut(tile_storage_id) else {
-                        tracing::warn!("Could not find TileStorage Entity {:?}", tile_storage_id);
-                        return None;
-                    };
+        let chunk_position = tilemap.tile_chunk_position(self.tile_position);
+        let tile_relative_position = tilemap.tile_relative_position(self.tile_position);
 
-                    let Some(mut tile_storage) = tilestorage_entity.get_mut::<TileStorage<T>>()
-                    else {
-                        tracing::warn!(
-                            "Could not find TileStorage on Entity {:?}",
-                            tile_storage_id
-                        );
-                        return None;
-                    };
+        if let Some(tile_storage_id) = tilemap.chunks.get(&chunk_position).cloned() {
+            let replaced_tile = tilemap_entity.world_scope(move |w| {
+                let Ok(mut tilestorage_entity) = w.get_entity_mut(tile_storage_id) else {
+                    tracing::warn!("Could not find TileStorage Entity {:?}", tile_storage_id);
+                    return None;
+                };
 
-                    tile_storage.set(tile_relative_position, self.maybe_tile)
-                });
-                SetTileResult { chunk_id: Some(tile_storage_id), replaced_tile }
-            } else {
-                let chunk_size = tilemap.chunk_size;
-                let tile_size = tilemap.tile_display_size;
-                let tile_storage_id = tilemap_entity.world_scope(move |w| {
-                    let mut tile_storage = TileStorage::<T>::new(chunk_size);
-                    tile_storage.set(tile_relative_position, self.maybe_tile);
-                    let translation = Vec2::new(chunk_size.x as f32, chunk_size.y as f32) * Vec2::new(tile_size.x as f32, tile_size.y as f32) * Vec2::new(chunk_position.x as f32, chunk_position.y as f32);
-                    let translation = Vec3::new(translation.x, translation.y, 0.0);
-                    let transform = Transform::from_translation(translation);
-                    w.spawn((ChildOf(self.tilemap_id), tile_storage, transform)).id()
-                });
-                let Some(mut tilemap) = tilemap_entity.get_mut::<Tilemap>() else {
-                    tracing::warn!("Could not find Tilemap on Entity {:?}", self.tilemap_id);
-                    return Default::default();
+                let Some(mut tile_storage) = tilestorage_entity.get_mut::<TileStorage<T>>() else {
+                    tracing::warn!("Could not find TileStorage on Entity {:?}", tile_storage_id);
+                    return None;
                 };
-                tilemap.chunks.insert(chunk_position, tile_storage_id);
-                SetTileResult { chunk_id: Some(tile_storage_id), replaced_tile: None }
+
+                tile_storage.set(tile_relative_position, self.maybe_tile)
+            });
+            SetTileResult {
+                chunk_id: Some(tile_storage_id),
+                replaced_tile,
+            }
+        } else {
+            let chunk_size = tilemap.chunk_size;
+            let tile_size = tilemap.tile_display_size;
+            let tile_storage_id = tilemap_entity.world_scope(move |w| {
+                let mut tile_storage = TileStorage::<T>::new(chunk_size);
+                tile_storage.set(tile_relative_position, self.maybe_tile);
+                let translation = Vec2::new(chunk_size.x as f32, chunk_size.y as f32)
+                    * Vec2::new(tile_size.x as f32, tile_size.y as f32)
+                    * Vec2::new(chunk_position.x as f32, chunk_position.y as f32);
+                let translation = Vec3::new(translation.x, translation.y, 0.0);
+                let transform = Transform::from_translation(translation);
+                w.spawn((ChildOf(self.tilemap_id), tile_storage, transform))
+                    .id()
+            });
+            let Some(mut tilemap) = tilemap_entity.get_mut::<Tilemap>() else {
+                tracing::warn!("Could not find Tilemap on Entity {:?}", self.tilemap_id);
+                return Default::default();
+            };
+            tilemap.chunks.insert(chunk_position, tile_storage_id);
+            SetTileResult {
+                chunk_id: Some(tile_storage_id),
+                replaced_tile: None,
             }
+        }
     }
 }
 
-pub struct RemoveTile<T: TileData> {
+pub struct RemoveTile {
     pub tilemap_id: Entity,
     pub tile_position: IVec2,
-    pub _t: PhantomData<T>
 }
 
-impl<T: TileData> Command<Option<T>> for RemoveTile<T> {
-    fn apply(self, world: &mut World) -> Option<T> {
+impl Command for RemoveTile {
+    fn apply(self, world: &mut World) {
         let Ok(mut tilemap_entity) = world.get_entity_mut(self.tilemap_id) else {
             tracing::warn!("Could not find Tilemap Entity {:?}", self.tilemap_id);
-            return Default::default();
+            return;
         };
 
         let Some(tilemap) = tilemap_entity.get::<Tilemap>() else {
             tracing::warn!("Could not find Tilemap on Entity {:?}", self.tilemap_id);
-            return Default::default();
+            return;
         };
 
         let chunk_position = tilemap.tile_chunk_position(self.tile_position);
         let tile_relative_position = tilemap.tile_relative_position(self.tile_position);
-        
+
         if let Some(tile_storage_id) = tilemap.chunks.get(&chunk_position).cloned() {
             tilemap_entity.world_scope(move |w| {
-                let Ok(mut tilestorage_entity) = w.get_entity_mut(tile_storage_id) else {
+                let Ok(mut tile_storage_entity) = w.get_entity_mut(tile_storage_id) else {
                     tracing::warn!("Could not find TileStorage Entity {:?}", tile_storage_id);
-                    return None;
+                    return;
                 };
 
-                let Some(mut tile_storage) = tilestorage_entity.get_mut::<TileStorage<T>>()
-                else {
+                let Some(tile_storages) = tile_storage_entity.get::<TileStorages>().cloned() else {
                     tracing::warn!(
-                        "Could not find TileStorage on Entity {:?}",
+                        "Could not find TileStorages on Entity {:?}",
                         tile_storage_id
                     );
-                    return None;
+                    return;
                 };
 
-                tile_storage.remove(tile_relative_position)
-            })
-        } 
-        else {
-            None
+                for (tile_storage, tile_removal) in tile_storages.removals {
+                    let Ok(storage) = tile_storage_entity.get_mut_by_id(tile_storage) else {
+                        continue;
+                    };
+                    tile_removal(storage, tile_relative_position);
+                }
+            });
         }
     }
-}
+}
diff --git a/crates/bevy_sprite/src/tilemap/entity_tiles.rs b/crates/bevy_sprite/src/tilemap/entity_tiles.rs
@@ -1,5 +1,3 @@
-use std::marker::PhantomData;
-
 use bevy_app::{App, Plugin};
 use bevy_derive::Deref;
 use bevy_ecs::{component::Component, entity::Entity, hierarchy::ChildOf, lifecycle::HookContext, system::Command, world::{DeferredWorld, World}};
@@ -93,16 +91,12 @@ fn on_remove_entity_tile(mut world: DeferredWorld, HookContext { entity, .. }: H
     world
         .commands()
         .queue(move |world: &mut World| {
-            let Some(removed) = RemoveTile::<EntityTile> {
+            RemoveTile {
                 tilemap_id: in_map.0,
                 tile_position: tile_position.0,
-                _t: PhantomData,
-            }.apply(world) else {
-                warn!("Tile {} could not be removed from map or was already removed.", entity);
-                return;
-            };
+            }.apply(world);
             
-            let mut removed = world.entity_mut(removed.0);
+            let mut removed = world.entity_mut(entity);
             if removed.contains::<DespawnOnRemove>() {
                 removed.despawn();
             } else {
diff --git a/crates/bevy_sprite/src/tilemap/storage.rs b/crates/bevy_sprite/src/tilemap/storage.rs
@@ -1,19 +1,40 @@
 use std::ops::Deref;
 
-use bevy_ecs::{component::Component, entity::Entity, name::Name, reflect::ReflectComponent};
+use bevy_ecs::{
+    change_detection::{DetectChangesMut, MutUntyped},
+    component::{Component, ComponentId},
+    entity::Entity,
+    lifecycle::HookContext,
+    name::Name,
+    ptr::PtrMut,
+    reflect::ReflectComponent,
+    world::{DeferredWorld, World},
+};
 use bevy_math::{URect, UVec2};
+use bevy_platform::collections::{HashMap, HashSet};
 use bevy_reflect::Reflect;
 use bevy_transform::components::Transform;
+use tracing::error;
+
+use crate::TileData;
+
+#[derive(Component, Clone, Debug, Default)]
+#[require(Name::new("TileStorage"), Transform)]
+pub struct TileStorages {
+    // Stores removal operations
+    pub(crate) removals: HashMap<ComponentId, fn(MutUntyped<'_>, UVec2)>,
+}
 
 #[derive(Component, Clone, Debug, Default, Reflect)]
 #[reflect(Component)]
-#[require(Name::new("TileStorage"), Transform)]
-pub struct TileStorage<T> {
+#[require(Name::new("TileStorage"), TileStorages, Transform)]
+#[component(on_add = on_add_tile_storage::<T>)]
+pub struct TileStorage<T: TileData> {
     pub tiles: Vec<Option<T>>,
     size: UVec2,
 }
 
-impl<T> TileStorage<T> {
+impl<T: TileData> TileStorage<T> {
     pub fn new(size: UVec2) -> Self {
         let mut tiles = Vec::new();
         tiles.resize_with(size.element_product() as usize, Default::default);
@@ -80,3 +101,43 @@ impl<T> TileStorage<T> {
         self.size
     }
 }
+
+fn on_add_tile_storage<T: TileData>(
+    mut world: DeferredWorld<'_>,
+    HookContext {
+        component_id,
+        entity,
+        ..
+    }: HookContext,
+) {
+    world.commands().queue(move |world: &mut World| {
+        let Ok(mut tile_storage_entity) = world.get_entity_mut(entity) else {
+            error!("Could not fine Tile Storage {}", entity);
+            return;
+        };
+
+        if let Some(mut storages) = tile_storage_entity.get_mut::<TileStorages>() {
+            storages.removals.insert(component_id, remove_tile::<T>);
+        } else {
+            let mut tile_storages = TileStorages {
+                removals: HashMap::with_capacity(1),
+            };
+            tile_storages
+                .removals
+                .insert(component_id, remove_tile::<T>);
+            tile_storage_entity.insert(tile_storages);
+        }
+    })
+}
+
+fn remove_tile<T: TileData>(mut raw: MutUntyped<'_>, tile_coord: UVec2) {
+    #[expect(unsafe_code, reason = "testing")]
+    let storage = unsafe {
+        raw.bypass_change_detection()
+            .reborrow()
+            .deref_mut::<TileStorage<T>>()
+    };
+    if storage.remove(tile_coord).is_some() {
+        raw.set_changed();
+    }
+}
diff --git a/crates/bevy_sprite_render/src/tilemap_chunk/mod.rs b/crates/bevy_sprite_render/src/tilemap_chunk/mod.rs
@@ -344,10 +344,10 @@ fn on_remove_tile_render_data(mut world: DeferredWorld, HookContext { entity, ..
     world
         .commands()
         .queue(move |world: &mut World| {
-            RemoveTile::<TileRenderData> {
+            SetTile::<TileRenderData> {
                 tilemap_id: in_map.0,
                 tile_position: tile_position.0,
-                _t: PhantomData::default(),
+                maybe_tile: None,
             }.apply(world);
         });
 }
diff --git a/examples/2d/tilemap_entities.rs b/examples/2d/tilemap_entities.rs
