Removal wip

jamescarterbell · jamescarterbell · commit 49a47377b96e · 2025-11-19T15:24:17.000-05:00
diff --git a/crates/bevy_sprite/src/tilemap/commands.rs b/crates/bevy_sprite/src/tilemap/commands.rs
@@ -1,17 +1,19 @@
+use std::marker::PhantomData;
+
 use crate::tilemap::{TileData, TileStorage, Tilemap};
-use bevy_ecs::{entity::Entity, error::HandleError, hierarchy::ChildOf, system::{Command, Commands}, world::World};
-use bevy_math::{IVec2, UVec2, Vec2, Vec3};
+use bevy_ecs::{entity::Entity, hierarchy::ChildOf, system::{Command, Commands}, world::World};
+use bevy_math::{IVec2, Vec2, Vec3};
 use bevy_transform::components::Transform;
 
 pub trait CommandsTilemapExt {
     fn set_tile<T: TileData>(
         &mut self,
-        tilemap: Entity,
+        tilemap_id: Entity,
         tile_position: IVec2,
         maybe_tile: Option<T>,
     );
 
-    fn remove_tile(&mut self, tilemap: Entity, tile_position: IVec2);
+    fn remove_tile<T: TileData>(&mut self, tilemap_id: Entity, tile_position: IVec2);
 }
 
 impl CommandsTilemapExt for Commands<'_, '_> {
@@ -24,8 +26,8 @@ impl CommandsTilemapExt for Commands<'_, '_> {
         self.queue(move |world: &mut World| {SetTile {tilemap_id, tile_position, maybe_tile }.apply(world);});
     }
 
-    fn remove_tile(&mut self, tilemap: Entity, tile_position: IVec2) {
-        todo!()
+    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);});
     }
 }
 
@@ -59,7 +61,7 @@ impl<T: TileData> Command<SetTileResult<T>> for SetTile<T> {
             };
 
             let chunk_position = tilemap.tile_chunk_position(self.tile_position);
-            let tile_position = tilemap.tile_chunk_local_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() {
                 let replaced_tile = tilemap_entity.world_scope(move |w| {
@@ -77,15 +79,15 @@ impl<T: TileData> Command<SetTileResult<T>> for SetTile<T> {
                         return None;
                     };
 
-                    tile_storage.set(tile_position, self.maybe_tile)
+                    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_position, self.maybe_tile);
+                    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);
@@ -99,4 +101,50 @@ impl<T: TileData> Command<SetTileResult<T>> for SetTile<T> {
                 SetTileResult { chunk_id: Some(tile_storage_id), replaced_tile: None }
             }
     }
+}
+
+pub struct RemoveTile<T: TileData> {
+    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> {
+        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 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 {
+                    tracing::warn!("Could not find TileStorage Entity {:?}", tile_storage_id);
+                    return None;
+                };
+
+                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;
+                };
+
+                tile_storage.remove(tile_relative_position)
+            })
+        } 
+        else {
+            None
+        }
+    }
 }
diff --git a/crates/bevy_sprite/src/tilemap/entity_tiles.rs b/crates/bevy_sprite/src/tilemap/entity_tiles.rs
@@ -1,18 +1,21 @@
+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}};
 use bevy_math::IVec2;
 use tracing::warn;
 
-use crate::{SetTile, SetTileResult, TileData};
+use crate::{RemoveTile, SetTile, SetTileResult, TileData};
 
 /// Plugin that handles the initialization and updating of tilemap chunks.
 /// Adds systems for processing newly added tilemap chunks.
 pub struct EntityTilePlugin;
 
 impl Plugin for EntityTilePlugin {
     fn build(&self, app: &mut App) {
-        app.world_mut().register_component_hooks::<TileCoord>().on_insert(on_insert_entity_tile);
+        app.world_mut().register_component_hooks::<TileCoord>().on_insert(on_insert_entity_tile).on_remove(on_remove_entity_tile);
+        app.world_mut().register_component_hooks::<InMap>().on_remove(on_remove_entity_tile);
     }
 }
 
@@ -24,11 +27,16 @@ impl TileData for EntityTile {
 }
 
 #[derive(Component, Clone, Debug, Deref)]
+#[component(immutable)]
 pub struct InMap(pub Entity);
 
 #[derive(Component, Clone, Debug, Deref)]
+#[component(immutable)]
 pub struct TileCoord(pub IVec2);
 
