Refactor project structure and improve performance

Changed the `ProjectRepository` class to be static for easier usage.
Changed `ProjectService` constants to public properties for accessibility.
Changed `App.xaml` to consolidate theme resources into `Override.xaml`.
Changed `App.xaml.cs` to implement an `AppStateMachine` for better state management.
Changed `ConsolePage` and `HierarchyPage` to utilize the new ViewModel structure.
Changed `ProjectPage` to use the `ExplorerItem` model for asset display.
Changed `Entity` and `EntityManager` to enhance component management with a new `IComponentData` interface.
Changed the `Logger` class to introduce structured logging functionality.
Changed the system architecture to support dependency management for better organization.
Changed the `QueryEnumerable` class to allow for more flexible entity queries.
Changed the `TypeHandle` class to improve efficiency in retrieving type handles.
Changed the `World` class to support robust world management and multiple worlds.
Updated the `Test` class to demonstrate the new entity and component management system.

Ghost.Editor/ViewModels/Pages/EngineEditor/ConsoleViewModel.cs

@@ -0,0 +1,92 @@
+using CommunityToolkit.Mvvm.ComponentModel;
+using CommunityToolkit.Mvvm.Input;
+using Ghost.Engine.Models;
+using Ghost.Engine.Services;
+using System.Collections.ObjectModel;
+
+namespace Ghost.Editor.ViewModels.Pages.EngineEditor;
+
+internal partial class ConsoleViewModel : ObservableObject
+{
+    [ObservableProperty]
+    public partial ObservableCollection<LogMessage> Logs
+    {
+        get; set;
+    } = new();
+
+    [ObservableProperty]
+    public partial bool ShowInfo
+    {
+        get; set;
+    } = true;
+
+    [ObservableProperty]
+    public partial bool ShowWarning
+    {
+        get; set;
+    } = true;
+
+    [ObservableProperty]
+    public partial bool ShowError
+    {
+        get; set;
+    } = true;
+
+    [ObservableProperty]
+    public partial bool ShowStackTrace
+    {
+        get; set;
+    } = false;
+
+    [ObservableProperty]
+    public partial LogMessage? SelectedLog
+    {
+        get; set;
+    }
+
+    public ConsoleViewModel()
+    {
+        foreach (var log in Logger.Logs)
+        {
+            Logs.Add(log);
+        }
+
+        Logger.OnLogsUpdate += UpdateLogs;
+    }
+
+    ~ConsoleViewModel()
+    {
+        Logger.OnLogsUpdate -= UpdateLogs;
+    }
+
+    private void UpdateLogs(LogChangeType updateType)
+    {
+        switch (updateType)
+        {
+            case LogChangeType.LogAdded:
+                Logs.Add(Logger.Logs[^1]);
+                break;
+            case LogChangeType.LogRemoved:
+                if (Logs.Count > 0)
+                {
+                    Logs.RemoveAt(0);
+                }
+                break;
+            case LogChangeType.LogsCleared:
+                Logs.Clear();
+                break;
+        }
+    }
+
+    partial void OnShowStackTraceChanged(bool value)
+    {
+        Logger.HasStackTrace = value;
+        Logger.LogInfo($"Stack trace visibility set to {value}.");
+    }
+
+    [RelayCommand]
+    private void ClearLogs()
+    {
+        Logger.Clear();
+    }
+}

Ghost.Editor/ViewModels/Pages/EngineEditor/HierarchyViewModel.cs

