Refactor Vector3Field and update project structure

Changed Vector3Field.cs to derive from ValueControl<Vector3> and use NumberBox controls for better UI handling.
Changed EditorControls.xaml to update resource paths for new controls.
Changed InternalControls.xaml to simplify the resource dictionary by removing unnecessary references.
Changed IComponentEditor.cs to reflect updates in the component editor's lifecycle methods.
Changed project files for Ghost.Editor and Ghost.Core to include new dependencies and project references.
Changed FileExtensions.cs and IInspectorService.cs to align with the new namespace structure.
Changed Result.cs to enhance error handling and success checking methods.
Changed TypeHandle.cs to improve type handling compatibility.
Changed AssemblyInfo.cs files to include new assembly visibility attributes for better encapsulation.
Added new graphics-related classes and interfaces in the Ghost.Engine project, including IGraphicsDevice and DX12GraphicsDevice.
Added a new Mesh class to handle 3D mesh data and provide methods for creating geometric shapes.
Added GraphicsPipeline.cs to manage the graphics rendering loop and device initialization.
Added ScenePage.xaml and ScenePage.xaml.cs to create a new page for rendering scenes.
Updated HierarchyPage.xaml.cs and InspectorPage.xaml.cs to use the new service locator pattern for service retrieval.
Updated LandingWindow.xaml.cs and EngineEditorWindow.xaml.cs to utilize the new service locator pattern for better service access.
Updated Logger.cs to enhance logging capabilities with optional stack traces and assertion logging.
Updated QueryFilter.cs and QueryEnumerable.cs to use the new TypeHandle structure for improved efficiency.
Updated WorldNode.cs and WorldNodeSerializer.cs to enhance serialization and management of world nodes.
Updated AssetDatabase and related classes to improve asset management and metadata generation.
Updated Ghost.UnitTest.csproj to include new project references and package dependencies for unit tests.

Ghost.Editor.Core/SceneGraph/EditorWorldManager.cs

@@ -0,0 +1,53 @@
+using Ghost.Editor.Core.Progress;
+using Ghost.Editor.Core.Resources;
+using Ghost.Editor.Core.Utilities;
+using System.Text.Json;
+
+namespace Ghost.Editor.Core.SceneGraph;
+
+public enum OpenWorldMode
+{
+    Single,
+    Additive,
+    AdditiveWithoutLoading
+}
+
+public static class EditorWorldManager
+{
+    // TODO: Use guid keys instead of string paths for better performance and uniqueness
+    private static readonly Dictionary<string, WorldNode> _loadedWorlds = new();
+    public static IEnumerable<WorldNode> LoadedWorlds => _loadedWorlds.Values;
+
+    public static event Action<WorldNode>? OnWorldLoaded;
+    public static event Action<WorldNode>? OnWorldUnloaded;
+
+    public static async Task LoadWorld(string worldPath)
+    {
+        if (_loadedWorlds.ContainsKey(worldPath)
+            || !File.Exists(worldPath)
+            || Path.GetExtension(worldPath) != FileExtensions.SCENE_FILE_EXTENSION)
+        {
+            return;
+        }
+
+        var progressService = EditorApplication.GetService<IProgressService>();
+        progressService.ShowIndeterminateProgress("Loading world...");
+
+        foreach (var world in _loadedWorlds)
+        {
+            world.Value.Unload();
+            OnWorldUnloaded?.Invoke(world.Value);
+        }
+
+        await using var readStream = new FileStream(worldPath, FileMode.Open, FileAccess.Read, FileShare.Read);
+        var deserializedScene = await JsonSerializer.DeserializeAsync<WorldNode>(readStream, Engine.Resources.StaticResource.defaultSerializerOptions) ?? throw new Exception("Deserialization failed.");
+
+        _loadedWorlds.Clear();
+
+        _loadedWorlds[worldPath] = deserializedScene;
+        await deserializedScene.LoadAsync();
+
+        progressService.HideProgress();
+        OnWorldLoaded?.Invoke(deserializedScene);
+    }
+}

Ghost.Editor.Core/SceneGraph/EntityNode.cs

