From 0b6e5b8501b75537c37b5c4c3c96a6b429aab44d Mon Sep 17 00:00:00 2001
From: Misaki <misaki_39@outlook.com>
Date: Wed, 1 Apr 2026 00:06:31 +0900
Subject: [PATCH] feat(mesh): update Vertex layout, add mesh loader

Refactored Vertex to use float3 position/normal, float2 uv, float4 tangent, and Color128 color, updating all mesh generation and HLSL code accordingly. Added MeshUtility for loading .obj/.fbx meshes with deduplication and normal/tangent computation. Updated GraphicsTestWindow to use the new loader and improved resource management. Fixed D3D12ResourceAllocator resource creation logic, improved camera projection math, and simplified RenderingLayerMask. Updated package references and app display name.

BREAKING CHANGE: Vertex struct layout changed; all mesh code and shaders must use the new format.
---
 src/Runtime/Ghost.Core/Ghost.Core.csproj      |   7 +-
 .../D3D12ResourceAllocator.cs                 |   5 +-
 src/Runtime/Ghost.Graphics.RHI/Common.cs      |  10 +-
 src/Runtime/Ghost.Graphics/Core/Mesh.cs       |  22 ++-
 .../Ghost.Graphics/Core/RenderingLayerMask.cs |  24 ---
 .../Shaders/Includes/Common.hlsl              |   8 +-
 .../Ghost.Graphics/Utilities/MeshBuilder.cs   |  50 ++---
 .../Utilities/MeshletUtility.cs               |   2 +-
 src/Runtime/Ghost.Graphics/test.gshdr         |   7 +-
 .../Ghost.Graphics.Test.csproj                |   1 +
 .../Ghost.Graphics.Test/Package.appxmanifest  |   2 +-
 .../RenderPasses/TestRenderPipeline.cs        |  10 +-
 .../Ghost.Graphics.Test/UnitTestApp.xaml.cs   |  12 +-
 .../Utilities/MeshUtility.cs                  | 176 ++++++++++++++++++
 .../Windows/GraphicsTestWindow.xaml.cs        |  55 ++++--
 15 files changed, 282 insertions(+), 109 deletions(-)
 create mode 100644 src/Test/Ghost.Graphics.Test/Utilities/MeshUtility.cs

diff --git a/src/Runtime/Ghost.Core/Ghost.Core.csproj b/src/Runtime/Ghost.Core/Ghost.Core.csproj
index 7cbe6bf..b334eca 100644
--- a/src/Runtime/Ghost.Core/Ghost.Core.csproj
+++ b/src/Runtime/Ghost.Core/Ghost.Core.csproj
@@ -9,19 +9,20 @@
 
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
     <IsAotCompatible>True</IsAotCompatible>
-    <DefineConstants>$(DefineConstants);MHP_ENABLE_SAFETY_CHECKS</DefineConstants>
+    <DefineConstants>$(DefineConstants);MHP_ENABLE_SAFETY_CHECKS;MHP_ENABLE_STACKTRACE</DefineConstants>
     <IsTrimmable>True</IsTrimmable>
   </PropertyGroup>
 
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|AnyCPU'">
     <IsAotCompatible>True</IsAotCompatible>
+    <!--<DefineConstants>$(DefineConstants);MHP_ENABLE_SAFETY_CHECKS</DefineConstants>-->
     <IsTrimmable>True</IsTrimmable>
   </PropertyGroup>
 
   <ItemGroup>
     <PackageReference Include="Misaki.HighPerformance" Version="1.0.6" />
-    <PackageReference Include="Misaki.HighPerformance.Jobs" Version="1.5.5" />
-    <PackageReference Include="Misaki.HighPerformance.LowLevel" Version="1.6.1">
+    <PackageReference Include="Misaki.HighPerformance.Jobs" Version="1.5.6" />
+    <PackageReference Include="Misaki.HighPerformance.LowLevel" Version="1.6.3">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
diff --git a/src/Runtime/Ghost.Graphics.D3D12/D3D12ResourceAllocator.cs b/src/Runtime/Ghost.Graphics.D3D12/D3D12ResourceAllocator.cs
index 90704ee..be6a02f 100644
--- a/src/Runtime/Ghost.Graphics.D3D12/D3D12ResourceAllocator.cs
+++ b/src/Runtime/Ghost.Graphics.D3D12/D3D12ResourceAllocator.cs
@@ -740,7 +740,10 @@ internal sealed unsafe partial class D3D12ResourceAllocator : IResourceAllocator
         else
         {
             hr = CreateResource(&allocationDesc, &resourceDesc, initialState, options, null, (void**)&pAllocation);
-            pResource = pAllocation->GetResource();
+            if (hr.SUCCEEDED)
+            {
+                pResource = pAllocation->GetResource();
+            }
         }
 
         if (hr.FAILED)