@@ -0,0 +1,38 @@
+using CommunityToolkit.Mvvm.ComponentModel;
+using Ghost.Editor.Infrastructures.SceneGraph;
+using Ghost.Entities;
+using System.Collections.ObjectModel;
+
+namespace Ghost.Editor.ViewModels.Pages.EngineEditor;
+
+internal partial class HierarchyViewModel : ObservableObject
+{
+    [ObservableProperty]
+    public partial ObservableCollection<SceneNode> SceneList
+    {
+        get;
+        private set;
+    } = new();
+
+    public HierarchyViewModel()
+    {
+        // Test only
+        var testWorld = World.Create();
+        var entity1 = SceneGraphHelpers.CreateEntityNode(testWorld, "entity 1");
+        var entity2 = SceneGraphHelpers.CreateEntityNode(testWorld, "entity 3");
+        var entity3 = SceneGraphHelpers.CreateEntityNode(testWorld, "entity 4");
+        var entity4 = SceneGraphHelpers.CreateEntityNode(testWorld, "entity 5");
+        var entity5 = SceneGraphHelpers.CreateEntityNode(testWorld, "entity 2");
+
+        var testScene = new SceneNode(testWorld, "Test Scene");
+
+        SceneGraphHelpers.AttachChild(testScene, entity1, entity2);
+        SceneGraphHelpers.AttachChild(testScene, entity1, entity3);
+        SceneGraphHelpers.AttachChild(testScene, entity2, entity4);
+
+        testScene.Children.Add(entity1);
+        testScene.Children.Add(entity5);
+
+        SceneList.Add(testScene);
+    }
+}

Ghost.Editor/ViewModels/Pages/EngineEditor/ProjectViewModel.cs

@@ -0,0 +1,142 @@
+using CommunityToolkit.Mvvm.ComponentModel;
+using Ghost.Data.Services;
+using Ghost.Editor.Models;
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.IO;
+using System.Threading.Tasks;
+
+namespace Ghost.Editor.ViewModels.Pages.EngineEditor;
+
+internal partial class ProjectViewModel : ObservableObject
+{
+    public ObservableCollection<ExplorerItem> SubDirectories
+    {
+        get;
+    } = new();
+
+    [ObservableProperty]
+    public partial ObservableCollection<ExplorerItem> DirectoryAssets
+    {
+        get;
+        set;
+    } = new();
+
+    [ObservableProperty]
+    public partial ExplorerItem? SelectedDirectory
+    {
+        get;
+        set;
+    }
+
+    [ObservableProperty]
+    public partial ExplorerItem? SelectedAsset
+    {
+        get;
+        set;
+    }
+
+    public ProjectViewModel()
+    {
+        if (ProjectService.CurrentProject.Metadata == null)
+        {
+            throw new InvalidOperationException("Current project is not set.");
+        }
+
+        var assetsItem = new ExplorerItem("Assets", Path.Combine(Path.GetDirectoryName(ProjectService.CurrentProject.Path)!, ProjectService.ASSETS_FOLDER), true);
+        LoadSubFolderRecursive(ref assetsItem);
+
+        SubDirectories.Add(assetsItem);
+    }
+
+    private void LoadSubFolderRecursive(ref ExplorerItem parentItem)
+    {
+        foreach (var directory in Directory.EnumerateDirectories(parentItem.Path))
+        {
+            var item = new ExplorerItem(Path.GetFileName(directory), directory, true);
+            LoadSubFolderRecursive(ref item);
+
+            parentItem.Children ??= new();
+            parentItem.Children.Add(item);
+        }
+    }
+
+    public static Task<ExplorerItem?> FindNodeIterative(ExplorerItem root, Func<ExplorerItem, bool> predicate)
+    {
+        var stack = new Stack<ExplorerItem>();
+        stack.Push(root);
+
+        return Task.Run(() =>
+        {
+            while (stack.Count > 0)
+            {
+                var node = stack.Pop();
+                if (predicate(node))
+                {
+                    return node;
+                }
+
+                if (node.Children == null || node.Children.Count == 0)
+                {
+                    continue;
+                }
+
+                for (var i = node.Children.Count - 1; i >= 0; i--)
+                {
+                    stack.Push(node.Children[i]);
+                }
+            }
+
+            return null;
+        });
+    }
+
+    private void NavigateToDirectory(string? path)
+    {
+        App.Window?.DispatcherQueue.TryEnqueue(async () =>
+        {
+            DirectoryAssets.Clear();
+
+            if (!Directory.Exists(path))
+            {
+                return;
+            }
+
+            foreach (var directory in Directory.EnumerateDirectories(path))
+            {
+                var directoryItem = new ExplorerItem(Path.GetFileName(directory), directory, true);
+                DirectoryAssets.Add(directoryItem);
+            }
+
+            foreach (var file in Directory.EnumerateFiles(path))
+            {
+                var fileItem = new ExplorerItem(Path.GetFileName(file), file, false);
+                DirectoryAssets.Add(fileItem);
+            }
+
+            SelectedDirectory = await FindNodeIterative(SubDirectories[0], x => x.Path == path);
+        });
+    }
+
+    public void NavigateToSelected()
+    {
+        if (SelectedAsset == null || !SelectedAsset.IsDirectory)
+        {
+            return;
+        }
+
+        NavigateToDirectory(SelectedAsset.Path);
+    }
+
+    partial void OnSelectedDirectoryChanged(ExplorerItem? value)
+    {
+        DirectoryAssets.Clear();
+        if (value == null)
+        {
+            return;
+        }
+
+        NavigateToDirectory(value.Path);
+    }
+}