@@ -0,0 +1,109 @@
+using Ghost.Editor.Controls.Internal;
+using Ghost.Editor.Core.Inspector;
+using Ghost.Editor.Core.Resources;
+using Ghost.Engine.Editor;
+using Ghost.Entities;
+using Microsoft.UI.Text;
+using Microsoft.UI.Xaml;
+using Microsoft.UI.Xaml.Controls;
+using Microsoft.UI.Xaml.Data;
+using System.Reflection;
+
+namespace Ghost.Editor.Core.SceneGraph;
+
+public partial class EntityNode : SceneGraphNode
+{
+    public WorldNode Owner
+    {
+        get;
+        set;
+    }
+
+    public Entity Entity
+    {
+        get;
+    }
+
+    public override SceneGraphNodeType NodeType => SceneGraphNodeType.Entity;
+
+    public EntityNode(WorldNode owner, Entity entity, string name)
+    {
+        Owner = owner;
+        Entity = entity;
+        Name = name;
+    }
+}
+
+public partial class EntityNode : IInspectable
+{
+    public IconSource? Icon => EditorIconSource.entity_24;
+
+    public UIElement? HeaderContent
+    {
+        get
+        {
+            var root = new StackPanel()
+            {
+                HorizontalAlignment = HorizontalAlignment.Stretch,
+                VerticalAlignment = VerticalAlignment.Center
+            };
+
+            var nameText = new TextBox
+            {
+                Text = Name,
+                FontWeight = FontWeights.Bold,
+            };
+            var idText = new TextBlock
+            {
+                Text = $"ID: {Entity.ID}   Generation: {Entity.Generation}",
+                Margin = new Thickness(5, 7, 0, 0),
+                Opacity = 0.75,
+                Style = Application.Current.Resources["CaptionTextBlockStyle"] as Style
+            };
+
+            nameText.SetBinding(TextBox.TextProperty, new Binding
+            {
+                Source = this,
+                Path = new PropertyPath(nameof(Name)),
+                Mode = BindingMode.TwoWay,
+                UpdateSourceTrigger = UpdateSourceTrigger.LostFocus,
+            });
+
+            root.Children.Add(nameText);
+            root.Children.Add(idText);
+
+            return root;
+        }
+    }
+
+    public UIElement? InspectorContent
+    {
+        get
+        {
+            var root = new StackPanel()
+            {
+                HorizontalAlignment = HorizontalAlignment.Stretch,
+                VerticalAlignment = VerticalAlignment.Top
+            };
+
+            foreach (var (typeHandle, componentPtr) in Owner.World.EntityManager.GetComponentsUnsafe(Entity))
+            {
+                if (componentPtr == IntPtr.Zero)
+                {
+                    continue;
+                }
+
+                var type = typeHandle.ToType();
+                if (type == null || type.GetCustomAttribute<HideEditorAttribute>() != null)
+                {
+                    continue;
+                }
+
+                var dataView = new ComponentDataView(type.Name, Owner.World, Entity, type);
+                root.Children.Add(dataView);
+            }
+
+            return root;
+        }
+    }
+}

Ghost.Editor.Core/SceneGraph/SceneGraphHelpers.cs