diff --git a/src/Runtime/Ghost.Graphics.RHI/Common.cs b/src/Runtime/Ghost.Graphics.RHI/Common.cs
index 59ff5f9..3d2535a 100644
--- a/src/Runtime/Ghost.Graphics.RHI/Common.cs
+++ b/src/Runtime/Ghost.Graphics.RHI/Common.cs
@@ -132,7 +132,7 @@ public struct Color128 : IEquatable<Color128>
 
 
 [StructLayout(LayoutKind.Sequential)]
-public struct Vertex
+public record struct Vertex
 {
     public static class Semantic
     {
@@ -145,11 +145,11 @@ public struct Vertex
         public static readonly FixedText32 Color = new("COLOR"u8);
     }
 
-    public float4 position;
-    public float4 normal;
-    public float4 tangent;
-    public float4 uv;
     public Color128 color;
+    public float4 tangent;
+    public float3 position;
+    public float3 normal;
+    public float2 uv;
 }
 
 public readonly struct ShaderVariant;
diff --git a/src/Runtime/Ghost.Graphics/Core/Mesh.cs b/src/Runtime/Ghost.Graphics/Core/Mesh.cs
index ea36c58..db662b7 100644
--- a/src/Runtime/Ghost.Graphics/Core/Mesh.cs
+++ b/src/Runtime/Ghost.Graphics/Core/Mesh.cs
@@ -210,18 +210,20 @@ public struct Mesh : IResourceReleasable
             maxVertices = 64,
             minTriangles = 32,
             maxTriangles = 124,
-            partitionSize = 128,
-            clusterSpatial = true,
+            partitionSpatial = true,
+            partitionSize = 16,
+            clusterSpatial = false,
+            clusterSplitFactor = 2.0f,
             clusterFillWeight = 1.0f,
-            clusterSplitFactor = 1.0f,
             simplifyRatio = 0.5f,
-            simplifyThreshold = 0.5f,
-            simplifyErrorMergePrevious = 0.5f,
-            simplifyErrorMergeAdditive = 0.5f,
-            simplifyErrorFactorSloppy = 1.0f,
-            simplifyErrorEdgeLimit = 1.0f,
-            optimizeBounds = true,
-            optimizeClusters = true
+            simplifyThreshold = 0.85f,
+            simplifyErrorMergePrevious = 1.0f,
+            simplifyErrorFactorSloppy = 2.0f,
+            simplifyPermissive = true,
+            simplifyFallbackPermissive = false,
+            simplifyFallbackSloppy = true,
+            //optimizeBounds = true,
+            //optimizeClusters = true
         };
 
         // 2. Map Mesh to ClodMesh
