tile set editor mockup

editor/src/asset/mod.rs

@@ -53,6 +53,7 @@ use crate::{
     Message, Mode,
 };
 use fyrox::core::Uuid;
+use fyrox::scene::tilemap::tileset::TileSet;
 use std::sync::mpsc;
 use std::sync::mpsc::Sender;
 use std::{
@@ -211,6 +212,14 @@ impl ContextMenu {
                                 sender.send(Message::OpenMaterialEditor(material));
                             }
                         }
+                    } else if item.path.extension().map_or(false, |ext| ext == "tileset") {
+                        if let Ok(path) = make_relative_path(&item.path) {
+                            if let Ok(tile_set) =
+                                block_on(engine.resource_manager.request::<TileSet>(path))
+                            {
+                                sender.send(Message::OpenTileSetEditor(tile_set));
+                            }
+                        }
                     } else {
                         open_in_explorer(&item.path)
                     }

editor/src/message.rs

@@ -13,6 +13,7 @@ use crate::{
     scene::Selection,
     SaveSceneConfirmationDialogAction,
 };
+use fyrox::scene::tilemap::tileset::TileSetResource;
 use std::{path::PathBuf, sync::mpsc::Sender};
 
 #[derive(Debug)]
@@ -43,6 +44,7 @@ pub enum Message {
     OpenAnimationEditor,
     OpenAbsmEditor,
     OpenMaterialEditor(MaterialResource),
+    OpenTileSetEditor(TileSetResource),
     OpenNodeRemovalDialog,
     ShowInAssetBrowser(PathBuf),
     LocateObject {

editor/src/plugins/tilemap/mod.rs

@@ -1,13 +1,16 @@
+pub mod tileset;
+
 use crate::{
     fyrox::{
         core::{algebra::Vector2, pool::Handle, type_traits::prelude::*, Uuid},
         engine::Engine,
         graph::{BaseSceneGraph, SceneGraphNode},
-        gui::{BuildContext, UiNode},
+        gui::{message::UiMessage, BuildContext, UiNode},
         scene::{node::Node, tilemap::TileMap},
     },
     interaction::{make_interaction_mode_button, InteractionMode},
     plugin::EditorPlugin,
+    plugins::tilemap::tileset::TileSetEditor,
     scene::{controller::SceneController, GameScene, Selection},
     settings::Settings,
     Editor, Message,
@@ -71,16 +74,45 @@ impl InteractionMode for TileMapInteractionMode {
         )
     }
 
+    fn update(
+        &mut self,
+        _editor_selection: &Selection,
+        controller: &mut dyn SceneController,
+        engine: &mut Engine,
+        _settings: &Settings,
+    ) {
+        let Some(game_scene) = controller.downcast_mut::<GameScene>() else {
+            return;
+        };
+
+        let _scene = &mut engine.scenes[game_scene.scene];
+    }
+
     fn uuid(&self) -> Uuid {
         Self::type_uuid()
     }
 }
 
 #[derive(Default)]
-pub struct TileMapEditorPlugin {}
+pub struct TileMapEditorPlugin {
+    tile_set_editor: Option<TileSetEditor>,
+}
 
 impl EditorPlugin for TileMapEditorPlugin {
+    fn on_ui_message(&mut self, message: &mut UiMessage, editor: &mut Editor) {
+        if let Some(tile_set_editor) = self.tile_set_editor.take() {
+            self.tile_set_editor =
+                tile_set_editor.handle_ui_message(message, editor.engine.user_interfaces.first());
+        }
+    }
+
     fn on_message(&mut self, message: &Message, editor: &mut Editor) {
+        if let Message::OpenTileSetEditor(tile_set) = message {
+            let ui = editor.engine.user_interfaces.first_mut();
+            let tile_set_editor = TileSetEditor::new(tile_set.clone(), &mut ui.build_ctx());
+            self.tile_set_editor = Some(tile_set_editor);
+        }
+
         let Some(entry) = editor.scenes.current_scene_entry_mut() else {
             return;
         };

editor/src/plugins/tilemap/tileset.rs

@@ -0,0 +1,105 @@
+use crate::fyrox::{
+    core::pool::Handle,
+    gui::{
+        button::ButtonBuilder,
+        grid::{Column, GridBuilder, Row},
+        list_view::ListViewBuilder,
+        message::{MessageDirection, UiMessage},
+        stack_panel::StackPanelBuilder,
+        utils::make_simple_tooltip,
+        widget::{WidgetBuilder, WidgetMessage},
+        window::{WindowBuilder, WindowMessage, WindowTitle},
+        wrap_panel::WrapPanelBuilder,
+        BuildContext, Orientation, Thickness, UiNode, UserInterface,
+    },
+    scene::tilemap::tileset::TileSetResource,
+};
+
+#[allow(dead_code)]
+pub struct TileSetEditor {
+    window: Handle<UiNode>,
+    tiles: Handle<UiNode>,
+    tile_set: TileSetResource,
+}
+
+impl TileSetEditor {
+    pub fn new(tile_set: TileSetResource, ctx: &mut BuildContext) -> Self {
+        let import;
+        let buttons = StackPanelBuilder::new(WidgetBuilder::new().on_row(0).with_child({
+            import = ButtonBuilder::new(
+                WidgetBuilder::new()
+                    .with_width(100.0)
+                    .with_height(24.0)
+                    .with_margin(Thickness::uniform(1.0))
+                    .with_tooltip(make_simple_tooltip(
+                        ctx,
+                        "Import tile set from a sprite sheet.",
+                    )),
+            )
+            .with_text("Import...")
+            .build(ctx);
+            import
+        }))
+        .with_orientation(Orientation::Horizontal)
+        .build(ctx);
+
+        let tiles = ListViewBuilder::new(
+            WidgetBuilder::new()
+                .on_row(1)
+                .with_margin(Thickness::uniform(1.0)),
+        )
+        .with_items_panel(
+            WrapPanelBuilder::new(WidgetBuilder::new())
+                .with_orientation(Orientation::Horizontal)
+                .build(ctx),
+        )
+        .build(ctx);
+
+        let content = GridBuilder::new(WidgetBuilder::new().with_child(buttons).with_child(tiles))
+            .add_row(Row::auto())
+            .add_row(Row::stretch())
+            .add_column(Column::stretch())
+            .build(ctx);
+
+        let window = WindowBuilder::new(WidgetBuilder::new().with_width(300.0).with_height(400.0))
+            .open(false)
+            .with_title(WindowTitle::text("Tile Set Editor"))
+            .with_content(content)
+            .build(ctx);
+
+        ctx.sender()
+            .send(WindowMessage::open(
+                window,
+                MessageDirection::ToWidget,
+                true,
+                true,
+            ))
+            .unwrap();
+
+        Self {
+            window,
+            tiles,
+            tile_set,
+        }
+    }
+
+    fn destroy(self, ui: &UserInterface) {
+        ui.send_message(WidgetMessage::remove(
+            self.window,
+            MessageDirection::ToWidget,
+        ));
+    }
+
+    pub fn handle_ui_message(self, message: &UiMessage, ui: &UserInterface) -> Option<Self> {
+        if let Some(WindowMessage::Close) = message.data() {
+            if message.destination() == self.window
+                && message.direction() == MessageDirection::FromWidget
+            {
+                self.destroy(ui);
+                return None;
+            }
+        }
+
+        Some(self)
+    }
+}