@@ -0,0 +1,112 @@
+using Ghost.Engine.Components;
+using Ghost.Entities;
+
+namespace Ghost.Editor.Core.SceneGraph;
+
+public class SceneGraphHelpers
+{
+    /// <summary>
+    /// Creates a new <see cref="EntityNode"/> entity with default components.
+    /// </summary>
+    /// <param name="world">The world context where the entity will be created.</param>
+    /// <param name="entity">The entity to be wrapped in the <see cref="EntityNode"/>.</param>
+    public static EntityNode CreateEntityNode(WorldNode owner, Entity entity, string name)
+    {
+        owner.World.EntityManager.AddComponent(entity, LocalToWorld.Identity);
+        owner.World.EntityManager.AddComponent(entity, Hierarchy.Root);
+        return new EntityNode(owner, entity, name);
+    }
+
+    /// <summary>
+    /// Creates a new <see cref="Entity"/> and <see cref="EntityNode"/> entity with default components.
+    /// </summary>
+    /// <param name="owner">The world context where the entity will be created.</param>
+    public static EntityNode CreateEntityNode(WorldNode owner, string name)
+    {
+        var entity = owner.World.EntityManager.CreateEntity();
+        return CreateEntityNode(owner, entity, name);
+    }
+
+    /// <summary>
+    /// Attaches childEntity to parentEntity in the scene graph.
+    /// </summary>
+    /// <param name="world">The world context where the entities exist.</param>
+    /// <param name="parentNode">The parent entity to which the child will be attached.</param>
+    /// <param name="childNode">The child entity to be attached.</param>
+    public static void AttachChild(WorldNode scene, EntityNode parentNode, EntityNode childNode)
+    {
+        // 1) If the child already has a parent, detach it first
+        var childHierarchy = scene.World.EntityManager.GetComponent<Hierarchy>(childNode.Entity);
+        if (childHierarchy.ValueRO.parent != Entity.Invalid)
+        {
+            DetachFromParent(scene, childNode);
+        }
+
+        // 2) Link child to new parent
+        childHierarchy.ValueRW.parent = parentNode.Entity;
+
+        // 3) Insert child at the head of parent's child list
+        var parentHierarchy = scene.World.EntityManager.GetComponent<Hierarchy>(parentNode.Entity);
+
+        childHierarchy.ValueRW.nextSibling = parentHierarchy.ValueRO.firstChild;
+        parentHierarchy.ValueRW.firstChild = childNode.Entity;
+
+        // 4) Write back
+        scene.World.EntityManager.SetComponent(parentNode.Entity, in parentHierarchy.ValueRO);
+        scene.World.EntityManager.SetComponent(childNode.Entity, in childHierarchy.ValueRO);
+
+        // 5) Update children list in parent node
+        parentNode.AddChild(childNode);
+    }
+
+    /// <summary>
+    /// Detaches the specified entity from its parent in the scene graph.
+    /// </summary>
+    /// <param name="world">The world context where the entities exist.</param>
+    /// <param name="node">The entity to detach from its parent.</param>
+    public static void DetachFromParent(WorldNode scene, EntityNode node)
+    {
+        var hierarchy = scene.World.EntityManager.GetComponent<Hierarchy>(node.Entity);
+        var parent = hierarchy.ValueRO.parent;
+        if (parent == Entity.Invalid)
+        {
+            return; // already root
+        }
+
+        var parentHierarchy = scene.World.EntityManager.GetComponent<Hierarchy>(parent);
+
+        // If entity is the first child, simply move head
+        if (parentHierarchy.ValueRO.firstChild == node.Entity)
+        {
+            parentHierarchy.ValueRW.firstChild = hierarchy.ValueRO.nextSibling;
+        }
+        else
+        {
+            // Otherwise, find the previous sibling in the linked list
+            var prevSibling = parentHierarchy.ValueRO.firstChild;
+            while (prevSibling != Entity.Invalid)
+            {
+                var prevHierarchy = scene.World.EntityManager.GetComponent<Hierarchy>(prevSibling);
+                if (prevHierarchy.ValueRW.nextSibling == node.Entity)
+                {
+                    prevHierarchy.ValueRW.nextSibling = hierarchy.ValueRO.nextSibling;
+                    scene.World.EntityManager.SetComponent(prevSibling, in prevHierarchy.ValueRO);
+                    break;
+                }
+
+                prevSibling = prevHierarchy.ValueRO.nextSibling;
+            }
+        }
+
+        // Clear child's references
+        hierarchy.ValueRW.parent = Entity.Invalid;
+        hierarchy.ValueRW.nextSibling = Entity.Invalid;
+
+        // Write back
+        scene.World.EntityManager.SetComponent(parent, in parentHierarchy.ValueRO);
+        scene.World.EntityManager.SetComponent(node.Entity, in hierarchy.ValueRO);
+
+        // Remove from parent's children list
+        scene.EntityNodeLookup[parent].RemoveChild(node);
+    }
+}

Ghost.Editor.Core/SceneGraph/SceneGraphNode.cs

@@ -0,0 +1,54 @@
+using CommunityToolkit.Mvvm.ComponentModel;
+using System.Collections.ObjectModel;
+
+namespace Ghost.Editor.Core.SceneGraph;
+
+public enum SceneGraphNodeType
+{
+    Scene,
+    Entity,
+}
+
+public abstract partial class SceneGraphNode : ObservableObject
+{
+    public ObservableCollection<SceneGraphNode>? Children
+    {
+        get;
+        private set;
+    }
+
+    [ObservableProperty]
+    public partial string Name
+    {
+        get;
+        set;
+    }
+
+    public abstract SceneGraphNodeType NodeType
+    {
+        get;
+    }
+
+    public int ChildCount => Children?.Count ?? 0;
+
+    public virtual void AddChild(SceneGraphNode child)
+    {
+        Children ??= new();
+        Children.Add(child);
+    }
+
+    public virtual bool RemoveChild(SceneGraphNode child)
+    {
+        return Children?.Remove(child) ?? false;
+    }
+
+    public SceneGraphNode GetChild(int index)
+    {
+        if (Children == null || index < 0 || index >= Children.Count)
+        {
+            throw new ArgumentOutOfRangeException(nameof(index), "Index is out of range.");
+        }
+
+        return Children[index];
+    }
+}

Ghost.Editor.Core/SceneGraph/WorldNode.cs