diff --git a/src/Runtime/Ghost.Graphics/Core/RenderingLayerMask.cs b/src/Runtime/Ghost.Graphics/Core/RenderingLayerMask.cs
index 0144ad1..975bc8c 100644
--- a/src/Runtime/Ghost.Graphics/Core/RenderingLayerMask.cs
+++ b/src/Runtime/Ghost.Graphics/Core/RenderingLayerMask.cs
@@ -1,31 +1,7 @@
-using System.Diagnostics;
-
 namespace Ghost.Graphics.Core;
 
 public readonly struct RenderingLayerMask : IEquatable<RenderingLayerMask>
 {
-    private static readonly Dictionary<string, uint> s_layerNameToBit = new(32);
-    private static readonly Dictionary<uint, string> s_bitToLayerName = new(32);
-
-    internal static void SetLayerName(int layerIndex, string name)
-    {
-        Debug.Assert(layerIndex >= 0 && layerIndex < 32, "Layer index must be between 0 and 31.");
-
-        var bit = 1u << layerIndex;
-        s_layerNameToBit[name] = bit;
-        s_bitToLayerName[bit] = name;
-    }
-
-    public static uint GetLayerBit(string name)
-    {
-        if (s_layerNameToBit.TryGetValue(name, out var bit))
-        {
-            return bit;
-        }
-
-        return 0u;
-    }
-
     private readonly uint _value;
 
     public static readonly RenderingLayerMask Empty = new(0);
diff --git a/src/Runtime/Ghost.Graphics/Shaders/Includes/Common.hlsl b/src/Runtime/Ghost.Graphics/Shaders/Includes/Common.hlsl
index 4497ba8..8b6bddb 100644
--- a/src/Runtime/Ghost.Graphics/Shaders/Includes/Common.hlsl
+++ b/src/Runtime/Ghost.Graphics/Shaders/Includes/Common.hlsl
@@ -3,11 +3,11 @@
 
 struct Vertex
 {
-    float4 position;
-    float4 normal;
-    float4 tangent;
-    float4 uv;
     float4 color;
+    float4 tangent;
+    float3 position;
+    float3 normal;
+    float2 uv;
 };
 
 struct Meshlet
diff --git a/src/Runtime/Ghost.Graphics/Utilities/MeshBuilder.cs b/src/Runtime/Ghost.Graphics/Utilities/MeshBuilder.cs
index d765140..b080836 100644
--- a/src/Runtime/Ghost.Graphics/Utilities/MeshBuilder.cs
+++ b/src/Runtime/Ghost.Graphics/Utilities/MeshBuilder.cs
@@ -17,12 +17,12 @@ public static unsafe class MeshBuilder
         vertices = new UnsafeList<Vertex>(24, allocator);
         indices = new UnsafeList<uint>(36, allocator);
 
-        var corners = new float4[]
+        var corners = new float3[]
         {
-            new (-half, -half, -half, 1.0f), new (half, -half, -half, 1.0f),
-            new (half, half, -half, 1.0f), new (-half, half, -half, 1.0f),
-            new (-half, -half, half, 1.0f), new (half, -half, half, 1.0f),
-            new (half, half, half, 1.0f), new (-half, half, half, 1.0f)
+            new (-half, -half, -half), new (half, -half, -half),
+            new (half, half, -half), new (-half, half, -half),
+            new (-half, -half, half), new (half, -half, half),
+            new (half, half, half), new (-half, half, half)
         };
 
         var faces = stackalloc int[]
@@ -46,10 +46,10 @@ public static unsafe class MeshBuilder
                 var vertex = new Vertex
                 {
                     position = corners[face[i]],
-                    normal = float4.zero,
+                    normal = float3.zero,
                     tangent = float4.zero,
                     color = color,
-                    uv = new(uvs[i], 0.0f, 0.0f)
+                    uv = uvs[i]
                 };
 
                 vertices.Add(vertex);
@@ -81,38 +81,38 @@ public static unsafe class MeshBuilder
 
         vertices.Add(new Vertex()
         {
-            position = new(-hw, 0.0f, -hd, 0.0f),
-            normal = float4.zero,
+            position = new float3(-hw, 0.0f, -hd),
+            normal = float3.zero,
             tangent = float4.zero,
             color = color,
-            uv = new(0.0f)
+            uv = float2.zero
         });
 
         vertices.Add(new Vertex()
         {
-            position = new(hw, 0.0f, -hd, 0.0f),
-            normal = float4.zero,
+            position = new float3(hw, 0.0f, -hd),
+            normal = float3.zero,
             tangent = float4.zero,
             color = color,
-            uv = new(1.0f, 0.0f, 0.0f, 0.0f)
+            uv = new float2(1.0f, 0.0f)
         });
 
         vertices.Add(new Vertex()
         {
-            position = new(hw, 0.0f, hd, 0.0f),
-            normal = float4.zero,
+            position = new float3(hw, 0.0f, hd),
+            normal = float3.zero,
             tangent = float4.zero,
             color = color,
-            uv = new(1.0f, 1.0f, 0.0f, 0.0f)
+            uv = new float2(1.0f, 1.0f)
         });
 
         vertices.Add(new Vertex()
         {
-            position = new(-hw, 0.0f, hd, 0.0f),
-            normal = float4.zero,
+            position = new float3(-hw, 0.0f, hd),
+            normal = float3.zero,
             tangent = float4.zero,
             color = color,
-            uv = new(0.0f, 1.0f, 0.0f, 0.0f)
+            uv = new float2(0.0f, 1.0f)
         });
 
         indices.Add(0);
@@ -153,11 +153,11 @@ public static unsafe class MeshBuilder
 
                 vertices.Add(new Vertex
                 {
-                    position = new float4(x, y, z, 0.0f) * radius,
-                    normal = float4.zero,
+                    position = new float3(x, y, z) * radius,
+                    normal = float3.zero,
                     tangent = float4.zero,
                     color = color,
-                    uv = new float4((float)lon / longitudeSegments, (float)lat / latitudeSegments, 0.0f, 0.0f)
+                    uv = new float2((float)lon / longitudeSegments, (float)lat / latitudeSegments)
                 });
             }
         }