Ghost.Editor/ViewModels/Pages/Landing/CreateProjectViewModel.cs

@@ -0,0 +1,95 @@
+using CommunityToolkit.Mvvm.ComponentModel;
+using CommunityToolkit.Mvvm.Input;
+using Ghost.Data.Models;
+using Ghost.Data.Services;
+using Ghost.Editor.Contracts;
+using Ghost.Editor.Helpers;
+using Ghost.Editor.Infrastructures.AppState;
+using Ghost.Editor.Services;
+using Ghost.Engine.Resources;
+using Microsoft.UI.Xaml.Controls;
+using System.Collections.ObjectModel;
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace Ghost.Editor.ViewModels.Pages.Landing;
+
+internal partial class CreateProjectViewModel(StackedNotificationService notificationService, ProjectService projectService, AppStateMachine stateService) : ObservableObject, INavigationAware
+{
+    public ObservableCollection<TemplateData> templates = new();
+
+    [ObservableProperty]
+    public partial TemplateData? SelectedTemplate
+    {
+        get;
+        set;
+    }
+
+    [ObservableProperty]
+    public partial string? ProjectName
+    {
+        get;
+        set;
+    }
+
+    [ObservableProperty]
+    public partial string? ProjectLocation
+    {
+        get;
+        set;
+    }
+
+    public async void OnNavigatedTo(object? parameter)
+    {
+        templates.Clear();
+        await foreach (var (path, info) in ProjectService.GetProjectTemplatesAsync())
+        {
+            templates.Add(new(path, info));
+        }
+
+        SelectedTemplate = templates.FirstOrDefault();
+    }
+
+    public void OnNavigatedFrom()
+    {
+    }
+
+    [RelayCommand]
+    private async Task SelectionProjectLocation()
+    {
+        var folder = await SystemUtilities.OpenFolderPickerAsync();
+        if (folder != null)
+        {
+            ProjectLocation = folder.Path;
+        }
+    }
+
+    [RelayCommand]
+    private async Task CreateProject()
+    {
+        if (string.IsNullOrWhiteSpace(ProjectName)
+            || !Directory.Exists(ProjectLocation)
+            || !SelectedTemplate.HasValue)
+        {
+            notificationService.ShowNotification("Incorrect project info", InfoBarSeverity.Error);
+            return;
+        }
+
+        var result = await projectService.CreateProjectAsync(ProjectName, ProjectLocation, EngineData.s_engineVersion, SelectedTemplate.Value.directory);
+        if (!result.success)
+        {
+            notificationService.ShowNotification(result.message, InfoBarSeverity.Error);
+            return;
+        }
+
+        try
+        {
+            await stateService.TransitionToAsync(StateKey.EngineEditor, result.data);
+        }
+        catch (System.Exception e)
+        {
+            notificationService.ShowNotification($"Failed to load project: {e.Message}", InfoBarSeverity.Error);
+        }
+    }
+}

Ghost.Editor/ViewModels/Pages/Landing/OpenProjectViewModel.cs