+#[derive(Component, Clone, Debug)]
+pub struct DespawnOnRemove;
+
 fn on_insert_entity_tile(mut world: DeferredWorld, HookContext { entity, .. }: HookContext){
     let Ok(tile) = world.get_entity(entity) else {
         warn!("Tile {} not found", entity);
@@ -58,7 +66,47 @@ fn on_insert_entity_tile(mut world: DeferredWorld, HookContext { entity, .. }: H
             world.entity_mut(entity).insert(ChildOf(chunk_id));
 
             if let Some(replaced_tile) = replaced_tile {
-                world.despawn(replaced_tile.0);
+                let mut replaced_tile = world.entity_mut(replaced_tile.0);
+                if replaced_tile.contains::<DespawnOnRemove>() {
+                    replaced_tile.despawn();
+                } else {
+                    replaced_tile.remove::<(InMap, TileCoord)>();
+                }
+            }
+        });
+}
+
+fn on_remove_entity_tile(mut world: DeferredWorld, HookContext { entity, .. }: HookContext){
+    let Ok(tile) = world.get_entity(entity) else {
+        warn!("Tile {} not found", entity);
+        return;
+    };
+    let Some(in_map) = tile.get::<InMap>().cloned() else {
+        warn!("Tile {} is not in a TileMap", entity);
+        return;
+    };
+    let Some(tile_position) = tile.get::<TileCoord>().cloned() else {
+        warn!("Tile {} has no tile coord.", entity);
+        return;
+    };
+
+    world
+        .commands()
+        .queue(move |world: &mut World| {
+            let Some(removed) = RemoveTile::<EntityTile> {
+                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;
+            };
+            
+            let mut removed = world.entity_mut(removed.0);
+            if removed.contains::<DespawnOnRemove>() {
+                removed.despawn();
+            } else {
+                removed.remove::<InMap>();
             }
         });
 }
diff --git a/crates/bevy_sprite/src/tilemap/mod.rs b/crates/bevy_sprite/src/tilemap/mod.rs
@@ -52,8 +52,7 @@ impl Tilemap {
     }
 
     /// Get the coordinates with in a chunk from a tiles global coordinates.
