Converted everything that was using the old "EngineArena" to our new Arena type

Juliet/Juliet.vcxproj

@@ -156,7 +156,6 @@
     <CustomBuild Include="src\Core\Math\Math_Private.h" />
     <CustomBuild Include="src\Core\Math\MathRound.cpp" />
     <CustomBuild Include="src\Core\Memory\Allocator.cpp" />
-    <CustomBuild Include="src\Core\Memory\EngineArena.h" />
     <CustomBuild Include="src\Core\Memory\MemoryArena.cpp" />
     <CustomBuild Include="src\Core\Memory\MemoryArenaTests.cpp" />
     <CustomBuild Include="src\Core\Memory\ScratchArena.cpp" />

Juliet/Juliet.vcxproj.filters

@@ -315,9 +315,6 @@
     <CustomBuild Include="src\Core\Memory\Allocator.cpp">
       <Filter>src\Core\Memory</Filter>
     </CustomBuild>
-    <CustomBuild Include="src\Core\Memory\EngineArena.h">
-      <Filter>src\Core\Memory</Filter>
-    </CustomBuild>
     <CustomBuild Include="src\Core\Memory\MemoryArena.cpp">
       <Filter>src\Core\Memory</Filter>
     </CustomBuild>

Juliet/include/Core/Container/Vector.h

@@ -16,7 +16,7 @@ namespace Juliet
             DataFirst = DataLast = nullptr;
             Count                = 0;
             Stride               = sizeof(Type);
-            Arena                = ArenaAllocate();
+            Arena                = ArenaAllocate(JULIET_DEBUG_ONLY({ .CanReserveMore = false }));
         }
         void Destroy()
         {
@@ -27,6 +27,14 @@ namespace Juliet
             Arena                = nullptr;
         }
 
+        void Resize(size_t newCount)
+        {
+            Type* entry = ArenaPushArray<Type>(Arena, newCount);
+            Count       = newCount;
+            DataFirst   = entry;
+            DataLast    = entry + newCount;
+        }
+
         void PushBack(const Type& value)
         {
             Assert(Arena);

Juliet/include/Core/HotReload/HotReload.h

@@ -9,6 +9,8 @@ namespace Juliet
 
     struct HotReloadCode
     {
+        Arena* Arena;
+
         String DLLFullPath;
         String LockFullPath;
         String TransientDLLName;
@@ -26,8 +28,7 @@ namespace Juliet
         bool IsValid : 1;
     };
 
-    extern JULIET_API void InitHotReloadCode(HotReloadCode& code, String dllName,
+    extern JULIET_API void InitHotReloadCode(HotReloadCode& code, String dllName, String transientDllName, String lockFilename);
-                                             String transientDllName, String lockFilename);
     extern JULIET_API void ShutdownHotReloadCode(HotReloadCode& code);
 
     extern JULIET_API void LoadCode(HotReloadCode& code);

Juliet/include/Core/Memory/MemoryArena.h

@@ -30,6 +30,8 @@ namespace Juliet
         uint64 Reserved;
 
         Arena* FreeLast;
+
+        JULIET_DEBUG_ONLY(bool CanReserveMore : 1;)
     };
     static_assert(sizeof(Arena) <= k_ArenaHeaderSize);
 
