ability to remove brush tiles by delete key

FyroxEngine · Jul 10, 2024 · 316cc3c · 316cc3c
1 parent 3b848e0
commit 316cc3c
Show file tree

Hide file tree

Showing 2 changed files with 66 additions and 20 deletions.
diff --git a/editor/src/plugins/tilemap/palette.rs b/editor/src/plugins/tilemap/palette.rs
@@ -15,7 +15,7 @@ use crate::{
             brush::Brush,
             define_constructor, define_widget_deref,
             draw::{CommandTexture, Draw, DrawingContext},
-            message::{MessageDirection, MouseButton, UiMessage},
+            message::{KeyCode, MessageDirection, MouseButton, UiMessage},
             widget::{Widget, WidgetBuilder, WidgetMessage},
             BuildContext, Control, UiNode, UserInterface,
         },
@@ -29,17 +29,24 @@ use std::ops::{Deref, DerefMut};
 
 #[derive(Debug, PartialEq, Clone)]
 pub enum PaletteMessage {
+    // Direction: FromWidget
     ActiveBrush(TileMapBrush),
+    // Direction: ToWidget
     AddTile(Handle<UiNode>),
+    // Direction: ToWidget
     RemoveTile(Handle<UiNode>),
+    // Direction: FromWidget
     MoveTiles(Vec<(Uuid, Vector2<i32>)>),
+    // Direction: FromWidget
+    DeleteTiles(Vec<Uuid>),
 }
 
 impl PaletteMessage {
     define_constructor!(PaletteMessage:ActiveBrush => fn active_brush(TileMapBrush), layout: false);
     define_constructor!(PaletteMessage:AddTile => fn add_tile(Handle<UiNode>), layout: false);
     define_constructor!(PaletteMessage:RemoveTile => fn remove_tile(Handle<UiNode>), layout: false);
     define_constructor!(PaletteMessage:MoveTiles => fn move_tiles(Vec<(Uuid, Vector2<i32>)>), layout: false);
+    define_constructor!(PaletteMessage:DeleteTiles => fn delete_tiles(Vec<Uuid>), layout: false);
 }
 
 #[derive(Debug, Clone, PartialEq, Visit, Reflect, Default)]
@@ -397,6 +404,25 @@ impl Control for PaletteWidget {
                     _ => (),
                 }
             }
+        } else if let Some(WidgetMessage::KeyDown(key)) = message.data() {
+            if *key == KeyCode::Delete && !message.handled() {
+                let tiles = self
+                    .tiles_to_brush(&self.selection, ui)
+                    .tiles
+                    .into_iter()
+                    .map(|tile| tile.id)
+                    .collect::<Vec<_>>();
+
+                if !tiles.is_empty() {
+                    ui.send_message(PaletteMessage::delete_tiles(
+                        self.handle,
+                        MessageDirection::FromWidget,
+                        tiles,
+                    ));
+
+                    message.set_handled(true);
+                }
+            };
         }
     }
 }

diff --git a/editor/src/plugins/tilemap/panel.rs b/editor/src/plugins/tilemap/panel.rs
@@ -196,35 +196,55 @@ impl TileMapPanel {
                     }
                 }
             }
-        } else if let Some(PaletteMessage::MoveTiles(move_data)) = message.data() {
+        } else if let Some(msg) = message.data() {
             if let Some(tile_map) = tile_map {
                 if let Some(active_brush_resource) = tile_map.active_brush().as_ref() {
                     if message.destination() == self.palette
                         && message.direction == MessageDirection::FromWidget
                     {
-                        let mut commands = vec![Command::new(MoveBrushTilesCommand {
-                            brush: active_brush_resource.clone(),
-                            positions: move_data.clone(),
-                        })];
+                        match msg {
+                            PaletteMessage::MoveTiles(move_data) => {
+                                let mut commands = vec![Command::new(MoveBrushTilesCommand {
+                                    brush: active_brush_resource.clone(),
+                                    positions: move_data.clone(),
+                                })];
 
-                        let active_brush = active_brush_resource.data_ref();
-                        for (id, new_tile_position) in move_data.iter() {
-                            if let Some(tile) = active_brush.find_tile(id) {
-                                for other_tile in active_brush.tiles.iter() {
-                                    if !std::ptr::eq(tile, other_tile)
-                                        && other_tile.local_position == *new_tile_position
-                                    {
-                                        commands.push(Command::new(RemoveBrushTileCommand {
-                                            brush: active_brush_resource.clone(),
-                                            id: other_tile.id,
-                                            tile: None,
-                                        }));
+                                let active_brush = active_brush_resource.data_ref();
+                                for (id, new_tile_position) in move_data.iter() {
+                                    if let Some(tile) = active_brush.find_tile(id) {
+                                        for other_tile in active_brush.tiles.iter() {
+                                            if !std::ptr::eq(tile, other_tile)
+                                                && other_tile.local_position == *new_tile_position
+                                            {
+                                                commands.push(Command::new(
+                                                    RemoveBrushTileCommand {
+                                                        brush: active_brush_resource.clone(),
+                                                        id: other_tile.id,
+                                                        tile: None,
+                                                    },
+                                                ));
+                                            }
+                                        }
                                     }
                                 }
+
+                                sender.do_command(CommandGroup::from(commands));
                             }
+                            PaletteMessage::DeleteTiles(ids) => {
+                                sender.do_command(CommandGroup::from(
+                                    ids.iter()
+                                        .map(|id| {
+                                            Command::new(RemoveBrushTileCommand {
+                                                brush: active_brush_resource.clone(),
+                                                id: *id,
+                                                tile: None,
+                                            })
+                                        })
+                                        .collect::<Vec<_>>(),
+                                ))
+                            }
+                            _ => (),
                         }
-
-                        sender.do_command(CommandGroup::from(commands));
                     }
                 }
             }