@@ -231,7 +231,7 @@ public static unsafe class MeshBuilder
     public static void ComputeTangents(UnsafeList<Vertex> vertices, UnsafeList<uint> indices)
     {
         using var scope = AllocationManager.CreateStackScope();
-        var bitangents = new UnsafeArray<float4>(vertices.Count, scope.AllocationHandle);
+        var bitangents = new UnsafeArray<float3>(vertices.Count, scope.AllocationHandle, AllocationOption.Clear);
 
         for (var i = 0; i < indices.Count; i += 3)
         {
@@ -269,7 +269,7 @@ public static unsafe class MeshBuilder
         for (var i = 0; i < vertices.Count; i++)
         {
             var n = vertices[i].normal;
-            var t = vertices[i].tangent;
+            var t = vertices[i].tangent.xyz;
 
             var proj = n * math.dot(n, t);
             t = math.normalize(t - proj);
@@ -277,7 +277,7 @@ public static unsafe class MeshBuilder
             var b = bitangents[i];
             var w = math.dot(math.cross(n.xyz, t.xyz), b.xyz) < 0.0f ? -1.0f : 1.0f;
 
-            vertices[i].tangent = new float4(t.x, t.y, t.z, w);
+            vertices[i].tangent = new float4(t.xyz, w);
         }
     }
 }
diff --git a/src/Runtime/Ghost.Graphics/Utilities/MeshletUtility.cs b/src/Runtime/Ghost.Graphics/Utilities/MeshletUtility.cs
index 3150141..a774a6f 100644
--- a/src/Runtime/Ghost.Graphics/Utilities/MeshletUtility.cs
+++ b/src/Runtime/Ghost.Graphics/Utilities/MeshletUtility.cs
@@ -582,7 +582,7 @@ public static unsafe class MeshletUtility
                     }
                 }
 
-                var targetSize = ((nuint)merged.Count / 3) * (nuint)config.simplifyRatio * 3;
+                var targetSize = (nuint)(merged.Count / 3 * config.simplifyRatio * 3.0f);
                 var bounds = MergeBounds(clusters, groups[i]);
 
                 var error = 0.0f;