@@ -37,6 +39,10 @@ namespace Juliet
     {
         uint64 ReserveSize = g_Arena_Default_Reserve_Size;
         uint64 CommitSize  = g_Arena_Default_Commit_Size;
+
+        // When false, will assert if a new block is reserved.
+        // Useful for Vectors as they are guaranteed to be linear and i wont need to implement memcopy to increase capacity
+        JULIET_DEBUG_ONLY(bool CanReserveMore : 1 = true;)
     };
 
     [[nodiscard]] Arena* ArenaAllocate(const ArenaParams&          params = {},

Juliet/include/Juliet.h

@@ -21,8 +21,10 @@
 
 #ifdef DEBUG
 #define JULIET_DEBUG 1
+#define JULIET_DEBUG_ONLY(expr) expr
 #else
 #define JULIET_DEBUG 0
+#define JULIET_DEBUG_ONLY(expr)
 #endif
 
 // Manual override to disable ImGui

Juliet/src/Core/HAL/Display/Display.cpp

@@ -2,7 +2,6 @@
 #include <Core/HAL/Display/Display_Private.h>
 #include <Core/HAL/Display/DisplayDevice.h>
 #include <Core/Memory/Allocator.h>
-#include <Core/Memory/EngineArena.h>
 #include <Core/Memory/MemoryArena.h>
 
 namespace Juliet

Juliet/src/Core/HAL/Display/Win32/Win32DisplayDevice.cpp

@@ -1,7 +1,6 @@
 #include <Core/HAL/Display/DisplayDevice.h>
 #include <Core/HAL/Display/Win32/Win32DisplayEvent.h>
 #include <Core/HAL/Display/Win32/Win32Window.h>
-#include <Core/Memory/EngineArena.h>
 
 namespace Juliet::Win32
 {

Juliet/src/Core/HAL/Display/Win32/Win32Window.cpp

@@ -2,8 +2,7 @@
 #include <Core/HAL/Display/Win32/Win32Window.h>
 #include <Core/HAL/Display/Window.h>
 #include <Core/Memory/Allocator.h>
-#include <Core/Memory/EngineArena.h>
+#include <Core/Memory/MemoryArena.h>
-#include <Core/Memory/Utils.h>
 
 namespace Juliet::Win32
 {

Juliet/src/Core/HotReload/HotReload.cpp

@@ -2,8 +2,6 @@
 #include <Core/HotReload/HotReload.h>
 #include <Core/Logging/LogManager.h>
 #include <Core/Logging/LogTypes.h>
-#include <Core/Memory/Allocator.h>
-#include <Core/Memory/EngineArena.h>
 #include <Core/Memory/MemoryArena.h>
 #include <Core/Thread/Thread.h>
 
@@ -13,6 +11,8 @@ namespace Juliet
 {
     void InitHotReloadCode(HotReloadCode& code, String dllName, String transientDllName, String lockFilename)
     {
+        code.Arena = ArenaAllocate();
+
         // Get the app base path and build the dll path from there.
         String basePath       = GetBasePath();
         size_t basePathLength = StringLength(basePath);
@@ -24,7 +24,8 @@ namespace Juliet
         // TODO: Add path composition into filesystem + string format + string builder
         const size_t dllFullPathLength =
             basePathLength + StringLength(dllName) + 1; // Need +1 because snprintf needs 0 terminated strings
-        code.DLLFullPath.Data = ArenaPushArray<char>(GetEngineArena(), dllFullPathLength, ConstString("DLLFullPath"));
+
+        code.DLLFullPath.Data = ArenaPushArray<char>(code.Arena, dllFullPathLength);
         int writtenSize = snprintf(CStr(code.DLLFullPath), dllFullPathLength, "%s%s", CStr(basePath), CStr(dllName));
         if (writtenSize < static_cast<int>(dllFullPathLength) - 1)
         {
@@ -37,7 +38,7 @@ namespace Juliet
         // Lock filename path
         const size_t lockPathLength =
             basePathLength + StringLength(lockFilename) + 1; // Need +1 because snprintf needs 0 terminated strings
-        code.LockFullPath.Data = ArenaPushArray<char>(GetEngineArena(), lockPathLength, ConstString("LockFullPath"));
+        code.LockFullPath.Data = ArenaPushArray<char>(code.Arena, lockPathLength);
         writtenSize = snprintf(CStr(code.LockFullPath), lockPathLength, "%s%s", CStr(basePath), CStr(lockFilename));
         if (writtenSize < static_cast<int>(lockPathLength) - 1)
         {
@@ -59,6 +60,8 @@ namespace Juliet
         // Arena memory persists until engine shutdown
         code.LockFullPath.Size = 0;
         // Arena memory persists until engine shutdown
+
+        ArenaRelease(code.Arena);
     }
 
     void ReloadCode(HotReloadCode& code)

Juliet/src/Core/ImGui/ImGuiService.cpp

@@ -9,7 +9,6 @@
 #include <backends/imgui_impl_win32.h>
 #include <imgui.h>
 
-#include <Core/Memory/EngineArena.h>
 #include <cstdio>
 
 // Forward declare implementation functions from backends
@@ -24,34 +23,16 @@ namespace Juliet::ImGuiService
 
         // Dedicated Paged Arena for ImGui
         // Sharing the same underlying Engine Pool for blocks, but separate Arena chain.
-        MemoryArena g_ImGuiArena;
+        Arena* g_ImGuiArena = {};
 
         void* ImGuiAllocWrapper(size_t size, void* /*user_data*/)
         {
-            // Store size in header to allow Pop
+            return ArenaPush(g_ImGuiArena, size, 8, false);
-            // Align total size to 16 to avoid padding issues with ArenaPop LIFO check
-            size_t actualSize = size + 16;
-            actualSize        = (actualSize + 15) & ~static_cast<size_t>(15);
-
-            // We do save the size when we push so we can pop exactly the size.
-            if (void* ptr = ArenaPush(&g_ImGuiArena, actualSize, 16, ConstString("ImGui")))
-            {
-                // Write size at start
-                *static_cast<size_t*>(ptr) = actualSize;
-                return static_cast<uint8*>(ptr) + 16;
-            }
-            return nullptr;
         }
 
-        void ImGuiFreeWrapper(void* ptr, void* /*user_data*/)
+        void ImGuiFreeWrapper(void* /*ptr*/, void* /*user_data*/)
         {
-            Assert(ptr);
+            // TODO : Free list of imgui elements.
-
-            uint8* originalPtr = static_cast<uint8*>(ptr) - 16;
-            size_t actualSize  = *reinterpret_cast<size_t*>(originalPtr);
-
-            // Attempt LIFO Pop
-            ArenaPop(&g_ImGuiArena, originalPtr, actualSize);
         }
     } // namespace
 
@@ -60,7 +41,7 @@ namespace Juliet::ImGuiService
         Assert(!g_Initialized);
 
         // Initialize ImGui Arena using Engine Pool
-        MemoryArenaCreate(&g_ImGuiArena, GetEngineArena()->BackingPool);
+        g_ImGuiArena = ArenaAllocate();
 
         // Setup Allocator
         ImGui::SetAllocatorFunctions(ImGuiAllocWrapper, ImGuiFreeWrapper, nullptr);

Juliet/src/Core/Memory/EngineArena.h

@@ -1,10 +0,0 @@
-#pragma once
-
-#include <Core/Memory/MemoryArena.h>
-
-namespace Juliet
-{
-    // Persistent engine-only arena.
-    // Not exported to the Game DLL.
-    MemoryArena* GetEngineArena();
-} // namespace Juliet

Juliet/src/Core/Memory/MemoryArena.cpp

@@ -44,6 +44,8 @@ namespace Juliet
         arena->BasePosition = 0;
         arena->Position     = k_ArenaHeaderSize;
 
+        arena->CanReserveMore = params.CanReserveMore;
+
         return arena;
     }
 
@@ -65,6 +67,8 @@ namespace Juliet
         // If allowed and needed, add a new block and chain it to the arena.
         if (current->Reserved < positionPostPush /* flags : chaining allowed */)
         {
+            Assert(arena->CanReserveMore);
+
             Arena* newBlock = nullptr;
             {
                 Arena* prev_block;
@@ -552,11 +556,9 @@ namespace Juliet
     namespace
     {
         MemoryPool g_ScratchMemory;
-        MemoryPool g_EngineMemory;
         MemoryPool g_GameMemory;
 
         MemoryArena g_ScratchArena;
-        MemoryArena g_EngineArena;
         MemoryArena g_GameArena;
 
         // Backing Buffers
@@ -565,7 +567,6 @@ namespace Juliet
         void* g_GameBuffer    = nullptr;
 
         constexpr size_t kScratchSize = Megabytes(64);
-        constexpr size_t kEngineSize  = Megabytes(256);
         constexpr size_t kGameSize    = Megabytes(512);
 
         void InitPool(MemoryPool* pool, void* buffer, size_t size)
@@ -589,10 +590,7 @@ namespace Juliet
     {
         return &g_ScratchArena;
     }
-    MemoryArena* GetEngineArena()
+
-    {
-        return &g_EngineArena;
-    }
     MemoryArena* GetGameArena()
     {
         return &g_GameArena;
@@ -606,15 +604,12 @@ namespace Juliet
     void MemoryArenasInit()
     {
         g_ScratchBuffer = Malloc(kScratchSize);
-        g_EngineBuffer  = Malloc(kEngineSize);
         g_GameBuffer    = Malloc(kGameSize);
 
         InitPool(&g_ScratchMemory, g_ScratchBuffer, kScratchSize);
-        InitPool(&g_EngineMemory, g_EngineBuffer, kEngineSize);
         InitPool(&g_GameMemory, g_GameBuffer, kGameSize);
 
         MemoryArenaCreate(&g_ScratchArena, &g_ScratchMemory);
-        MemoryArenaCreate(&g_EngineArena, &g_EngineMemory);
         MemoryArenaCreate(&g_GameArena, &g_GameMemory);
 
 #if JULIET_DEBUG

Juliet/src/Engine/Debug/MemoryDebugger.cpp

@@ -1,5 +1,4 @@
 #include <Core/Common/String.h>
-#include <Core/Memory/EngineArena.h>
 #include <Engine/Debug/MemoryDebugger.h>
 #include <imgui.h>
 
@@ -420,7 +419,6 @@ namespace Juliet::Debug
         if (ImGui::Begin("Memory Debugger"))
         {
             DrawMemoryArena(ConstString("Game Arena"), *GetGameArena(), s_ConfirmedHovered, frameHovered);
-            DrawMemoryArena(ConstString("Engine Arena"), *GetEngineArena(), s_ConfirmedHovered, frameHovered);
         }
         ImGui::End();
 

Juliet/src/Graphics/D3D12/D3D12CommandList.cpp

@@ -454,8 +454,11 @@ namespace Juliet::D3D12
                 return false;
             }
 
-            ReturnSamplerHeapToPool(driver, commandList->Sampler_Heap);
+            if (commandList->Sampler_Heap) [[likely]]
-            commandList->Sampler_Heap     = nullptr;
+            {
+                ReturnSamplerHeapToPool(driver, commandList->Sampler_Heap);
+                commandList->Sampler_Heap = nullptr;
+            }
             commandList->CRB_SRV_UAV_Heap = nullptr;
 
             // Clean up resource tracking

Juliet/src/Graphics/D3D12/D3D12Common.cpp

@@ -4,8 +4,8 @@
 #include <Graphics/D3D12/D3D12Common.h>
 #include <Graphics/D3D12/D3D12GraphicsDevice.h>
 #include <Graphics/D3D12/D3D12Includes.h>
-#include <Graphics/D3D12/D3D12Utils.h>
 
+// TODO: Convert the whole file to memory arenas
 namespace Juliet::D3D12::Internal
 {
     namespace
@@ -25,8 +25,8 @@ namespace Juliet::D3D12::Internal
 
         bool ExtendStagingDescriptorPool(NonNullPtr<D3D12Driver> driver, D3D12StagingDescriptorPool& pool)
         {
-            D3D12DescriptorHeap* heap =
+            D3D12DescriptorHeap* heap = Internal::CreateDescriptorHeap(driver, pool.Arena, pool.Heaps[0]->HeapType,
-                Internal::CreateDescriptorHeap(driver, pool.Heaps[0]->HeapType, kStagingHeapDescriptorExpectedCount, true);
+                                                                       kStagingHeapDescriptorExpectedCount, true);
             if (!heap)
             {
                 return false;
@@ -49,13 +49,17 @@ namespace Juliet::D3D12::Internal
 
     D3D12StagingDescriptorPool* CreateStagingDescriptorPool(NonNullPtr<D3D12Driver> driver, D3D12_DESCRIPTOR_HEAP_TYPE type)
     {
-        D3D12DescriptorHeap* heap = CreateDescriptorHeap(driver, type, kStagingHeapDescriptorExpectedCount, true);
+        Arena* arena = ArenaAllocate();
+
+        D3D12DescriptorHeap* heap = CreateDescriptorHeap(driver, arena, type, kStagingHeapDescriptorExpectedCount, true);
         if (!heap)
         {
+            ArenaRelease(arena);
             return nullptr;
         }
 
-        auto pool = static_cast<D3D12StagingDescriptorPool*>(Calloc(1, sizeof(D3D12StagingDescriptorPool)));
+        auto pool   = static_cast<D3D12StagingDescriptorPool*>(Calloc(1, sizeof(D3D12StagingDescriptorPool)));
+        pool->Arena = arena;
 
         // First create the heaps
         pool->HeapCount = 1;
@@ -113,6 +117,8 @@ namespace Juliet::D3D12::Internal
 
         Free(pool->Heaps);
         Free(pool->FreeDescriptors);
+
+        ArenaRelease(pool->Arena);
         Free(pool.Get());
     }
 } // namespace Juliet::D3D12::Internal

Juliet/src/Graphics/D3D12/D3D12Common.h

@@ -22,8 +22,9 @@ namespace Juliet::D3D12
 
     struct D3D12StagingDescriptorPool
     {
+        Arena*                          Arena;
         Internal::D3D12DescriptorHeap** Heaps;
-        uint32                HeapCount;
+        uint32                          HeapCount;
 
         // Descriptor handles are owned by resources, so these can be thought of as descriptions of a free index within a heap.
         uint32                  FreeDescriptorCapacity;
@@ -35,9 +36,9 @@ namespace Juliet::D3D12
     struct D3D12StagingDescriptor
     {
         D3D12StagingDescriptorPool*    Pool;
-        Internal::D3D12DescriptorHeap*        Heap;
+        Internal::D3D12DescriptorHeap* Heap;
-        D3D12_CPU_DESCRIPTOR_HANDLE CpuHandle;
+        D3D12_CPU_DESCRIPTOR_HANDLE    CpuHandle;
-        uint32                      CpuHandleIndex;
+        uint32                         CpuHandleIndex;
     };
 
     namespace Internal

Juliet/src/Graphics/D3D12/D3D12DescriptorHeap.cpp

@@ -1,26 +1,52 @@
 #include <Core/Logging/LogManager.h>
 #include <Core/Logging/LogTypes.h>
 #include <Core/Memory/Allocator.h>
-#include <Core/Memory/EngineArena.h>
 #include <Graphics/D3D12/D3D12DescriptorHeap.h>
 #include <Graphics/D3D12/D3D12GraphicsDevice.h>
 #include <Graphics/D3D12/D3D12Utils.h>
 
 namespace Juliet::D3D12::Internal
 {
-    D3D12DescriptorHeap* CreateDescriptorHeap(NonNullPtr<D3D12Driver> driver, D3D12_DESCRIPTOR_HEAP_TYPE type, uint32 count, bool isStaging)
+    void CreateDescriptorHeapPool(NonNullPtr<D3D12Driver> driver, D3D12DescriptorHeapPool& heapPool,
+                                  D3D12_DESCRIPTOR_HEAP_TYPE type, uint32 count)
     {
-        auto heap = ArenaPushType<D3D12DescriptorHeap>(GetEngineArena(), ConstString("D3D12DescriptorHeap"));
+        // Heap pool is just single linked list of free elements
-        if (!heap)
+        constexpr size_t kInitialCapacity = 4;
+        heapPool.Arena                    = ArenaAllocate();
+        heapPool.FirstFreeDescriptorHeap  = nullptr;
+
+        // Pre allocate 4
+        for (uint32 i = 0; i < kInitialCapacity; ++i)
         {
-            return nullptr;
+            D3D12DescriptorHeap* descriptorHeap = CreateDescriptorHeap(driver, heapPool.Arena, type, count, false);
+            descriptorHeap->Next                = heapPool.FirstFreeDescriptorHeap;
+            heapPool.FirstFreeDescriptorHeap    = descriptorHeap;
         }
+    }
+
+    void DestroyDescriptorHeapPool(D3D12DescriptorHeapPool& heapPool)
+    {
+        D3D12DescriptorHeap* current = heapPool.FirstFreeDescriptorHeap;
+        while (current != nullptr)
+        {
+            D3D12DescriptorHeap* next = current->Next;
+            DestroyDescriptorHeap(current);
+            current = next;
+        }
+        ArenaRelease(heapPool.Arena);
+    }
+
+    D3D12DescriptorHeap* CreateDescriptorHeap(NonNullPtr<D3D12Driver> driver, NonNullPtr<Arena> arena,
+                                              D3D12_DESCRIPTOR_HEAP_TYPE type, uint32 count, bool isStaging)
+    {
+        D3D12DescriptorHeap* heap = ArenaPushStruct<D3D12DescriptorHeap>(arena.Get());
+        Assert(heap);
 
         heap->CurrentDescriptorIndex = 0;
-        heap->FreeIndicesCapacity    = 16;
+
-        heap->FreeIndicesCount       = 0;
+        heap->FreeIndices.Create();
-        heap->FreeIndices            = ArenaPushArray<uint32>(GetEngineArena(), heap->FreeIndicesCapacity,
+        heap->FreeIndices.Resize(16);
-                                                              ConstString("D3D12DescriptorHeap/FreeIndices"));
+        heap->CurrentFreeIndex = 0;
 
         D3D12_DESCRIPTOR_HEAP_DESC heapDesc;
         heapDesc.NumDescriptors = count;
@@ -54,23 +80,21 @@ namespace Juliet::D3D12::Internal
 
     void DestroyDescriptorHeap(NonNullPtr<D3D12DescriptorHeap> heap)
     {
+        heap->FreeIndices.Destroy();
         if (heap->Handle)
         {
             heap->Handle->Release();
         }
-        // TODO: should not free because its on an arena, but need to use arena properly
-        // SafeFree(heap->FreeIndices);
-        // Free(heap.Get());
     }
 
     bool AssignDescriptor(D3D12DescriptorHeap* heap, D3D12Descriptor& outDescriptor)
     {
         uint32 index = UINT32_MAX;
 
-        if (heap->FreeIndicesCount > 0)
+        if (heap->CurrentFreeIndex > 0)
         {
-            heap->FreeIndicesCount -= 1;
+            heap->CurrentFreeIndex -= 1;
-            index = heap->FreeIndices[heap->FreeIndicesCount];
+            index = heap->FreeIndices[heap->CurrentFreeIndex];
         }
         else if (heap->CurrentDescriptorIndex < heap->MaxDescriptors)
         {
@@ -102,55 +126,42 @@ namespace Juliet::D3D12::Internal
 
         D3D12DescriptorHeap* heap = descriptor.Heap;
 
-        if (heap->FreeIndicesCount >= heap->FreeIndicesCapacity)
+        if (heap->CurrentFreeIndex >= heap->FreeIndices.Count)
         {
-            size_t oldCapacity = heap->FreeIndicesCapacity;
+            heap->FreeIndices.PushBack(descriptor.Index);
-            heap->FreeIndicesCapacity *= 2;
-            heap->FreeIndices = ArenaRealloc<uint32>(GetEngineArena(), heap->FreeIndices, oldCapacity,
-                                                     heap->FreeIndicesCapacity, ConstString("FreeIndices"));
-        }
-
-        heap->FreeIndices[heap->FreeIndicesCount] = descriptor.Index;
-        heap->FreeIndicesCount++;
-    }
-
-    D3D12DescriptorHeap* AcquireSamplerHeapFromPool(NonNullPtr<D3D12Driver> d3d12Driver, DescriptorHeapCreator creator)
-    {
-        D3D12DescriptorHeap*     result;
-        D3D12DescriptorHeapPool* pool = &d3d12Driver->SamplerHeapPool;
-
-        if (pool->Count > 0)
-        {
-            result = pool->Heaps[pool->Count - 1];
-            pool->Count -= 1;
         }
         else
         {
-            result = creator(d3d12Driver, D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER, GPUDriver::kSampler_HeapDescriptorCount, false);
+            heap->FreeIndices[heap->CurrentFreeIndex] = descriptor.Index;
+            heap->CurrentFreeIndex++;
+        }
+    }
+
+    D3D12DescriptorHeap* AcquireSamplerHeapFromPool(NonNullPtr<D3D12Driver> d3d12Driver)
+    {
+        D3D12DescriptorHeapPool& pool = d3d12Driver->SamplerHeapPool;
+
+        D3D12DescriptorHeap* result = pool.FirstFreeDescriptorHeap;
+        if (result)
+        {
+            pool.FirstFreeDescriptorHeap = pool.FirstFreeDescriptorHeap->Next;
+        }
+        else
+        {
+            result = CreateDescriptorHeap(d3d12Driver, pool.Arena, D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER,
+                                          GPUDriver::kSampler_HeapDescriptorCount, false);
         }
 
         return result;
     }
 
-    void ReturnSamplerHeapToPool(NonNullPtr<D3D12Driver> d3d12Driver, D3D12DescriptorHeap* heap)
+    void ReturnSamplerHeapToPool(NonNullPtr<D3D12Driver> d3d12Driver, NonNullPtr<D3D12DescriptorHeap> heap)
     {
-        if (heap == nullptr)
+        D3D12DescriptorHeapPool& pool = d3d12Driver->SamplerHeapPool;
-        {
-            return;
-        }
-
-        D3D12DescriptorHeapPool* pool = &d3d12Driver->SamplerHeapPool;
 
         heap->CurrentDescriptorIndex = 0;
 
-        if (pool->Count >= pool->Capacity)
+        heap->Next                   = pool.FirstFreeDescriptorHeap;
-        {
+        pool.FirstFreeDescriptorHeap = heap;
-            size_t oldCapacity = pool->Capacity;
-            pool->Capacity *= 2;
-            pool->Heaps = ArenaRealloc(GetEngineArena(), pool->Heaps, oldCapacity, pool->Capacity, ConstString("Heaps"));
-        }
-
-        pool->Heaps[pool->Count] = heap;
-        pool->Count += 1;
     }
 } // namespace Juliet::D3D12::Internal

Juliet/src/Graphics/D3D12/D3D12DescriptorHeap.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <Core/Common/NonNullPtr.h>
+#include <Core/Networking/NetworkPacket.h>
 #include <Graphics/D3D12/D3D12Includes.h>
 
 // Forward declare
@@ -14,6 +15,7 @@ namespace Juliet::D3D12::Internal
     // https://learn.microsoft.com/en-us/windows/win32/direct3d12/descriptor-heaps
     struct D3D12DescriptorHeap
     {
+        D3D12DescriptorHeap*        Next;
         ID3D12DescriptorHeap*       Handle;
         D3D12_DESCRIPTOR_HEAP_TYPE  HeapType;
         D3D12_CPU_DESCRIPTOR_HANDLE DescriptorHeapCPUStart;
@@ -22,11 +24,10 @@ namespace Juliet::D3D12::Internal
         uint32                      DescriptorSize;
         uint32                      CurrentDescriptorIndex; // only used by GPU heaps
 
-        uint32*                     FreeIndices;
+        VectorArena<uint32> FreeIndices;
-        uint32                      FreeIndicesCapacity;
+        index_t             CurrentFreeIndex;
-        uint32                      FreeIndicesCount;
 
-        bool                        Staging : 1;
+        bool Staging : 1;
     };
 
     struct D3D12Descriptor
@@ -39,20 +40,24 @@ namespace Juliet::D3D12::Internal
 
     struct D3D12DescriptorHeapPool
     {
-        D3D12DescriptorHeap** Heaps;
+        Arena*               Arena;
-        size_t                Capacity;
+        D3D12DescriptorHeap* FirstFreeDescriptorHeap;
-        size_t                Count;
     };
 
-    using DescriptorHeapCreator = D3D12DescriptorHeap* (*)(NonNullPtr<D3D12Driver>, D3D12_DESCRIPTOR_HEAP_TYPE, uint32, bool);
+    using DescriptorHeapCreator = D3D12DescriptorHeap* (*)(NonNullPtr<D3D12Driver>, D3D12DescriptorHeapPool& heapPool,
+                                                           D3D12_DESCRIPTOR_HEAP_TYPE, uint32, bool);
 
-    extern D3D12DescriptorHeap* CreateDescriptorHeap(NonNullPtr<D3D12Driver>    driver,
+    extern void CreateDescriptorHeapPool(NonNullPtr<D3D12Driver> driver, D3D12DescriptorHeapPool& heapPool,
-                                                 D3D12_DESCRIPTOR_HEAP_TYPE type, uint32 count, bool isStaging);
+                                         D3D12_DESCRIPTOR_HEAP_TYPE type, uint32 count);
+    extern void DestroyDescriptorHeapPool(D3D12DescriptorHeapPool& pool);
+
+    extern D3D12DescriptorHeap* CreateDescriptorHeap(NonNullPtr<D3D12Driver> driver, NonNullPtr<Arena> arena,
+                                                     D3D12_DESCRIPTOR_HEAP_TYPE type, uint32 count, bool isStaging);
     extern void                 DestroyDescriptorHeap(NonNullPtr<D3D12DescriptorHeap> heap);
 
-    extern D3D12DescriptorHeap* AcquireSamplerHeapFromPool(NonNullPtr<D3D12Driver> d3d12Driver, DescriptorHeapCreator creator = CreateDescriptorHeap);
+    extern D3D12DescriptorHeap* AcquireSamplerHeapFromPool(NonNullPtr<D3D12Driver> d3d12Driver);
-    extern void                 ReturnSamplerHeapToPool(NonNullPtr<D3D12Driver> d3d12Driver, D3D12DescriptorHeap* heap);
+    extern void ReturnSamplerHeapToPool(NonNullPtr<D3D12Driver> d3d12Driver, NonNullPtr<D3D12DescriptorHeap> heap);
 
     extern bool AssignDescriptor(D3D12DescriptorHeap* heap, D3D12Descriptor& outDescriptor);
     extern void ReleaseDescriptor(const D3D12Descriptor& descriptor);
-} // namespace Juliet::D3D12
+} // namespace Juliet::D3D12::Internal

Juliet/src/Graphics/D3D12/D3D12GraphicsDevice.cpp

@@ -3,7 +3,6 @@
 #include <Core/Logging/LogManager.h>
 #include <Core/Logging/LogTypes.h>
 #include <Core/Memory/Allocator.h>
-#include <Core/Memory/EngineArena.h>
 #include <Graphics/D3D12/D3D12Buffer.h>
 #include <Graphics/D3D12/D3D12CommandList.h>
 #include <Graphics/D3D12/D3D12DescriptorHeap.h>
@@ -471,22 +470,7 @@ namespace Juliet::D3D12
                 }
             }
 
-            auto DestroyDescriptorHeapPool = [](Internal::D3D12DescriptorHeapPool& heapPool)
+            Internal::DestroyDescriptorHeapPool(driver->SamplerHeapPool);
-            {
-                if (heapPool.Heaps)
-                {
-                    for (uint32 i = 0; i < heapPool.Count; ++i)
-                    {
-                        if (heapPool.Heaps[i])
-                        {
-                            Internal::DestroyDescriptorHeap(heapPool.Heaps[i]);
-                            heapPool.Heaps[i] = nullptr;
-                        }
-                    }
-                    // SafeFree(heapPool.Heaps); // Allocated with Arena, do not free.
-                }
-            };
-            DestroyDescriptorHeapPool(driver->SamplerHeapPool);
 
             // Release command buffers
             for (uint32 i = 0; i < driver->AvailableCommandListCount; i += 1)
@@ -571,6 +555,7 @@ namespace Juliet::D3D12
 
             driver->D3D12SerializeVersionedRootSignatureFct = nullptr;
 
+            ArenaRelease(driver->DriverArena);
             Free(driver.Get());
         }
 
@@ -745,6 +730,9 @@ namespace Juliet::D3D12
         {
             auto driver = static_cast<D3D12Driver*>(Calloc(1, sizeof(D3D12Driver)));
 
+            // TODO : Convert everything to arena
+            driver->DriverArena = ArenaAllocate();
+
 #if JULIET_DEBUG
 #ifdef IDXGIINFOQUEUE_SUPPORTED
             if (enableDebug)
@@ -1023,32 +1011,8 @@ namespace Juliet::D3D12
                 }
             }
 
-            // Other Descriptor pools
+            CreateDescriptorHeapPool(driver, driver->SamplerHeapPool, D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER,
-            auto CreateDescriptorPool = [&](Internal::D3D12DescriptorHeapPool& heapPool,
+                                     GPUDriver::kSampler_HeapDescriptorCount);
-                                            D3D12_DESCRIPTOR_HEAP_TYPE type, uint32 count) -> bool
-            {
-                heapPool.Capacity = 4;
-                heapPool.Count    = 4;
-                heapPool.Heaps    = ArenaPushArray<Internal::D3D12DescriptorHeap*>(GetEngineArena(), heapPool.Capacity,
-                                                                                   ConstString("DescriptorHeap"));
-
-                for (uint32 i = 0; i < heapPool.Capacity; ++i)
-                {
-                    heapPool.Heaps[i] = Internal::CreateDescriptorHeap(driver, type, count, false);
-
-                    if (heapPool.Heaps[i] == nullptr)
-                    {
-                        return false;
-                    }
-                }
-                return true;
-            };
-
-            if (!CreateDescriptorPool(driver->SamplerHeapPool, D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER, GPUDriver::kSampler_HeapDescriptorCount))
-            {
-                DestroyDriver_Internal(driver);
-                return nullptr;
-            }
 
             // Deferred dispose vectors
             driver->GraphicsPipelinesToDisposeCapacity = 4;
@@ -1125,8 +1089,9 @@ namespace Juliet::D3D12
             driver->GraphicsDevice = device;
 
             // Create Global Bindless Heap that stays alive for the driver whole lifetime
-            driver->BindlessDescriptorHeap = Internal::CreateDescriptorHeap(driver, D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV,
+            driver->BindlessDescriptorHeap =
-                                                                            GPUDriver::kCBV_SRV_UAV_HeapDescriptorCount, false);
+                Internal::CreateDescriptorHeap(driver, driver->DriverArena, D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV,
+                                               GPUDriver::kCBV_SRV_UAV_HeapDescriptorCount, false);
 
             return device;
         }

Juliet/src/Graphics/GraphicsDevice.h

@@ -30,6 +30,8 @@ namespace Juliet
 
     struct GPUDriver
     {
+        Arena* DriverArena = {};
+
         static constexpr uint8 kMaxFramesInFlight         = 3;
         static constexpr uint8 kMaxColorTargetInfo        = 4;
         static constexpr uint8 kMaxUniformBuffersPerStage = 4;
@@ -74,9 +76,6 @@ namespace Juliet
         void (*DrawIndexedPrimitives)(NonNullPtr<CommandList> commandList, uint32 numIndices, uint32 numInstances,
                                       uint32 firstIndex, uint32 vertexOffset, uint32 firstInstance);
 
-
-
-
         void (*SetPushConstants)(NonNullPtr<CommandList> commandList, ShaderStage stage, uint32 rootParameterIndex,
                                  uint32 numConstants, const void* constants);
 
@@ -108,10 +107,10 @@ namespace Juliet
 
         void* (*MapGraphicsTransferBuffer)(NonNullPtr<GPUDriver> driver, NonNullPtr<GraphicsTransferBuffer> buffer);
         void (*UnmapGraphicsTransferBuffer)(NonNullPtr<GPUDriver> driver, NonNullPtr<GraphicsTransferBuffer> buffer);
-         void (*CopyBuffer)(NonNullPtr<CommandList> commandList, NonNullPtr<GraphicsBuffer> dst,
+        void (*CopyBuffer)(NonNullPtr<CommandList> commandList, NonNullPtr<GraphicsBuffer> dst,
-                            NonNullPtr<GraphicsTransferBuffer> src, size_t size, size_t dstOffset, size_t srcOffset);
+                           NonNullPtr<GraphicsTransferBuffer> src, size_t size, size_t dstOffset, size_t srcOffset);
-         void (*CopyBufferToTexture)(NonNullPtr<CommandList> commandList, NonNullPtr<Texture> dst,
+        void (*CopyBufferToTexture)(NonNullPtr<CommandList> commandList, NonNullPtr<Texture> dst,
-                                     NonNullPtr<GraphicsTransferBuffer> src); // Assume full copy for now
+                                    NonNullPtr<GraphicsTransferBuffer> src); // Assume full copy for now
 
         void (*TransitionBufferToReadable)(NonNullPtr<CommandList> commandList, NonNullPtr<GraphicsBuffer> buffer);
         uint32 (*GetDescriptorIndex)(NonNullPtr<GraphicsDevice> device, NonNullPtr<GraphicsBuffer> buffer);