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/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);
+        }
+    }
+}