diff --git a/src/Runtime/Ghost.Graphics/test.gshdr b/src/Runtime/Ghost.Graphics/test.gshdr
index af6209a..8afea0f 100644
--- a/src/Runtime/Ghost.Graphics/test.gshdr
+++ b/src/Runtime/Ghost.Graphics/test.gshdr
@@ -29,11 +29,12 @@ shader "MyShader/Standard"
 
         hlsl
         {
+            #line 31 "MyShader_Standard_Forward_hlsl_block"
             struct PixelInput
             {
                 float4 position : SV_POSITION;
                 float4 color : COLOR;
-                float4 uv : TEXCOORD0;
+                float2 uv : TEXCOORD0;
                 nointerpolation uint meshletID : MESHLET_ID;
             };
 
@@ -72,9 +73,9 @@ shader "MyShader/Standard"
                     float4 worldPos = mul(instanceData.localToWorld, float4(v.position.xyz, 1.0f));
                     float4 viewPos = mul(viewData.viewMatrix, worldPos);
 
-                    // outVerts[groupThreadID.x].position = mul(viewData.projectionMatrix, viewPos);
+                    outVerts[groupThreadID.x].position = mul(viewData.projectionMatrix, viewPos);
                     // For testing.
-                    outVerts[groupThreadID.x].position = float4(v.position.xyz, 1.0f);
+                    // outVerts[groupThreadID.x].position = v.position.xyz;
 
                     outVerts[groupThreadID.x].color = v.color;
                     outVerts[groupThreadID.x].uv = v.uv;
diff --git a/src/Test/Ghost.Graphics.Test/Ghost.Graphics.Test.csproj b/src/Test/Ghost.Graphics.Test/Ghost.Graphics.Test.csproj
index 2eb85fa..c5b7443 100644
--- a/src/Test/Ghost.Graphics.Test/Ghost.Graphics.Test.csproj
+++ b/src/Test/Ghost.Graphics.Test/Ghost.Graphics.Test.csproj
@@ -53,6 +53,7 @@
     <ProjectReference Include="..\..\Test\Ghost.Test.Core\Ghost.Test.Core.csproj" />
     <ProjectReference Include="..\..\Runtime\Ghost.Graphics\Ghost.Graphics.csproj" />
     <ProjectReference Include="..\..\Editor\Ghost.DSL\Ghost.DSL.csproj" />
+    <ProjectReference Include="..\..\ThridParty\Ghost.Ufbx\Ghost.Ufbx.csproj" />
   </ItemGroup>
 
   <!-- 
diff --git a/src/Test/Ghost.Graphics.Test/Package.appxmanifest b/src/Test/Ghost.Graphics.Test/Package.appxmanifest
index 36cf5a3..644bb33 100644
--- a/src/Test/Ghost.Graphics.Test/Package.appxmanifest
+++ b/src/Test/Ghost.Graphics.Test/Package.appxmanifest
@@ -34,7 +34,7 @@
       Executable="$targetnametoken$.exe"
       EntryPoint="$targetentrypoint$">
       <uap:VisualElements
-        DisplayName="Ghost.UnitTest"
+        DisplayName="Ghost.Graphics.Test"
         Description="Ghost.UnitTest"
         BackgroundColor="transparent"
         Square150x150Logo="Assets\Square150x150Logo.png"
diff --git a/src/Test/Ghost.Graphics.Test/RenderPasses/TestRenderPipeline.cs b/src/Test/Ghost.Graphics.Test/RenderPasses/TestRenderPipeline.cs
index 6d3422f..ca92a9b 100644
--- a/src/Test/Ghost.Graphics.Test/RenderPasses/TestRenderPipeline.cs
+++ b/src/Test/Ghost.Graphics.Test/RenderPasses/TestRenderPipeline.cs
@@ -159,8 +159,8 @@ public unsafe partial class TestRenderPipeline : IRenderPipeline
                 // NOTE: We assume camera's scale is always (1, 1, 1). Otherwise fastinverse will fail and we need to use regular inverse which is more expensive.
                 var viewMatrix = math.fastinverse(request.view.localToWorld);
 
-                var vfov = 2.0f * math.atan(request.view.sensorSize.y / 2.0f * request.view.focalLength);
-                var hfov = 2.0f * math.atan(request.view.sensorSize.x / 2.0f * request.view.focalLength);
+                var vfov = 2.0f * math.atan(request.view.sensorSize.y / (2.0f * request.view.focalLength));
+                var hfov = 2.0f * math.atan(request.view.sensorSize.x / (2.0f * request.view.focalLength));
                 var aspectSensor = request.view.sensorSize.x / request.view.sensorSize.y;
 
                 float vfovF;
@@ -200,10 +200,10 @@ public unsafe partial class TestRenderPipeline : IRenderPipeline
                         break;
                 }
 
-                var m_00 = 1.0f / aspectScreen * math.tan(vfovF * 0.5f);
                 var m_11 = 1.0f / math.tan(vfovF * 0.5f);
-                var m_22 = -(request.view.farClipPlane + request.view.nearClipPlane) / (request.view.farClipPlane - request.view.nearClipPlane);
-                var m_23 = -(2.0f * request.view.farClipPlane * request.view.nearClipPlane) / (request.view.farClipPlane - request.view.nearClipPlane);
+                var m_00 = m_11 / aspectScreen;
+                var m_22 = -request.view.farClipPlane / (request.view.farClipPlane - request.view.nearClipPlane);
+                var m_23 = -(request.view.farClipPlane * request.view.nearClipPlane) / (request.view.farClipPlane - request.view.nearClipPlane);
 
                 var projectionMatrix = new float4x4
                 (
diff --git a/src/Test/Ghost.Graphics.Test/UnitTestApp.xaml.cs b/src/Test/Ghost.Graphics.Test/UnitTestApp.xaml.cs
index 5548965..653343c 100644
--- a/src/Test/Ghost.Graphics.Test/UnitTestApp.xaml.cs
+++ b/src/Test/Ghost.Graphics.Test/UnitTestApp.xaml.cs
@@ -59,15 +59,6 @@ public partial class UnitTestApp : Application
     {
         LoadDll();
 
-        var opts = new AllocationManagerInitOpts
-        {
-            ArenaCapacity = 1024 * 1024 * 1024, // 1GB
-            StackCapacity = 1024 * 1024 * 32, // 32MB
-            FreeListConcurrencyLevel = Environment.ProcessorCount,
-        };
-
-        AllocationManager.Initialize(opts);
-
         _window = new GraphicsTestWindow();
         _window.Activate();
 
@@ -77,6 +68,7 @@ public partial class UnitTestApp : Application
 #if DEBUG
             System.Diagnostics.Debugger.Break();
 #endif
+            Environment.FailFast("Unhandled exception", e.Exception);
         };
     }
