UI Workspaces & Parallel Transform Hierarchy

.gitignore

@@ -38,6 +38,7 @@ install_manifest.txt
 # ==========================================
 # Binaries, Intermediates, and Compiled Objects
 # ==========================================
+Assets/
 Binaries/
 Intermediates/
 [Dd]ebug/

.gitmodules

@@ -8,8 +8,8 @@
 	path = External/ImGuiFileDialog
 	url = https://github.com/aiekick/ImGuiFileDialog
 [submodule "External/imgui-node-editor"]
-	path = External/imgui-node-editor
-	url = https://github.com/thedmd/imgui-node-editor.git
+    path = External/imgui-node-editor
+    url = https://github.com/TamasPetii/imgui-node-editor
 [submodule "External/IconFontCppHeaders"]
 	path = External/IconFontCppHeaders
 	url = https://github.com/juliettef/IconFontCppHeaders.git

README.md

@@ -8,8 +8,17 @@ Synapse Engine is a research-oriented real-time rendering engine focusing on eli
 
 The system integrates a segmented data-oriented ECS with a hierarchical GPU culling architecture, modern mesh shader support, and an advanced virtualized shadow map system for directional, spot, and point lights (supporting both CPU and GPU-driven paths). The engine now utilizes an MVI architecture for its tooling and features a robust cross-platform build system using `xmake` for Windows and Linux.
 
-![Synapse Engine Editor UI](Docs/Images/EditorUI.png)
-*Synapse Engine running with the integrated ImGui editor, showcasing the MVI architecture.*
+![Synapse Engine Scene Workspace](Docs/Images/SceneWorkspace.png)
+*Synapse Engine running with the integrated ImGui editor (Scene Workspace), showcasing the MVI architecture.*
+
+![Synapse Engine Model Workspace](Docs/Images/ModelWorkspace.png)
+*Model Workspace*
+
+![Synapse Engine Material Workspace](Docs/Images/MaterialWorkspace.png)
+*Material Workspace*
+
+![Synapse Engine Texture Workspace](Docs/Images/TextureWorkspace.png)
+*Texture Workspace*
 
 ## Core Concepts
 

SynapseEngine/Editor/Core/Windows/GlfwWindow.cpp

@@ -160,4 +160,15 @@ namespace Syn {
     void GlfwWindow::SetCallbacks(const WindowCallbacks& callbacks) {
         _data.callbacks = callbacks;
     }
+
+    void GlfwWindow::SetIcon(uint32_t width, uint32_t height, const uint8_t* pixels) {
+        if (!_window || !pixels) return;
+
+        GLFWimage image;
+        image.width = static_cast<int>(width);
+        image.height = static_cast<int>(height);
+        image.pixels = const_cast<unsigned char*>(pixels);
+
+        glfwSetWindowIcon(_window, 1, &image);
+    }
 }

SynapseEngine/Editor/Core/Windows/GlfwWindow.h

