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<ID3D12Heap>(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;
}
bool WrappedID3D12Device::Serialise_CreateCommittedResource(
const D3D12_HEAP_PROPERTIES *pHeapProperties, D3D12_HEAP_FLAGS HeapFlags,
const D3D12_RESOURCE_DESC *pDesc, D3D12_RESOURCE_STATES InitialResourceState,
const D3D12_CLEAR_VALUE *pOptimizedClearValue, REFIID riidResource, void **ppvResource)
{
SERIALISE_ELEMENT(D3D12_HEAP_PROPERTIES, props, *pHeapProperties);
SERIALISE_ELEMENT(D3D12_HEAP_FLAGS, flags, HeapFlags);
SERIALISE_ELEMENT(D3D12_RESOURCE_DESC, desc, *pDesc);
SERIALISE_ELEMENT(D3D12_RESOURCE_STATES, state, InitialResourceState);
SERIALISE_ELEMENT(bool, HasClearValue, pOptimizedClearValue != NULL);
SERIALISE_ELEMENT_OPT(D3D12_CLEAR_VALUE, clearVal, *pOptimizedClearValue, HasClearValue);
SERIALISE_ELEMENT(IID, guid, riidResource);
SERIALISE_ELEMENT(ResourceId, Res, ((WrappedID3D12Resource *)*ppvResource)->GetResourceID());
if(m_State == READING)
{
pOptimizedClearValue = HasClearValue ? &clearVal : NULL;
ID3D12Resource *ret = NULL;
HRESULT hr = m_pDevice->CreateCommittedResource(&props, flags, &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,
const D3D12_RESOURCE_DESC *pDesc,
D3D12_RESOURCE_STATES InitialState,
const D3D12_CLEAR_VALUE *pOptimizedClearValue,
REFIID riid, void **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;
}
FetchTexture D3D12Replay::GetTexture(ResourceId id)
{
FetchTexture ret;
ret.ID = m_pDevice->GetResourceManager()->GetOriginalID(id);
auto it = WrappedID3D12Resource::m_List.find(id);
if(it == WrappedID3D12Resource::m_List.end())
return ret;
D3D12_RESOURCE_DESC desc = it->second->GetDesc();
ret.format = MakeResourceFormat(desc.Format);
ret.dimension = desc.Dimension - D3D12_RESOURCE_DIMENSION_BUFFER;
ret.width = (uint32_t)desc.Width;
ret.height = desc.Height;
ret.depth = desc.Dimension == D3D12_RESOURCE_DIMENSION_TEXTURE3D ? desc.DepthOrArraySize : 1;
ret.arraysize = desc.Dimension != D3D12_RESOURCE_DIMENSION_TEXTURE3D ? desc.DepthOrArraySize : 1;
ret.numSubresources = GetNumSubresources(&desc);
ret.mips = desc.MipLevels;
ret.msQual = desc.SampleDesc.Quality;
ret.msSamp = desc.SampleDesc.Count;
ret.byteSize = 0;
for(uint32_t i = 0; i < ret.mips; i++)
ret.byteSize += GetByteSize(ret.width, ret.height, ret.depth, desc.Format, i);
switch(ret.dimension)
{
case 1: ret.resType = ret.arraysize > 1 ? eResType_Texture1DArray : eResType_Texture1D; break;
case 2:
if(ret.msSamp > 1)
ret.resType = ret.arraysize > 1 ? eResType_Texture2DMSArray : eResType_Texture2DMS;
else
ret.resType = ret.arraysize > 1 ? eResType_Texture2DArray : eResType_Texture2D;
break;
case 3: ret.resType = eResType_Texture3D; break;
}
// TODO determine this from usage?
ret.cubemap = false; // eResType_TextureCube, eResType_TextureCubeArray
ret.creationFlags = eTextureCreate_SRV;
if(desc.Flags & D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET)
ret.creationFlags |= eTextureCreate_RTV;
if(desc.Flags & D3D12_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL)
ret.creationFlags |= eTextureCreate_DSV;
if(desc.Flags & D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS)
ret.creationFlags |= eTextureCreate_UAV;
if(ret.ID == m_pDevice->GetQueue()->GetBackbufferResourceID())
{
ret.format = MakeResourceFormat(GetTypedFormat(desc.Format, eCompType_UNorm));
ret.creationFlags |= eTextureCreate_SwapBuffer;
}
ret.customName = true;
string str = ""; // TODO GetName(it.second);
if(str == "")
{
const char *suffix = "";
const char *ms = "";
if(ret.msSamp > 1)
ms = "MS";
if(ret.creationFlags & eTextureCreate_RTV)
suffix = " RTV";
if(ret.creationFlags & eTextureCreate_DSV)
suffix = " DSV";
ret.customName = false;
if(ret.arraysize > 1)
str = StringFormat::Fmt("Texture%uD%sArray%s %llu", ret.dimension, ms, suffix, ret.ID);
else
str = StringFormat::Fmt("Texture%uD%s%s %llu", ret.dimension, ms, suffix, ret.ID);
}
ret.name = str;
return ret;
}