-}
+}
\ No newline at end of file
diff --git a/src/Test/Ghost.Graphics.Test/Utilities/MeshUtility.cs b/src/Test/Ghost.Graphics.Test/Utilities/MeshUtility.cs
new file mode 100644
index 0000000..9d072ae
--- /dev/null
+++ b/src/Test/Ghost.Graphics.Test/Utilities/MeshUtility.cs
@@ -0,0 +1,176 @@
+using Ghost.Core;
+using Ghost.Graphics.RHI;
+using Ghost.Graphics.Utilities;
+using Ghost.MeshOptimizer;
+using Ghost.Ufbx;
+using Misaki.HighPerformance.LowLevel;
+using Misaki.HighPerformance.LowLevel.Buffer;
+using Misaki.HighPerformance.LowLevel.Collections;
+using Misaki.HighPerformance.LowLevel.Utilities;
+using Misaki.HighPerformance.Mathematics;
+using System.Text;
+
+namespace Ghost.Graphics.Test.Utilities;
+
+internal static class MeshUtility
+{
+    private static float4 ComputeTangent(float3 t, float3 n, float3 b)
+    {
+        var proj = n * math.dot(n, t);
+        t = math.normalize(t - proj);
+        var w = math.dot(math.cross(n.xyz, t.xyz), b.xyz) < 0.0f ? -1.0f : 1.0f;
+        return new float4(t.xyz, w);
+    }
+
+    public static unsafe Result LoadMesh(string filePath, Allocator allocator, out UnsafeList<Vertex> vertices, out UnsafeList<uint> indices)
+    {
+        vertices = default;
+        indices = default;
+
+        if (!File.Exists(filePath))
+        {
+            return Result.Failure("Invalid file path.");
+        }
+
+        if (!Path.GetExtension(filePath).Equals(".obj", StringComparison.OrdinalIgnoreCase)
+            && !Path.GetExtension(filePath).Equals(".fbx", StringComparison.OrdinalIgnoreCase))
+        {
+            return Result.Failure("Unsupported file format. Only .obj and .fbx are supported.");
+        }
+
+        var load_Opts = new ufbx_load_opts();
+        var error = new ufbx_error();
+
+        using var pool = new MemoryPool<VirtualStack, VirtualStack.CreationOpts>(new VirtualStack.CreationOpts
+        {
+            reserveCapacity = 256 * 1024 * 1024 // 256 MB should be enough for most models, adjust as needed. Note that this use virtual memory and does not actually consume physical memory until allocations are made.
+        });
+
+        using var scope0 = pool.Allocator.CreateScope(pool.AllocationHandle);
+        using var str = new UnsafeArray<byte>(Encoding.UTF8.GetByteCount(filePath) + 1, scope0.AllocationHandle);
+        var count = Encoding.UTF8.GetBytes(filePath, str.AsSpan());
+        str[count] = 0;
+
+        using var scene = new DisposablePtr<ufbx_scene>(ufbx_scene.LoadFile((sbyte*)str.GetUnsafePtr(), &load_Opts, &error));
+        if (scene.Get() == null)
+        {
+            return Result.Failure(error.description.ToString());
+        }
+
+        using var flatVertices = new UnsafeList<Vertex>(1024, scope0.AllocationHandle);
+        //using var flatIndices = new UnsafeList<uint>(1024, scope0.AllocationHandle);
+
+        var needComputeNormals = false;
+
+        for (var i = 0u; i < scene.Get()->nodes.count; i++)
+        {
+            var node = scene.Get()->nodes.data[i];
+            if (node->is_root)
+            {
+                continue;
+            }
+
+            using var scope1 = pool.Allocator.CreateScope(pool.AllocationHandle);
+
+            if (node->mesh != null)
+            {
+                var pMesh = node->mesh;
+                if (pMesh->num_faces == 0)
+                {
+                    continue;
+                }
+
+                var maxScratchIndices = (uint)(pMesh->max_face_triangles * 3u);
+                
+                using var triIndicesArray = new UnsafeArray<uint>((int)maxScratchIndices, scope1.AllocationHandle);
+
+                for (var j = 0u; j < pMesh->num_faces; j++)
+                {
+                    var face = pMesh->faces.data[j];
+
+                    var numTris = UfbxApi.TriangulateFace((uint*)triIndicesArray.GetUnsafePtr(), maxScratchIndices, pMesh, face);
+
+                    var totalIndices = numTris * 3;
+                    for (var k = 0; k < totalIndices; k++)
+                    {
+                        var ufbxTopologyIndex = triIndicesArray[k];
+
+                        // TODO: Check if normals/UVs exist before accessing .flatIndices.data
+                        // If it does not exist, we leave uv as (0,0) and compute normals/tangents later
+
+                        var posIdx = pMesh->vertex_position.indices.data[ufbxTopologyIndex];
+                        var normIdx = pMesh->vertex_normal.exists ? pMesh->vertex_normal.indices.data[ufbxTopologyIndex] : uint.MaxValue;
+                        var tanIdx =  pMesh->vertex_tangent.exists ? pMesh->vertex_tangent.indices.data[ufbxTopologyIndex] : uint.MaxValue;
+                        var uvIdx = pMesh->vertex_uv.exists ? pMesh->vertex_uv.indices.data[ufbxTopologyIndex] : uint.MaxValue;
+                        var colIdx = pMesh->vertex_color.exists ? pMesh->vertex_color.indices.data[ufbxTopologyIndex] : uint.MaxValue;
+                        var btanIdx = pMesh->vertex_bitangent.exists ? pMesh->vertex_bitangent.indices.data[ufbxTopologyIndex] : uint.MaxValue;
+
+                        var vertex = new Vertex
+                        {
+                            position = pMesh->vertex_position.values.data[posIdx],
+                            normal = normIdx != uint.MaxValue ? pMesh->vertex_normal.values.data[normIdx] : default,
+                            uv = uvIdx != uint.MaxValue ? pMesh->vertex_uv.values.data[uvIdx] : default,
+                            color = colIdx != uint.MaxValue ? new Color128(pMesh->vertex_color.values.data[colIdx]) : default,
+                        };
+
+                        if (tanIdx != uint.MaxValue)
+                        {
+                            var t = pMesh->vertex_tangent.values.data[tanIdx];
+                            var n = vertex.normal;
+                            var b = btanIdx != uint.MaxValue ? pMesh->vertex_bitangent.values.data[btanIdx] : math.cross(n, t);
+                            vertex.tangent = ComputeTangent(t, n, b);
+                        }
+
+                        var newIndex = (uint)flatVertices.Count;
+
+                        flatVertices.Add(vertex);
+                        //flatIndices.Add(newIndex);
+
+                        if (!needComputeNormals)
+                        {
+                            needComputeNormals = normIdx == uint.MaxValue || tanIdx == uint.MaxValue;
+                        }
+                    }
+                }
+            }
+        }
+
+        var numIndices = (uint)flatVertices.Count;
+
+        using var weldedIndices = new UnsafeArray<uint>((int)numIndices, scope0.AllocationHandle);
+        using var cachedIndices = new UnsafeArray<uint>((int)numIndices, scope0.AllocationHandle);
+
+        var stream = new ufbx_vertex_stream
+        {
+            data = flatVertices.GetUnsafePtr(),
+            vertex_count = numIndices,
+            vertex_size = (nuint)sizeof(Vertex)
+        };
+
+        var numUniqueVertices = stream.GenerateIndices(1, (uint*)weldedIndices.GetUnsafePtr(), (nuint)weldedIndices.Count, null, &error);
+        if (numUniqueVertices == 0 && error.type != ufbx_error_type.UFBX_ERROR_NONE)
+        {
+            return Result.Failure($"Welding failed: {error.description}");
+        }
+
+        MeshOptApi.OptimizeVertexCache((uint*)cachedIndices.GetUnsafePtr(), (uint*)weldedIndices.GetUnsafePtr(), numIndices, numIndices);
+
+        vertices = new UnsafeList<Vertex>((int)numUniqueVertices, allocator);
+        indices = new UnsafeList<uint>((int)numIndices, allocator);
+
+        var finalVertexCount = MeshOptApi.OptimizeVertexFetch(vertices.GetUnsafePtr(), (uint*)cachedIndices.GetUnsafePtr(), numIndices, flatVertices.GetUnsafePtr(), numIndices, (nuint)sizeof(Vertex));
+
+        vertices.UnsafeSetCount((int)finalVertexCount);
+
+        MemoryUtility.MemCpy(indices.GetUnsafePtr(), cachedIndices.GetUnsafePtr(), numIndices * sizeof(uint));
+        indices.UnsafeSetCount((int)numIndices);
+
+        if (needComputeNormals)
+        {
+            MeshBuilder.ComputeNormal(vertices, indices);
+            MeshBuilder.ComputeTangents(vertices, indices);
+        }
+
+        return Result.Success();
+    }
+}
diff --git a/src/Test/Ghost.Graphics.Test/Windows/GraphicsTestWindow.xaml.cs b/src/Test/Ghost.Graphics.Test/Windows/GraphicsTestWindow.xaml.cs
index 85a1af6..29969aa 100644
--- a/src/Test/Ghost.Graphics.Test/Windows/GraphicsTestWindow.xaml.cs
+++ b/src/Test/Ghost.Graphics.Test/Windows/GraphicsTestWindow.xaml.cs
@@ -5,6 +5,7 @@ using Ghost.Engine.Utilities;
 using Ghost.Entities;
 using Ghost.Graphics.Core;
 using Ghost.Graphics.RHI;