@@ -0,0 +1,184 @@
+using Ghost.Editor.Core.AssetHandle;
+using Ghost.Editor.Core.Inspector;
+using Ghost.Editor.Core.Resources;
+using Ghost.Editor.Core.Serializer;
+using Ghost.Engine.Components;
+using Ghost.Entities;
+using Microsoft.UI.Xaml;
+using Microsoft.UI.Xaml.Controls;
+using System.Text.Json.Serialization;
+
+namespace Ghost.Editor.Core.SceneGraph;
+
+[JsonConverter(typeof(WorldNodeSerializer))]
+public partial class WorldNode : SceneGraphNode, IEquatable<WorldNode>
+{
+    private World _world;
+    private Dictionary<Entity, EntityNode> _entityNodeLookup = new();
+
+    public World World => _world;
+    public Dictionary<Entity, EntityNode> EntityNodeLookup => _entityNodeLookup;
+
+    public override SceneGraphNodeType NodeType => SceneGraphNodeType.Scene;
+
+    public WorldNode(World world, string name)
+    {
+        _world = world;
+        Name = name;
+    }
+
+    internal WorldNode()
+    {
+        _world = World.Create();
+    }
+
+    private void UpdateLookup(Entity key, EntityNode value)
+    {
+        _entityNodeLookup[key] = value;
+        if (value.Children == null)
+        {
+            return;
+        }
+
+        foreach (var child in value.Children)
+        {
+            if (child is EntityNode entityChild)
+            {
+                UpdateLookup(entityChild.Entity, entityChild);
+            }
+        }
+    }
+
+    public override void AddChild(SceneGraphNode child)
+    {
+        if (child is not EntityNode entityNode)
+        {
+            throw new ArgumentException("Child must be of type EntityNode.", nameof(child));
+        }
+
+        base.AddChild(entityNode);
+        UpdateLookup(entityNode.Entity, entityNode);
+    }
+
+    public override bool RemoveChild(SceneGraphNode child)
+    {
+        if (child is not EntityNode entityNode)
+        {
+            throw new ArgumentException("Child must be of type EntityNode.", nameof(child));
+        }
+
+        var result = base.RemoveChild(child);
+        if (result)
+        {
+            _entityNodeLookup.Remove(entityNode.Entity);
+        }
+
+        return result;
+    }
+
+    private EntityNode BuildNodeRecursive(Entity entity)
+    {
+        if (!_entityNodeLookup.TryGetValue(entity, out var node))
+        {
+            node = new EntityNode(this, entity, "New Entity");
+            _entityNodeLookup[entity] = node;
+        }
+
+        var hc = _world.EntityManager.GetComponent<Hierarchy>(entity);
+        var child = hc.ValueRO.firstChild;
+
+        while (child != Entity.Invalid)
+        {
+            node.AddChild(BuildNodeRecursive(child));
+            var childHC = _world.EntityManager.GetComponent<Hierarchy>(child);
+            child = childHC.ValueRO.nextSibling;
+        }
+
+        return node;
+    }
+
+    private void BuildGraph()
+    {
+        foreach (var (entity, hierarchy) in _world.Query<Hierarchy>())
+        {
+            if (hierarchy.ValueRO.parent == Entity.Invalid)
+            {
+                var node = BuildNodeRecursive(entity);
+                AddChild(node);
+            }
+        }
+    }
+
+    public Task LoadAsync()
+    {
+        return Task.Run(BuildGraph);
+    }
+
+    public void Unload()
+    {
+        _world.Dispose();
+        _world = null!;
+
+        Children?.Clear();
+        _entityNodeLookup.Clear();
+    }
+
+    public override string ToString()
+    {
+        return $"WorldNode: {Name} (World ID: {_world.ID})";
+    }
+
+    public override int GetHashCode()
+    {
+        return HashCode.Combine(_world, Name);
+    }
+
+    public override bool Equals(object? obj)
+    {
+        return obj is WorldNode other && Equals(other);
+    }
+
+    public bool Equals(WorldNode? other)
+    {
+        if (other is null)
+        {
+            return false;
+        }
+
+        if (ReferenceEquals(this, other))
+        {
+            return true;
+        }
+
+        return _world.Equals(other._world) && Name == other.Name;
+    }
+
+    public static bool operator ==(WorldNode? left, WorldNode? right)
+    {
+        if (left is null)
+        {
+            return right is null;
+        }
+        return left.Equals(right);
+    }
+
+    public static bool operator !=(WorldNode? left, WorldNode? right)
+    {
+        return !(left == right);
+    }
+}
+
+public partial class WorldNode : IInspectable
+{
+    public IconSource? Icon => EditorIconSource.scene_24;
+
+    [AssetOpenHandler(FileExtensions.SCENE_FILE_EXTENSION)]
+    public static async void Open(string path)
+    {
+        await EditorWorldManager.LoadWorld(path);
+    }
+
+    public UIElement? HeaderContent => null;
+
+    public UIElement? InspectorContent => null;
+}