Refactor and enhance rendering pipeline

- Added new C# formatting rules in .editorconfig.
- Introduced `IKeyType`, `Key<T>`, and `Ptr<T>` structs.
- Updated `Result` and `Result<T>` for implicit conversions.
- Added AOT compatibility to project files.
- Introduced a `Camera` class and refactored namespaces.
- Enhanced rendering with bindless support and pipeline state management.
- Refactored `D3D12CommandBuffer` for new rendering features.
- Improved `D3D12PipelineLibrary` with disk caching methods.
- Added support for UAVs and raw buffers in `D3D12ResourceAllocator`.
- Improved shader compilation and reflection in `D3D12ShaderCompiler`.
- Refactored descriptor heap and swap chain initialization.
- Added enums and structs for rendering configurations.
- Expanded `ICommandBuffer` and `IPipelineLibrary` interfaces.
- Updated `MeshRenderPass` to align with the new pipeline.
- Consolidated namespaces and improved code maintainability.

Ghost.Core/Handle.cs

@@ -2,6 +2,7 @@
 
 public interface IHandleType;
 public interface IIdentifierType;
+public interface IKeyType;
 
 public readonly struct Handle<T>
     where T : IHandleType
@@ -93,4 +94,49 @@ public readonly struct Identifier<T>
     {
         return !a.Equals(b);
     }
-}
+}
+
+public readonly struct Key<T>
+    where T : IKeyType
+{
+    public readonly ulong value;
+
+    public Key(ulong value)
+    {
+        this.value = value;
+    }
+
+    public static Key<T> Invalid => new(0);
+
+    public bool IsValid => this != Invalid;
+
+    public readonly override int GetHashCode()
+    {
+        return value.GetHashCode();
+    }
+
+    public readonly override bool Equals(object? obj)
+    {
+        return obj is Key<T> id && Equals(id);
+    }
+
+    public readonly bool Equals(Key<T> other)
+    {
+        return value == other.value;
+    }
+
+    public readonly int CompareTo(Key<T> other)
+    {
+        return value.CompareTo(other.value);
+    }
+
+    public static bool operator ==(Key<T> a, Key<T> b)
+    {
+        return a.Equals(b);
+    }
+
+    public static bool operator !=(Key<T> a, Key<T> b)
+    {
+        return !a.Equals(b);
+    }
+}

Ghost.Core/Ptr.cs

@@ -0,0 +1,27 @@
+using System.Runtime.CompilerServices;
+
+namespace Ghost.Core;
+
+public unsafe readonly struct Ptr<T>
+    where T : unmanaged
+{
+    public readonly T* value;
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public Ptr(T* value)
+    {
+        this.value = value;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static implicit operator T*(Ptr<T> ptr)
+    {
+        return ptr.value;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static implicit operator Ptr<T>(T* value)
+    {
+        return new Ptr<T>(value);
+    }
+}

Ghost.Core/Result.cs

@@ -24,7 +24,7 @@ public readonly struct Result
 
     public override string ToString() => success ? "OK" : $"Error: {message}";
 
-    public static implicit operator Result(bool success) => success ? Success() : Fail(null);
+    public static implicit operator bool(Result result) => result.success;
 }
 
 public readonly struct Result<T>
@@ -54,6 +54,7 @@ public readonly struct Result<T>
     public override string ToString() => success ? $"OK: {value}" : $"Error: {message}";
 
     public static implicit operator Result<T>(T? data) => data is not null ? Success(data) : Fail(null);
+    public static implicit operator Result<T>(Result result) => result.success ? Success(default!) : Fail(result.message);
 }
 
 public static class ResultExtensions
@@ -75,4 +76,4 @@ public static class ResultExtensions
 
         return result.value;
     }
-}
+}

Ghost.Core/Utilities/Win32Utility.cs

@@ -1,4 +1,5 @@
-using System.Diagnostics;
+using System.ComponentModel;
+using System.Diagnostics;
 using System.Runtime.CompilerServices;
 using System.Runtime.Versioning;
 using TerraFX.Interop.Windows;
@@ -7,33 +8,82 @@ namespace Ghost.Core.Utilities;
 
 #if PLATEFORME_WIN64
 [SupportedOSPlatform("windows10.0.19041.0")]
-internal unsafe static class Win32Utility
+internal static unsafe class Win32Utility
 {
-    public static Guid* IID_NULL => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID.IID_NULL));
-
-    [Conditional("DEBUG")]
-    public static void Assert(this HRESULT hr)
+    [EditorBrowsable(EditorBrowsableState.Never)]
+    public readonly ref struct IID_PPV
     {
-        Debug.Assert(hr.SUCCEEDED);
+        public readonly Guid* iid;
+        public readonly void** ppv;
+
+        public IID_PPV(Guid* iid, void** ppv)
+        {
+            this.iid = iid;
+            this.ppv = ppv;
+        }
+
+        public void Deconstruct(out Guid* iid, out void** ppv)
+        {
+            iid = this.iid;
+            ppv = this.ppv;
+        }
     }
 
+    public static Guid* IID_NULL
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        get => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in TerraFX.Interop.Windows.IID.IID_NULL));
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static IID_PPV IID_PPV_ARGS<T>(ComPtr<T> comPtr)
+        where T : unmanaged, IUnknown.Interface
+    {
+        return new IID_PPV(Windows.__uuidof<T>(), comPtr.PPV());
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static IID_PPV IID_PPV_ARGS<T>(T** ppv)
+        where T : unmanaged, IUnknown.Interface
+    {
+        return new IID_PPV(Windows.__uuidof<T>(), (void**)ppv);
+    }
+
+    [Conditional("DEBUG")]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static void Assert(this HRESULT hr)
+    {
+        Debug.Assert(hr.SUCCEEDED, hr.ToString());
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static void ThrowIfFailed(this HRESULT hr)
     {
         Windows.ThrowIfFailed(hr);
     }
 
-    public static void** GetVoidAddressOf<T>(this ComPtr<T> comPtr)
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Guid* IID<T>(this ComPtr<T> comPtr)
+        where T : unmanaged, IUnknown.Interface
+    {
+        return Windows.__uuidof<T>();
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static void** PPV<T>(this ComPtr<T> comPtr)
         where T : unmanaged, IUnknown.Interface
     {
         return (void**)comPtr.GetAddressOf();
     }
 
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static void** ReleaseAndGetVoidAddressOf<T>(this ComPtr<T> comPtr)
         where T : unmanaged, IUnknown.Interface
     {
         return (void**)comPtr.ReleaseAndGetAddressOf();
     }
 
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static ComPtr<T> Move<T>(ref this ComPtr<T> comPtr)
         where T : unmanaged, IUnknown.Interface
     {
@@ -42,10 +92,11 @@ internal unsafe static class Win32Utility
         return copy;
     }
 
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static bool HasFlag<T>(this uint flags, T flag)
         where T : Enum
     {
         return (flags & Unsafe.As<T, uint>(ref flag)) != 0;
     }
 }
-#endif
+#endif