From 0027ff1a106b9dd94e34b52ad5f8744d467d03aa Mon Sep 17 00:00:00 2001 From: baldurk Date: Thu, 28 Sep 2017 12:16:05 +0100 Subject: [PATCH] Change D3D11 device wrappers to new serialisation method --- renderdoc/driver/d3d11/d3d11_common.h | 2 + renderdoc/driver/d3d11/d3d11_device.h | 18 +- renderdoc/driver/d3d11/d3d11_device_wrap.cpp | 1190 +++++++++--------- renderdoc/driver/d3d11/d3d11_resources.h | 4 +- 4 files changed, 630 insertions(+), 584 deletions(-) diff --git a/renderdoc/driver/d3d11/d3d11_common.h b/renderdoc/driver/d3d11/d3d11_common.h index d3c9ba28e..57df69715 100644 --- a/renderdoc/driver/d3d11/d3d11_common.h +++ b/renderdoc/driver/d3d11/d3d11_common.h @@ -247,6 +247,8 @@ public: template \ bool CONCAT(Serialise_, func(SerialiserType &ser, __VA_ARGS__)); +#define USE_SCRATCH_SERIALISER() WriteSerialiser &ser = m_ScratchSerialiser; + // A handy macros to say "is the serialiser reading and we're doing replay-mode stuff?" // The reason we check both is that checking the first allows the compiler to eliminate the other // path at compile-time, and the second because we might be just struct-serialising in which case we diff --git a/renderdoc/driver/d3d11/d3d11_device.h b/renderdoc/driver/d3d11/d3d11_device.h index 3591c936f..1a91b0ce4 100644 --- a/renderdoc/driver/d3d11/d3d11_device.h +++ b/renderdoc/driver/d3d11/d3d11_device.h @@ -520,15 +520,15 @@ public: // this is defined as a macro so that we can re-use it to explicitly instantiate these functions as // templates in the wrapper definition file. -#define SERIALISED_ID3D11DEVICE_FAKE_FUNCTIONS() \ - IMPLEMENT_FUNCTION_SERIALISED(ID3D11ClassInstance *, CreateClassInstance, LPCSTR pClassTypeName, \ - UINT ConstantBufferOffset, UINT ConstantVectorOffset, \ - UINT TextureOffset, UINT SamplerOffset, \ - WrappedID3D11ClassLinkage *linkage, ID3D11ClassInstance *inst); \ - \ - IMPLEMENT_FUNCTION_SERIALISED(ID3D11ClassInstance *, GetClassInstance, \ - LPCSTR pClassInstanceName, UINT InstanceIndex, \ - WrappedID3D11ClassLinkage *linkage, ID3D11ClassInstance *inst); +#define SERIALISED_ID3D11DEVICE_FAKE_FUNCTIONS() \ + IMPLEMENT_FUNCTION_SERIALISED( \ + ID3D11ClassInstance *, CreateClassInstance, LPCSTR pClassTypeName, \ + UINT ConstantBufferOffset, UINT ConstantVectorOffset, UINT TextureOffset, \ + UINT SamplerOffset, ID3D11ClassLinkage *pClassLinkage, ID3D11ClassInstance **ppInstance); \ + \ + IMPLEMENT_FUNCTION_SERIALISED(ID3D11ClassInstance *, GetClassInstance, LPCSTR pClassInstanceName, \ + UINT InstanceIndex, ID3D11ClassLinkage *pClassLinkage, \ + ID3D11ClassInstance **ppInstance); SERIALISED_ID3D11DEVICE_FAKE_FUNCTIONS(); diff --git a/renderdoc/driver/d3d11/d3d11_device_wrap.cpp b/renderdoc/driver/d3d11/d3d11_device_wrap.cpp index a96230f55..1ff5da35b 100644 --- a/renderdoc/driver/d3d11/d3d11_device_wrap.cpp +++ b/renderdoc/driver/d3d11/d3d11_device_wrap.cpp @@ -27,32 +27,38 @@ #include "driver/d3d11/d3d11_context.h" #include "driver/d3d11/d3d11_resources.h" -bool WrappedID3D11Device::Serialise_CreateBuffer(const D3D11_BUFFER_DESC *pDesc, +template +bool WrappedID3D11Device::Serialise_CreateBuffer(SerialiserType &ser, const D3D11_BUFFER_DESC *pDesc, const D3D11_SUBRESOURCE_DATA *pInitialData, ID3D11Buffer **ppBuffer) { + SERIALISE_ELEMENT_LOCAL(Descriptor, *pDesc).Named("pDesc"); + SERIALISE_ELEMENT_LOCAL(pBuffer, GetIDForResource(*ppBuffer)); + + // unused, just for the sake of the user + SERIALISE_ELEMENT_LOCAL(HasInitialData, bool(pInitialData != NULL)); + if(HasInitialData) + { + SERIALISE_ELEMENT_LOCAL(SysMemPitch, pInitialData->SysMemPitch); + SERIALISE_ELEMENT_LOCAL(SysMemSlicePitch, pInitialData->SysMemSlicePitch); + } + D3D11_SUBRESOURCE_DATA fakeData; RDCEraseEl(fakeData); - - SERIALISE_ELEMENT_PTR(D3D11_BUFFER_DESC, Descriptor, pDesc); - if(pInitialData == NULL && m_State >= WRITING) + // we always want buffers to have data, so we create some to serialise + if(pInitialData == NULL && ser.IsWriting()) { - fakeData.pSysMem = new char[Descriptor.ByteWidth]; + fakeData.pSysMem = new byte[Descriptor.ByteWidth]; fakeData.SysMemPitch = fakeData.SysMemSlicePitch = Descriptor.ByteWidth; + // fill with 0xfefefefe to indicate that the data is uninitialised. memset((void *)fakeData.pSysMem, 0xfe, Descriptor.ByteWidth); pInitialData = &fakeData; } - // this is a bit of a hack, but to maintain backwards compatibility we have a - // separate function here that aligns the next serialised buffer to a 32-byte - // boundary in memory while writing (just skips the padding on read). - if(m_State >= WRITING || GetLogVersion() >= 0x000007) - m_pSerialiser->AlignNextBuffer(32); - // work around an nvidia driver bug, if a buffer is created as IMMUTABLE then it // can't be CopySubresourceRegion'd with a box offset, the data that's read is // wrong. - if(m_State < WRITING && Descriptor.Usage == D3D11_USAGE_IMMUTABLE) + if(IsReplayingAndReading() && Descriptor.Usage == D3D11_USAGE_IMMUTABLE) { Descriptor.Usage = D3D11_USAGE_DEFAULT; // paranoid - I don't know what requirements might change, so set some sane default @@ -60,18 +66,23 @@ bool WrappedID3D11Device::Serialise_CreateBuffer(const D3D11_BUFFER_DESC *pDesc, Descriptor.BindFlags = D3D11_BIND_VERTEX_BUFFER; } - SERIALISE_ELEMENT_BUF(byte *, InitialData, pInitialData->pSysMem, Descriptor.ByteWidth); + const void *InitialData = NULL; + uint64_t InitialDataLength = 0; - uint64_t offs = m_pSerialiser->GetOffset() - Descriptor.ByteWidth; - - RDCASSERT((offs % 16) == 0); - - SERIALISE_ELEMENT(uint32_t, MemPitch, pInitialData->SysMemPitch); - SERIALISE_ELEMENT(uint32_t, MemSlicePitch, pInitialData->SysMemSlicePitch); - SERIALISE_ELEMENT(ResourceId, pBuffer, GetIDForResource(*ppBuffer)); - - if(m_State >= WRITING) + if(ser.IsWriting()) { + InitialData = pInitialData->pSysMem; + InitialDataLength = Descriptor.ByteWidth; + } + + SERIALISE_ELEMENT_ARRAY(InitialData, InitialDataLength); + + if(ser.IsWriting()) + { + uint64_t offs = ser.GetWriter()->GetOffset() - InitialDataLength; + + RDCASSERT((offs % 64) == 0); + RDCASSERT(GetResourceManager()->GetResourceRecord(pBuffer) == NULL); D3D11ResourceRecord *record = GetResourceManager()->AddResourceRecord(pBuffer); @@ -80,7 +91,7 @@ bool WrappedID3D11Device::Serialise_CreateBuffer(const D3D11_BUFFER_DESC *pDesc, record->Length = Descriptor.ByteWidth; } - if(m_State == READING) + if(IsReplayingAndReading()) { ID3D11Buffer *ret; @@ -93,8 +104,8 @@ bool WrappedID3D11Device::Serialise_CreateBuffer(const D3D11_BUFFER_DESC *pDesc, D3D11_SUBRESOURCE_DATA data; data.pSysMem = InitialData; - data.SysMemPitch = MemPitch; - data.SysMemSlicePitch = MemSlicePitch; + data.SysMemPitch = Descriptor.ByteWidth; + data.SysMemSlicePitch = Descriptor.ByteWidth; hr = m_pDevice->CreateBuffer(&Descriptor, &data, &ret); if(FAILED(hr)) @@ -138,8 +149,6 @@ bool WrappedID3D11Device::Serialise_CreateBuffer(const D3D11_BUFFER_DESC *pDesc, eInitialContents_Copy, NULL)); } } - - SAFE_DELETE_ARRAY(InitialData); } char *arr = (char *)fakeData.pSysMem; @@ -166,13 +175,14 @@ HRESULT WrappedID3D11Device::CreateBuffer(const D3D11_BUFFER_DESC *pDesc, wrapped = new WrappedID3D11Buffer(real, pDesc ? pDesc->ByteWidth : 0, this); - if(m_State >= WRITING) + if(IsCaptureMode(m_State)) { Chunk *chunk = NULL; { - SCOPED_SERIALISE_CONTEXT(CREATE_BUFFER); - Serialise_CreateBuffer(pDesc, pInitialData, &wrapped); + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(D3D11Chunk::CreateBuffer); + Serialise_CreateBuffer(GET_SERIALISER, pDesc, pInitialData, &wrapped); chunk = scope.Get(); } @@ -196,9 +206,10 @@ HRESULT WrappedID3D11Device::CreateBuffer(const D3D11_BUFFER_DESC *pDesc, return ret; } -vector WrappedID3D11Device::Serialise_CreateTextureData( - ID3D11Resource *tex, ResourceId id, const D3D11_SUBRESOURCE_DATA *data, UINT w, UINT h, UINT d, - DXGI_FORMAT fmt, UINT mips, UINT arr, bool HasData) +template +std::vector WrappedID3D11Device::Serialise_CreateTextureData( + SerialiserType &ser, ID3D11Resource *tex, ResourceId id, const D3D11_SUBRESOURCE_DATA *data, + UINT w, UINT h, UINT d, DXGI_FORMAT fmt, UINT mips, UINT arr, bool HasData) { UINT numSubresources = mips; UINT numMips = mips; @@ -208,26 +219,28 @@ vector WrappedID3D11Device::Serialise_CreateTextureData( numSubresources *= arr; - vector descs; - if(m_State == READING && HasData) - { + std::vector descs; + if(IsReplayingAndReading() && HasData) descs.resize(numSubresources); - } + // scratch memory. Used to linearise & tightly pack incoming data for serialising, so that we know + // the data is in a fixed and predictable layout for byte *scratch = NULL; for(UINT i = 0; i < numSubresources; i++) { int mip = i % numMips; - UINT subresourceSize = GetByteSize(w, h, d, fmt, mip); + byte *SubresourceContents = NULL; + UINT SubresourceContentsLength = GetByteSize(w, h, d, fmt, mip); - RDCASSERT(subresourceSize > 0); + RDCASSERT(SubresourceContentsLength > 0); D3D11ResourceRecord *record = GetResourceManager()->GetResourceRecord(id); - if(m_State >= WRITING) + if(ser.IsWriting()) { + // on the first iteration, set up the resource record if(i == 0) { RDCASSERT(record == NULL); @@ -247,19 +260,23 @@ vector WrappedID3D11Device::Serialise_CreateTextureData( } } - RDCASSERT(record != NULL); + RDCASSERT(record); - record->SubResources[i]->Length = subresourceSize; + record->SubResources[i]->Length = SubresourceContentsLength; } + // skip the remaining if there's no data to serialise if(!HasData) continue; - if(scratch == NULL && m_State >= WRITING) - scratch = new byte[subresourceSize]; - - if(m_State >= WRITING) + // we linearise the data so that future functions know the format of the data in the record + if(ser.IsWriting()) { + // since we iterate from largest subresource down, we only need to allocate once - the rest of + // the subresources use progressively less of the allocation at a time + if(scratch == NULL) + scratch = new byte[SubresourceContentsLength]; + MapIntercept intercept; intercept.SetD3D(data[i]); @@ -276,51 +293,59 @@ vector WrappedID3D11Device::Serialise_CreateTextureData( RDCERR("Unexpected resource type!"); intercept.CopyFromD3D(); + + SubresourceContents = scratch; } - // this is a bit of a hack, but to maintain backwards compatibility we have a - // separate function here that aligns the next serialised buffer to a 32-byte - // boundary in memory while writing (just skips the padding on read). - if(m_State >= WRITING || GetLogVersion() >= 0x000007) - m_pSerialiser->AlignNextBuffer(32); + SERIALISE_ELEMENT_ARRAY(SubresourceContents, SubresourceContentsLength); - SERIALISE_ELEMENT_BUF(byte *, buf, scratch, subresourceSize); - - if(m_State >= WRITING) + if(ser.IsWriting()) { RDCASSERT(record); - record->SubResources[i]->SetDataOffset(m_pSerialiser->GetOffset() - subresourceSize); + record->SubResources[i]->SetDataOffset(ser.GetWriter()->GetOffset() - SubresourceContentsLength); } - if(m_State == READING) + if(IsReplayingAndReading()) { - descs[i].pSysMem = buf; + // we 'steal' the SubresourceContents buffer so it doesn't get de-serialised and free'd + descs[i].pSysMem = SubresourceContents; + SubresourceContents = NULL; + + // calculate tightly packed pitches descs[i].SysMemPitch = GetByteSize(w, 1, 1, fmt, mip); descs[i].SysMemSlicePitch = GetByteSize(w, h, 1, fmt, mip); } } - if(scratch) - SAFE_DELETE_ARRAY(scratch); + // delete our scratch memory + SAFE_DELETE_ARRAY(scratch); return descs; } -bool WrappedID3D11Device::Serialise_CreateTexture1D(const D3D11_TEXTURE1D_DESC *pDesc, +template +bool WrappedID3D11Device::Serialise_CreateTexture1D(SerialiserType &ser, + const D3D11_TEXTURE1D_DESC *pDesc, const D3D11_SUBRESOURCE_DATA *pInitialData, ID3D11Texture1D **ppTexture1D) { - SERIALISE_ELEMENT_PTR(D3D11_TEXTURE1D_DESC, Descriptor, pDesc); - SERIALISE_ELEMENT(ResourceId, pTexture, GetIDForResource(*ppTexture1D)); + SERIALISE_ELEMENT_LOCAL(Descriptor, *pDesc); + SERIALISE_ELEMENT_LOCAL(pTexture, GetIDForResource(*ppTexture1D)); - SERIALISE_ELEMENT(bool, HasInitialData, pInitialData != NULL); + SERIALISE_ELEMENT_LOCAL(HasInitialData, bool(pInitialData != NULL)); + // unused, just for the sake of the user + if(HasInitialData) + { + SERIALISE_ELEMENT_LOCAL(SysMemPitch, pInitialData->SysMemPitch); + SERIALISE_ELEMENT_LOCAL(SysMemSlicePitch, pInitialData->SysMemSlicePitch); + } - vector descs = Serialise_CreateTextureData( - ppTexture1D ? *ppTexture1D : NULL, pTexture, pInitialData, Descriptor.Width, 1, 1, + std::vector descs = Serialise_CreateTextureData( + ser, ppTexture1D ? *ppTexture1D : NULL, pTexture, pInitialData, Descriptor.Width, 1, 1, Descriptor.Format, Descriptor.MipLevels, Descriptor.ArraySize, HasInitialData); - if(m_State == READING) + if(IsReplayingAndReading()) { ID3D11Texture1D *ret; HRESULT hr = S_OK; @@ -347,10 +372,11 @@ bool WrappedID3D11Device::Serialise_CreateTexture1D(const D3D11_TEXTURE1D_DESC * GetResourceManager()->AddLiveResource(pTexture, ret); } - } - for(size_t i = 0; i < descs.size(); i++) - SAFE_DELETE_ARRAY(descs[i].pSysMem); + // free the serialised buffers we stole in Serialise_CreateTextureData + for(size_t i = 0; i < descs.size(); i++) + FreeAlignedBuffer((byte *)descs[i].pSysMem); + } return true; } @@ -373,13 +399,14 @@ HRESULT WrappedID3D11Device::CreateTexture1D(const D3D11_TEXTURE1D_DESC *pDesc, wrapped = new WrappedID3D11Texture1D(real, this); - if(m_State >= WRITING) + if(IsCaptureMode(m_State)) { Chunk *chunk = NULL; { - SCOPED_SERIALISE_CONTEXT(CREATE_TEXTURE_1D); - Serialise_CreateTexture1D(pDesc, pInitialData, &wrapped); + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(D3D11Chunk::CreateTexture1D); + Serialise_CreateTexture1D(GET_SERIALISER, pDesc, pInitialData, &wrapped); chunk = scope.Get(); } @@ -404,20 +431,29 @@ HRESULT WrappedID3D11Device::CreateTexture1D(const D3D11_TEXTURE1D_DESC *pDesc, return ret; } -bool WrappedID3D11Device::Serialise_CreateTexture2D(const D3D11_TEXTURE2D_DESC *pDesc, +template +bool WrappedID3D11Device::Serialise_CreateTexture2D(SerialiserType &ser, + const D3D11_TEXTURE2D_DESC *pDesc, const D3D11_SUBRESOURCE_DATA *pInitialData, ID3D11Texture2D **ppTexture2D) { - SERIALISE_ELEMENT_PTR(D3D11_TEXTURE2D_DESC, Descriptor, pDesc); - SERIALISE_ELEMENT(ResourceId, pTexture, GetIDForResource(*ppTexture2D)); + SERIALISE_ELEMENT_LOCAL(Descriptor, *pDesc); + SERIALISE_ELEMENT_LOCAL(pTexture, GetIDForResource(*ppTexture2D)); - SERIALISE_ELEMENT(bool, HasInitialData, pInitialData != NULL); + SERIALISE_ELEMENT_LOCAL(HasInitialData, bool(pInitialData != NULL)); + // unused, just for the sake of the user + if(HasInitialData) + { + SERIALISE_ELEMENT_LOCAL(SysMemPitch, pInitialData->SysMemPitch); + SERIALISE_ELEMENT_LOCAL(SysMemSlicePitch, pInitialData->SysMemSlicePitch); + } - vector descs = Serialise_CreateTextureData( - ppTexture2D ? *ppTexture2D : NULL, pTexture, pInitialData, Descriptor.Width, Descriptor.Height, - 1, Descriptor.Format, Descriptor.MipLevels, Descriptor.ArraySize, HasInitialData); + std::vector descs = + Serialise_CreateTextureData(ser, ppTexture2D ? *ppTexture2D : NULL, pTexture, pInitialData, + Descriptor.Width, Descriptor.Height, 1, Descriptor.Format, + Descriptor.MipLevels, Descriptor.ArraySize, HasInitialData); - if(m_State == READING) + if(IsReplayingAndReading()) { ID3D11Texture2D *ret; HRESULT hr = S_OK; @@ -444,10 +480,11 @@ bool WrappedID3D11Device::Serialise_CreateTexture2D(const D3D11_TEXTURE2D_DESC * GetResourceManager()->AddLiveResource(pTexture, ret); } - } - for(size_t i = 0; i < descs.size(); i++) - SAFE_DELETE_ARRAY(descs[i].pSysMem); + // free the serialised buffers we stole in Serialise_CreateTextureData + for(size_t i = 0; i < descs.size(); i++) + FreeAlignedBuffer((byte *)descs[i].pSysMem); + } return true; } @@ -470,13 +507,14 @@ HRESULT WrappedID3D11Device::CreateTexture2D(const D3D11_TEXTURE2D_DESC *pDesc, wrapped = new WrappedID3D11Texture2D1(real, this); - if(m_State >= WRITING) + if(IsCaptureMode(m_State)) { Chunk *chunk = NULL; { - SCOPED_SERIALISE_CONTEXT(CREATE_TEXTURE_2D); - Serialise_CreateTexture2D(pDesc, pInitialData, &wrapped); + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(D3D11Chunk::CreateTexture2D); + Serialise_CreateTexture2D(GET_SERIALISER, pDesc, pInitialData, &wrapped); chunk = scope.Get(); } @@ -501,20 +539,29 @@ HRESULT WrappedID3D11Device::CreateTexture2D(const D3D11_TEXTURE2D_DESC *pDesc, return ret; } -bool WrappedID3D11Device::Serialise_CreateTexture3D(const D3D11_TEXTURE3D_DESC *pDesc, +template +bool WrappedID3D11Device::Serialise_CreateTexture3D(SerialiserType &ser, + const D3D11_TEXTURE3D_DESC *pDesc, const D3D11_SUBRESOURCE_DATA *pInitialData, ID3D11Texture3D **ppTexture3D) { - SERIALISE_ELEMENT_PTR(D3D11_TEXTURE3D_DESC, Descriptor, pDesc); - SERIALISE_ELEMENT(ResourceId, pTexture, GetIDForResource(*ppTexture3D)); + SERIALISE_ELEMENT_LOCAL(Descriptor, *pDesc); + SERIALISE_ELEMENT_LOCAL(pTexture, GetIDForResource(*ppTexture3D)); - SERIALISE_ELEMENT(bool, HasInitialData, pInitialData != NULL); + SERIALISE_ELEMENT_LOCAL(HasInitialData, bool(pInitialData != NULL)); + // unused, just for the sake of the user + if(HasInitialData) + { + SERIALISE_ELEMENT_LOCAL(SysMemPitch, pInitialData->SysMemPitch); + SERIALISE_ELEMENT_LOCAL(SysMemSlicePitch, pInitialData->SysMemSlicePitch); + } - vector descs = Serialise_CreateTextureData( - ppTexture3D ? *ppTexture3D : NULL, pTexture, pInitialData, Descriptor.Width, Descriptor.Height, - Descriptor.Depth, Descriptor.Format, Descriptor.MipLevels, 1, HasInitialData); + std::vector descs = + Serialise_CreateTextureData(ser, ppTexture3D ? *ppTexture3D : NULL, pTexture, pInitialData, + Descriptor.Width, Descriptor.Height, Descriptor.Depth, + Descriptor.Format, Descriptor.MipLevels, 1, HasInitialData); - if(m_State == READING) + if(IsReplayingAndReading()) { ID3D11Texture3D *ret; HRESULT hr = S_OK; @@ -541,10 +588,11 @@ bool WrappedID3D11Device::Serialise_CreateTexture3D(const D3D11_TEXTURE3D_DESC * GetResourceManager()->AddLiveResource(pTexture, ret); } - } - for(size_t i = 0; i < descs.size(); i++) - SAFE_DELETE_ARRAY(descs[i].pSysMem); + // free the serialised buffers we stole in Serialise_CreateTextureData + for(size_t i = 0; i < descs.size(); i++) + FreeAlignedBuffer((byte *)descs[i].pSysMem); + } return true; } @@ -567,13 +615,14 @@ HRESULT WrappedID3D11Device::CreateTexture3D(const D3D11_TEXTURE3D_DESC *pDesc, wrapped = new WrappedID3D11Texture3D1(real, this); - if(m_State >= WRITING) + if(IsCaptureMode(m_State)) { Chunk *chunk = NULL; { - SCOPED_SERIALISE_CONTEXT(CREATE_TEXTURE_3D); - Serialise_CreateTexture3D(pDesc, pInitialData, &wrapped); + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(D3D11Chunk::CreateTexture3D); + Serialise_CreateTexture3D(GET_SERIALISER, pDesc, pInitialData, &wrapped); chunk = scope.Get(); } @@ -598,32 +647,28 @@ HRESULT WrappedID3D11Device::CreateTexture3D(const D3D11_TEXTURE3D_DESC *pDesc, return ret; } -bool WrappedID3D11Device::Serialise_CreateShaderResourceView(ID3D11Resource *pResource, - const D3D11_SHADER_RESOURCE_VIEW_DESC *pDesc, - ID3D11ShaderResourceView **ppSRView) +template +bool WrappedID3D11Device::Serialise_CreateShaderResourceView( + SerialiserType &ser, ID3D11Resource *pResource, const D3D11_SHADER_RESOURCE_VIEW_DESC *pDesc, + ID3D11ShaderResourceView **ppSRView) { - SERIALISE_ELEMENT(ResourceId, Resource, GetIDForResource(pResource)); - SERIALISE_ELEMENT(bool, HasDesc, pDesc != NULL); - SERIALISE_ELEMENT_PTR_OPT(D3D11_SHADER_RESOURCE_VIEW_DESC, Descriptor, pDesc, HasDesc); - SERIALISE_ELEMENT(ResourceId, pView, GetIDForResource(*ppSRView)); + SERIALISE_ELEMENT(pResource); + SERIALISE_ELEMENT_OPT(pDesc); + SERIALISE_ELEMENT_LOCAL(pView, GetIDForResource(*ppSRView)); - if(m_State == READING && GetResourceManager()->HasLiveResource(Resource)) + if(IsReplayingAndReading() && pResource) { ID3D11ShaderResourceView *ret; - D3D11_SHADER_RESOURCE_VIEW_DESC *pSRVDesc = NULL; - if(HasDesc) - pSRVDesc = &Descriptor; + D3D11_SHADER_RESOURCE_VIEW_DESC *pSRVDesc = (D3D11_SHADER_RESOURCE_VIEW_DESC *)pDesc; - ID3D11Resource *live = (ID3D11Resource *)GetResourceManager()->GetLiveResource(Resource); - - WrappedID3D11Texture2D1 *tex2d = (WrappedID3D11Texture2D1 *)live; + WrappedID3D11Texture2D1 *tex2d = (WrappedID3D11Texture2D1 *)pResource; D3D11_SHADER_RESOURCE_VIEW_DESC backbufferTypedDesc; // need to fixup typeless backbuffer fudging, if a descriptor isn't specified then // we need to make one to give the correct type - if(!HasDesc && WrappedID3D11Texture2D1::IsAlloc(live) && tex2d->m_RealDescriptor) + if(!pDesc && WrappedID3D11Texture2D1::IsAlloc(pResource) && tex2d->m_RealDescriptor) { backbufferTypedDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D; @@ -644,13 +689,13 @@ bool WrappedID3D11Device::Serialise_CreateShaderResourceView(ID3D11Resource *pRe // This behaviour is documented only for render targets, but seems to be used & work for // SRVs, so apply it here too. if(pSRVDesc && pSRVDesc->Format == DXGI_FORMAT_UNKNOWN && - WrappedID3D11Texture2D1::IsAlloc(live) && tex2d->m_RealDescriptor) + WrappedID3D11Texture2D1::IsAlloc(pResource) && tex2d->m_RealDescriptor) { pSRVDesc->Format = tex2d->m_RealDescriptor->Format; } - HRESULT hr = m_pDevice->CreateShaderResourceView(GetResourceManager()->UnwrapResource(live), - pSRVDesc, &ret); + HRESULT hr = m_pDevice->CreateShaderResourceView( + GetResourceManager()->UnwrapResource(pResource), pSRVDesc, &ret); if(FAILED(hr)) { @@ -658,7 +703,7 @@ bool WrappedID3D11Device::Serialise_CreateShaderResourceView(ID3D11Resource *pRe } else { - ret = new WrappedID3D11ShaderResourceView1(ret, live, this); + ret = new WrappedID3D11ShaderResourceView1(ret, pResource, this); GetResourceManager()->AddLiveResource(pView, ret); } @@ -689,10 +734,11 @@ HRESULT WrappedID3D11Device::CreateShaderResourceView(ID3D11Resource *pResource, Chunk *chunk = NULL; - if(m_State >= WRITING) + if(IsCaptureMode(m_State)) { - SCOPED_SERIALISE_CONTEXT(CREATE_SRV); - Serialise_CreateShaderResourceView(pResource, pDesc, &wrapped); + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(D3D11Chunk::CreateShaderResourceView); + Serialise_CreateShaderResourceView(GET_SERIALISER, pResource, pDesc, &wrapped); chunk = scope.Get(); @@ -730,27 +776,21 @@ HRESULT WrappedID3D11Device::CreateShaderResourceView(ID3D11Resource *pResource, return ret; } +template bool WrappedID3D11Device::Serialise_CreateUnorderedAccessView( - ID3D11Resource *pResource, const D3D11_UNORDERED_ACCESS_VIEW_DESC *pDesc, + SerialiserType &ser, ID3D11Resource *pResource, const D3D11_UNORDERED_ACCESS_VIEW_DESC *pDesc, ID3D11UnorderedAccessView **ppUAView) { - SERIALISE_ELEMENT(ResourceId, Resource, GetIDForResource(pResource)); - SERIALISE_ELEMENT(bool, HasDesc, pDesc != NULL); - SERIALISE_ELEMENT_PTR_OPT(D3D11_UNORDERED_ACCESS_VIEW_DESC, Descriptor, pDesc, HasDesc); - SERIALISE_ELEMENT(ResourceId, pView, GetIDForResource(*ppUAView)); + SERIALISE_ELEMENT(pResource); + SERIALISE_ELEMENT_OPT(pDesc); + SERIALISE_ELEMENT_LOCAL(pView, GetIDForResource(*ppUAView)); - if(m_State == READING && GetResourceManager()->HasLiveResource(Resource)) + if(IsReplayingAndReading() && pResource) { ID3D11UnorderedAccessView *ret; - D3D11_UNORDERED_ACCESS_VIEW_DESC *pUAVDesc = NULL; - if(HasDesc) - pUAVDesc = &Descriptor; - - ID3D11Resource *live = (ID3D11Resource *)GetResourceManager()->GetLiveResource(Resource); - - HRESULT hr = m_pDevice->CreateUnorderedAccessView(GetResourceManager()->UnwrapResource(live), - pUAVDesc, &ret); + HRESULT hr = m_pDevice->CreateUnorderedAccessView( + GetResourceManager()->UnwrapResource(pResource), pDesc, &ret); if(FAILED(hr)) { @@ -758,7 +798,7 @@ bool WrappedID3D11Device::Serialise_CreateUnorderedAccessView( } else { - ret = new WrappedID3D11UnorderedAccessView1(ret, live, this); + ret = new WrappedID3D11UnorderedAccessView1(ret, pResource, this); GetResourceManager()->AddLiveResource(pView, ret); } @@ -789,10 +829,11 @@ HRESULT WrappedID3D11Device::CreateUnorderedAccessView(ID3D11Resource *pResource Chunk *chunk = NULL; - if(m_State >= WRITING) + if(IsCaptureMode(m_State)) { - SCOPED_SERIALISE_CONTEXT(CREATE_UAV); - Serialise_CreateUnorderedAccessView(pResource, pDesc, &wrapped); + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(D3D11Chunk::CreateUnorderedAccessView); + Serialise_CreateUnorderedAccessView(GET_SERIALISER, pResource, pDesc, &wrapped); chunk = scope.Get(); @@ -829,32 +870,29 @@ HRESULT WrappedID3D11Device::CreateUnorderedAccessView(ID3D11Resource *pResource return ret; } -bool WrappedID3D11Device::Serialise_CreateRenderTargetView(ID3D11Resource *pResource, +template +bool WrappedID3D11Device::Serialise_CreateRenderTargetView(SerialiserType &ser, + ID3D11Resource *pResource, const D3D11_RENDER_TARGET_VIEW_DESC *pDesc, ID3D11RenderTargetView **ppRTView) { - SERIALISE_ELEMENT(ResourceId, Resource, GetIDForResource(pResource)); - SERIALISE_ELEMENT(bool, HasDesc, pDesc != NULL); - SERIALISE_ELEMENT_PTR_OPT(D3D11_RENDER_TARGET_VIEW_DESC, Descriptor, pDesc, HasDesc); - SERIALISE_ELEMENT(ResourceId, pView, GetIDForResource(*ppRTView)); + SERIALISE_ELEMENT(pResource); + SERIALISE_ELEMENT_OPT(pDesc); + SERIALISE_ELEMENT_LOCAL(pView, GetIDForResource(*ppRTView)); - if(m_State == READING && GetResourceManager()->HasLiveResource(Resource)) + if(IsReplayingAndReading() && pResource) { ID3D11RenderTargetView *ret; - D3D11_RENDER_TARGET_VIEW_DESC *pRTVDesc = NULL; - if(HasDesc) - pRTVDesc = &Descriptor; + D3D11_RENDER_TARGET_VIEW_DESC *pRTVDesc = (D3D11_RENDER_TARGET_VIEW_DESC *)pDesc; - ID3D11Resource *live = (ID3D11Resource *)GetResourceManager()->GetLiveResource(Resource); - - WrappedID3D11Texture2D1 *tex2d = (WrappedID3D11Texture2D1 *)live; + WrappedID3D11Texture2D1 *tex2d = (WrappedID3D11Texture2D1 *)pResource; D3D11_RENDER_TARGET_VIEW_DESC backbufferTypedDesc; // need to fixup typeless backbuffer fudging, if a descriptor isn't specified then // we need to make one to give the correct type - if(!HasDesc && WrappedID3D11Texture2D1::IsAlloc(live) && tex2d->m_RealDescriptor) + if(!pDesc && WrappedID3D11Texture2D1::IsAlloc(pResource) && tex2d->m_RealDescriptor) { backbufferTypedDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2D; @@ -871,12 +909,12 @@ bool WrappedID3D11Device::Serialise_CreateRenderTargetView(ID3D11Resource *pReso // the texture's format. But as above, we fudge around the typeless backbuffer so we // have to set the correct typed format if(pRTVDesc && pRTVDesc->Format == DXGI_FORMAT_UNKNOWN && - WrappedID3D11Texture2D1::IsAlloc(live) && tex2d->m_RealDescriptor) + WrappedID3D11Texture2D1::IsAlloc(pResource) && tex2d->m_RealDescriptor) { pRTVDesc->Format = tex2d->m_RealDescriptor->Format; } - HRESULT hr = m_pDevice->CreateRenderTargetView(GetResourceManager()->UnwrapResource(live), + HRESULT hr = m_pDevice->CreateRenderTargetView(GetResourceManager()->UnwrapResource(pResource), pRTVDesc, &ret); if(FAILED(hr)) @@ -885,7 +923,7 @@ bool WrappedID3D11Device::Serialise_CreateRenderTargetView(ID3D11Resource *pReso } else { - ret = new WrappedID3D11RenderTargetView1(ret, live, this); + ret = new WrappedID3D11RenderTargetView1(ret, pResource, this); GetResourceManager()->AddLiveResource(pView, ret); } @@ -916,10 +954,11 @@ HRESULT WrappedID3D11Device::CreateRenderTargetView(ID3D11Resource *pResource, Chunk *chunk = NULL; - if(m_State >= WRITING) + if(IsCaptureMode(m_State)) { - SCOPED_SERIALISE_CONTEXT(CREATE_RTV); - Serialise_CreateRenderTargetView(pResource, pDesc, &wrapped); + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(D3D11Chunk::CreateRenderTargetView); + Serialise_CreateRenderTargetView(GET_SERIALISER, pResource, pDesc, &wrapped); chunk = scope.Get(); @@ -957,27 +996,21 @@ HRESULT WrappedID3D11Device::CreateRenderTargetView(ID3D11Resource *pResource, return ret; } -bool WrappedID3D11Device::Serialise_CreateDepthStencilView(ID3D11Resource *pResource, - const D3D11_DEPTH_STENCIL_VIEW_DESC *pDesc, - ID3D11DepthStencilView **ppDepthStencilView) +template +bool WrappedID3D11Device::Serialise_CreateDepthStencilView( + SerialiserType &ser, ID3D11Resource *pResource, const D3D11_DEPTH_STENCIL_VIEW_DESC *pDesc, + ID3D11DepthStencilView **ppDepthStencilView) { - SERIALISE_ELEMENT(ResourceId, Resource, GetIDForResource(pResource)); - SERIALISE_ELEMENT(bool, HasDesc, pDesc != NULL); - SERIALISE_ELEMENT_PTR_OPT(D3D11_DEPTH_STENCIL_VIEW_DESC, Descriptor, pDesc, HasDesc); - SERIALISE_ELEMENT(ResourceId, pView, GetIDForResource(*ppDepthStencilView)); + SERIALISE_ELEMENT(pResource); + SERIALISE_ELEMENT_OPT(pDesc); + SERIALISE_ELEMENT_LOCAL(pView, GetIDForResource(*ppDepthStencilView)); - if(m_State == READING && GetResourceManager()->HasLiveResource(Resource)) + if(IsReplayingAndReading() && pResource) { ID3D11DepthStencilView *ret; - ID3D11Resource *live = (ID3D11Resource *)GetResourceManager()->GetLiveResource(Resource); - - pDesc = NULL; - if(HasDesc) - pDesc = &Descriptor; - - HRESULT hr = - m_pDevice->CreateDepthStencilView(GetResourceManager()->UnwrapResource(live), pDesc, &ret); + HRESULT hr = m_pDevice->CreateDepthStencilView(GetResourceManager()->UnwrapResource(pResource), + pDesc, &ret); if(FAILED(hr)) { @@ -985,7 +1018,7 @@ bool WrappedID3D11Device::Serialise_CreateDepthStencilView(ID3D11Resource *pReso } else { - ret = new WrappedID3D11DepthStencilView(ret, live, this); + ret = new WrappedID3D11DepthStencilView(ret, pResource, this); GetResourceManager()->AddLiveResource(pView, ret); } @@ -1016,10 +1049,11 @@ HRESULT WrappedID3D11Device::CreateDepthStencilView(ID3D11Resource *pResource, Chunk *chunk = NULL; - if(m_State >= WRITING) + if(IsCaptureMode(m_State)) { - SCOPED_SERIALISE_CONTEXT(CREATE_DSV); - Serialise_CreateDepthStencilView(pResource, pDesc, &wrapped); + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(D3D11Chunk::CreateDepthStencilView); + Serialise_CreateDepthStencilView(GET_SERIALISER, pResource, pDesc, &wrapped); chunk = scope.Get(); @@ -1057,35 +1091,21 @@ HRESULT WrappedID3D11Device::CreateDepthStencilView(ID3D11Resource *pResource, return ret; } +template bool WrappedID3D11Device::Serialise_CreateInputLayout( - const D3D11_INPUT_ELEMENT_DESC *pInputElementDescs, UINT NumElements, + SerialiserType &ser, const D3D11_INPUT_ELEMENT_DESC *pInputElementDescs, UINT NumElements, const void *pShaderBytecodeWithInputSignature, SIZE_T BytecodeLength, ID3D11InputLayout **ppInputLayout) { - SERIALISE_ELEMENT(uint32_t, NumElems, NumElements); + SERIALISE_ELEMENT_ARRAY(pInputElementDescs, NumElements); + SERIALISE_ELEMENT_ARRAY(pShaderBytecodeWithInputSignature, BytecodeLength); + SERIALISE_ELEMENT_LOCAL(pInputLayout, GetIDForResource(*ppInputLayout)); - D3D11_INPUT_ELEMENT_DESC *layouts = new D3D11_INPUT_ELEMENT_DESC[NumElems]; - - for(UINT i = 0; i < NumElems; i++) + if(IsReplayingAndReading()) { - SERIALISE_ELEMENT(D3D11_INPUT_ELEMENT_DESC, layout, pInputElementDescs[i]); - - layouts[i] = layout; - } - - SERIALISE_ELEMENT(uint32_t, BytecodeLen, (uint32_t)BytecodeLength); - SERIALISE_ELEMENT_BUF(byte *, ShaderBytecode, pShaderBytecodeWithInputSignature, BytecodeLength); - SERIALISE_ELEMENT(ResourceId, pLayout, GetIDForResource(*ppInputLayout)); - - ID3D11InputLayout *ret = NULL; - if(m_State >= WRITING) - { - ret = *ppInputLayout; - } - else if(m_State == READING) - { - HRESULT hr = - m_pDevice->CreateInputLayout(layouts, NumElems, ShaderBytecode, (size_t)BytecodeLen, &ret); + ID3D11InputLayout *ret = NULL; + HRESULT hr = m_pDevice->CreateInputLayout( + pInputElementDescs, NumElements, pShaderBytecodeWithInputSignature, BytecodeLength, &ret); if(FAILED(hr)) { @@ -1095,21 +1115,18 @@ bool WrappedID3D11Device::Serialise_CreateInputLayout( { ret = new WrappedID3D11InputLayout(ret, this); - GetResourceManager()->AddLiveResource(pLayout, ret); + GetResourceManager()->AddLiveResource(pInputLayout, ret); } - vector descvec(layouts, layouts + NumElems); + m_LayoutDescs[ret] = + std::vector(pInputElementDescs, pInputElementDescs + NumElements); - m_LayoutDescs[ret] = descvec; - if(BytecodeLen > 0 && ShaderBytecode) + if(BytecodeLength > 0 && pShaderBytecodeWithInputSignature) m_LayoutShaders[ret] = - new WrappedShader(this, pLayout, GetIDForResource(ret), ShaderBytecode, BytecodeLen); - - SAFE_DELETE_ARRAY(ShaderBytecode); + new WrappedShader(this, pInputLayout, GetIDForResource(ret), + (const byte *)pShaderBytecodeWithInputSignature, BytecodeLength); } - SAFE_DELETE_ARRAY(layouts); - return true; } @@ -1135,10 +1152,11 @@ HRESULT WrappedID3D11Device::CreateInputLayout(const D3D11_INPUT_ELEMENT_DESC *p wrapped = new WrappedID3D11InputLayout(real, this); - if(m_State >= WRITING) + if(IsCaptureMode(m_State)) { - SCOPED_SERIALISE_CONTEXT(CREATE_INPUT_LAYOUT); - Serialise_CreateInputLayout(pInputElementDescs, NumElements, + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(D3D11Chunk::CreateInputLayout); + Serialise_CreateInputLayout(GET_SERIALISER, pInputElementDescs, NumElements, pShaderBytecodeWithInputSignature, BytecodeLength, &wrapped); WrappedID3D11InputLayout *lay = (WrappedID3D11InputLayout *)wrapped; @@ -1158,25 +1176,22 @@ HRESULT WrappedID3D11Device::CreateInputLayout(const D3D11_INPUT_ELEMENT_DESC *p return ret; } -bool WrappedID3D11Device::Serialise_CreateVertexShader(const void *pShaderBytecode, +template +bool WrappedID3D11Device::Serialise_CreateVertexShader(SerialiserType &ser, + const void *pShaderBytecode, SIZE_T BytecodeLength, ID3D11ClassLinkage *pClassLinkage, ID3D11VertexShader **ppVertexShader) { - SERIALISE_ELEMENT(uint32_t, BytecodeLen, (uint32_t)BytecodeLength); - SERIALISE_ELEMENT_BUF(byte *, ShaderBytecode, (void *&)pShaderBytecode, BytecodeLength); - SERIALISE_ELEMENT(ResourceId, pLinkage, GetIDForResource(pClassLinkage)); - SERIALISE_ELEMENT(ResourceId, pShader, GetIDForResource(*ppVertexShader)); + SERIALISE_ELEMENT_ARRAY(pShaderBytecode, BytecodeLength); + SERIALISE_ELEMENT(pClassLinkage); + SERIALISE_ELEMENT_LOCAL(pShader, GetIDForResource(*ppVertexShader)); - if(m_State == READING) + if(IsReplayingAndReading()) { - ID3D11ClassLinkage *linkage = NULL; - if(GetResourceManager()->HasLiveResource(pLinkage)) - linkage = UNWRAP(WrappedID3D11ClassLinkage, - (ID3D11ClassLinkage *)GetResourceManager()->GetLiveResource(pLinkage)); - ID3D11VertexShader *ret; - HRESULT hr = m_pDevice->CreateVertexShader(ShaderBytecode, (size_t)BytecodeLen, linkage, &ret); + HRESULT hr = m_pDevice->CreateVertexShader( + pShaderBytecode, BytecodeLength, UNWRAP(WrappedID3D11ClassLinkage, pClassLinkage), &ret); if(FAILED(hr)) { @@ -1184,13 +1199,11 @@ bool WrappedID3D11Device::Serialise_CreateVertexShader(const void *pShaderByteco } else { - ret = new WrappedID3D11Shader(ret, pShader, ShaderBytecode, - (size_t)BytecodeLen, this); + ret = new WrappedID3D11Shader(ret, pShader, (const byte *)pShaderBytecode, + BytecodeLength, this); GetResourceManager()->AddLiveResource(pShader, ret); } - - SAFE_DELETE_ARRAY(ShaderBytecode); } return true; @@ -1217,10 +1230,12 @@ HRESULT WrappedID3D11Device::CreateVertexShader(const void *pShaderBytecode, SIZ wrapped = new WrappedID3D11Shader( real, ResourceId(), (const byte *)pShaderBytecode, BytecodeLength, this); - if(m_State >= WRITING) + if(IsCaptureMode(m_State)) { - SCOPED_SERIALISE_CONTEXT(CREATE_VERTEX_SHADER); - Serialise_CreateVertexShader(pShaderBytecode, BytecodeLength, pClassLinkage, &wrapped); + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(D3D11Chunk::CreateVertexShader); + Serialise_CreateVertexShader(GET_SERIALISER, pShaderBytecode, BytecodeLength, pClassLinkage, + &wrapped); WrappedID3D11Shader *sh = (WrappedID3D11Shader *)wrapped; @@ -1246,25 +1261,22 @@ HRESULT WrappedID3D11Device::CreateVertexShader(const void *pShaderBytecode, SIZ return ret; } -bool WrappedID3D11Device::Serialise_CreateGeometryShader(const void *pShaderBytecode, +template +bool WrappedID3D11Device::Serialise_CreateGeometryShader(SerialiserType &ser, + const void *pShaderBytecode, SIZE_T BytecodeLength, ID3D11ClassLinkage *pClassLinkage, ID3D11GeometryShader **ppGeometryShader) { - SERIALISE_ELEMENT(uint32_t, BytecodeLen, (uint32_t)BytecodeLength); - SERIALISE_ELEMENT_BUF(byte *, ShaderBytecode, pShaderBytecode, BytecodeLength); - SERIALISE_ELEMENT(ResourceId, pLinkage, GetIDForResource(pClassLinkage)); - SERIALISE_ELEMENT(ResourceId, pShader, GetIDForResource(*ppGeometryShader)); + SERIALISE_ELEMENT_ARRAY(pShaderBytecode, BytecodeLength); + SERIALISE_ELEMENT(pClassLinkage); + SERIALISE_ELEMENT_LOCAL(pShader, GetIDForResource(*ppGeometryShader)); - if(m_State == READING) + if(IsReplayingAndReading()) { - ID3D11ClassLinkage *linkage = NULL; - if(GetResourceManager()->HasLiveResource(pLinkage)) - linkage = UNWRAP(WrappedID3D11ClassLinkage, - (ID3D11ClassLinkage *)GetResourceManager()->GetLiveResource(pLinkage)); - ID3D11GeometryShader *ret; - HRESULT hr = m_pDevice->CreateGeometryShader(ShaderBytecode, (size_t)BytecodeLen, linkage, &ret); + HRESULT hr = m_pDevice->CreateGeometryShader( + pShaderBytecode, BytecodeLength, UNWRAP(WrappedID3D11ClassLinkage, pClassLinkage), &ret); if(FAILED(hr)) { @@ -1272,13 +1284,11 @@ bool WrappedID3D11Device::Serialise_CreateGeometryShader(const void *pShaderByte } else { - ret = new WrappedID3D11Shader(ret, pShader, ShaderBytecode, - (size_t)BytecodeLen, this); + ret = new WrappedID3D11Shader( + ret, pShader, (const byte *)pShaderBytecode, BytecodeLength, this); GetResourceManager()->AddLiveResource(pShader, ret); } - - SAFE_DELETE_ARRAY(ShaderBytecode); } return true; @@ -1305,10 +1315,12 @@ HRESULT WrappedID3D11Device::CreateGeometryShader(const void *pShaderBytecode, S wrapped = new WrappedID3D11Shader( real, ResourceId(), (const byte *)pShaderBytecode, BytecodeLength, this); - if(m_State >= WRITING) + if(IsCaptureMode(m_State)) { - SCOPED_SERIALISE_CONTEXT(CREATE_GEOMETRY_SHADER); - Serialise_CreateGeometryShader(pShaderBytecode, BytecodeLength, pClassLinkage, &wrapped); + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(D3D11Chunk::CreateGeometryShader); + Serialise_CreateGeometryShader(GET_SERIALISER, pShaderBytecode, BytecodeLength, pClassLinkage, + &wrapped); WrappedID3D11Shader *sh = (WrappedID3D11Shader *)wrapped; @@ -1335,37 +1347,26 @@ HRESULT WrappedID3D11Device::CreateGeometryShader(const void *pShaderBytecode, S return ret; } +template bool WrappedID3D11Device::Serialise_CreateGeometryShaderWithStreamOutput( - const void *pShaderBytecode, SIZE_T BytecodeLength, + SerialiserType &ser, const void *pShaderBytecode, SIZE_T BytecodeLength, const D3D11_SO_DECLARATION_ENTRY *pSODeclaration, UINT NumEntries, const UINT *pBufferStrides, UINT NumStrides, UINT RasterizedStream, ID3D11ClassLinkage *pClassLinkage, ID3D11GeometryShader **ppGeometryShader) { - SERIALISE_ELEMENT(uint32_t, BytecodeLen, (uint32_t)BytecodeLength); - SERIALISE_ELEMENT_BUF(byte *, ShaderBytecode, pShaderBytecode, BytecodeLength); + SERIALISE_ELEMENT_ARRAY(pShaderBytecode, BytecodeLength); + SERIALISE_ELEMENT_ARRAY(pSODeclaration, NumEntries); + SERIALISE_ELEMENT_ARRAY(pBufferStrides, NumStrides); + SERIALISE_ELEMENT(RasterizedStream); + SERIALISE_ELEMENT(pClassLinkage); + SERIALISE_ELEMENT_LOCAL(pShader, GetIDForResource(*ppGeometryShader)); - SERIALISE_ELEMENT(uint32_t, numEntries, NumEntries); - SERIALISE_ELEMENT_ARR(D3D11_SO_DECLARATION_ENTRY, SODecl, pSODeclaration, numEntries); - - SERIALISE_ELEMENT(uint32_t, numStrides, NumStrides); - SERIALISE_ELEMENT_ARR(uint32_t, BufStrides, pBufferStrides, numStrides); - - SERIALISE_ELEMENT(uint32_t, RastStream, RasterizedStream); - - SERIALISE_ELEMENT(ResourceId, pLinkage, GetIDForResource(pClassLinkage)); - SERIALISE_ELEMENT(ResourceId, pShader, GetIDForResource(*ppGeometryShader)); - - if(m_State == READING) + if(IsReplayingAndReading()) { - ID3D11ClassLinkage *linkage = NULL; - if(GetResourceManager()->HasLiveResource(pLinkage)) - linkage = UNWRAP(WrappedID3D11ClassLinkage, - (ID3D11ClassLinkage *)GetResourceManager()->GetLiveResource(pLinkage)); - ID3D11GeometryShader *ret; HRESULT hr = m_pDevice->CreateGeometryShaderWithStreamOutput( - ShaderBytecode, (size_t)BytecodeLen, SODecl, numEntries, - numStrides == 0 ? NULL : BufStrides, numStrides, RastStream, linkage, &ret); + pShaderBytecode, BytecodeLength, pSODeclaration, NumEntries, pBufferStrides, NumStrides, + RasterizedStream, UNWRAP(WrappedID3D11ClassLinkage, pClassLinkage), &ret); if(FAILED(hr)) { @@ -1373,18 +1374,13 @@ bool WrappedID3D11Device::Serialise_CreateGeometryShaderWithStreamOutput( } else { - ret = new WrappedID3D11Shader(ret, pShader, ShaderBytecode, - (size_t)BytecodeLen, this); + ret = new WrappedID3D11Shader( + ret, pShader, (const byte *)pShaderBytecode, BytecodeLength, this); GetResourceManager()->AddLiveResource(pShader, ret); } - - SAFE_DELETE_ARRAY(ShaderBytecode); } - SAFE_DELETE_ARRAY(SODecl); - SAFE_DELETE_ARRAY(BufStrides); - return true; } @@ -1413,12 +1409,13 @@ HRESULT WrappedID3D11Device::CreateGeometryShaderWithStreamOutput( wrapped = new WrappedID3D11Shader( real, ResourceId(), (const byte *)pShaderBytecode, BytecodeLength, this); - if(m_State >= WRITING) + if(IsCaptureMode(m_State)) { - SCOPED_SERIALISE_CONTEXT(CREATE_GEOMETRY_SHADER_WITH_SO); - Serialise_CreateGeometryShaderWithStreamOutput(pShaderBytecode, BytecodeLength, pSODeclaration, - NumEntries, pBufferStrides, NumStrides, - RasterizedStream, pClassLinkage, &wrapped); + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(D3D11Chunk::CreateGeometryShaderWithStreamOutput); + Serialise_CreateGeometryShaderWithStreamOutput( + GET_SERIALISER, pShaderBytecode, BytecodeLength, pSODeclaration, NumEntries, + pBufferStrides, NumStrides, RasterizedStream, pClassLinkage, &wrapped); WrappedID3D11Shader *sh = (WrappedID3D11Shader *)wrapped; @@ -1445,25 +1442,22 @@ HRESULT WrappedID3D11Device::CreateGeometryShaderWithStreamOutput( return ret; } -bool WrappedID3D11Device::Serialise_CreatePixelShader(const void *pShaderBytecode, +template +bool WrappedID3D11Device::Serialise_CreatePixelShader(SerialiserType &ser, + const void *pShaderBytecode, SIZE_T BytecodeLength, ID3D11ClassLinkage *pClassLinkage, ID3D11PixelShader **ppPixelShader) { - SERIALISE_ELEMENT(uint32_t, BytecodeLen, (uint32_t)BytecodeLength); - SERIALISE_ELEMENT_BUF(byte *, ShaderBytecode, pShaderBytecode, BytecodeLength); - SERIALISE_ELEMENT(ResourceId, pLinkage, GetIDForResource(pClassLinkage)); - SERIALISE_ELEMENT(ResourceId, pShader, GetIDForResource(*ppPixelShader)); + SERIALISE_ELEMENT_ARRAY(pShaderBytecode, BytecodeLength); + SERIALISE_ELEMENT(pClassLinkage); + SERIALISE_ELEMENT_LOCAL(pShader, GetIDForResource(*ppPixelShader)); - if(m_State == READING) + if(IsReplayingAndReading()) { - ID3D11ClassLinkage *linkage = NULL; - if(GetResourceManager()->HasLiveResource(pLinkage)) - linkage = UNWRAP(WrappedID3D11ClassLinkage, - (ID3D11ClassLinkage *)GetResourceManager()->GetLiveResource(pLinkage)); - ID3D11PixelShader *ret; - HRESULT hr = m_pDevice->CreatePixelShader(ShaderBytecode, (size_t)BytecodeLen, linkage, &ret); + HRESULT hr = m_pDevice->CreatePixelShader( + pShaderBytecode, BytecodeLength, UNWRAP(WrappedID3D11ClassLinkage, pClassLinkage), &ret); if(FAILED(hr)) { @@ -1471,13 +1465,11 @@ bool WrappedID3D11Device::Serialise_CreatePixelShader(const void *pShaderBytecod } else { - ret = new WrappedID3D11Shader(ret, pShader, ShaderBytecode, - (size_t)BytecodeLen, this); + ret = new WrappedID3D11Shader(ret, pShader, (const byte *)pShaderBytecode, + BytecodeLength, this); GetResourceManager()->AddLiveResource(pShader, ret); } - - SAFE_DELETE_ARRAY(ShaderBytecode); } return true; @@ -1504,10 +1496,12 @@ HRESULT WrappedID3D11Device::CreatePixelShader(const void *pShaderBytecode, SIZE wrapped = new WrappedID3D11Shader( real, ResourceId(), (const byte *)pShaderBytecode, BytecodeLength, this); - if(m_State >= WRITING) + if(IsCaptureMode(m_State)) { - SCOPED_SERIALISE_CONTEXT(CREATE_PIXEL_SHADER); - Serialise_CreatePixelShader(pShaderBytecode, BytecodeLength, pClassLinkage, &wrapped); + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(D3D11Chunk::CreatePixelShader); + Serialise_CreatePixelShader(GET_SERIALISER, pShaderBytecode, BytecodeLength, pClassLinkage, + &wrapped); WrappedID3D11Shader *sh = (WrappedID3D11Shader *)wrapped; ResourceId id = sh->GetResourceID(); @@ -1532,25 +1526,21 @@ HRESULT WrappedID3D11Device::CreatePixelShader(const void *pShaderBytecode, SIZE return ret; } -bool WrappedID3D11Device::Serialise_CreateHullShader(const void *pShaderBytecode, +template +bool WrappedID3D11Device::Serialise_CreateHullShader(SerialiserType &ser, const void *pShaderBytecode, SIZE_T BytecodeLength, ID3D11ClassLinkage *pClassLinkage, ID3D11HullShader **ppHullShader) { - SERIALISE_ELEMENT(uint32_t, BytecodeLen, (uint32_t)BytecodeLength); - SERIALISE_ELEMENT_BUF(byte *, ShaderBytecode, pShaderBytecode, BytecodeLength); - SERIALISE_ELEMENT(ResourceId, pLinkage, GetIDForResource(pClassLinkage)); - SERIALISE_ELEMENT(ResourceId, pShader, GetIDForResource(*ppHullShader)); + SERIALISE_ELEMENT_ARRAY(pShaderBytecode, BytecodeLength); + SERIALISE_ELEMENT(pClassLinkage); + SERIALISE_ELEMENT_LOCAL(pShader, GetIDForResource(*ppHullShader)); - if(m_State == READING) + if(IsReplayingAndReading()) { - ID3D11ClassLinkage *linkage = NULL; - if(GetResourceManager()->HasLiveResource(pLinkage)) - linkage = UNWRAP(WrappedID3D11ClassLinkage, - (ID3D11ClassLinkage *)GetResourceManager()->GetLiveResource(pLinkage)); - ID3D11HullShader *ret; - HRESULT hr = m_pDevice->CreateHullShader(ShaderBytecode, (size_t)BytecodeLen, linkage, &ret); + HRESULT hr = m_pDevice->CreateHullShader( + pShaderBytecode, BytecodeLength, UNWRAP(WrappedID3D11ClassLinkage, pClassLinkage), &ret); if(FAILED(hr)) { @@ -1558,13 +1548,11 @@ bool WrappedID3D11Device::Serialise_CreateHullShader(const void *pShaderBytecode } else { - ret = new WrappedID3D11Shader(ret, pShader, ShaderBytecode, - (size_t)BytecodeLen, this); + ret = new WrappedID3D11Shader(ret, pShader, (const byte *)pShaderBytecode, + BytecodeLength, this); GetResourceManager()->AddLiveResource(pShader, ret); } - - SAFE_DELETE_ARRAY(ShaderBytecode); } return true; @@ -1591,10 +1579,12 @@ HRESULT WrappedID3D11Device::CreateHullShader(const void *pShaderBytecode, SIZE_ wrapped = new WrappedID3D11Shader( real, ResourceId(), (const byte *)pShaderBytecode, BytecodeLength, this); - if(m_State >= WRITING) + if(IsCaptureMode(m_State)) { - SCOPED_SERIALISE_CONTEXT(CREATE_HULL_SHADER); - Serialise_CreateHullShader(pShaderBytecode, BytecodeLength, pClassLinkage, &wrapped); + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(D3D11Chunk::CreateHullShader); + Serialise_CreateHullShader(GET_SERIALISER, pShaderBytecode, BytecodeLength, pClassLinkage, + &wrapped); WrappedID3D11Shader *sh = (WrappedID3D11Shader *)wrapped; ResourceId id = sh->GetResourceID(); @@ -1619,25 +1609,22 @@ HRESULT WrappedID3D11Device::CreateHullShader(const void *pShaderBytecode, SIZE_ return ret; } -bool WrappedID3D11Device::Serialise_CreateDomainShader(const void *pShaderBytecode, +template +bool WrappedID3D11Device::Serialise_CreateDomainShader(SerialiserType &ser, + const void *pShaderBytecode, SIZE_T BytecodeLength, ID3D11ClassLinkage *pClassLinkage, ID3D11DomainShader **ppDomainShader) { - SERIALISE_ELEMENT(uint32_t, BytecodeLen, (uint32_t)BytecodeLength); - SERIALISE_ELEMENT_BUF(byte *, ShaderBytecode, pShaderBytecode, BytecodeLength); - SERIALISE_ELEMENT(ResourceId, pLinkage, GetIDForResource(pClassLinkage)); - SERIALISE_ELEMENT(ResourceId, pShader, GetIDForResource(*ppDomainShader)); + SERIALISE_ELEMENT_ARRAY(pShaderBytecode, BytecodeLength); + SERIALISE_ELEMENT(pClassLinkage); + SERIALISE_ELEMENT_LOCAL(pShader, GetIDForResource(*ppDomainShader)); - if(m_State == READING) + if(IsReplayingAndReading()) { - ID3D11ClassLinkage *linkage = NULL; - if(GetResourceManager()->HasLiveResource(pLinkage)) - linkage = UNWRAP(WrappedID3D11ClassLinkage, - (ID3D11ClassLinkage *)GetResourceManager()->GetLiveResource(pLinkage)); - ID3D11DomainShader *ret; - HRESULT hr = m_pDevice->CreateDomainShader(ShaderBytecode, (size_t)BytecodeLen, linkage, &ret); + HRESULT hr = m_pDevice->CreateDomainShader( + pShaderBytecode, BytecodeLength, UNWRAP(WrappedID3D11ClassLinkage, pClassLinkage), &ret); if(FAILED(hr)) { @@ -1645,13 +1632,11 @@ bool WrappedID3D11Device::Serialise_CreateDomainShader(const void *pShaderByteco } else { - ret = new WrappedID3D11Shader(ret, pShader, ShaderBytecode, - (size_t)BytecodeLen, this); + ret = new WrappedID3D11Shader(ret, pShader, (const byte *)pShaderBytecode, + BytecodeLength, this); GetResourceManager()->AddLiveResource(pShader, ret); } - - SAFE_DELETE_ARRAY(ShaderBytecode); } return true; @@ -1678,10 +1663,12 @@ HRESULT WrappedID3D11Device::CreateDomainShader(const void *pShaderBytecode, SIZ wrapped = new WrappedID3D11Shader( real, ResourceId(), (const byte *)pShaderBytecode, BytecodeLength, this); - if(m_State >= WRITING) + if(IsCaptureMode(m_State)) { - SCOPED_SERIALISE_CONTEXT(CREATE_DOMAIN_SHADER); - Serialise_CreateDomainShader(pShaderBytecode, BytecodeLength, pClassLinkage, &wrapped); + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(D3D11Chunk::CreateDomainShader); + Serialise_CreateDomainShader(GET_SERIALISER, pShaderBytecode, BytecodeLength, pClassLinkage, + &wrapped); WrappedID3D11Shader *sh = (WrappedID3D11Shader *)wrapped; @@ -1707,25 +1694,22 @@ HRESULT WrappedID3D11Device::CreateDomainShader(const void *pShaderBytecode, SIZ return ret; } -bool WrappedID3D11Device::Serialise_CreateComputeShader(const void *pShaderBytecode, +template +bool WrappedID3D11Device::Serialise_CreateComputeShader(SerialiserType &ser, + const void *pShaderBytecode, SIZE_T BytecodeLength, ID3D11ClassLinkage *pClassLinkage, ID3D11ComputeShader **ppComputeShader) { - SERIALISE_ELEMENT(uint32_t, BytecodeLen, (uint32_t)BytecodeLength); - SERIALISE_ELEMENT_BUF(byte *, ShaderBytecode, pShaderBytecode, BytecodeLength); - SERIALISE_ELEMENT(ResourceId, pLinkage, GetIDForResource(pClassLinkage)); - SERIALISE_ELEMENT(ResourceId, pShader, GetIDForResource(*ppComputeShader)); + SERIALISE_ELEMENT_ARRAY(pShaderBytecode, BytecodeLength); + SERIALISE_ELEMENT(pClassLinkage); + SERIALISE_ELEMENT_LOCAL(pShader, GetIDForResource(*ppComputeShader)); - if(m_State == READING) + if(IsReplayingAndReading()) { - ID3D11ClassLinkage *linkage = NULL; - if(GetResourceManager()->HasLiveResource(pLinkage)) - linkage = UNWRAP(WrappedID3D11ClassLinkage, - (ID3D11ClassLinkage *)GetResourceManager()->GetLiveResource(pLinkage)); - ID3D11ComputeShader *ret; - HRESULT hr = m_pDevice->CreateComputeShader(ShaderBytecode, (size_t)BytecodeLen, linkage, &ret); + HRESULT hr = m_pDevice->CreateComputeShader( + pShaderBytecode, BytecodeLength, UNWRAP(WrappedID3D11ClassLinkage, pClassLinkage), &ret); if(FAILED(hr)) { @@ -1733,13 +1717,11 @@ bool WrappedID3D11Device::Serialise_CreateComputeShader(const void *pShaderBytec } else { - ret = new WrappedID3D11Shader(ret, pShader, ShaderBytecode, - (size_t)BytecodeLen, this); + ret = new WrappedID3D11Shader( + ret, pShader, (const byte *)pShaderBytecode, BytecodeLength, this); GetResourceManager()->AddLiveResource(pShader, ret); } - - SAFE_DELETE_ARRAY(ShaderBytecode); } return true; @@ -1766,10 +1748,12 @@ HRESULT WrappedID3D11Device::CreateComputeShader(const void *pShaderBytecode, SI wrapped = new WrappedID3D11Shader( real, ResourceId(), (const byte *)pShaderBytecode, BytecodeLength, this); - if(m_State >= WRITING) + if(IsCaptureMode(m_State)) { - SCOPED_SERIALISE_CONTEXT(CREATE_COMPUTE_SHADER); - Serialise_CreateComputeShader(pShaderBytecode, BytecodeLength, pClassLinkage, &wrapped); + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(D3D11Chunk::CreateComputeShader); + Serialise_CreateComputeShader(GET_SERIALISER, pShaderBytecode, BytecodeLength, pClassLinkage, + &wrapped); WrappedID3D11Shader *sh = (WrappedID3D11Shader *)wrapped; @@ -1797,30 +1781,29 @@ HRESULT WrappedID3D11Device::CreateComputeShader(const void *pShaderBytecode, SI } // Class Linkage 'fake' interfaces -bool WrappedID3D11Device::Serialise_CreateClassInstance( - LPCSTR pClassTypeName, UINT ConstantBufferOffset, UINT ConstantVectorOffset, UINT TextureOffset, - UINT SamplerOffset, WrappedID3D11ClassLinkage *linkage, ID3D11ClassInstance *inst) +template +bool WrappedID3D11Device::Serialise_CreateClassInstance(SerialiserType &ser, LPCSTR pClassTypeName, + UINT ConstantBufferOffset, + UINT ConstantVectorOffset, + UINT TextureOffset, UINT SamplerOffset, + ID3D11ClassLinkage *pClassLinkage, + ID3D11ClassInstance **ppInstance) { - string name = pClassTypeName ? pClassTypeName : ""; - m_pSerialiser->Serialise("name", name); + SERIALISE_ELEMENT(pClassTypeName); + SERIALISE_ELEMENT(ConstantBufferOffset); + SERIALISE_ELEMENT(ConstantVectorOffset); + SERIALISE_ELEMENT(TextureOffset); + SERIALISE_ELEMENT(SamplerOffset); + SERIALISE_ELEMENT(pClassLinkage); + SERIALISE_ELEMENT_LOCAL(pInstance, GetIDForResource(*ppInstance)); - SERIALISE_ELEMENT(UINT, cbOffset, ConstantBufferOffset); - SERIALISE_ELEMENT(UINT, cvOffset, ConstantVectorOffset); - SERIALISE_ELEMENT(UINT, texOffset, TextureOffset); - SERIALISE_ELEMENT(UINT, sampOffset, SamplerOffset); - SERIALISE_ELEMENT(ResourceId, pLinkage, linkage->GetResourceID()); - SERIALISE_ELEMENT(ResourceId, instance, GetIDForResource(inst)); - - if(m_State == READING && GetResourceManager()->HasLiveResource(pLinkage)) + if(IsReplayingAndReading() && pClassLinkage) { - ID3D11ClassLinkage *wrappedLink = - (ID3D11ClassLinkage *)GetResourceManager()->GetLiveResource(pLinkage); - ID3D11ClassLinkage *realLink = UNWRAP(WrappedID3D11ClassLinkage, wrappedLink); - ID3D11ClassInstance *real = NULL; ID3D11ClassInstance *wrapped = NULL; - HRESULT hr = realLink->CreateClassInstance(name.c_str(), cbOffset, cvOffset, texOffset, - sampOffset, &real); + HRESULT hr = UNWRAP(WrappedID3D11ClassLinkage, pClassLinkage) + ->CreateClassInstance(pClassTypeName, ConstantBufferOffset, + ConstantVectorOffset, TextureOffset, SamplerOffset, &real); if(FAILED(hr)) { @@ -1828,9 +1811,9 @@ bool WrappedID3D11Device::Serialise_CreateClassInstance( } else { - wrapped = new WrappedID3D11ClassInstance(real, wrappedLink, this); + wrapped = new WrappedID3D11ClassInstance(real, pClassLinkage, this); - GetResourceManager()->AddLiveResource(instance, wrapped); + GetResourceManager()->AddLiveResource(pInstance, wrapped); } } @@ -1839,20 +1822,22 @@ bool WrappedID3D11Device::Serialise_CreateClassInstance( ID3D11ClassInstance *WrappedID3D11Device::CreateClassInstance( LPCSTR pClassTypeName, UINT ConstantBufferOffset, UINT ConstantVectorOffset, UINT TextureOffset, - UINT SamplerOffset, WrappedID3D11ClassLinkage *linkage, ID3D11ClassInstance *inst) + UINT SamplerOffset, ID3D11ClassLinkage *pClassLinkage, ID3D11ClassInstance **ppInstance) { ID3D11ClassInstance *wrapped = NULL; - if(m_State >= WRITING) + if(IsCaptureMode(m_State)) { SCOPED_LOCK(m_D3DLock); - wrapped = new WrappedID3D11ClassInstance(inst, linkage, this); + wrapped = new WrappedID3D11ClassInstance(*ppInstance, pClassLinkage, this); { - SCOPED_SERIALISE_CONTEXT(CREATE_CLASS_INSTANCE); - Serialise_CreateClassInstance(pClassTypeName, ConstantBufferOffset, ConstantVectorOffset, - TextureOffset, SamplerOffset, linkage, wrapped); + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(D3D11Chunk::CreateClassInstance); + Serialise_CreateClassInstance(GET_SERIALISER, pClassTypeName, ConstantBufferOffset, + ConstantVectorOffset, TextureOffset, SamplerOffset, + pClassLinkage, &wrapped); m_DeviceRecord->AddChunk(scope.Get()); } @@ -1860,29 +1845,27 @@ ID3D11ClassInstance *WrappedID3D11Device::CreateClassInstance( return wrapped; } - return inst; + RDCERR("Creating class instances while not in capture mode!"); + return NULL; } -bool WrappedID3D11Device::Serialise_GetClassInstance(LPCSTR pClassInstanceName, UINT InstanceIndex, - WrappedID3D11ClassLinkage *linkage, - ID3D11ClassInstance *inst) +template +bool WrappedID3D11Device::Serialise_GetClassInstance(SerialiserType &ser, LPCSTR pClassInstanceName, + UINT InstanceIndex, + ID3D11ClassLinkage *pClassLinkage, + ID3D11ClassInstance **ppInstance) { - string name = pClassInstanceName ? pClassInstanceName : ""; - m_pSerialiser->Serialise("name", name); + SERIALISE_ELEMENT(pClassInstanceName); + SERIALISE_ELEMENT(InstanceIndex); + SERIALISE_ELEMENT(pClassLinkage); + SERIALISE_ELEMENT_LOCAL(pInstance, GetIDForResource(*ppInstance)); - SERIALISE_ELEMENT(UINT, idx, InstanceIndex); - SERIALISE_ELEMENT(ResourceId, pLinkage, linkage->GetResourceID()); - SERIALISE_ELEMENT(ResourceId, instance, GetIDForResource(inst)); - - if(m_State == READING && GetResourceManager()->HasLiveResource(pLinkage)) + if(IsReplayingAndReading() && pClassLinkage) { - ID3D11ClassLinkage *wrappedLink = - (ID3D11ClassLinkage *)GetResourceManager()->GetLiveResource(pLinkage); - ID3D11ClassLinkage *realLink = UNWRAP(WrappedID3D11ClassLinkage, wrappedLink); - ID3D11ClassInstance *real = NULL; ID3D11ClassInstance *wrapped = NULL; - HRESULT hr = realLink->GetClassInstance(name.c_str(), idx, &real); + HRESULT hr = UNWRAP(WrappedID3D11ClassLinkage, pClassLinkage) + ->GetClassInstance(pClassInstanceName, InstanceIndex, &real); if(FAILED(hr)) { @@ -1890,9 +1873,9 @@ bool WrappedID3D11Device::Serialise_GetClassInstance(LPCSTR pClassInstanceName, } else { - wrapped = new WrappedID3D11ClassInstance(real, wrappedLink, this); + wrapped = new WrappedID3D11ClassInstance(real, pClassLinkage, this); - GetResourceManager()->AddLiveResource(instance, wrapped); + GetResourceManager()->AddLiveResource(pInstance, wrapped); } } @@ -1901,20 +1884,22 @@ bool WrappedID3D11Device::Serialise_GetClassInstance(LPCSTR pClassInstanceName, ID3D11ClassInstance *WrappedID3D11Device::GetClassInstance(LPCSTR pClassInstanceName, UINT InstanceIndex, - WrappedID3D11ClassLinkage *linkage, - ID3D11ClassInstance *inst) + ID3D11ClassLinkage *pClassLinkage, + ID3D11ClassInstance **ppInstance) { ID3D11ClassInstance *wrapped = NULL; - if(m_State >= WRITING) + if(IsCaptureMode(m_State)) { SCOPED_LOCK(m_D3DLock); - wrapped = new WrappedID3D11ClassInstance(inst, linkage, this); + wrapped = new WrappedID3D11ClassInstance(*ppInstance, pClassLinkage, this); { - SCOPED_SERIALISE_CONTEXT(GET_CLASS_INSTANCE); - Serialise_GetClassInstance(pClassInstanceName, InstanceIndex, linkage, wrapped); + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(D3D11Chunk::GetClassInstance); + Serialise_GetClassInstance(GET_SERIALISER, pClassInstanceName, InstanceIndex, pClassLinkage, + &wrapped); m_DeviceRecord->AddChunk(scope.Get()); } @@ -1922,14 +1907,17 @@ ID3D11ClassInstance *WrappedID3D11Device::GetClassInstance(LPCSTR pClassInstance return wrapped; } - return inst; + RDCERR("Creating class instances while not in capture mode!"); + return NULL; } -bool WrappedID3D11Device::Serialise_CreateClassLinkage(ID3D11ClassLinkage **ppLinkage) +template +bool WrappedID3D11Device::Serialise_CreateClassLinkage(SerialiserType &ser, + ID3D11ClassLinkage **ppLinkage) { - SERIALISE_ELEMENT(ResourceId, pLinkage, GetIDForResource(*ppLinkage)); + SERIALISE_ELEMENT_LOCAL(pLinkage, GetIDForResource(*ppLinkage)); - if(m_State == READING) + if(IsReplayingAndReading()) { ID3D11ClassLinkage *ret; HRESULT hr = m_pDevice->CreateClassLinkage(&ret); @@ -1959,16 +1947,17 @@ HRESULT WrappedID3D11Device::CreateClassLinkage(ID3D11ClassLinkage **ppLinkage) ID3D11ClassLinkage *wrapped = NULL; HRESULT ret = m_pDevice->CreateClassLinkage(&real); - if(SUCCEEDED(ret) && m_State >= WRITING) + if(SUCCEEDED(ret)) { SCOPED_LOCK(m_D3DLock); wrapped = new WrappedID3D11ClassLinkage(real, this); - if(m_State >= WRITING) + if(IsCaptureMode(m_State)) { - SCOPED_SERIALISE_CONTEXT(CREATE_CLASS_LINKAGE); - Serialise_CreateClassLinkage(&wrapped); + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(D3D11Chunk::CreateClassLinkage); + Serialise_CreateClassLinkage(GET_SERIALISER, &wrapped); m_DeviceRecord->AddChunk(scope.Get()); } @@ -1979,13 +1968,15 @@ HRESULT WrappedID3D11Device::CreateClassLinkage(ID3D11ClassLinkage **ppLinkage) return ret; } -bool WrappedID3D11Device::Serialise_CreateBlendState(const D3D11_BLEND_DESC *pBlendStateDesc, +template +bool WrappedID3D11Device::Serialise_CreateBlendState(SerialiserType &ser, + const D3D11_BLEND_DESC *pBlendStateDesc, ID3D11BlendState **ppBlendState) { - SERIALISE_ELEMENT_PTR(D3D11_BLEND_DESC, Descriptor, pBlendStateDesc); - SERIALISE_ELEMENT(ResourceId, State, GetIDForResource(*ppBlendState)); + SERIALISE_ELEMENT_LOCAL(Descriptor, *pBlendStateDesc); + SERIALISE_ELEMENT_LOCAL(pState, GetIDForResource(*ppBlendState)); - if(m_State == READING) + if(IsReplayingAndReading()) { ID3D11BlendState *ret; HRESULT hr = m_pDevice->CreateBlendState(&Descriptor, &ret); @@ -2002,13 +1993,13 @@ bool WrappedID3D11Device::Serialise_CreateBlendState(const D3D11_BLEND_DESC *pBl ret = (ID3D11BlendState *)GetResourceManager()->GetWrapper(ret); ret->AddRef(); - GetResourceManager()->AddLiveResource(State, ret); + GetResourceManager()->AddLiveResource(pState, ret); } else { ret = new WrappedID3D11BlendState1(ret, this); - GetResourceManager()->AddLiveResource(State, ret); + GetResourceManager()->AddLiveResource(pState, ret); } } } @@ -2050,10 +2041,11 @@ HRESULT WrappedID3D11Device::CreateBlendState(const D3D11_BLEND_DESC *pBlendStat m_CachedStateObjects.insert(wrapped); } - if(m_State >= WRITING) + if(IsCaptureMode(m_State)) { - SCOPED_SERIALISE_CONTEXT(CREATE_BLEND_STATE); - Serialise_CreateBlendState(pBlendStateDesc, &wrapped); + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(D3D11Chunk::CreateBlendState); + Serialise_CreateBlendState(GET_SERIALISER, pBlendStateDesc, &wrapped); m_DeviceRecord->AddChunk(scope.Get()); } @@ -2064,13 +2056,15 @@ HRESULT WrappedID3D11Device::CreateBlendState(const D3D11_BLEND_DESC *pBlendStat return ret; } +template bool WrappedID3D11Device::Serialise_CreateDepthStencilState( - const D3D11_DEPTH_STENCIL_DESC *pDepthStencilDesc, ID3D11DepthStencilState **ppDepthStencilState) + SerialiserType &ser, const D3D11_DEPTH_STENCIL_DESC *pDepthStencilDesc, + ID3D11DepthStencilState **ppDepthStencilState) { - SERIALISE_ELEMENT_PTR(D3D11_DEPTH_STENCIL_DESC, Descriptor, pDepthStencilDesc); - SERIALISE_ELEMENT(ResourceId, State, GetIDForResource(*ppDepthStencilState)); + SERIALISE_ELEMENT_LOCAL(Descriptor, *pDepthStencilDesc); + SERIALISE_ELEMENT_LOCAL(pState, GetIDForResource(*ppDepthStencilState)); - if(m_State == READING) + if(IsReplayingAndReading()) { ID3D11DepthStencilState *ret; HRESULT hr = m_pDevice->CreateDepthStencilState(&Descriptor, &ret); @@ -2087,13 +2081,13 @@ bool WrappedID3D11Device::Serialise_CreateDepthStencilState( ret = (ID3D11DepthStencilState *)GetResourceManager()->GetWrapper(ret); ret->AddRef(); - GetResourceManager()->AddLiveResource(State, ret); + GetResourceManager()->AddLiveResource(pState, ret); } else { ret = new WrappedID3D11DepthStencilState(ret, this); - GetResourceManager()->AddLiveResource(State, ret); + GetResourceManager()->AddLiveResource(pState, ret); } } } @@ -2135,10 +2129,11 @@ HRESULT WrappedID3D11Device::CreateDepthStencilState(const D3D11_DEPTH_STENCIL_D m_CachedStateObjects.insert(wrapped); } - if(m_State >= WRITING) + if(IsCaptureMode(m_State)) { - SCOPED_SERIALISE_CONTEXT(CREATE_DEPTHSTENCIL_STATE); - Serialise_CreateDepthStencilState(pDepthStencilDesc, &wrapped); + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(D3D11Chunk::CreateDepthStencilState); + Serialise_CreateDepthStencilState(GET_SERIALISER, pDepthStencilDesc, &wrapped); m_DeviceRecord->AddChunk(scope.Get()); } @@ -2149,13 +2144,15 @@ HRESULT WrappedID3D11Device::CreateDepthStencilState(const D3D11_DEPTH_STENCIL_D return ret; } -bool WrappedID3D11Device::Serialise_CreateRasterizerState(const D3D11_RASTERIZER_DESC *pRasterizerDesc, +template +bool WrappedID3D11Device::Serialise_CreateRasterizerState(SerialiserType &ser, + const D3D11_RASTERIZER_DESC *pRasterizerDesc, ID3D11RasterizerState **ppRasterizerState) { - SERIALISE_ELEMENT_PTR(D3D11_RASTERIZER_DESC, Descriptor, pRasterizerDesc); - SERIALISE_ELEMENT(ResourceId, State, GetIDForResource(*ppRasterizerState)); + SERIALISE_ELEMENT_LOCAL(Descriptor, *pRasterizerDesc); + SERIALISE_ELEMENT_LOCAL(pState, GetIDForResource(*ppRasterizerState)); - if(m_State == READING) + if(IsReplayingAndReading()) { ID3D11RasterizerState *ret; HRESULT hr = m_pDevice->CreateRasterizerState(&Descriptor, &ret); @@ -2172,13 +2169,13 @@ bool WrappedID3D11Device::Serialise_CreateRasterizerState(const D3D11_RASTERIZER ret = (ID3D11RasterizerState *)GetResourceManager()->GetWrapper(ret); ret->AddRef(); - GetResourceManager()->AddLiveResource(State, ret); + GetResourceManager()->AddLiveResource(pState, ret); } else { ret = new WrappedID3D11RasterizerState2(ret, this); - GetResourceManager()->AddLiveResource(State, ret); + GetResourceManager()->AddLiveResource(pState, ret); } } } @@ -2220,10 +2217,11 @@ HRESULT WrappedID3D11Device::CreateRasterizerState(const D3D11_RASTERIZER_DESC * m_CachedStateObjects.insert(wrapped); } - if(m_State >= WRITING) + if(IsCaptureMode(m_State)) { - SCOPED_SERIALISE_CONTEXT(CREATE_RASTER_STATE); - Serialise_CreateRasterizerState(pRasterizerDesc, &wrapped); + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(D3D11Chunk::CreateRasterizerState); + Serialise_CreateRasterizerState(GET_SERIALISER, pRasterizerDesc, &wrapped); m_DeviceRecord->AddChunk(scope.Get()); } @@ -2234,13 +2232,15 @@ HRESULT WrappedID3D11Device::CreateRasterizerState(const D3D11_RASTERIZER_DESC * return ret; } -bool WrappedID3D11Device::Serialise_CreateSamplerState(const D3D11_SAMPLER_DESC *pSamplerDesc, +template +bool WrappedID3D11Device::Serialise_CreateSamplerState(SerialiserType &ser, + const D3D11_SAMPLER_DESC *pSamplerDesc, ID3D11SamplerState **ppSamplerState) { - SERIALISE_ELEMENT_PTR(D3D11_SAMPLER_DESC, Descriptor, pSamplerDesc); - SERIALISE_ELEMENT(ResourceId, State, GetIDForResource(*ppSamplerState)); + SERIALISE_ELEMENT_LOCAL(Descriptor, *pSamplerDesc); + SERIALISE_ELEMENT_LOCAL(pState, GetIDForResource(*ppSamplerState)); - if(m_State == READING) + if(IsReplayingAndReading()) { ID3D11SamplerState *ret; HRESULT hr = m_pDevice->CreateSamplerState(&Descriptor, &ret); @@ -2257,13 +2257,13 @@ bool WrappedID3D11Device::Serialise_CreateSamplerState(const D3D11_SAMPLER_DESC ret = (ID3D11SamplerState *)GetResourceManager()->GetWrapper(ret); ret->AddRef(); - GetResourceManager()->AddLiveResource(State, ret); + GetResourceManager()->AddLiveResource(pState, ret); } else { ret = new WrappedID3D11SamplerState(ret, this); - GetResourceManager()->AddLiveResource(State, ret); + GetResourceManager()->AddLiveResource(pState, ret); } } } @@ -2305,10 +2305,11 @@ HRESULT WrappedID3D11Device::CreateSamplerState(const D3D11_SAMPLER_DESC *pSampl m_CachedStateObjects.insert(wrapped); } - if(m_State >= WRITING) + if(IsCaptureMode(m_State)) { - SCOPED_SERIALISE_CONTEXT(CREATE_SAMPLER_STATE); - Serialise_CreateSamplerState(pSamplerDesc, &wrapped); + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(D3D11Chunk::CreateSamplerState); + Serialise_CreateSamplerState(GET_SERIALISER, pSamplerDesc, &wrapped); m_DeviceRecord->AddChunk(scope.Get()); } @@ -2319,13 +2320,15 @@ HRESULT WrappedID3D11Device::CreateSamplerState(const D3D11_SAMPLER_DESC *pSampl return ret; } -bool WrappedID3D11Device::Serialise_CreateQuery(const D3D11_QUERY_DESC *pQueryDesc, +template +bool WrappedID3D11Device::Serialise_CreateQuery(SerialiserType &ser, + const D3D11_QUERY_DESC *pQueryDesc, ID3D11Query **ppQuery) { - SERIALISE_ELEMENT_PTR(D3D11_QUERY_DESC, Descriptor, pQueryDesc); - SERIALISE_ELEMENT(ResourceId, Query, GetIDForResource(*ppQuery)); + SERIALISE_ELEMENT_LOCAL(Descriptor, *pQueryDesc); + SERIALISE_ELEMENT_LOCAL(pQuery, GetIDForResource(*ppQuery)); - if(m_State == READING) + if(IsReplayingAndReading()) { ID3D11Query *ret; HRESULT hr = m_pDevice->CreateQuery(&Descriptor, &ret); @@ -2338,7 +2341,7 @@ bool WrappedID3D11Device::Serialise_CreateQuery(const D3D11_QUERY_DESC *pQueryDe { ret = new WrappedID3D11Query1(ret, this); - GetResourceManager()->AddLiveResource(Query, ret); + GetResourceManager()->AddLiveResource(pQuery, ret); } } @@ -2352,25 +2355,39 @@ HRESULT WrappedID3D11Device::CreateQuery(const D3D11_QUERY_DESC *pQueryDesc, ID3 return m_pDevice->CreateQuery(pQueryDesc, NULL); ID3D11Query *real = NULL; + ID3D11Query *wrapped = NULL; HRESULT ret = m_pDevice->CreateQuery(pQueryDesc, &real); if(SUCCEEDED(ret)) { SCOPED_LOCK(m_D3DLock); - *ppQuery = new WrappedID3D11Query1(real, this); + wrapped = new WrappedID3D11Query1(real, this); + + if(IsCaptureMode(m_State)) + { + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(D3D11Chunk::CreateQuery); + Serialise_CreateQuery(GET_SERIALISER, pQueryDesc, &wrapped); + + m_DeviceRecord->AddChunk(scope.Get()); + } + + *ppQuery = wrapped; } return ret; } -bool WrappedID3D11Device::Serialise_CreatePredicate(const D3D11_QUERY_DESC *pPredicateDesc, +template +bool WrappedID3D11Device::Serialise_CreatePredicate(SerialiserType &ser, + const D3D11_QUERY_DESC *pPredicateDesc, ID3D11Predicate **ppPredicate) { - SERIALISE_ELEMENT_PTR(D3D11_QUERY_DESC, Descriptor, pPredicateDesc); - SERIALISE_ELEMENT(ResourceId, Predicate, GetIDForResource(*ppPredicate)); + SERIALISE_ELEMENT_LOCAL(Descriptor, *pPredicateDesc); + SERIALISE_ELEMENT_LOCAL(pPredicate, GetIDForResource(*ppPredicate)); - if(m_State == READING) + if(IsReplayingAndReading()) { ID3D11Predicate *ret; HRESULT hr = m_pDevice->CreatePredicate(&Descriptor, &ret); @@ -2383,7 +2400,7 @@ bool WrappedID3D11Device::Serialise_CreatePredicate(const D3D11_QUERY_DESC *pPre { ret = new WrappedID3D11Predicate(ret, this); - GetResourceManager()->AddLiveResource(Predicate, ret); + GetResourceManager()->AddLiveResource(pPredicate, ret); } } @@ -2407,10 +2424,11 @@ HRESULT WrappedID3D11Device::CreatePredicate(const D3D11_QUERY_DESC *pPredicateD wrapped = new WrappedID3D11Predicate(real, this); - if(m_State >= WRITING) + if(IsCaptureMode(m_State)) { - SCOPED_SERIALISE_CONTEXT(CREATE_PREDICATE); - Serialise_CreatePredicate(pPredicateDesc, &wrapped); + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(D3D11Chunk::CreatePredicate); + Serialise_CreatePredicate(GET_SERIALISER, pPredicateDesc, &wrapped); m_DeviceRecord->AddChunk(scope.Get()); } @@ -2421,13 +2439,15 @@ HRESULT WrappedID3D11Device::CreatePredicate(const D3D11_QUERY_DESC *pPredicateD return ret; } -bool WrappedID3D11Device::Serialise_CreateCounter(const D3D11_COUNTER_DESC *pCounterDesc, +template +bool WrappedID3D11Device::Serialise_CreateCounter(SerialiserType &ser, + const D3D11_COUNTER_DESC *pCounterDesc, ID3D11Counter **ppCounter) { - SERIALISE_ELEMENT_PTR(D3D11_COUNTER_DESC, Descriptor, pCounterDesc); - SERIALISE_ELEMENT(ResourceId, Counter, GetIDForResource(*ppCounter)); + SERIALISE_ELEMENT_LOCAL(Descriptor, *pCounterDesc); + SERIALISE_ELEMENT_LOCAL(pCounter, GetIDForResource(*ppCounter)); - if(m_State == READING) + if(IsReplayingAndReading()) { ID3D11Counter *ret; HRESULT hr = m_pDevice->CreateCounter(&Descriptor, &ret); @@ -2440,7 +2460,7 @@ bool WrappedID3D11Device::Serialise_CreateCounter(const D3D11_COUNTER_DESC *pCou { ret = new WrappedID3D11Counter(ret, this); - GetResourceManager()->AddLiveResource(Counter, ret); + GetResourceManager()->AddLiveResource(pCounter, ret); } } @@ -2455,29 +2475,42 @@ HRESULT WrappedID3D11Device::CreateCounter(const D3D11_COUNTER_DESC *pCounterDes return m_pDevice->CreateCounter(pCounterDesc, NULL); ID3D11Counter *real = NULL; + ID3D11Counter *wrapped = NULL; HRESULT ret = m_pDevice->CreateCounter(pCounterDesc, &real); if(SUCCEEDED(ret)) { SCOPED_LOCK(m_D3DLock); - *ppCounter = new WrappedID3D11Counter(real, this); + wrapped = new WrappedID3D11Counter(real, this); + + if(IsCaptureMode(m_State)) + { + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(D3D11Chunk::CreateCounter); + Serialise_CreateCounter(GET_SERIALISER, pCounterDesc, &wrapped); + + m_DeviceRecord->AddChunk(scope.Get()); + } + + *ppCounter = wrapped; } return ret; } -bool WrappedID3D11Device::Serialise_CreateDeferredContext(const UINT ContextFlags, +template +bool WrappedID3D11Device::Serialise_CreateDeferredContext(SerialiserType &ser, + const UINT ContextFlags, ID3D11DeviceContext **ppDeferredContext) { - SERIALISE_ELEMENT(uint32_t, Flags, ContextFlags); - SERIALISE_ELEMENT(ResourceId, Context, - ((WrappedID3D11DeviceContext *)(*ppDeferredContext))->GetResourceID()); + SERIALISE_ELEMENT(ContextFlags); + SERIALISE_ELEMENT_LOCAL(pDeferredContext, GetIDForDeviceChild(*ppDeferredContext)); - if(m_State == READING) + if(IsReplayingAndReading()) { ID3D11DeviceContext *ret; - HRESULT hr = m_pDevice->CreateDeferredContext(Flags, &ret); + HRESULT hr = m_pDevice->CreateDeferredContext(ContextFlags, &ret); if(FAILED(hr)) { @@ -2485,11 +2518,11 @@ bool WrappedID3D11Device::Serialise_CreateDeferredContext(const UINT ContextFlag } else { - ret = new WrappedID3D11DeviceContext(this, ret, m_pSerialiser); + ret = new WrappedID3D11DeviceContext(this, ret); AddDeferredContext((WrappedID3D11DeviceContext *)ret); - GetResourceManager()->AddLiveResource(Context, ret); + GetResourceManager()->AddLiveResource(pDeferredContext, ret); } } @@ -2511,19 +2544,20 @@ HRESULT WrappedID3D11Device::CreateDeferredContext(UINT ContextFlags, { SCOPED_LOCK(m_D3DLock); - WrappedID3D11DeviceContext *w = new WrappedID3D11DeviceContext(this, real, m_pSerialiser); + WrappedID3D11DeviceContext *w = new WrappedID3D11DeviceContext(this, real); wrapped = w; - if(m_State == WRITING_CAPFRAME) + if(IsActiveCapturing(m_State)) w->AttemptCapture(); - if(m_State >= WRITING) + if(IsCaptureMode(m_State)) { AddDeferredContext(w); - SCOPED_SERIALISE_CONTEXT(CREATE_DEFERRED_CONTEXT); - Serialise_CreateDeferredContext(ContextFlags, &wrapped); + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(D3D11Chunk::CreateDeferredContext); + Serialise_CreateDeferredContext(GET_SERIALISER, ContextFlags, &wrapped); m_DeviceRecord->AddChunk(scope.Get()); } @@ -2534,35 +2568,42 @@ HRESULT WrappedID3D11Device::CreateDeferredContext(UINT ContextFlags, return ret; } -bool WrappedID3D11Device::Serialise_OpenSharedResource(HANDLE hResource, REFIID ReturnedInterface, - void **ppResource) +template +bool WrappedID3D11Device::Serialise_OpenSharedResource(SerialiserType &ser, HANDLE hResource, + REFIID ReturnedInterface, void **ppResource) { - SERIALISE_ELEMENT(ResourceType, type, IdentifyTypeByPtr((IUnknown *)*ppResource)); - SERIALISE_ELEMENT(ResourceId, pResource, GetIDForResource((ID3D11DeviceChild *)*ppResource)); + ID3D11DeviceChild *res = ppResource ? (ID3D11DeviceChild *)*ppResource : NULL; - if(type == Resource_Buffer) + SERIALISE_ELEMENT_LOCAL(Type, IdentifyTypeByPtr(res)); + SERIALISE_ELEMENT_LOCAL(pResource, GetIDForResource(res)); + + if(Type == Resource_Buffer) { - D3D11_BUFFER_DESC desc; - RDCEraseEl(desc); + D3D11_BUFFER_DESC Descriptor; + RDCEraseEl(Descriptor); - if(m_State >= WRITING) + byte *BufferContents = NULL; + + if(ser.IsWriting()) { - ID3D11Buffer *buf = (ID3D11Buffer *)*ppResource; - buf->GetDesc(&desc); + ID3D11Buffer *buf = (ID3D11Buffer *)res; + buf->GetDesc(&Descriptor); + + // need to allocate record storage for this buffer + BufferContents = new byte[Descriptor.ByteWidth]; } - SERIALISE_ELEMENT(D3D11_BUFFER_DESC, Descriptor, desc); + SERIALISE_ELEMENT(Descriptor); + SERIALISE_ELEMENT_ARRAY(BufferContents, Descriptor.ByteWidth); - char *dummy = new char[Descriptor.ByteWidth]; - SERIALISE_ELEMENT_BUF(byte *, InitialData, dummy, Descriptor.ByteWidth); - delete[] dummy; - - uint64_t offs = m_pSerialiser->GetOffset() - Descriptor.ByteWidth; - - RDCASSERT((offs % 16) == 0); - - if(m_State >= WRITING) + if(ser.IsWriting()) { + SAFE_DELETE_ARRAY(BufferContents); + + uint64_t offs = ser.GetWriter()->GetOffset() - Descriptor.ByteWidth; + + RDCASSERT((offs % 64) == 0); + RDCASSERT(GetResourceManager()->GetResourceRecord(pResource) == NULL); D3D11ResourceRecord *record = GetResourceManager()->AddResourceRecord(pResource); @@ -2571,7 +2612,7 @@ bool WrappedID3D11Device::Serialise_OpenSharedResource(HANDLE hResource, REFIID record->Length = Descriptor.ByteWidth; } - if(m_State == READING) + if(IsReplayingAndReading()) { ID3D11Buffer *ret; @@ -2583,7 +2624,7 @@ bool WrappedID3D11Device::Serialise_OpenSharedResource(HANDLE hResource, REFIID D3D11_RESOURCE_MISC_GDI_COMPATIBLE | D3D11_RESOURCE_MISC_SHARED_NTHANDLE); D3D11_SUBRESOURCE_DATA data; - data.pSysMem = InitialData; + data.pSysMem = BufferContents; data.SysMemPitch = Descriptor.ByteWidth; data.SysMemSlicePitch = Descriptor.ByteWidth; hr = m_pDevice->CreateBuffer(&Descriptor, &data, &ret); @@ -2603,17 +2644,17 @@ bool WrappedID3D11Device::Serialise_OpenSharedResource(HANDLE hResource, REFIID { ID3D11Buffer *stage = NULL; - RDCEraseEl(desc); - desc.ByteWidth = Descriptor.ByteWidth; - desc.MiscFlags = 0; - desc.StructureByteStride = 0; + RDCEraseEl(Descriptor); + Descriptor.ByteWidth = Descriptor.ByteWidth; + Descriptor.MiscFlags = 0; + Descriptor.StructureByteStride = 0; // We don't need to bind this, but IMMUTABLE requires at least one // BindFlags. - desc.BindFlags = D3D11_BIND_VERTEX_BUFFER; - desc.CPUAccessFlags = 0; - desc.Usage = D3D11_USAGE_IMMUTABLE; + Descriptor.BindFlags = D3D11_BIND_VERTEX_BUFFER; + Descriptor.CPUAccessFlags = 0; + Descriptor.Usage = D3D11_USAGE_IMMUTABLE; - hr = m_pDevice->CreateBuffer(&desc, &data, &stage); + hr = m_pDevice->CreateBuffer(&Descriptor, &data, &stage); if(FAILED(hr) || stage == NULL) { @@ -2627,28 +2668,24 @@ bool WrappedID3D11Device::Serialise_OpenSharedResource(HANDLE hResource, REFIID eInitialContents_Copy, NULL)); } } - - SAFE_DELETE_ARRAY(InitialData); } } - else if(type == Resource_Texture1D) + else if(Type == Resource_Texture1D) { - D3D11_TEXTURE1D_DESC desc; - RDCEraseEl(desc); + D3D11_TEXTURE1D_DESC Descriptor; + RDCEraseEl(Descriptor); - if(m_State >= WRITING) - { - ID3D11Texture1D *tex = (ID3D11Texture1D *)*ppResource; - tex->GetDesc(&desc); - } + ID3D11Texture1D *tex = (ID3D11Texture1D *)res; - SERIALISE_ELEMENT(D3D11_TEXTURE1D_DESC, Descriptor, desc); + if(ser.IsWriting()) + tex->GetDesc(&Descriptor); - Serialise_CreateTextureData(ppResource ? (ID3D11Texture1D *)*ppResource : NULL, pResource, NULL, - Descriptor.Width, 1, 1, Descriptor.Format, Descriptor.MipLevels, - Descriptor.ArraySize, false); + SERIALISE_ELEMENT(Descriptor); - if(m_State == READING) + Serialise_CreateTextureData(ser, tex, pResource, NULL, Descriptor.Width, 1, 1, Descriptor.Format, + Descriptor.MipLevels, Descriptor.ArraySize, false); + + if(IsReplayingAndReading()) { ID3D11Texture1D *ret; HRESULT hr = S_OK; @@ -2674,24 +2711,22 @@ bool WrappedID3D11Device::Serialise_OpenSharedResource(HANDLE hResource, REFIID } } } - else if(type == Resource_Texture2D) + else if(Type == Resource_Texture2D) { - D3D11_TEXTURE2D_DESC desc; - RDCEraseEl(desc); + D3D11_TEXTURE2D_DESC Descriptor; + RDCEraseEl(Descriptor); - if(m_State >= WRITING) - { - ID3D11Texture2D *tex = (ID3D11Texture2D *)*ppResource; - tex->GetDesc(&desc); - } + ID3D11Texture2D *tex = (ID3D11Texture2D *)res; - SERIALISE_ELEMENT(D3D11_TEXTURE2D_DESC, Descriptor, desc); + if(ser.IsWriting()) + tex->GetDesc(&Descriptor); - Serialise_CreateTextureData(ppResource ? (ID3D11Texture2D *)*ppResource : NULL, pResource, NULL, - Descriptor.Width, Descriptor.Height, 1, Descriptor.Format, - Descriptor.MipLevels, Descriptor.ArraySize, false); + SERIALISE_ELEMENT(Descriptor); - if(m_State == READING) + Serialise_CreateTextureData(ser, tex, pResource, NULL, Descriptor.Width, Descriptor.Height, 1, + Descriptor.Format, Descriptor.MipLevels, Descriptor.ArraySize, false); + + if(IsReplayingAndReading()) { ID3D11Texture2D *ret; HRESULT hr = S_OK; @@ -2717,24 +2752,22 @@ bool WrappedID3D11Device::Serialise_OpenSharedResource(HANDLE hResource, REFIID } } } - else if(type == Resource_Texture3D) + else if(Type == Resource_Texture3D) { - D3D11_TEXTURE3D_DESC desc; - RDCEraseEl(desc); + D3D11_TEXTURE3D_DESC Descriptor; + RDCEraseEl(Descriptor); - if(m_State >= WRITING) - { - ID3D11Texture3D *tex = (ID3D11Texture3D *)*ppResource; - tex->GetDesc(&desc); - } + ID3D11Texture3D *tex = (ID3D11Texture3D *)res; - SERIALISE_ELEMENT(D3D11_TEXTURE3D_DESC, Descriptor, desc); + if(ser.IsWriting()) + tex->GetDesc(&Descriptor); - Serialise_CreateTextureData(ppResource ? (ID3D11Texture3D *)*ppResource : NULL, pResource, NULL, - Descriptor.Width, Descriptor.Height, Descriptor.Depth, - Descriptor.Format, Descriptor.MipLevels, 1, false); + SERIALISE_ELEMENT(Descriptor); - if(m_State == READING) + Serialise_CreateTextureData(ser, tex, pResource, NULL, Descriptor.Width, Descriptor.Height, + Descriptor.Depth, Descriptor.Format, Descriptor.MipLevels, 1, false); + + if(IsReplayingAndReading()) { ID3D11Texture3D *ret; HRESULT hr = S_OK; @@ -2760,6 +2793,10 @@ bool WrappedID3D11Device::Serialise_OpenSharedResource(HANDLE hResource, REFIID } } } + else + { + RDCERR("Unknown type of resource being shared"); + } return true; } @@ -2767,7 +2804,13 @@ bool WrappedID3D11Device::Serialise_OpenSharedResource(HANDLE hResource, REFIID HRESULT WrappedID3D11Device::OpenSharedResource(HANDLE hResource, REFIID ReturnedInterface, void **ppResource) { - if(m_State < WRITING || ppResource == NULL) + if(IsReplayMode(m_State)) + { + RDCERR("Don't support opening shared resources during replay."); + return E_NOTIMPL; + } + + if(ppResource == NULL) return E_INVALIDARG; bool isDXGIRes = (ReturnedInterface == __uuidof(IDXGIResource) ? true : false); @@ -2888,8 +2931,9 @@ HRESULT WrappedID3D11Device::OpenSharedResource(HANDLE hResource, REFIID Returne Chunk *chunk = NULL; { - SCOPED_SERIALISE_CONTEXT(OPEN_SHARED_RESOURCE); - Serialise_OpenSharedResource(hResource, ReturnedInterface, ppResource); + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(D3D11Chunk::OpenSharedResource); + Serialise_OpenSharedResource(GET_SERIALISER, hResource, ReturnedInterface, ppResource); chunk = scope.Get(); } @@ -2980,14 +3024,13 @@ void WrappedID3D11Device::GetImmediateContext(ID3D11DeviceContext **ppImmediateC } } -bool WrappedID3D11Device::Serialise_SetExceptionMode(UINT RaiseFlags) +template +bool WrappedID3D11Device::Serialise_SetExceptionMode(SerialiserType &ser, UINT RaiseFlags) { - SERIALISE_ELEMENT(uint32_t, Flags, RaiseFlags); + SERIALISE_ELEMENT(RaiseFlags); - if(m_State == READING) - { - m_pDevice->SetExceptionMode(Flags); - } + if(IsReplayingAndReading()) + m_pDevice->SetExceptionMode(RaiseFlags); return true; } @@ -2996,12 +3039,13 @@ HRESULT WrappedID3D11Device::SetExceptionMode(UINT RaiseFlags) { HRESULT ret = m_pDevice->SetExceptionMode(RaiseFlags); - if(SUCCEEDED(ret) && m_State >= WRITING) + if(SUCCEEDED(ret) && IsCaptureMode(m_State)) { SCOPED_LOCK(m_D3DLock); - SCOPED_SERIALISE_CONTEXT(SET_EXCEPTION_MODE); - Serialise_SetExceptionMode(RaiseFlags); + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(D3D11Chunk::SetExceptionMode); + Serialise_SetExceptionMode(GET_SERIALISER, RaiseFlags); m_DeviceRecord->AddChunk(scope.Get()); } diff --git a/renderdoc/driver/d3d11/d3d11_resources.h b/renderdoc/driver/d3d11/d3d11_resources.h index 16474ab60..1de7cffc1 100644 --- a/renderdoc/driver/d3d11/d3d11_resources.h +++ b/renderdoc/driver/d3d11/d3d11_resources.h @@ -1228,7 +1228,7 @@ public: if(SUCCEEDED(hr) && real) { - *ppInstance = m_pDevice->GetClassInstance(pClassInstanceName, InstanceIndex, this, real); + *ppInstance = m_pDevice->GetClassInstance(pClassInstanceName, InstanceIndex, this, &real); } else { @@ -1264,7 +1264,7 @@ public: { *ppInstance = m_pDevice->CreateClassInstance(pClassTypeName, ConstantBufferOffset, ConstantVectorOffset, - TextureOffset, SamplerOffset, this, real); + TextureOffset, SamplerOffset, this, &real); } else {