@@ -0,0 +1,109 @@
+using CommunityToolkit.Mvvm.ComponentModel;
+using Ghost.Data.Models;
+using Ghost.Data.Services;
+using Ghost.Editor.Contracts;
+using Ghost.Editor.Infrastructures.AppState;
+using Ghost.Editor.Services;
+using Microsoft.UI.Xaml;
+using Microsoft.UI.Xaml.Controls;
+using System;
+using System.Collections.ObjectModel;
+using System.Linq;
+using System.Threading.Tasks;
+using Windows.ApplicationModel.DataTransfer;
+using Windows.Storage;
+
+namespace Ghost.Editor.ViewModels.Pages.Landing;
+
+internal partial class OpenProjectViewModel(ProjectService projectService, StackedNotificationService _notificationService, AppStateMachine _stateService) : ObservableObject, INavigationAware
+{
+    public readonly ObservableCollection<ProjectMetadataInfo> projects = new();
+
+    [ObservableProperty]
+    public partial Visibility EmptyVisibility
+    {
+        get;
+        set;
+    }
+
+    [ObservableProperty]
+    public partial Visibility DragVisibility
+    {
+        get;
+        set;
+    }
+
+    public void UpdateEmptyPlaceHolderVisibility()
+    {
+        EmptyVisibility = projects.Count == 0 ? Visibility.Visible : Visibility.Collapsed;
+    }
+
+    public async void OnNavigatedTo(object? parameter)
+    {
+        projects.Clear();
+        await foreach (var projectInfo in projectService.LoadAllProjectAsync())
+        {
+            var metadata = await ProjectService.LoadMetadataAsync(projectInfo.MetadataPath);
+            if (metadata == null)
+            {
+                continue;
+            }
+
+            projects.Add(new(projectInfo.MetadataPath, metadata));
+        }
+
+        UpdateEmptyPlaceHolderVisibility();
+    }
+
+    public void OnNavigatedFrom()
+    {
+    }
+
+    public async Task ContentDrop(DataPackageView dataView)
+    {
+        var errorMessage = string.Empty;
+        if (dataView.Contains(StandardDataFormats.StorageItems))
+        {
+            var items = await dataView.GetStorageItemsAsync();
+            var rootFolder = items.OfType<StorageFolder>().FirstOrDefault();
+            if (rootFolder != null)
+            {
+                var result = await projectService.AddProjectFromDirectoryAsync(rootFolder.Path);
+                if (result.success)
+                {
+                    projects.Add(result.data);
+                    goto CloseDropPanel;
+                }
+                else
+                {
+                    errorMessage = result.message;
+                }
+            }
+        }
+        else
+        {
+            errorMessage = "Unsupported data format. Please drop a folder containing a project.";
+        }
+
+        _notificationService.ShowNotification(errorMessage, InfoBarSeverity.Error);
+
+    CloseDropPanel:
+        DragVisibility = Visibility.Collapsed;
+        UpdateEmptyPlaceHolderVisibility();
+    }
+
+    public async Task LoadProject(ProjectMetadataInfo project)
+    {
+        try
+        {
+            project.Metadata.LastOpened = DateTime.Now;
+            await ProjectService.CreateMetadataFileAsync(project.Path, project.Metadata);
+
+            await _stateService.TransitionToAsync(StateKey.EngineEditor, project);
+        }
+        catch (Exception e)
+        {
+            _notificationService.ShowNotification($"Failed to load project: {e.Message}", InfoBarSeverity.Error);
+        }
+    }
+}

Ghost.Editor/ViewModels/Windows/EngineEditorViewModel.cs

@@ -0,0 +1,13 @@
+using CommunityToolkit.Mvvm.ComponentModel;
+using Ghost.Data.Models;
+using Ghost.Data.Services;
+using Ghost.Engine.Resources;
+
+namespace Ghost.Editor.ViewModels.Windows;
+
+internal partial class EngineEditorViewModel : ObservableRecipient
+{
+    public string engineVersionDescriptor = $"{EngineData.ENGINE_NAME} - {EngineData.s_engineVersion}";
+
+    public ProjectMetadataInfo CurrentProject => ProjectService.CurrentProject;
+}