+using Ghost.Graphics.Test.Utilities;
 using Ghost.Graphics.Utilities;
 using Microsoft.UI.Xaml;
 using Microsoft.UI.Xaml.Controls;
@@ -33,6 +34,15 @@ public sealed partial class GraphicsTestWindow : Window
 
         Panel.SizeChanged += SwapChainPanel_SizeChanged;
         Panel.CompositionScaleChanged += SwapChainPanel_CompositionScaleChanged;
+        
+        var opts = new AllocationManagerInitOpts
+        {
+            ArenaCapacity = 1024 * 1024 * 1024, // 1GB
+            StackCapacity = 1024 * 1024 * 32, // 32MB
+            FreeListConcurrencyLevel = Environment.ProcessorCount,
+        };
+
+        AllocationManager.Initialize(opts);
     }
 
     private void GraphicsTestWindow_Activated(object sender, WindowActivatedEventArgs e)
@@ -42,6 +52,9 @@ public sealed partial class GraphicsTestWindow : Window
             return;
         }
 
+        e.Handled = true;
+        _isFirstActivationHandled = true;
+
         _renderSystem = new RenderSystem(new RenderSystemDesc()
         {
             FrameBufferCount = 2,
@@ -92,11 +105,12 @@ public sealed partial class GraphicsTestWindow : Window
 
         _world.EntityManager.SetComponent(cameraEntity, new LocalToWorld
         {
-            matrix = float4x4.TRS(new float3(0.0f, 0.0f, -5.0f), quaternion.identity, new float3(1.0f, 1.0f, 1.0f))
+            matrix = float4x4.TRS(new float3(0.0f, 1.0f, 5.0f), quaternion.EulerXYZ(new float3(0, 0, 0)), new float3(1.0f, 1.0f, 1.0f))
         });
 
         // Create Mesh Entity
-        MeshBuilder.CreateCube(0.75f, default, Allocator.Persistent, out var vertices, out var indices);
+        //MeshBuilder.CreateCube(0.75f, default, Allocator.Persistent, out var vertices, out var indices);
+        MeshUtility.LoadMesh("F:/c/SimpleRayTracer/native/assets/bunny.obj", Allocator.Persistent, out var vertices, out var indices).ThrowIfFailed();
 
         // TODO: Put this to the beginning of the frame without createing another command buffer?
         using var directCmd = _renderSystem.GraphicsEngine.CreateCommandBuffer(CommandBufferType.Graphics);
@@ -127,27 +141,34 @@ public sealed partial class GraphicsTestWindow : Window
         });
 
         CompositionTarget.Rendering += OnRendering;
-
-        e.Handled = true;
-        _isFirstActivationHandled = true;
     }
 
     private void GraphicsTestWindow_Closed(object sender, WindowEventArgs e)
     {
-        CompositionTarget.Rendering -= OnRendering;
-        _renderSystem?.Stop();
-
-        if (_world != null)
+        try
+        {
+            CompositionTarget.Rendering -= OnRendering;
+            _renderSystem?.Stop();
+
+            if (_world != null)
+            {
+                World.Destroy(_world.ID);
+            }
+
+            _renderSystem?.ResourceManager.ReleaseMesh(_meshHandle);
+
+            _swapChain?.Dispose();
+            _renderSystem?.Dispose();
+
+            AllocationManager.Dispose();
+        }
+        catch (Exception ex)
+        {
+            Environment.FailFast("Failed to close the window properly.", ex);
+        }
+        finally
         {
-            World.Destroy(_world.ID);
         }
-
-        _renderSystem?.ResourceManager.ReleaseMesh(_meshHandle);
-
-        _swapChain?.Dispose();
-        _renderSystem?.Dispose();
-
-        AllocationManager.Dispose();
     }
 
     private void SwapChainPanel_SizeChanged(object sender, SizeChangedEventArgs e)