From 76848ab4e38e9f7baec8adbbdef74eed5aa24ee9 Mon Sep 17 00:00:00 2001 From: Patedam Date: Sat, 29 Mar 2025 22:05:09 -0400 Subject: [PATCH] Move heap descriptor into its own file and prepare for the removing of the staging descriptor --- Juliet/Juliet.vcxproj | 2 + .../src/Graphics/D3D12/D3D12CommandList.cpp | 69 +------ Juliet/src/Graphics/D3D12/D3D12CommandList.h | 4 +- Juliet/src/Graphics/D3D12/D3D12Common.cpp | 172 ++++++------------ Juliet/src/Graphics/D3D12/D3D12Common.h | 31 +--- .../Graphics/D3D12/D3D12DescriptorHeap.cpp | 119 ++++++++++++ .../src/Graphics/D3D12/D3D12DescriptorHeap.h | 41 +++++ .../Graphics/D3D12/D3D12GraphicsDevice.cpp | 8 +- .../src/Graphics/D3D12/D3D12GraphicsDevice.h | 8 +- 9 files changed, 239 insertions(+), 215 deletions(-) create mode 100644 Juliet/src/Graphics/D3D12/D3D12DescriptorHeap.cpp create mode 100644 Juliet/src/Graphics/D3D12/D3D12DescriptorHeap.h diff --git a/Juliet/Juliet.vcxproj b/Juliet/Juliet.vcxproj index 0e0dd34..9189651 100644 --- a/Juliet/Juliet.vcxproj +++ b/Juliet/Juliet.vcxproj @@ -187,6 +187,7 @@ + @@ -231,6 +232,7 @@ + diff --git a/Juliet/src/Graphics/D3D12/D3D12CommandList.cpp b/Juliet/src/Graphics/D3D12/D3D12CommandList.cpp index c6ff77e..c48ed5f 100644 --- a/Juliet/src/Graphics/D3D12/D3D12CommandList.cpp +++ b/Juliet/src/Graphics/D3D12/D3D12CommandList.cpp @@ -368,79 +368,14 @@ namespace Juliet::D3D12 namespace Internal { - namespace - { - D3D12DescriptorHeap* AcquireDescriptorHeapFromPool(NonNullPtr commandList, D3D12_DESCRIPTOR_HEAP_TYPE type) - { - D3D12Driver* d3d12Driver = commandList->Driver; - - D3D12DescriptorHeapPool* pool = nullptr; - uint32 count = 0; - if (type == D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV) - { - pool = &d3d12Driver->CRB_SRV_UAV_HeapPool; - count = GPUDriver::kCBV_SRV_UAV_HeapDescriptorCount; - } - else if (type == D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER) - { - pool = &d3d12Driver->RTV_HeapPool; - count = GPUDriver::kSampler_HeapDescriptorCount; - } - Assert(pool != nullptr); - - D3D12DescriptorHeap* result = nullptr; - if (pool->Count > 0) - { - result = pool->Heaps[pool->Count - 1]; - pool->Count -= 1; - } - else - { - result = CreateDescriptorHeap(d3d12Driver, type, count, false); - } - - return result; - } - - void ReturnDescriptorHeapToPool(NonNullPtr d3d12Driver, D3D12DescriptorHeap* heap) - { - if (heap == nullptr) - { - return; - } - - D3D12DescriptorHeapPool* pool = nullptr; - if (heap->HeapType == D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV) - { - pool = &d3d12Driver->CRB_SRV_UAV_HeapPool; - } - else if (heap->HeapType == D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER) - { - pool = &d3d12Driver->RTV_HeapPool; - } - Assert(pool != nullptr); - heap->CurrentDescriptorIndex = 0; - - if (pool->Count >= pool->Capacity) - { - pool->Capacity *= 2; - pool->Heaps = - static_cast(Realloc(pool->Heaps, pool->Capacity * sizeof(D3D12DescriptorHeap*))); - } - - pool->Heaps[pool->Count] = heap; - pool->Count += 1; - } - } // namespace - void SetDescriptorHeaps(NonNullPtr commandList) { ID3D12DescriptorHeap* heaps[2]; D3D12DescriptorHeap* viewHeap = nullptr; D3D12DescriptorHeap* samplerHeap = nullptr; - viewHeap = AcquireDescriptorHeapFromPool(commandList, D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV); - samplerHeap = AcquireDescriptorHeapFromPool(commandList, D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER); + viewHeap = AcquireDescriptorHeapFromPool(commandList->Driver, D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV); + samplerHeap = AcquireDescriptorHeapFromPool(commandList->Driver, D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER); commandList->CRB_SRV_UAV_Heap = viewHeap; commandList->RTV_Heap = samplerHeap; diff --git a/Juliet/src/Graphics/D3D12/D3D12CommandList.h b/Juliet/src/Graphics/D3D12/D3D12CommandList.h index 6705ba7..a4d665b 100644 --- a/Juliet/src/Graphics/D3D12/D3D12CommandList.h +++ b/Juliet/src/Graphics/D3D12/D3D12CommandList.h @@ -75,8 +75,8 @@ namespace Juliet::D3D12 // D3D12UniformBuffer *vertexUniformBuffers[GPUDriver::kMaxUniformBuffersPerStage]; // D3D12UniformBuffer *fragmentUniformBuffers[GPUDriver::kMaxUniformBuffersPerStage]; - D3D12DescriptorHeap* CRB_SRV_UAV_Heap; - D3D12DescriptorHeap* RTV_Heap; + Internal::D3D12DescriptorHeap* CRB_SRV_UAV_Heap; + Internal::D3D12DescriptorHeap* RTV_Heap; // Resource Tracking D3D12Texture** UsedTextures; diff --git a/Juliet/src/Graphics/D3D12/D3D12Common.cpp b/Juliet/src/Graphics/D3D12/D3D12Common.cpp index 8f31c02..2500ec6 100644 --- a/Juliet/src/Graphics/D3D12/D3D12Common.cpp +++ b/Juliet/src/Graphics/D3D12/D3D12Common.cpp @@ -8,7 +8,7 @@ #include #include -namespace Juliet::D3D12 +namespace Juliet::D3D12::Internal { namespace { @@ -49,126 +49,72 @@ namespace Juliet::D3D12 } } // namespace - namespace Internal + D3D12StagingDescriptorPool* CreateStagingDescriptorPool(NonNullPtr driver, D3D12_DESCRIPTOR_HEAP_TYPE type) { - D3D12DescriptorHeap* CreateDescriptorHeap(NonNullPtr driver, D3D12_DESCRIPTOR_HEAP_TYPE type, - uint32 count, bool isStaging) + D3D12DescriptorHeap* heap = CreateDescriptorHeap(driver, type, kStagingHeapDescriptorExpectedCount, true); + if (!heap) { - ID3D12DescriptorHeap* handle; - - auto heap = static_cast(Calloc(1, sizeof(D3D12DescriptorHeap))); - if (!heap) - { - return nullptr; - } - - heap->CurrentDescriptorIndex = 0; - - D3D12_DESCRIPTOR_HEAP_DESC heapDesc; - heapDesc.NumDescriptors = count; - heapDesc.Type = type; - heapDesc.Flags = isStaging ? D3D12_DESCRIPTOR_HEAP_FLAG_NONE : D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE; - heapDesc.NodeMask = 0; - - HRESULT result = - ID3D12Device_CreateDescriptorHeap(driver->D3D12Device, &heapDesc, IID_ID3D12DescriptorHeap, (void**)&handle); - if (FAILED(result)) - { - LogError(driver->D3D12Device, "Failed to create descriptor heap!", result); - DestroyDescriptorHeap(heap); - return nullptr; - } - - heap->Handle = handle; - heap->HeapType = type; - heap->MaxDescriptors = count; - heap->Staging = isStaging; - heap->DescriptorSize = ID3D12Device_GetDescriptorHandleIncrementSize(driver->D3D12Device, type); - ID3D12DescriptorHeap_GetCPUDescriptorHandleForHeapStart(handle, &heap->DescriptorHeapCPUStart); - if (!isStaging) - { - ID3D12DescriptorHeap_GetGPUDescriptorHandleForHeapStart(handle, &heap->DescriptorHeapGPUStart); - } - - return heap; + return nullptr; } - void DestroyDescriptorHeap(NonNullPtr heap) + auto pool = static_cast(Calloc(1, sizeof(D3D12StagingDescriptorPool))); + + // First create the heaps + pool->HeapCount = 1; + pool->Heaps = static_cast(Malloc(sizeof(D3D12DescriptorHeap*))); + pool->Heaps[0] = heap; + + pool->FreeDescriptorCapacity = kStagingHeapDescriptorExpectedCount; + pool->FreeDescriptorCount = kStagingHeapDescriptorExpectedCount; + pool->FreeDescriptors = + static_cast(Malloc(kStagingHeapDescriptorExpectedCount * sizeof(D3D12StagingDescriptor))); + + InitStagingDescriptorPool(heap, pool); + + return pool; + } + + bool AssignStagingDescriptor(NonNullPtr driver, D3D12_DESCRIPTOR_HEAP_TYPE type, D3D12StagingDescriptor& outDescriptor) + { + // TODO: Make it thread safe + D3D12StagingDescriptor* descriptor = nullptr; + D3D12StagingDescriptorPool* pool = driver->StagingDescriptorPools[type]; + + if (pool->FreeDescriptorCount == 0) { - if (heap->Handle) + if (!ExtendStagingDescriptorPool(driver, *pool)) { - ID3D12DescriptorHeap_Release(heap->Handle); - } - Free(heap.Get()); - } - - D3D12StagingDescriptorPool* CreateStagingDescriptorPool(NonNullPtr driver, D3D12_DESCRIPTOR_HEAP_TYPE type) - { - D3D12DescriptorHeap* heap = CreateDescriptorHeap(driver, type, kStagingHeapDescriptorExpectedCount, true); - if (!heap) - { - return nullptr; - } - - auto pool = static_cast(Calloc(1, sizeof(D3D12StagingDescriptorPool))); - - // First create the heaps - pool->HeapCount = 1; - pool->Heaps = static_cast(Malloc(sizeof(D3D12DescriptorHeap*))); - pool->Heaps[0] = heap; - - pool->FreeDescriptorCapacity = kStagingHeapDescriptorExpectedCount; - pool->FreeDescriptorCount = kStagingHeapDescriptorExpectedCount; - pool->FreeDescriptors = static_cast( - Malloc(kStagingHeapDescriptorExpectedCount * sizeof(D3D12StagingDescriptor))); - - InitStagingDescriptorPool(heap, pool); - - return pool; - } - - bool AssignStagingDescriptor(NonNullPtr driver, D3D12_DESCRIPTOR_HEAP_TYPE type, D3D12StagingDescriptor& outDescriptor) - { - // TODO: Make it thread safe - D3D12StagingDescriptor* descriptor = nullptr; - D3D12StagingDescriptorPool* pool = driver->StagingDescriptorPools[type]; - - if (pool->FreeDescriptorCount == 0) - { - if (!ExtendStagingDescriptorPool(driver, *pool)) - { - return false; - } - } - - descriptor = &pool->FreeDescriptors[pool->FreeDescriptorCount - 1]; - MemCopy(&outDescriptor, descriptor, sizeof(D3D12StagingDescriptor)); - pool->FreeDescriptorCount -= 1; - - return true; - } - - void ReleaseStagingDescriptor(NonNullPtr driver, D3D12StagingDescriptor& cpuDescriptor) - { - D3D12StagingDescriptorPool* pool = cpuDescriptor.Pool; - - if (pool != nullptr) - { - MemCopy(&pool->FreeDescriptors[pool->FreeDescriptorCount], &cpuDescriptor, sizeof(D3D12StagingDescriptor)); - pool->FreeDescriptorCount += 1; + return false; } } - void DestroyStagingDescriptorPool(NonNullPtr pool) - { - for (uint32 i = 0; i < pool->HeapCount; i += 1) - { - DestroyDescriptorHeap(pool->Heaps[i]); - } + descriptor = &pool->FreeDescriptors[pool->FreeDescriptorCount - 1]; + MemCopy(&outDescriptor, descriptor, sizeof(D3D12StagingDescriptor)); + pool->FreeDescriptorCount -= 1; - Free(pool->Heaps); - Free(pool->FreeDescriptors); - Free(pool.Get()); + return true; + } + + void ReleaseStagingDescriptor(NonNullPtr driver, D3D12StagingDescriptor& cpuDescriptor) + { + D3D12StagingDescriptorPool* pool = cpuDescriptor.Pool; + + if (pool != nullptr) + { + MemCopy(&pool->FreeDescriptors[pool->FreeDescriptorCount], &cpuDescriptor, sizeof(D3D12StagingDescriptor)); + pool->FreeDescriptorCount += 1; } - } // namespace Internal -} // namespace Juliet::D3D12 + } + + void DestroyStagingDescriptorPool(NonNullPtr pool) + { + for (uint32 i = 0; i < pool->HeapCount; i += 1) + { + DestroyDescriptorHeap(pool->Heaps[i]); + } + + Free(pool->Heaps); + Free(pool->FreeDescriptors); + Free(pool.Get()); + } +} // namespace Juliet::D3D12::Internal diff --git a/Juliet/src/Graphics/D3D12/D3D12Common.h b/Juliet/src/Graphics/D3D12/D3D12Common.h index 4584787..ff0f676 100644 --- a/Juliet/src/Graphics/D3D12/D3D12Common.h +++ b/Juliet/src/Graphics/D3D12/D3D12Common.h @@ -2,6 +2,7 @@ #include #include +#include #include // Definitions: @@ -19,29 +20,9 @@ namespace Juliet::D3D12 struct D3D12Driver; struct D3D12StagingDescriptor; - // https://learn.microsoft.com/en-us/windows/win32/direct3d12/descriptor-heaps - struct D3D12DescriptorHeap - { - ID3D12DescriptorHeap* Handle; - D3D12_DESCRIPTOR_HEAP_TYPE HeapType; - D3D12_CPU_DESCRIPTOR_HANDLE DescriptorHeapCPUStart; - D3D12_GPU_DESCRIPTOR_HANDLE DescriptorHeapGPUStart; // only used by GPU heaps - uint32 MaxDescriptors; - uint32 DescriptorSize; - uint32 CurrentDescriptorIndex; // only used by GPU heaps - bool Staging : 1; - }; - - struct D3D12DescriptorHeapPool - { - D3D12DescriptorHeap** Heaps; - size_t Capacity; - size_t Count; - }; - struct D3D12StagingDescriptorPool { - D3D12DescriptorHeap** Heaps; + Internal::D3D12DescriptorHeap** Heaps; uint32 HeapCount; // Descriptor handles are owned by resources, so these can be thought of as descriptions of a free index within a heap. @@ -53,18 +34,14 @@ namespace Juliet::D3D12 // https://learn.microsoft.com/en-us/windows/win32/direct3d12/descriptors-overview struct D3D12StagingDescriptor { - D3D12StagingDescriptorPool* Pool; - D3D12DescriptorHeap* Heap; + D3D12StagingDescriptorPool* Pool; + Internal::D3D12DescriptorHeap* Heap; D3D12_CPU_DESCRIPTOR_HANDLE CpuHandle; uint32 CpuHandleIndex; }; namespace Internal { - extern D3D12DescriptorHeap* CreateDescriptorHeap(NonNullPtr driver, - D3D12_DESCRIPTOR_HEAP_TYPE type, uint32 count, bool isStaging); - extern void DestroyDescriptorHeap(NonNullPtr heap); - extern D3D12StagingDescriptorPool* CreateStagingDescriptorPool(NonNullPtr driver, D3D12_DESCRIPTOR_HEAP_TYPE type); extern bool AssignStagingDescriptor(NonNullPtr driver, D3D12_DESCRIPTOR_HEAP_TYPE type, D3D12StagingDescriptor& outDescriptor); diff --git a/Juliet/src/Graphics/D3D12/D3D12DescriptorHeap.cpp b/Juliet/src/Graphics/D3D12/D3D12DescriptorHeap.cpp new file mode 100644 index 0000000..a2cdadd --- /dev/null +++ b/Juliet/src/Graphics/D3D12/D3D12DescriptorHeap.cpp @@ -0,0 +1,119 @@ +#include + +#include +#include +#include +#include + +namespace Juliet::D3D12::Internal +{ + D3D12DescriptorHeap* CreateDescriptorHeap(NonNullPtr driver, D3D12_DESCRIPTOR_HEAP_TYPE type, uint32 count, bool isStaging) + { + ID3D12DescriptorHeap* handle; + + auto heap = static_cast(Calloc(1, sizeof(D3D12DescriptorHeap))); + if (!heap) + { + return nullptr; + } + + heap->CurrentDescriptorIndex = 0; + + D3D12_DESCRIPTOR_HEAP_DESC heapDesc; + heapDesc.NumDescriptors = count; + heapDesc.Type = type; + heapDesc.Flags = isStaging ? D3D12_DESCRIPTOR_HEAP_FLAG_NONE : D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE; + heapDesc.NodeMask = 0; + + HRESULT result = + ID3D12Device_CreateDescriptorHeap(driver->D3D12Device, &heapDesc, IID_ID3D12DescriptorHeap, (void**)&handle); + if (FAILED(result)) + { + LogError(driver->D3D12Device, "Failed to create descriptor heap!", result); + DestroyDescriptorHeap(heap); + return nullptr; + } + + heap->Handle = handle; + heap->HeapType = type; + heap->MaxDescriptors = count; + heap->Staging = isStaging; + heap->DescriptorSize = ID3D12Device_GetDescriptorHandleIncrementSize(driver->D3D12Device, type); + ID3D12DescriptorHeap_GetCPUDescriptorHandleForHeapStart(handle, &heap->DescriptorHeapCPUStart); + if (!isStaging) + { + ID3D12DescriptorHeap_GetGPUDescriptorHandleForHeapStart(handle, &heap->DescriptorHeapGPUStart); + } + + return heap; + } + + void DestroyDescriptorHeap(NonNullPtr heap) + { + if (heap->Handle) + { + ID3D12DescriptorHeap_Release(heap->Handle); + } + Free(heap.Get()); + } + + D3D12DescriptorHeap* AcquireDescriptorHeapFromPool(NonNullPtr d3d12Driver, D3D12_DESCRIPTOR_HEAP_TYPE type) + { + D3D12DescriptorHeapPool* pool = nullptr; + uint32 count = 0; + if (type == D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV) + { + pool = &d3d12Driver->CRB_SRV_UAV_HeapPool; + count = GPUDriver::kCBV_SRV_UAV_HeapDescriptorCount; + } + else if (type == D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER) + { + pool = &d3d12Driver->RTV_HeapPool; + count = GPUDriver::kSampler_HeapDescriptorCount; + } + Assert(pool != nullptr); + + D3D12DescriptorHeap* result = nullptr; + if (pool->Count > 0) + { + result = pool->Heaps[pool->Count - 1]; + pool->Count -= 1; + } + else + { + result = CreateDescriptorHeap(d3d12Driver, type, count, false); + } + + return result; + } + + void ReturnDescriptorHeapToPool(NonNullPtr d3d12Driver, D3D12DescriptorHeap* heap) + { + if (heap == nullptr) + { + return; + } + + D3D12DescriptorHeapPool* pool = nullptr; + if (heap->HeapType == D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV) + { + pool = &d3d12Driver->CRB_SRV_UAV_HeapPool; + } + else if (heap->HeapType == D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER) + { + pool = &d3d12Driver->RTV_HeapPool; + } + Assert(pool != nullptr); + heap->CurrentDescriptorIndex = 0; + + if (pool->Count >= pool->Capacity) + { + pool->Capacity *= 2; + pool->Heaps = + static_cast(Realloc(pool->Heaps, pool->Capacity * sizeof(D3D12DescriptorHeap*))); + } + + pool->Heaps[pool->Count] = heap; + pool->Count += 1; + } +} // namespace Juliet::D3D12::Internal diff --git a/Juliet/src/Graphics/D3D12/D3D12DescriptorHeap.h b/Juliet/src/Graphics/D3D12/D3D12DescriptorHeap.h new file mode 100644 index 0000000..c43b6c6 --- /dev/null +++ b/Juliet/src/Graphics/D3D12/D3D12DescriptorHeap.h @@ -0,0 +1,41 @@ +#pragma once + +#include +#include + +// Forward declare +namespace Juliet::D3D12 +{ + struct D3D12Driver; +} + +namespace Juliet::D3D12::Internal +{ + // https://learn.microsoft.com/en-us/windows/win32/direct3d12/descriptor-heaps + struct D3D12DescriptorHeap + { + ID3D12DescriptorHeap* Handle; + D3D12_DESCRIPTOR_HEAP_TYPE HeapType; + D3D12_CPU_DESCRIPTOR_HANDLE DescriptorHeapCPUStart; + D3D12_GPU_DESCRIPTOR_HANDLE DescriptorHeapGPUStart; // only used by GPU heaps + uint32 MaxDescriptors; + uint32 DescriptorSize; + uint32 CurrentDescriptorIndex; // only used by GPU heaps + bool Staging : 1; + }; + + struct D3D12DescriptorHeapPool + { + D3D12DescriptorHeap** Heaps; + size_t Capacity; + size_t Count; + }; + + extern D3D12DescriptorHeap* CreateDescriptorHeap(NonNullPtr driver, + D3D12_DESCRIPTOR_HEAP_TYPE type, uint32 count, bool isStaging); + extern void DestroyDescriptorHeap(NonNullPtr heap); + + extern D3D12DescriptorHeap* AcquireDescriptorHeapFromPool(NonNullPtr commandList, + D3D12_DESCRIPTOR_HEAP_TYPE type); + extern void ReturnDescriptorHeapToPool(NonNullPtr d3d12Driver, D3D12DescriptorHeap* heap); +} // namespace Juliet::D3D12 diff --git a/Juliet/src/Graphics/D3D12/D3D12GraphicsDevice.cpp b/Juliet/src/Graphics/D3D12/D3D12GraphicsDevice.cpp index 02c88e5..3f47ea6 100644 --- a/Juliet/src/Graphics/D3D12/D3D12GraphicsDevice.cpp +++ b/Juliet/src/Graphics/D3D12/D3D12GraphicsDevice.cpp @@ -4,6 +4,7 @@ #include #include #include +#include #include #include #include @@ -471,7 +472,7 @@ namespace Juliet::D3D12 } } - auto DestroyDescriptorHeapPool = [](D3D12DescriptorHeapPool& heapPool) + auto DestroyDescriptorHeapPool = [](Internal::D3D12DescriptorHeapPool& heapPool) { if (heapPool.Heaps) { @@ -914,11 +915,12 @@ namespace Juliet::D3D12 } // Other Descriptor pools - auto CreateDescriptorPool = [&](D3D12DescriptorHeapPool& heapPool, D3D12_DESCRIPTOR_HEAP_TYPE type, uint32 count) -> bool + auto CreateDescriptorPool = [&](Internal::D3D12DescriptorHeapPool& heapPool, + D3D12_DESCRIPTOR_HEAP_TYPE type, uint32 count) -> bool { heapPool.Capacity = 4; heapPool.Count = 4; - heapPool.Heaps = static_cast(Calloc(heapPool.Capacity, sizeof(D3D12DescriptorHeap*))); + heapPool.Heaps = static_cast(Calloc(heapPool.Capacity, sizeof(Internal::D3D12DescriptorHeap*))); for (uint32 i = 0; i < heapPool.Capacity; ++i) { diff --git a/Juliet/src/Graphics/D3D12/D3D12GraphicsDevice.h b/Juliet/src/Graphics/D3D12/D3D12GraphicsDevice.h index a41ef52..124542d 100644 --- a/Juliet/src/Graphics/D3D12/D3D12GraphicsDevice.h +++ b/Juliet/src/Graphics/D3D12/D3D12GraphicsDevice.h @@ -2,6 +2,7 @@ #include #include +#include #include #include #include @@ -13,6 +14,7 @@ namespace Juliet namespace Juliet::D3D12 { + struct D3D12StagingDescriptorPool; // Forward Declare struct D3D12CommandList; struct D3D12Fence; @@ -93,9 +95,9 @@ namespace Juliet::D3D12 D3D12GraphicsRootSignature* BindlessRootSignature; - D3D12StagingDescriptorPool* StagingDescriptorPools[D3D12_DESCRIPTOR_HEAP_TYPE_NUM_TYPES]; - D3D12DescriptorHeapPool CRB_SRV_UAV_HeapPool; - D3D12DescriptorHeapPool RTV_HeapPool; + D3D12StagingDescriptorPool* StagingDescriptorPools[D3D12_DESCRIPTOR_HEAP_TYPE_NUM_TYPES]; + Internal::D3D12DescriptorHeapPool CRB_SRV_UAV_HeapPool; + Internal::D3D12DescriptorHeapPool RTV_HeapPool; String Semantic;