-    // TODO: NAME THIS BETTER
-    pub fn tile_chunk_local_position(&self, tile_position: IVec2) -> UVec2 {
+    pub fn tile_relative_position(&self, tile_position: IVec2) -> UVec2 {
         let chunk_size = self
             .chunk_size
             .try_into()
diff --git a/crates/bevy_sprite_render/src/tilemap_chunk/mod.rs b/crates/bevy_sprite_render/src/tilemap_chunk/mod.rs
@@ -1,4 +1,4 @@
-use std::any::type_name;
+use std::{any::type_name, marker::PhantomData};
 
 use crate::{AlphaMode2d, MeshMaterial2d};
 use bevy_app::{App, Plugin, Update};
@@ -14,7 +14,7 @@ use bevy_math::{primitives::Rectangle, UVec2};
 use bevy_mesh::{Mesh, Mesh2d};
 use bevy_platform::collections::HashMap;
 use bevy_reflect::{prelude::*, Reflect};
-use bevy_sprite::{InMap, SetTile, TileCoord, TileData, TileStorage, Tilemap};
+use bevy_sprite::{InMap, RemoveTile, SetTile, TileCoord, TileData, TileStorage, Tilemap};
 use bevy_transform::components::Transform;
 use bevy_utils::default;
 use tracing::{trace, warn};
@@ -32,7 +32,7 @@ impl Plugin for TilemapChunkPlugin {
         app.init_resource::<TilemapChunkMeshCache>()
             .add_systems(Update, update_tilemap_chunk_indices);
         app.world_mut().register_component_hooks::<TileStorage<TileRenderData>>().on_insert(on_insert_chunk_tile_render_data);
-        app.world_mut().register_component_hooks::<TileRenderData>().on_insert(on_insert_tile_render_data);
+        app.world_mut().register_component_hooks::<TileRenderData>().on_insert(on_insert_tile_render_data).on_remove(on_remove_tile_render_data);
     }
 }
 
@@ -139,6 +139,7 @@ fn on_insert_chunk_tile_render_data(mut world: DeferredWorld, HookContext { enti
 /// Data for a single tile in the tilemap chunk.
 #[derive(Component, Clone, Copy, Debug, Reflect)]
 #[reflect(Clone, Debug, Default)]
+#[component(immutable)]
 pub struct TileRenderData {
     /// The index of the tile in the corresponding tileset array texture.
     pub tileset_index: u16,
@@ -293,7 +294,6 @@ fn update_tilemap_chunk_indices(
     }
 }
 
-
 fn on_insert_tile_render_data(mut world: DeferredWorld, HookContext { entity, .. }: HookContext){
     let Ok(tile) = world.get_entity(entity) else {
         warn!("Tile {} not found", entity);
@@ -321,4 +321,33 @@ fn on_insert_tile_render_data(mut world: DeferredWorld, HookContext { entity, ..
                 maybe_tile: Some(tile_render_data),
             }.apply(world);
         });
+}
+
+fn on_remove_tile_render_data(mut world: DeferredWorld, HookContext { entity, .. }: HookContext){
+    let Ok(tile) = world.get_entity(entity) else {
+        warn!("Tile {} not found", entity);
+        return;
+    };
+    let Some(in_map) = tile.get::<InMap>().cloned() else {
+        warn!("Tile {} is not in a TileMap", entity);
+        return;
+    };
+    let Some(tile_position) = tile.get::<TileCoord>().cloned() else {
+        warn!("Tile {} has no tile coord.", entity);
+        return;
+    };
+    let Some(tile_render_data) = tile.get::<TileRenderData>().cloned()  else {
+        warn!("Tile {} does not have TileRenderData", entity);
+        return;
+    };
+
+    world
+        .commands()
+        .queue(move |world: &mut World| {
+            RemoveTile::<TileRenderData> {
+                tilemap_id: in_map.0,
+                tile_position: tile_position.0,
+                _t: PhantomData::default(),
+            }.apply(world);
+        });
 }
diff --git a/examples/2d/tilemap_entities.rs b/examples/2d/tilemap_entities.rs
@@ -1,7 +1,7 @@
 //! Shows a tilemap chunk rendered with a single draw call.
 
 use bevy::{
-    color::palettes::tailwind::RED_400, image::{ImageArrayLayout, ImageLoaderSettings}, prelude::*, sprite::{CommandsTilemapExt, InMap, TileCoord, TileStorage, Tilemap}, sprite_render::{TileRenderData, TilemapChunkRenderData, TilemapRenderData}
+    color::palettes::tailwind::RED_400, image::{ImageArrayLayout, ImageLoaderSettings}, prelude::*, sprite::{CommandsTilemapExt, DespawnOnRemove, InMap, TileCoord, TileStorage, Tilemap}, sprite_render::{TileRenderData, TilemapChunkRenderData, TilemapRenderData}
 };
 use rand::{Rng, SeedableRng};
 use rand_chacha::ChaCha8Rng;
@@ -60,7 +60,7 @@ fn update_tilemap(
         let x = rng.random_range(-64..=64);
         let y = rng.random_range(-64..=64);
 
-        commands.spawn((InMap(map), TileCoord(IVec2::new(x, y)), TileRenderData { tileset_index: rng.random_range(0..4), ..Default::default()}));
+        commands.spawn((InMap(map), TileCoord(IVec2::new(x, y)), TileRenderData { tileset_index: rng.random_range(0..4), ..Default::default()}, DespawnOnRemove));
     }
 }
 

Original file line number	Diff line number	Diff line change
`@@ -52,8 +52,7 @@ impl Tilemap {`
`52`	`52`	`}`
`53`	`53`
`54`	`54`	`/// Get the coordinates with in a chunk from a tiles global coordinates.`
`55`		`- // TODO: NAME THIS BETTER`
`56`		`- pub fn tile_chunk_local_position(&self, tile_position: IVec2) -> UVec2 {`
	`55`	`+ pub fn tile_relative_position(&self, tile_position: IVec2) -> UVec2 {`
`57`	`56`	`let chunk_size = self`
`58`	`57`	`.chunk_size`
`59`	`58`	`.try_into()`
Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,7 @@`
`1`	`1`	`//! Shows a tilemap chunk rendered with a single draw call.`
`2`	`2`
`3`	`3`	`use bevy::{`
`4`		`- color::palettes::tailwind::RED_400, image::{ImageArrayLayout, ImageLoaderSettings}, prelude::*, sprite::{CommandsTilemapExt, InMap, TileCoord, TileStorage, Tilemap}, sprite_render::{TileRenderData, TilemapChunkRenderData, TilemapRenderData}`
	`4`	`+ color::palettes::tailwind::RED_400, image::{ImageArrayLayout, ImageLoaderSettings}, prelude::*, sprite::{CommandsTilemapExt, DespawnOnRemove, InMap, TileCoord, TileStorage, Tilemap}, sprite_render::{TileRenderData, TilemapChunkRenderData, TilemapRenderData}`
`5`	`5`	`};`
`6`	`6`	`use rand::{Rng, SeedableRng};`
`7`	`7`	`use rand_chacha::ChaCha8Rng;`
`@@ -60,7 +60,7 @@ fn update_tilemap(`
`60`	`60`	`let x = rng.random_range(-64..=64);`
`61`	`61`	`let y = rng.random_range(-64..=64);`
`62`	`62`
`63`		`- commands.spawn((InMap(map), TileCoord(IVec2::new(x, y)), TileRenderData { tileset_index: rng.random_range(0..4), ..Default::default()}));`
	`63`	`+ commands.spawn((InMap(map), TileCoord(IVec2::new(x, y)), TileRenderData { tileset_index: rng.random_range(0..4), ..Default::default()}, DespawnOnRemove));`
`64`	`64`	`}`
`65`	`65`	`}`
`66`	`66`