feat: implement drag-and-drop for entities and external files (#342)

<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->

## Summary by CodeRabbit

* **New Features**
* Added drag-and-drop support for assets and files in the editor,
including the Asset Manager, Scene Tree, and Editor Scene windows.
* Users can now import files by dragging them into the editor, and
rearrange assets and scene objects using drag-and-drop.
* Visual indicators and overlays are displayed during drag-and-drop
operations for improved usability.

* **Improvements**
  * Asset paths are now automatically normalized for consistency.
  * Asset metadata can now be edited directly.
  * Enhanced asset location string formatting and handling.
  * Streamlined folder structure handling in the Asset Manager.
  * Toolbar alignment in the Editor Scene window is now more precise.

* **Bug Fixes**
* Corrected asset grid filtering to ensure accurate folder content
display.

* **Other**
* Undo/redo actions now support entity parent changes in the scene
hierarchy.
* Internal support for file drop events added to the application and
window system.

<!-- end of auto-generated comment: release notes by coderabbit.ai -->

Author: Thyodas

common/Path.cpp

@@ -0,0 +1,56 @@
+//// Path.cpp ///////////////////////////////////////////////////////////////
+//
+//  zzzzz       zzz  zzzzzzzzzzzzz    zzzz      zzzz       zzzzzz  zzzzz
+//  zzzzzzz     zzz  zzzz                    zzzz       zzzz           zzzz
+//  zzz   zzz   zzz  zzzzzzzzzzzzz         zzzz        zzzz             zzz
+//  zzz    zzz  zzz  z                  zzzz  zzzz      zzzz           zzzz
+//  zzz         zzz  zzzzzzzzzzzzz    zzzz       zzz      zzzzzzz  zzzzz
+//
+//  Author:      Mehdy MORVAN
+//  Date:        24/07/2025
+//  Description: Source file for the path utilities
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include "Path.hpp"
+
+namespace nexo {
+
+    const std::filesystem::path& Path::getExecutablePath()
+    {
+        if (!m_executablePathCached.empty() && !m_executableRootPathCached.empty())
+            return m_executablePathCached;
+        const boost::dll::fs::path path = boost::dll::program_location();
+        m_executablePathCached = path.c_str();
+        m_executableRootPathCached = m_executablePathCached.parent_path();
+        return m_executablePathCached;
+    }
+
+    std::filesystem::path Path::resolvePathRelativeToExe(const std::filesystem::path& path)
+    {
+        if (m_executableRootPathCached.empty())
+            getExecutablePath();
+        return (m_executableRootPathCached / path).lexically_normal();
+    }
+
+    void Path::resetCache()
+    {
+        m_executablePathCached.clear();
+        m_executableRootPathCached.clear();
+    }
+
+    std::string normalizePathAndRemovePrefixSlash(const std::string &rawPath)
+    {
+        namespace fs = std::filesystem;
+        fs::path p = fs::path(rawPath).lexically_normal();
+
+        std::string s = p.generic_string();
+
+        if (s == "/" || s.empty())
+            return {};
+
+        size_t start = s.find_first_not_of('/');
+        size_t end   = s.find_last_not_of('/');
+        return s.substr(start, end - start + 1);
+    }
+}

common/Path.hpp

@@ -28,15 +28,7 @@ namespace nexo {
          * @brief Get the path to the executable (e.g.: nexoEditor)
          * @return The path to the executable
          */
-        static const std::filesystem::path& getExecutablePath()
-        {
-            if (!m_executablePathCached.empty() && !m_executableRootPathCached.empty())
-                return m_executablePathCached;
-            const boost::dll::fs::path path = boost::dll::program_location();
-            m_executablePathCached = path.c_str();
-            m_executableRootPathCached = m_executablePathCached.parent_path();
-            return m_executablePathCached;
-        }
+        static const std::filesystem::path& getExecutablePath();
 
         /**
         * @brief Resolve a path relative to the executable
@@ -46,21 +38,12 @@ namespace nexo {
         * @note Example: if assets is a folder in the same directory as the executable, you can use: resolvePathRelativeToExe("assets")
         * @example ../editor/src/Editor.cpp
         */
-        static std::filesystem::path resolvePathRelativeToExe(const std::filesystem::path& path)
-        {
-            if (m_executableRootPathCached.empty())
-                getExecutablePath();
-            return (m_executableRootPathCached / path).lexically_normal();
-        }
+        static std::filesystem::path resolvePathRelativeToExe(const std::filesystem::path& path);
 
         /**
          * @brief Reset the cached paths
          */
-        static void resetCache()
-        {
-            m_executablePathCached.clear();
-            m_executableRootPathCached.clear();
-        }
+        static void resetCache();
 
         private:
             Path() = default;
@@ -69,5 +52,5 @@ namespace nexo {
             inline static std::filesystem::path m_executableRootPathCached;
     };
 
-
+    std::string normalizePathAndRemovePrefixSlash(const std::string &rawPath);
 } // namespace nexo

editor/CMakeLists.txt

@@ -11,6 +11,7 @@ set(SRCS
         common/Exception.cpp
         common/math/Matrix.cpp
         common/math/Light.cpp
+        common/Path.cpp
         editor/main.cpp
         editor/src/backends/ImGuiBackend.cpp
         editor/src/backends/opengl/openglImGuiBackend.cpp
@@ -47,12 +48,14 @@ set(SRCS
         editor/src/DocumentWindows/EditorScene/Shutdown.cpp
         editor/src/DocumentWindows/EditorScene/Toolbar.cpp
         editor/src/DocumentWindows/EditorScene/Update.cpp
+        editor/src/DocumentWindows/EditorScene/DragDrop.cpp
         editor/src/DocumentWindows/AssetManager/Init.cpp
         editor/src/DocumentWindows/AssetManager/Show.cpp
         editor/src/DocumentWindows/AssetManager/Shutdown.cpp
         editor/src/DocumentWindows/AssetManager/Update.cpp
         editor/src/DocumentWindows/AssetManager/FolderTree.cpp
         editor/src/DocumentWindows/AssetManager/Thumbnail.cpp
+        editor/src/DocumentWindows/AssetManager/FileDrop.cpp
         editor/src/DocumentWindows/ConsoleWindow/Init.cpp
         editor/src/DocumentWindows/ConsoleWindow/Log.cpp
         editor/src/DocumentWindows/ConsoleWindow/Show.cpp
@@ -77,6 +80,7 @@ set(SRCS
         editor/src/DocumentWindows/SceneTreeWindow/Shutdown.cpp
         editor/src/DocumentWindows/SceneTreeWindow/Update.cpp
         editor/src/DocumentWindows/SceneTreeWindow/Shortcuts.cpp
+        editor/src/DocumentWindows/SceneTreeWindow/DragDrop.cpp
         editor/src/DocumentWindows/PopupManager.cpp
         editor/src/DocumentWindows/EntityProperties/TransformProperty.cpp
         editor/src/DocumentWindows/EntityProperties/RenderProperty.cpp

editor/src/DocumentWindows/AssetManager/AssetManagerWindow.hpp

@@ -18,10 +18,12 @@
 #include <imgui.h>
 #include <assets/AssetRef.hpp>
 #include "utils/TransparentStringHash.hpp"
+#include <core/event/WindowEvent.hpp>
+#include "assets/Asset.hpp"
 
 namespace nexo::editor {
 
-    class AssetManagerWindow final : public ADocumentWindow {
+    class AssetManagerWindow final : public ADocumentWindow, LISTENS_TO(event::EventFileDrop) {
         public:
             using ADocumentWindow::ADocumentWindow;
 
@@ -30,6 +32,8 @@ namespace nexo::editor {
             void show() override;
             void update() override;
 
+            void handleEvent(event::EventFileDrop& event) override;
+
         private:
             struct LayoutSettings {
                 struct LayoutSizes {
@@ -74,7 +78,8 @@ namespace nexo::editor {
             void handleSelection(int index, bool isSelected);
 
             assets::AssetType m_selectedType = assets::AssetType::UNKNOWN;
-            std::string m_currentFolder;
+            std::string m_currentFolder;  // Currently selected folder
+            std::string m_hoveredFolder;  // Currently hovered folder
             std::vector<std::pair<std::string, std::string>> m_folderStructure;  // Pairs of (path, name)
             char m_searchBuffer[256] = "";
 
@@ -110,5 +115,25 @@ namespace nexo::editor {
                 const ImVec2& itemPos,
                 const ImVec2& itemSize
             );
+
+            std::vector<std::string> m_pendingDroppedFiles;
+            bool m_showDropIndicator = false;
+
+            void handleDroppedFiles();
+            const assets::AssetLocation getAssetLocation(const std::filesystem::path &path) const;
+            void importDroppedFile(const std::string& filePath);
+    };
+
+    /**
+     * @brief Payload structure for drag and drop operations from asset manager.
+     *
+     * Contains information about the asset being dragged.
+     */
+    struct AssetDragDropPayload
+    {
+        assets::AssetType type; ///< Type of the asset
+        assets::AssetID id; ///< ID of the asset
+        std::string path; ///< Path to the asset
+        std::string name; ///< Display name of the asset
     };
 }

editor/src/DocumentWindows/AssetManager/FileDrop.cpp

@@ -0,0 +1,111 @@
+//// FileDrop.cpp /////////////////////////////////////////////////////////////
+//
+//  zzzzz       zzz  zzzzzzzzzzzzz    zzzz      zzzz       zzzzzz  zzzzz
+//  zzzzzzz     zzz  zzzz                    zzzz       zzzz           zzzz
+//  zzz   zzz   zzz  zzzzzzzzzzzzz         zzzz        zzzz             zzz
+//  zzz    zzz  zzz  z                  zzzz  zzzz      zzzz           zzzz
+//  zzz         zzz  zzzzzzzzzzzzz    zzzz       zzz      zzzzzzz  zzzzz
+//
+//  Author:      Jean CARDONNE
+//  Date:        30/06/2025
+//  Description: Implementation of file drop handling for asset manager
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include "AssetManagerWindow.hpp"
+#include "assets/Asset.hpp"
+#include "assets/AssetImporter.hpp"
+#include "assets/AssetLocation.hpp"
+#include "assets/Assets/Model/Model.hpp"
+#include "assets/Assets/Texture/Texture.hpp"
+#include "Logger.hpp"
+#include <filesystem>
+#include <algorithm>
+
+namespace nexo::editor {
+
+    static assets::AssetType getAssetTypeFromExtension(const std::string &extension)
+    {
+        static const std::set<std::string> imageExtensions = {
+            ".png", ".jpg", ".jpeg", ".bmp", ".tga", ".gif", ".psd", ".hdr", ".pic", ".pnm", ".ppm", ".pgm"
+        };
+        if (imageExtensions.contains(extension))
+            return assets::AssetType::TEXTURE;
+        static const std::set<std::string> modelExtensions = {
+            ".gltf", ".glb", ".fbx", ".obj", ".dae", ".3ds", ".stl", ".ply", ".blend", ".x3d", ".ifc"
+        };
+        if (modelExtensions.contains(extension))
+            return assets::AssetType::MODEL;
+        return assets::AssetType::UNKNOWN;
+    }
+
+    const assets::AssetLocation AssetManagerWindow::getAssetLocation(const std::filesystem::path &path) const
+    {
+        std::string assetName = path.stem().string();
+        std::filesystem::path folderPath;
+        std::string targetFolder = !m_hoveredFolder.empty() ? m_hoveredFolder : m_currentFolder;
+
+        std::string assetPath = targetFolder;
+        std::string locationString = assetName + "@" + assetPath;
+
+        LOG(NEXO_DEV,
+            "Creating asset location: {} (current folder: '{}', hovered: '{}')",
+            locationString,
+            m_currentFolder,
+            m_hoveredFolder);
+
+        assets::AssetLocation location(locationString);
+        return location;
+    }
+
+    void AssetManagerWindow::handleEvent(event::EventFileDrop& event)
+    {
+        m_pendingDroppedFiles.insert(m_pendingDroppedFiles.end(),
+                                    event.files.begin(),
+                                    event.files.end());
+    }
+
+    void AssetManagerWindow::handleDroppedFiles()
+    {
+        if (m_pendingDroppedFiles.empty())
+            return;
+
+        for (const auto& filePath : m_pendingDroppedFiles)
+            importDroppedFile(filePath);
+        m_pendingDroppedFiles.clear();
+
+        m_folderStructure.clear();
+        buildFolderStructure();
+    }
+
+    void AssetManagerWindow::importDroppedFile(const std::string& filePath)
+    {
+        std::filesystem::path path(filePath);
+
+        if (!std::filesystem::exists(path)) {
+            LOG(NEXO_WARN, "Dropped file does not exist: {}", filePath);
+            return;
+        }
+
+        std::string extension = path.extension().string();
+        std::transform(extension.begin(), extension.end(), extension.begin(), ::tolower);
+
+        assets::AssetType assetType = getAssetTypeFromExtension(extension);
+        if (assetType == assets::AssetType::UNKNOWN) {
+            LOG(NEXO_WARN, "Unsupported file type: {}", extension);
+            return;
+        }
+
+        assets::AssetLocation location = getAssetLocation(path);
+
+        assets::AssetImporter importer;
+        assets::ImporterFileInput fileInput{path};
+        try {
+            auto assetRef = importer.importAssetAuto(location, fileInput);
+            if (!assetRef)
+                LOG(NEXO_ERROR, "Failed to import asset: {}", location.getPath().data());
+        } catch (const std::exception& e) {
+            LOG(NEXO_ERROR, "Exception while importing {}: {}", location.getPath().data(), e.what());
+        }
+    }
+}

editor/src/DocumentWindows/AssetManager/FolderTree.cpp

@@ -155,51 +155,48 @@ namespace nexo::editor {
     void AssetManagerWindow::buildFolderStructure()
     {
         m_folderStructure.clear();
+        // Root entry
         m_folderStructure.emplace_back("", "Assets");
         m_folderChildren.clear(); // Clear the folder children map
 
         // First pass: build the folder structure
         std::set<std::string, std::less<>> uniqueFolderPaths;
 
+        std::unordered_set<std::string> seen{""};
+
         const auto assets = assets::AssetCatalog::getInstance().getAssets();
-        for (const auto& asset : assets) {
-            if (auto assetData = asset.lock()) {
-                std::string fullPath = assetData->getMetadata().location.getPath();
-                std::filesystem::path fsPath(fullPath);
-
-                // Extract all parent directories from the path
-                while (fsPath.has_parent_path()) {
-                    fsPath = fsPath.parent_path();
-                    if (!fsPath.empty()) {
-                        uniqueFolderPaths.insert(fsPath.string());
+        for (auto& ref : assets) {
+            if (auto assetData = ref.lock()) {
+                // normalized path: e.g. "Random/Sub"
+                std::filesystem::path p{ assetData->getMetadata().location.getPath() };
+                std::filesystem::path curr;
+                for (auto const& part : p) {
+                    // skip empty or “_internal” style parts
+                    auto s = part.string();
+                    if (s.empty() || s.front() == '_')
+                        continue;
+                    curr /= part;
+                    auto folderPath = curr.string();
+                    if (seen.emplace(folderPath).second) {
+                        m_folderStructure.emplace_back(
+                            folderPath,
+                            curr.filename().string()
+                        );
                     }
                 }
             }
         }
 
-        // Add the unique folder paths to m_folderStructure
-        for (const auto& folderPath : uniqueFolderPaths) {
-            std::filesystem::path fsPath(folderPath);
-            std::string folderName = fsPath.filename().string();
-            m_folderStructure.emplace_back(folderPath, folderName);
-        }
-
-        // Second pass: build the parent-child map
-        for (const auto& [path, name] : m_folderStructure) {
-            if (path.empty()) continue; // Skip root
-
-            std::filesystem::path fsPath(path);
-            std::string parentPath = fsPath.parent_path().string();
-
-            // If parent path is empty, set it to "" (root)
-            if (parentPath.empty()) {
-                parentPath = "";
+        std::sort(
+            m_folderStructure.begin() + 1,
+            m_folderStructure.end(),
+            [](auto const& a, auto const& b){
+                return a.first < b.first;
             }
-
-            m_folderChildren[parentPath].push_back(path);
-        }
+        );
     }
 
+
     void AssetManagerWindow::drawFolderTree()
     {
         handleNewFolderCreation();