Update rendering and resource management

Changed the `EditorState` class to use a timeout in the `WaitForGPUReady` method for improved responsiveness.
Changed the `nativeDebugging` setting in `launchSettings.json` to `false` for the "Ghost.Editor (Package)" profile.
Changed the `D3D12Renderer` class to set the swap chain only for the composition target type and replaced back buffer reset with dispose.
Changed the mapping of resources in `D3D12Resource` to use a pointer for improved safety and clarity.
Changed the `Mesh` class's upload buffer creation to not use the `true` flag for better memory management.
Added a new `Vertex` struct with a `StructLayout` attribute for improved interoperability with unmanaged code.
Refactored the `GraphicsPipeline` class to replace `IsGpuReady` with `WaitForGPUReady`, including a timeout parameter.
Added a constant buffer to the HLSL source code in `MeshRenderPass` for passing transformation matrices to the vertex shader.
Expanded the `UnitTestAppWindow` class to include event handlers for window activation and size changes for better resource management.
Updated the XAML for `UnitTestAppWindow` to include a `SwapChainPanel` and corrected the XML declaration for formatting consistency.

Ghost.Editor/Core/AppState/EditorState.cs

@@ -64,7 +64,7 @@ internal class EditorState : IAppState
 
     private void OnRendering(object? sender, object e)
     {
-        if (GraphicsPipeline.IsGpuReady())
+        if (GraphicsPipeline.WaitForGPUReady(0))
         {
             _window?.DispatcherQueue.TryEnqueue(Microsoft.UI.Dispatching.DispatcherQueuePriority.High, () =>
             {

Ghost.Editor/Properties/launchSettings.json

@@ -2,7 +2,7 @@
   "profiles": {
     "Ghost.Editor (Package)": {
       "commandName": "MsixPackage",
-      "nativeDebugging": true
+      "nativeDebugging": false
     },
     "Ghost.Editor (Unpackaged)": {
       "commandName": "Project"

Ghost.Graphics/D3D12/D3D12Renderer.cs

@@ -130,7 +130,7 @@ internal unsafe class D3D12Renderer : IRenderer
             case SwapChainPresenter.TargetType.Hwnd:
                 var swapChainFullscreenDesc = new SwapChainFullscreenDescription
                 {
-                    Windowed = false,
+                    Windowed = true,
                 };
 
                 _graphicsDevice.DXGIFactory.Ptr->CreateSwapChainForHwnd(
@@ -150,7 +150,10 @@ internal unsafe class D3D12Renderer : IRenderer
             throw new InvalidOperationException("Failed to create IDXGISwapChain4 interface.");
         }
 
-        _swapChainPresenter.SwapChainPanelNative.SetSwapChain((IntPtr)_swapChain.Get());
+        if (_swapChainPresenter.Type == SwapChainPresenter.TargetType.Composition)
+        {
+            _swapChainPresenter.SwapChainPanelNative.SetSwapChain((IntPtr)_swapChain.Get());
+        }
         _backBufferIndex = _swapChain.Get()->GetCurrentBackBufferIndex();
     }
 
@@ -221,7 +224,7 @@ internal unsafe class D3D12Renderer : IRenderer
             ref var frameResource = ref _frameResources[i];
             if (frameResource.backBuffer.Get() is not null)
             {
-                frameResource.backBuffer.Reset();
+                frameResource.backBuffer.Dispose();
                 _rtvHeap.ReleaseDescriptor(frameResource.backBufferDescriptorIndexes);
             }
 

Ghost.Graphics/D3D12/D3D12Resource.cs

@@ -49,12 +49,14 @@ public unsafe class D3D12Resource : IResource
 
         fixed (T* ptr = data)
         {
-            var hr = _nativeResource.Get()->Map(0, &range, (void**)&ptr);
+            void* mappedPtr;
+            var hr = _nativeResource.Get()->Map(0, &range, &mappedPtr);
             if (hr.Failure)
             {
                 var message = hr.ToString();
                 throw new InvalidOperationException($"Failed to map resource: {message}");
             }
+            Unsafe.CopyBlock(mappedPtr, ptr, size);
             _nativeResource.Get()->Unmap(0, &range);
         }
     }

Ghost.Graphics/Data/Mesh.cs

@@ -220,8 +220,8 @@ public unsafe sealed class Mesh(int initialVertexCapacity = 256, int initialInde
         _vertexBuffer = GraphicsPipeline.ResourceAllocator.CreateCopyDestinationBuffer(vertexBufferSize);
         _indexBuffer = GraphicsPipeline.ResourceAllocator.CreateCopyDestinationBuffer(indexBufferSize);
 
-        var vertexUploadBuffer = GraphicsPipeline.ResourceAllocator.CreateUploadBuffer(vertexBufferSize, true);
+        var vertexUploadBuffer = GraphicsPipeline.ResourceAllocator.CreateUploadBuffer(vertexBufferSize, false);
-        var indexUploadBuffer = GraphicsPipeline.ResourceAllocator.CreateUploadBuffer(indexBufferSize, true);
+        var indexUploadBuffer = GraphicsPipeline.ResourceAllocator.CreateUploadBuffer(indexBufferSize, false);
 
         vertexUploadBuffer.SetData(_vertices.AsSpan());
         indexUploadBuffer.SetData(_indices.AsSpan());

Ghost.Graphics/Data/Vertex.cs

@@ -1,10 +1,12 @@
 using System.Numerics;
 using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
 using System.Text;
 using Win32.Graphics.Dxgi.Common;
 
 namespace Ghost.Graphics.Data;
 
+[StructLayout(LayoutKind.Sequential)]
 public struct Vertex(Vector4 position, Vector4 normal, Vector4 tangent, Color128 color, Vector4 uv)
 {
     public unsafe struct Semantic

Ghost.Graphics/GraphicsPipeline.cs

@@ -118,13 +118,8 @@ public static class GraphicsPipeline
         }
     }
 
-    internal static bool IsGpuReady()
-    {
-        return _gpuFenceValue >= _cpuFenceValue;
-    }
 
-
+    internal static bool WaitForGPUReady(int timeOut = -1)
-    internal static void WaitForGPUReady()
     {
         if (_gpuReadyEvent == null)
         {
@@ -132,7 +127,7 @@ public static class GraphicsPipeline
         }
 
         var eventIndex = (int)(_cpuFenceValue % _FRAME_COUNT);
-        _gpuReadyEvent[eventIndex].WaitOne();
+        return _gpuReadyEvent[eventIndex].WaitOne(timeOut);
     }
 
     internal static void SignalCPUReady()

Ghost.Graphics/RenderPasses/MeshRenderPass.cs

@@ -4,6 +4,7 @@ using Ghost.Graphics.D3D12.Utilities;
 using Ghost.Graphics.Data;
 using Ghost.Graphics.Utilities;
 using System.Drawing;
+using System.Runtime.CompilerServices;
 using Win32;
 using Win32.Graphics.Direct3D;
 using Win32.Graphics.Direct3D12;
@@ -14,6 +15,12 @@ namespace Ghost.Graphics.RenderPasses;
 internal unsafe class MeshRenderPass : IRenderPass
 {
     private const string _HLSL_SOURCE = @"
+
+cbuffer ConstantBuffer : register(b0)
+{
+    float4x4 WVP_Matrix;
+};
+
 struct VertexInput
 {
     float3 position : POSITION;
@@ -56,7 +63,17 @@ float4 PSMain(PixelInput input) : SV_TARGET
 
     private void CreateRootSignature()
     {
-        var rootSignatureDesc = new RootSignatureDescription(0u, null)
+        var rootParameters = new RootParameter[]
+        {
+            new ()
+            {
+                ParameterType = RootParameterType.Cbv,
+                ShaderVisibility = ShaderVisibility.Vertex,
+                Descriptor = new RootDescriptor(0, 0)
+            }
+        };
+
+        var rootSignatureDesc = new RootSignatureDescription(0u, (RootParameter*)Unsafe.AsPointer(ref rootParameters[0]))
         {
             Flags = RootSignatureFlags.AllowInputAssemblerInputLayout
         };

Ghost.UnitTest/Properties/launchSettings.json

@@ -1,7 +1,8 @@
 {
   "profiles": {
     "Ghost.UnitTest (Package)": {
-      "commandName": "MsixPackage"
+      "commandName": "MsixPackage",
+      "nativeDebugging": true
     },
     "Ghost.UnitTest (Unpackaged)": {
       "commandName": "Project"

Ghost.UnitTest/UnitTestAppWindow.xaml

@@ -1,19 +1,22 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="utf-8" ?>
 <Window
     x:Class="Ghost.UnitTest.UnitTestAppWindow"
     xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
     xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
-    xmlns:local="using:Ghost.UnitTest"
     xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+    xmlns:local="using:Ghost.UnitTest"
     xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
-    mc:Ignorable="d"
+    Title="Ghost.UnitTest"
-    Title="Ghost.UnitTest">
+    mc:Ignorable="d">
 
     <Window.SystemBackdrop>
         <MicaBackdrop />
     </Window.SystemBackdrop>
 
     <Grid>
-
+        <SwapChainPanel
+            x:Name="Panel"
+            HorizontalAlignment="Stretch"
+            VerticalAlignment="Stretch" />
     </Grid>
 </Window>

Ghost.UnitTest/UnitTestAppWindow.xaml.cs

@@ -1,13 +1,68 @@
+using Ghost.Graphics;
+using Ghost.Graphics.Contracts;
 using Microsoft.UI.Xaml;
-
+using Microsoft.UI.Xaml.Media;
-// To learn more about WinUI, the WinUI project structure,
+using Misaki.HighPerformance.Unsafe.Buffer;
-// and more about our project templates, see: http://aka.ms/winui-project-info.
+using WinRT;
 
 namespace Ghost.UnitTest;
+
 public sealed partial class UnitTestAppWindow : Window
 {
+    private IRenderer? _renderView;
+    private ISwapChainPanelNative _swapChainPanelNative;
+
     public UnitTestAppWindow()
     {
         InitializeComponent();
+
+        Activated += UnitTestAppWindow_Activated;
+        Closed += UnitTestAppWindow_Closed;
+
+        Panel.SizeChanged += SwapChainPanel_SizeChanged;
+    }
+
+    private void SwapChainPanel_SizeChanged(object sender, SizeChangedEventArgs e)
+    {
+        if (e.NewSize.Width > 8.0 && e.NewSize.Height > 8.0)
+        {
+            _renderView?.RequestResize((uint)e.NewSize.Width, (uint)e.NewSize.Height);
+        }
+    }
+
+    private void UnitTestAppWindow_Activated(object sender, WindowActivatedEventArgs args)
+    {
+        AllocationManager.Initialize();
+        GraphicsPipeline.Initialize(Graphics.Data.GraphicsAPI.D3D12);
+        GraphicsPipeline.Start();
+
+        var guid = typeof(ISwapChainPanelNative.Interface).GUID;
+        ((IWinRTObject)Panel).NativeObject.TryAs(guid, out var swapChainPanelNativeHandle);
+        _swapChainPanelNative = new ISwapChainPanelNative(swapChainPanelNativeHandle);
+
+        _renderView = GraphicsPipeline.GraphicsDevice.CreateRenderer(new(_swapChainPanelNative, (uint)AppWindow.Size.Width, (uint)AppWindow.Size.Height));
+
+        CompositionTarget.Rendering += OnRendering;
+    }
+
+    private void UnitTestAppWindow_Closed(object sender, WindowEventArgs args)
+    {
+        GraphicsPipeline.SignalCPUReady();
+        GraphicsPipeline.Shutdown();
+        AllocationManager.Dispose();
+        CompositionTarget.Rendering -= OnRendering;
+        _swapChainPanelNative.Dispose();
+        _renderView?.Dispose();
+    }
+
+    private void OnRendering(object? sender, object e)
+    {
+        if (GraphicsPipeline.WaitForGPUReady(0))
+        {
+            DispatcherQueue.TryEnqueue(Microsoft.UI.Dispatching.DispatcherQueuePriority.High, () =>
+            {
+                GraphicsPipeline.SignalCPUReady();
+            });
+        }
     }
 }