@@ -22,7 +22,7 @@ namespace Syn {
 
         void CreateSurface(VkInstance instance, VkSurfaceKHR* surface) override;
         void SetCallbacks(const WindowCallbacks& callbacks) override;
-
+        void SetIcon(uint32_t width, uint32_t height, const uint8_t* pixels) override;
         void* GetNativePointer() const override { return _window; }
     private:
         void Init(const WindowConfig& config);

SynapseEngine/Editor/Core/Windows/Window.h

@@ -47,7 +47,7 @@ namespace Syn
 
         virtual void CreateSurface(VkInstance instance, VkSurfaceKHR* surface) = 0;
         virtual void SetCallbacks(const WindowCallbacks& callbacks) = 0;
-
+        virtual void SetIcon(uint32_t width, uint32_t height, const uint8_t* pixels) = 0;
         virtual void* GetNativePointer() const = 0;
 
         static std::unique_ptr<Window> Create(const WindowConfig& config);

SynapseEngine/Editor/EditorApi/EditorApiUtils.h

@@ -2,8 +2,16 @@
 #include "Engine/Scene/SceneManager.h"
 #include "Engine/Scene/Scene.h"
 #include "EditorCore/Types/EntityHandle.h"
+#include <type_traits>
+#include <concepts>
 
 namespace Syn {
+
+    template <typename T>
+    concept HasStorageCategory = requires(T pool, EntityID entity) {
+        pool->SetCategory(entity, pool->GetCategory(entity));
+    };
+
     class EditorApiUtils {
     public:
         template <typename T, typename Getter, typename ReturnType>
@@ -44,5 +52,35 @@ namespace Syn {
             auto registry = scene->GetRegistry();
             return registry && registry->HasComponent<T>(entity);
         }
+
+
+        template <typename... Components>
+        static void CloneEntityComponents(SceneManager* sm, EntityID src, EntityID dst) {
+            auto scene = sm->GetActiveScene();
+            if (!scene) return;
+
+            auto registry = scene->GetRegistry();
+            if (!registry) return;
+
+            (
+                [&]() {
+                    auto pool = registry->GetPool<Components>();
+                    if (pool && pool->Has(src)) {
+
+                        if constexpr (std::is_empty_v<Components>) {
+                            pool->Add(dst);
+                        }
+                        else {
+                            registry->AddComponent<Components>(dst);
+                            registry->GetComponent<Components>(dst) = registry->GetComponent<Components>(src);
+                        }
+
+                        if constexpr (HasStorageCategory<decltype(pool)>) {
+                            pool->SetCategory(dst, pool->GetCategory(src));
+                        }
+                    }
+                }(), ... 
+                    );
+        }
     };
 }

SynapseEngine/Editor/EditorApi/EditorContext.cpp

@@ -12,25 +12,49 @@
 #include "Impl/SelectionApiImpl.h"
 #include "Impl/PointLightApiImpl.h"
 #include "Impl/SpotLightApiImpl.h"
+#include "Impl/TextureApiImpl.h"
+#include "Impl/ModelApiImpl.h"
+#include "Impl/CameraApiImpl.h"
+#include "Impl/BoxColliderApiImpl.h"
+#include "Impl/SphereColliderApiImpl.h"
+#include "Impl/CapsuleColliderApiImpl.h"
+#include "Impl/ConvexColliderApiImpl.h"
+#include "Impl/MeshColliderApiImpl.h"
+#include "Impl/RigidBodyApiImpl.h"
+#include "Impl/ModelComponentApiImpl.h"
+#include "Impl/AnimationApiImpl.h"
+#include "Impl/MaterialOverrideApiImpl.h"
+#include "Impl/PreviewApiImpl.h"
 
 namespace Syn {
     EditorContext::EditorContext(Engine* engine, GuiTextureManager* textureManager) {
         SceneManager* sm = engine->GetSceneManager();
 
-        _selectionApi = std::make_unique<SelectionApiImpl>(sm);
-        _tagApi = std::make_unique<TagApiImpl>(sm);
-        _transformApi = std::make_unique<TransformApiImpl>(sm);
-        _directionLightApi = std::make_unique<DirectionLightApiImpl>(sm);
-        _fileSystemApi = std::make_unique<FileSystemApiImpl>();
-        _hierarchyApi = std::make_unique<HierarchyApiImpl>(sm);
-        _loggerApi = std::make_unique<LoggerApiImpl>(engine);
-        _materialApi = std::make_unique<MaterialApiImpl>(engine);
-        _renderApi = std::make_unique<RenderApiImpl>(engine, textureManager, sm);
-        _sceneApi = std::make_unique<SceneApiImpl>(sm);
-        _settingsApi = std::make_unique<SettingsApiImpl>(sm);
-        _pointLightApi = std::make_unique<PointLightApiImpl>(sm);
-        _spotLightApi = std::make_unique<SpotLightApiImpl>(sm);
+        RegisterApi<ISelectionApi, SelectionApiImpl>(sm);
+        RegisterApi<ITagApi, TagApiImpl>(sm);
+        RegisterApi<ITransformApi, TransformApiImpl>(sm);
+        RegisterApi<IDirectionLightApi, DirectionLightApiImpl>(sm);
+        RegisterApi<IFileSystemApi, FileSystemApiImpl>();
+        RegisterApi<IHierarchyApi, HierarchyApiImpl>(sm, engine->GetModelManager());
+        RegisterApi<ILoggerApi, LoggerApiImpl>(engine);
+        RegisterApi<IMaterialApi, MaterialApiImpl>(engine->GetMaterialManager(), sm);
+        RegisterApi<IRenderApi, RenderApiImpl>(engine, textureManager, sm);
+        RegisterApi<ISceneApi, SceneApiImpl>(sm);
+        RegisterApi<ISettingsApi, SettingsApiImpl>(sm);
+        RegisterApi<IPointLightApi, PointLightApiImpl>(sm);
+        RegisterApi<ISpotLightApi, SpotLightApiImpl>(sm);
+        RegisterApi<ITextureApi, TextureApiImpl>(engine->GetImageManager(), textureManager);
+        RegisterApi<IModelApi, ModelApiImpl>(engine->GetModelManager(), sm);
+        RegisterApi<ICameraApi, CameraApiImpl>(sm);
+        RegisterApi<IBoxColliderApi, BoxColliderApiImpl>(sm);
+        RegisterApi<ISphereColliderApi, SphereColliderApiImpl>(sm);
+        RegisterApi<ICapsuleColliderApi, CapsuleColliderApiImpl>(sm);
+        RegisterApi<IConvexColliderApi, ConvexColliderApiImpl>(sm);
+        RegisterApi<IMeshColliderApi, MeshColliderApiImpl>(sm);
+        RegisterApi<IRigidBodyApi, RigidBodyApiImpl>(sm);
+        RegisterApi<IModelComponentApi, ModelComponentApiImpl>(sm);
+        RegisterApi<IAnimationApi, AnimationApiImpl>(sm);
+        RegisterApi<IMaterialOverrideApi, MaterialOverrideApiImpl>(sm);
+        RegisterApi<IPreviewApi, PreviewApiImpl>(engine->GetPreviewManager(), textureManager, engine->GetImageManager());
     }
-
-    EditorContext::~EditorContext() = default;
 }

SynapseEngine/Editor/EditorApi/EditorContext.h

@@ -1,8 +1,11 @@
 #pragma once
 #include <memory>
+#include <unordered_map>
+#include <typeindex>
 #include "Engine/Engine.h"
 #include "Editor/Manager/GuiTextureManager.h"
 
+#include "EditorCore/Api/IApi.h" 
 #include "EditorCore/Api/ISelectionApi.h"
 #include "EditorCore/Api/ITagApi.h"
 #include "EditorCore/Api/ITransformApi.h"
@@ -16,39 +19,42 @@
 #include "EditorCore/Api/ISettingsApi.h"
 #include "EditorCore/Api/IPointLightApi.h"
 #include "EditorCore/Api/ISpotLightApi.h"
+#include "EditorCore/Api/ITextureApi.h"
+#include "EditorCore/Api/IModelApi.h"
+#include "EditorCore/Api/ICameraApi.h"
+#include "EditorCore/Api/IBoxColliderApi.h"
+#include "EditorCore/Api/ISphereColliderApi.h"
+#include "EditorCore/Api/ICapsuleColliderApi.h"
+#include "EditorCore/Api/IConvexColliderApi.h"
+#include "EditorCore/Api/IMeshColliderApi.h"
+#include "EditorCore/Api/IRigidBodyApi.h"
+#include "EditorCore/Api/IModelComponentApi.h"
+#include "EditorCore/Api/IAnimationApi.h"
+#include "EditorCore/Api/IMaterialOverrideApi.h"
+#include "EditorCore/Api/IPreviewApi.h"
 
 namespace Syn {
     class EditorContext {
     public:
         EditorContext(Engine* engine, GuiTextureManager* textureManager);
-        ~EditorContext();
 
-        ISelectionApi* GetSelectionApi() const { return _selectionApi.get(); }
-        ITagApi* GetTagApi() const { return _tagApi.get(); }
-        ITransformApi* GetTransformApi() const { return _transformApi.get(); }
-        IDirectionLightApi* GetDirectionLightApi() const { return _directionLightApi.get(); }
-        IFileSystemApi* GetFileSystemApi() const { return _fileSystemApi.get(); }
-        IHierarchyApi* GetHierarchyApi() const { return _hierarchyApi.get(); }
-        ILoggerApi* GetLoggerApi() const { return _loggerApi.get(); }
-        IMaterialApi* GetMaterialApi() const { return _materialApi.get(); }
-        IRenderApi* GetRenderApi() const { return _renderApi.get(); }
-        ISceneApi* GetSceneApi() const { return _sceneApi.get(); }
-        ISettingsApi* GetSettingsApi() const { return _settingsApi.get(); }
-        IPointLightApi* GetPointLightApi() const { return _pointLightApi.get(); }
-        ISpotLightApi* GetSpotLightApi() const { return _spotLightApi.get(); }
+        template <typename T>
+        T* GetApi() const {
+            auto it = _apis.find(std::type_index(typeid(T)));
+
+            if (it != _apis.end()) {
+                return static_cast<T*>(it->second.get());
+            }
+
+            return nullptr;
+        }
+
     private:
-        std::unique_ptr<ISelectionApi> _selectionApi;
-        std::unique_ptr<ITagApi> _tagApi;
-        std::unique_ptr<ITransformApi> _transformApi;
-        std::unique_ptr<IFileSystemApi> _fileSystemApi;
-        std::unique_ptr<IHierarchyApi> _hierarchyApi;
-        std::unique_ptr<ILoggerApi> _loggerApi;
-        std::unique_ptr<IMaterialApi> _materialApi;
-        std::unique_ptr<IRenderApi> _renderApi;
-        std::unique_ptr<ISceneApi> _sceneApi;
-        std::unique_ptr<ISettingsApi> _settingsApi;
-        std::unique_ptr<IDirectionLightApi> _directionLightApi;
-        std::unique_ptr<IPointLightApi> _pointLightApi;
-        std::unique_ptr<ISpotLightApi> _spotLightApi;
+        template <typename Interface, typename Implementation, typename... Args>
+        void RegisterApi(Args&&... args) {
+            _apis[std::type_index(typeid(Interface))] = std::make_unique<Implementation>(std::forward<Args>(args)...);
+        }
+
+        std::unordered_map<std::type_index, std::unique_ptr<IApi>> _apis;
     };
 }

SynapseEngine/Editor/EditorApi/Impl/AnimationApiImpl.cpp

@@ -0,0 +1,49 @@
+#include "AnimationApiImpl.h"
+#include "../EditorApiUtils.h"
+#include "Engine/Component/Rendering/AnimationComponent.h"
+#include "Engine/ServiceLocator.h"
+#include "Engine/Animation/AnimationManager.h"
+
+namespace Syn {
+    bool AnimationApiImpl::HasAnimation(EntityID entity) const {
+        return EditorApiUtils::HasComponent<AnimationComponent>(_sceneManager, entity);
+    }
+
+    float AnimationApiImpl::GetAnimationSpeed(EntityID entity) const {
+        return EditorApiUtils::ReadComponent<AnimationComponent>(_sceneManager, entity, [](const auto& c) { return c.speed; }, 1.0f);
+    }
+
+    uint32_t AnimationApiImpl::GetAnimationIndex(EntityID entity) const {
+        return EditorApiUtils::ReadComponent<AnimationComponent>(_sceneManager, entity, [](const auto& c) { return c.animationIndex; }, UINT32_MAX);
+    }
+
+    void AnimationApiImpl::SetAnimationSpeed(EntityID entity, float speed) {
+        EditorApiUtils::ModifyComponent<AnimationComponent>(_sceneManager, entity, [&](auto& c, auto pool) { c.speed = speed; });
+    }
+
+    void AnimationApiImpl::SetAnimationIndex(EntityID entity, uint32_t index) {
+        EditorApiUtils::ModifyComponent<AnimationComponent>(_sceneManager, entity, [&](auto& c, auto pool) {
+            c.animationIndex = index;
+            });
+    }
+
+    std::vector<std::pair<uint32_t, std::string>> AnimationApiImpl::GetAvailableAnimations() const {
+        std::vector<std::pair<uint32_t, std::string>> result;
+
+        auto animManager = ServiceLocator::GetAnimationManager();
+        if (!animManager) {
+            return result;
+        }
+
+        auto paths = animManager->GetResourcePaths();
+        auto snapshots = animManager->GetResourceSnapshot();
+
+        for (uint32_t i = 0; i < paths.size(); ++i) {
+            if (snapshots[i].state == ResourceState::Ready) {
+                result.push_back({ i, paths[i] });
+            }
+        }
+
+        return result;
+    }
+}