From af259e24ef63899078a2fcfcbbafb543fcb77a87 Mon Sep 17 00:00:00 2001 From: baldurk Date: Fri, 16 Sep 2016 13:47:58 +0200 Subject: [PATCH] Serialise CreateHeap and CreatePlacedResource --- renderdoc/driver/d3d12/d3d12_common.cpp | 11 ++ renderdoc/driver/d3d12/d3d12_common.h | 4 + renderdoc/driver/d3d12/d3d12_device.cpp | 4 + renderdoc/driver/d3d12/d3d12_device_wrap.cpp | 169 ++++++++++++++++++- 4 files changed, 183 insertions(+), 5 deletions(-) diff --git a/renderdoc/driver/d3d12/d3d12_common.cpp b/renderdoc/driver/d3d12/d3d12_common.cpp index 1f9eb6ac3..8823bc15e 100644 --- a/renderdoc/driver/d3d12/d3d12_common.cpp +++ b/renderdoc/driver/d3d12/d3d12_common.cpp @@ -825,6 +825,17 @@ void Serialiser::Serialise(const char *name, D3D12_HEAP_PROPERTIES &el) Serialise("VisibleNodeMask", el.VisibleNodeMask); } +template <> +void Serialiser::Serialise(const char *name, D3D12_HEAP_DESC &el) +{ + ScopedContext scope(this, name, "D3D12_HEAP_DESC", 0, true); + + Serialise("SizeInBytes", el.SizeInBytes); + Serialise("Properties", el.Properties); + Serialise("Alignment", el.Alignment); + Serialise("Flags", el.Flags); +} + template <> void Serialiser::Serialise(const char *name, D3D12_DESCRIPTOR_HEAP_DESC &el) { diff --git a/renderdoc/driver/d3d12/d3d12_common.h b/renderdoc/driver/d3d12/d3d12_common.h index 1302ac2e2..0a957cfca 100644 --- a/renderdoc/driver/d3d12/d3d12_common.h +++ b/renderdoc/driver/d3d12/d3d12_common.h @@ -177,6 +177,8 @@ void Serialiser::Serialise(const char *name, D3D12_RESOURCE_BARRIER &el); template <> void Serialiser::Serialise(const char *name, D3D12_HEAP_PROPERTIES &el); template <> +void Serialiser::Serialise(const char *name, D3D12_HEAP_DESC &el); +template <> void Serialiser::Serialise(const char *name, D3D12_DESCRIPTOR_HEAP_DESC &el); template <> void Serialiser::Serialise(const char *name, D3D12_SAMPLER_DESC &el); @@ -227,7 +229,9 @@ void Serialiser::Serialise(const char *name, D3D12Descriptor &el); D3D12_CHUNK_MACRO(CREATE_DESCRIPTOR_HEAP, "ID3D12Device::CreateDescriptorHeap") \ D3D12_CHUNK_MACRO(CREATE_ROOT_SIG, "ID3D12Device::CreateRootSignature") \ \ + D3D12_CHUNK_MACRO(CREATE_HEAP, "ID3D12Device::CreateHrap") \ D3D12_CHUNK_MACRO(CREATE_COMMITTED_RESOURCE, "ID3D12Device::CreateCommittedResource") \ + D3D12_CHUNK_MACRO(CREATE_PLACED_RESOURCE, "ID3D12Device::CreatePlacedResource") \ \ D3D12_CHUNK_MACRO(CREATE_FENCE, "ID3D12Device::CreateFence") \ \ diff --git a/renderdoc/driver/d3d12/d3d12_device.cpp b/renderdoc/driver/d3d12/d3d12_device.cpp index 3592532fe..e28ba8086 100644 --- a/renderdoc/driver/d3d12/d3d12_device.cpp +++ b/renderdoc/driver/d3d12/d3d12_device.cpp @@ -1605,10 +1605,14 @@ void WrappedID3D12Device::ProcessChunk(uint64_t offset, D3D12ChunkType context) case CREATE_DESCRIPTOR_HEAP: Serialise_CreateDescriptorHeap(NULL, IID(), NULL); break; case CREATE_ROOT_SIG: Serialise_CreateRootSignature(0, NULL, 0, IID(), NULL); break; + case CREATE_HEAP: Serialise_CreateHeap(NULL, IID(), NULL); break; case CREATE_COMMITTED_RESOURCE: Serialise_CreateCommittedResource(NULL, D3D12_HEAP_FLAG_NONE, NULL, D3D12_RESOURCE_STATE_COMMON, NULL, IID(), NULL); break; + case CREATE_PLACED_RESOURCE: + Serialise_CreatePlacedResource(NULL, 0, NULL, D3D12_RESOURCE_STATE_COMMON, NULL, IID(), NULL); + break; case CREATE_FENCE: Serialise_CreateFence(0, D3D12_FENCE_FLAG_NONE, IID(), NULL); break; diff --git a/renderdoc/driver/d3d12/d3d12_device_wrap.cpp b/renderdoc/driver/d3d12/d3d12_device_wrap.cpp index 07ece379b..b7846b173 100644 --- a/renderdoc/driver/d3d12/d3d12_device_wrap.cpp +++ b/renderdoc/driver/d3d12/d3d12_device_wrap.cpp @@ -723,10 +723,115 @@ HRESULT WrappedID3D12Device::CreateCommittedResource(const D3D12_HEAP_PROPERTIES return ret; } +bool WrappedID3D12Device::Serialise_CreateHeap(const D3D12_HEAP_DESC *pDesc, REFIID riid, + void **ppvHeap) +{ + SERIALISE_ELEMENT(D3D12_HEAP_DESC, desc, *pDesc); + SERIALISE_ELEMENT(IID, guid, riid); + SERIALISE_ELEMENT(ResourceId, Res, ((WrappedID3D12Heap *)*ppvHeap)->GetResourceID()); + + if(m_State == READING) + { + ID3D12Heap *ret = NULL; + HRESULT hr = m_pDevice->CreateHeap(&desc, guid, (void **)&ret); + + if(FAILED(hr)) + { + RDCERR("Failed on resource serialise-creation, HRESULT: 0x%08x", hr); + } + else + { + ret = new WrappedID3D12Heap(ret, this); + + GetResourceManager()->AddLiveResource(Res, ret); + } + } + + return true; +} + HRESULT WrappedID3D12Device::CreateHeap(const D3D12_HEAP_DESC *pDesc, REFIID riid, void **ppvHeap) { - D3D12NOTIMP(__PRETTY_FUNCTION_SIGNATURE__); - return m_pDevice->CreateHeap(pDesc, riid, ppvHeap); + if(ppvHeap == NULL) + return m_pDevice->CreateHeap(pDesc, riid, ppvHeap); + + if(riid != __uuidof(ID3D12Heap)) + return E_NOINTERFACE; + + ID3D12Heap *real = NULL; + HRESULT ret = m_pDevice->CreateHeap(pDesc, riid, (void **)&real); + + if(SUCCEEDED(ret)) + { + SCOPED_LOCK(m_D3DLock); + + WrappedID3D12Heap *wrapped = new WrappedID3D12Heap(real, this); + + if(m_State >= WRITING) + { + SCOPED_SERIALISE_CONTEXT(CREATE_HEAP); + Serialise_CreateHeap(pDesc, riid, (void **)&wrapped); + + D3D12ResourceRecord *record = GetResourceManager()->AddResourceRecord(wrapped->GetResourceID()); + record->type = Resource_Heap; + record->Length = 0; + wrapped->SetResourceRecord(record); + + record->AddChunk(scope.Get()); + } + else + { + GetResourceManager()->AddLiveResource(wrapped->GetResourceID(), wrapped); + } + + *ppvHeap = (ID3D12Heap *)wrapped; + } + + return ret; +} + +bool WrappedID3D12Device::Serialise_CreatePlacedResource(ID3D12Heap *pHeap, UINT64 HeapOffset, + const D3D12_RESOURCE_DESC *pDesc, + D3D12_RESOURCE_STATES InitialState, + const D3D12_CLEAR_VALUE *pOptimizedClearValue, + REFIID riid, void **ppvResource) +{ + SERIALISE_ELEMENT(ResourceId, Heap, GetResID(pHeap)); + SERIALISE_ELEMENT(UINT64, Offset, HeapOffset); + SERIALISE_ELEMENT(D3D12_RESOURCE_DESC, desc, *pDesc); + SERIALISE_ELEMENT(D3D12_RESOURCE_STATES, state, InitialState); + + SERIALISE_ELEMENT(bool, HasClearValue, pOptimizedClearValue != NULL); + SERIALISE_ELEMENT_OPT(D3D12_CLEAR_VALUE, clearVal, *pOptimizedClearValue, HasClearValue); + + SERIALISE_ELEMENT(IID, guid, riid); + SERIALISE_ELEMENT(ResourceId, Res, ((WrappedID3D12Resource *)*ppvResource)->GetResourceID()); + + if(m_State == READING) + { + pHeap = GetResourceManager()->GetLiveAs(Heap); + pOptimizedClearValue = HasClearValue ? &clearVal : NULL; + + ID3D12Resource *ret = NULL; + HRESULT hr = m_pDevice->CreatePlacedResource(Unwrap(pHeap), Offset, &desc, state, + pOptimizedClearValue, guid, (void **)&ret); + + if(FAILED(hr)) + { + RDCERR("Failed on resource serialise-creation, HRESULT: 0x%08x", hr); + } + else + { + ret = new WrappedID3D12Resource(ret, this); + + GetResourceManager()->AddLiveResource(Res, ret); + + SubresourceStateVector &states = m_ResourceStates[GetResID(ret)]; + states.resize(GetNumSubresources(&desc), state); + } + } + + return true; } HRESULT WrappedID3D12Device::CreatePlacedResource(ID3D12Heap *pHeap, UINT64 HeapOffset, @@ -735,9 +840,63 @@ HRESULT WrappedID3D12Device::CreatePlacedResource(ID3D12Heap *pHeap, UINT64 Heap const D3D12_CLEAR_VALUE *pOptimizedClearValue, REFIID riid, void **ppvResource) { - D3D12NOTIMP(__PRETTY_FUNCTION_SIGNATURE__); - return m_pDevice->CreatePlacedResource(Unwrap(pHeap), HeapOffset, pDesc, InitialState, - pOptimizedClearValue, riid, ppvResource); + if(ppvResource == NULL) + return m_pDevice->CreatePlacedResource(Unwrap(pHeap), HeapOffset, pDesc, InitialState, + pOptimizedClearValue, riid, NULL); + + if(riid != __uuidof(ID3D12Resource)) + return E_NOINTERFACE; + + ID3D12Resource *real = NULL; + HRESULT ret = m_pDevice->CreatePlacedResource(Unwrap(pHeap), HeapOffset, pDesc, InitialState, + pOptimizedClearValue, riid, (void **)&real); + + if(SUCCEEDED(ret)) + { + SCOPED_LOCK(m_D3DLock); + + WrappedID3D12Resource *wrapped = new WrappedID3D12Resource(real, this); + + if(m_State >= WRITING) + { + SCOPED_SERIALISE_CONTEXT(CREATE_PLACED_RESOURCE); + Serialise_CreatePlacedResource(pHeap, HeapOffset, pDesc, InitialState, pOptimizedClearValue, + riid, (void **)&wrapped); + + D3D12ResourceRecord *record = GetResourceManager()->AddResourceRecord(wrapped->GetResourceID()); + record->type = Resource_Resource; + record->Length = 0; + wrapped->SetResourceRecord(record); + + RDCASSERT(pHeap); + + record->AddParent(GetRecord(pHeap)); + record->AddChunk(scope.Get()); + + { + SCOPED_LOCK(m_CapTransitionLock); + if(m_State != WRITING_CAPFRAME) + GetResourceManager()->MarkDirtyResource(wrapped->GetResourceID()); + else + GetResourceManager()->MarkPendingDirty(wrapped->GetResourceID()); + } + } + else + { + GetResourceManager()->AddLiveResource(wrapped->GetResourceID(), wrapped); + } + + { + SCOPED_LOCK(m_ResourceStatesLock); + SubresourceStateVector &states = m_ResourceStates[wrapped->GetResourceID()]; + + states.resize(GetNumSubresources(pDesc), InitialState); + } + + *ppvResource = (ID3D12Resource *)wrapped; + } + + return ret; } HRESULT WrappedID3D12Device::CreateReservedResource(const D3D12_RESOURCE_DESC *pDesc,