Refactor core systems and improve resource management

- Updated dependencies, including `Misaki.HighPerformance` and `TerraFX.Interop`.
- Refactored `Result` struct for better error handling and chaining.
- Removed `Ptr<T>` struct as it was no longer necessary.
- Enhanced `Win32Utility` with `Attach` and `Dispose` methods.
- Improved `ProjectService` and `AppStateMachine` with `Result` integration.
- Refactored `IShaderCompiler` to support SPIR-V cross-compilation and pass-level compilation.
- Standardized Direct3D12 resource management with `UniquePtr` and added `D3D12Object` base class.
- Improved shader reflection validation and pipeline creation in `D3D12PipelineLibrary`.
- Updated `SDLCompiler` for better error handling during shader generation.
- Enhanced logging, debugging, and code readability across the codebase.
- Performed general code cleanup, including unused namespace removal and naming consistency.

Ghost.Editor.Core/AppState/AppStateMachine.cs

@@ -1,3 +1,5 @@
+using Ghost.Core;
+
 namespace Ghost.Editor.Core.AppState;
 
 internal partial class AppStateMachine : IDisposable, IAsyncDisposable
@@ -5,52 +7,91 @@ internal partial class AppStateMachine : IDisposable, IAsyncDisposable
     private Dictionary<StateKey, Lazy<IAppState>> _states = new();
     private IAppState? _current;
 
+    private bool _disposed;
+
     public void RegisterState(StateKey key, Func<IAppState> stateFactory)
     {
         _states[key] = new(stateFactory);
     }
 
-    public async Task TransitionToAsync(StateKey stateKey, object? parameter = null)
+    public async Task<Result> TransitionToAsync(StateKey stateKey, object? parameter = null)
     {
         var previous = _current;
         if (!_states.TryGetValue(stateKey, out var next))
         {
-            throw new InvalidOperationException($"State '{stateKey}' is not registered.");
+            return Result.Failure($"State '{stateKey}' not found.");
+        }
+
+        Result result;
+        if (previous != null)
+        {
+            result = await previous.OnExitingAsync();
+            if (result.IsFailure)
+            {
+                return result;
+            }
+        }
+
+        result = await next.Value.OnEnteringAsync(parameter);
+        if (result.IsFailure)
+        {
+            if (previous != null)
+            {
+                await previous.OnEnteredAsync(parameter);
+            }
+
+            return result;
         }
 
         if (previous != null)
         {
-            await previous.OnExitingAsync();
+            result = await previous.OnExitedAsync();
+            if (result.IsFailure)
+            {
+                await next.Value.OnExitedAsync();
+                await previous.OnEnteredAsync(parameter);
+                return result;
+            }
         }
 
-        await next.Value.OnEnteringAsync(parameter);
-
-        if (previous != null)
+        result = await next.Value.OnEnteredAsync(parameter);
+        if (result.IsFailure)
         {
-            await previous.OnExitedAsync();
-        }
+            await next.Value.OnExitedAsync();
 
-        await next.Value.OnEnteredAsync(parameter);
+            if (previous != null)
+            {
+                await previous.OnEnteredAsync(parameter);
+            }
+
+            return result;
+        }
 
         _current = next.Value;
+
+        return Result.Success();
     }
 
     public void Dispose()
     {
-        _states.Clear();
-
-        _current?.OnExitingAsync().GetAwaiter().GetResult();
-        _current?.OnExitedAsync().GetAwaiter().GetResult();
-        _current = null;
+        DisposeAsync().AsTask().Wait();
     }
 
     public async ValueTask DisposeAsync()
     {
+        if (_disposed)
+        {
+            return;
+        }
+
         _states.Clear();
         if (_current != null)
         {
             await _current.OnExitingAsync();
             await _current.OnExitedAsync();
         }
+
+        _current = null;
+        _disposed = true;
     }
 }

Ghost.Editor.Core/AppState/IAppState.cs

@@ -1,3 +1,5 @@
+using Ghost.Core;
+
 namespace Ghost.Editor.Core.AppState;
 
 internal interface IAppState
@@ -5,22 +7,22 @@ internal interface IAppState
     /// <summary>
     /// Called when exiting the state.
     /// </summary>
-    public Task OnExitingAsync();
+    public Task<Result> OnExitingAsync();
 
     /// <summary>
     /// Called when entering the state, right after OnEnteringAsync.
     /// <paramref name="parameter">can be used to pass data into the state, such as a project to load.</summary>
     /// </summary>
-    public Task OnEnteringAsync(object? parameter);
+    public Task<Result> OnEnteringAsync(object? parameter);
 
     /// <summary>
     /// Called when exiting the state, specifically for pose transitions.
     /// </summary>
-    public Task OnExitedAsync();
+    public Task<Result> OnExitedAsync();
 
     /// <summary>
     /// Called when entered the state, specifically after the state has been fully initialized and is ready for interaction.
     /// </summary>
     /// <param name="parameter">can be used to pass data into the state, such as a project to load.</param>
-    public Task OnEnteredAsync(object? parameter);
+    public Task<Result> OnEnteredAsync(object? parameter);
 }