diff --git a/renderdoc/driver/d3d11/d3d11_context.cpp b/renderdoc/driver/d3d11/d3d11_context.cpp index 59caf5efa..6bd17490f 100644 --- a/renderdoc/driver/d3d11/d3d11_context.cpp +++ b/renderdoc/driver/d3d11/d3d11_context.cpp @@ -264,18 +264,6 @@ bool WrappedID3D11DeviceContext::Serialise_BeginCaptureFrame(SerialiserType &ser SERIALISE_ELEMENT(state); - if(IsReplayingAndReading() && applyInitialState) - { - m_DoStateVerify = false; - { - m_CurrentPipelineState->CopyState(state); - m_CurrentPipelineState->SetDevice(m_pDevice); - state.ApplyState(this); - } - m_DoStateVerify = true; - VerifyState(); - } - // stream-out hidden counters need to be saved, in case their results are used // for a DrawAuto() somewhere. Each buffer used as a stream-out target has a hidden // counter saved with it that stores the number of primitives written, which is then @@ -365,12 +353,26 @@ bool WrappedID3D11DeviceContext::Serialise_BeginCaptureFrame(SerialiserType &ser SERIALISE_ELEMENT(HiddenStreamOutCounters); - // read in the known stream-out counters at the start of the frame. - // any stream-out that happens in the captured frame will be replayed - // and those counters will override this value when it comes to a - // DrawAuto() - if(IsReplayingAndReading()) + SERIALISE_CHECK_READ_ERRORS(); + + if(IsReplayingAndReading() && applyInitialState) { + if(applyInitialState) + { + m_DoStateVerify = false; + { + m_CurrentPipelineState->CopyState(state); + m_CurrentPipelineState->SetDevice(m_pDevice); + state.ApplyState(this); + } + m_DoStateVerify = true; + VerifyState(); + } + + // read in the known stream-out counters at the start of the frame. + // any stream-out that happens in the captured frame will be replayed + // and those counters will override this value when it comes to a + // DrawAuto() for(const HiddenCounter &c : HiddenStreamOutCounters) { if(m_pDevice->GetResourceManager()->HasLiveResource(c.id)) @@ -624,169 +626,207 @@ bool WrappedID3D11DeviceContext::IsFL11_1() return m_pDevice->GetFeatureLevel() >= D3D_FEATURE_LEVEL_11_1; } -void WrappedID3D11DeviceContext::ProcessChunk(ReadSerialiser &ser, D3D11Chunk chunk) +bool WrappedID3D11DeviceContext::ProcessChunk(ReadSerialiser &ser, D3D11Chunk chunk) { ResourceId ctxId; SERIALISE_ELEMENT(ctxId).Named("Context ID"); + SERIALISE_CHECK_READ_ERRORS(); + m_AddedDrawcall = false; + bool ret = false; + switch(chunk) { - case D3D11Chunk::IASetInputLayout: Serialise_IASetInputLayout(ser, 0x0); break; + case D3D11Chunk::IASetInputLayout: ret = Serialise_IASetInputLayout(ser, 0x0); break; case D3D11Chunk::IASetVertexBuffers: - Serialise_IASetVertexBuffers(ser, 0, 0, 0x0, 0x0, 0x0); + ret = Serialise_IASetVertexBuffers(ser, 0, 0, 0x0, 0x0, 0x0); break; case D3D11Chunk::IASetIndexBuffer: - Serialise_IASetIndexBuffer(ser, 0, DXGI_FORMAT_UNKNOWN, 0); + ret = Serialise_IASetIndexBuffer(ser, 0, DXGI_FORMAT_UNKNOWN, 0); break; case D3D11Chunk::IASetPrimitiveTopology: - Serialise_IASetPrimitiveTopology(ser, D3D11_PRIMITIVE_TOPOLOGY_UNDEFINED); + ret = Serialise_IASetPrimitiveTopology(ser, D3D11_PRIMITIVE_TOPOLOGY_UNDEFINED); break; - case D3D11Chunk::VSSetConstantBuffers: Serialise_VSSetConstantBuffers(ser, 0, 0, 0x0); break; - case D3D11Chunk::VSSetShaderResources: Serialise_VSSetShaderResources(ser, 0, 0, 0x0); break; - case D3D11Chunk::VSSetSamplers: Serialise_VSSetSamplers(ser, 0, 0, 0x0); break; - case D3D11Chunk::VSSetShader: Serialise_VSSetShader(ser, 0x0, 0x0, 0); break; + case D3D11Chunk::VSSetConstantBuffers: + ret = Serialise_VSSetConstantBuffers(ser, 0, 0, 0x0); + break; + case D3D11Chunk::VSSetShaderResources: + ret = Serialise_VSSetShaderResources(ser, 0, 0, 0x0); + break; + case D3D11Chunk::VSSetSamplers: ret = Serialise_VSSetSamplers(ser, 0, 0, 0x0); break; + case D3D11Chunk::VSSetShader: ret = Serialise_VSSetShader(ser, 0x0, 0x0, 0); break; - case D3D11Chunk::HSSetConstantBuffers: Serialise_HSSetConstantBuffers(ser, 0, 0, 0x0); break; - case D3D11Chunk::HSSetShaderResources: Serialise_HSSetShaderResources(ser, 0, 0, 0x0); break; - case D3D11Chunk::HSSetSamplers: Serialise_HSSetSamplers(ser, 0, 0, 0x0); break; - case D3D11Chunk::HSSetShader: Serialise_HSSetShader(ser, 0x0, 0x0, 0); break; + case D3D11Chunk::HSSetConstantBuffers: + ret = Serialise_HSSetConstantBuffers(ser, 0, 0, 0x0); + break; + case D3D11Chunk::HSSetShaderResources: + ret = Serialise_HSSetShaderResources(ser, 0, 0, 0x0); + break; + case D3D11Chunk::HSSetSamplers: ret = Serialise_HSSetSamplers(ser, 0, 0, 0x0); break; + case D3D11Chunk::HSSetShader: ret = Serialise_HSSetShader(ser, 0x0, 0x0, 0); break; - case D3D11Chunk::DSSetConstantBuffers: Serialise_DSSetConstantBuffers(ser, 0, 0, 0x0); break; - case D3D11Chunk::DSSetShaderResources: Serialise_DSSetShaderResources(ser, 0, 0, 0x0); break; - case D3D11Chunk::DSSetSamplers: Serialise_DSSetSamplers(ser, 0, 0, 0x0); break; - case D3D11Chunk::DSSetShader: Serialise_DSSetShader(ser, 0x0, 0x0, 0); break; + case D3D11Chunk::DSSetConstantBuffers: + ret = Serialise_DSSetConstantBuffers(ser, 0, 0, 0x0); + break; + case D3D11Chunk::DSSetShaderResources: + ret = Serialise_DSSetShaderResources(ser, 0, 0, 0x0); + break; + case D3D11Chunk::DSSetSamplers: ret = Serialise_DSSetSamplers(ser, 0, 0, 0x0); break; + case D3D11Chunk::DSSetShader: ret = Serialise_DSSetShader(ser, 0x0, 0x0, 0); break; - case D3D11Chunk::GSSetConstantBuffers: Serialise_GSSetConstantBuffers(ser, 0, 0, 0x0); break; - case D3D11Chunk::GSSetShaderResources: Serialise_GSSetShaderResources(ser, 0, 0, 0x0); break; - case D3D11Chunk::GSSetSamplers: Serialise_GSSetSamplers(ser, 0, 0, 0x0); break; - case D3D11Chunk::GSSetShader: Serialise_GSSetShader(ser, 0x0, 0x0, 0); break; + case D3D11Chunk::GSSetConstantBuffers: + ret = Serialise_GSSetConstantBuffers(ser, 0, 0, 0x0); + break; + case D3D11Chunk::GSSetShaderResources: + ret = Serialise_GSSetShaderResources(ser, 0, 0, 0x0); + break; + case D3D11Chunk::GSSetSamplers: ret = Serialise_GSSetSamplers(ser, 0, 0, 0x0); break; + case D3D11Chunk::GSSetShader: ret = Serialise_GSSetShader(ser, 0x0, 0x0, 0); break; - case D3D11Chunk::SOSetTargets: Serialise_SOSetTargets(ser, 0, 0x0, 0x0); break; + case D3D11Chunk::SOSetTargets: ret = Serialise_SOSetTargets(ser, 0, 0x0, 0x0); break; - case D3D11Chunk::PSSetConstantBuffers: Serialise_PSSetConstantBuffers(ser, 0, 0, 0x0); break; - case D3D11Chunk::PSSetShaderResources: Serialise_PSSetShaderResources(ser, 0, 0, 0x0); break; - case D3D11Chunk::PSSetSamplers: Serialise_PSSetSamplers(ser, 0, 0, 0x0); break; - case D3D11Chunk::PSSetShader: Serialise_PSSetShader(ser, 0x0, 0x0, 0); break; + case D3D11Chunk::PSSetConstantBuffers: + ret = Serialise_PSSetConstantBuffers(ser, 0, 0, 0x0); + break; + case D3D11Chunk::PSSetShaderResources: + ret = Serialise_PSSetShaderResources(ser, 0, 0, 0x0); + break; + case D3D11Chunk::PSSetSamplers: ret = Serialise_PSSetSamplers(ser, 0, 0, 0x0); break; + case D3D11Chunk::PSSetShader: ret = Serialise_PSSetShader(ser, 0x0, 0x0, 0); break; - case D3D11Chunk::CSSetConstantBuffers: Serialise_CSSetConstantBuffers(ser, 0, 0, 0x0); break; - case D3D11Chunk::CSSetShaderResources: Serialise_CSSetShaderResources(ser, 0, 0, 0x0); break; + case D3D11Chunk::CSSetConstantBuffers: + ret = Serialise_CSSetConstantBuffers(ser, 0, 0, 0x0); + break; + case D3D11Chunk::CSSetShaderResources: + ret = Serialise_CSSetShaderResources(ser, 0, 0, 0x0); + break; case D3D11Chunk::CSSetUnorderedAccessViews: - Serialise_CSSetUnorderedAccessViews(ser, 0, 0, 0x0, 0x0); + ret = Serialise_CSSetUnorderedAccessViews(ser, 0, 0, 0x0, 0x0); break; - case D3D11Chunk::CSSetSamplers: Serialise_CSSetSamplers(ser, 0, 0, 0x0); break; - case D3D11Chunk::CSSetShader: Serialise_CSSetShader(ser, 0x0, 0x0, 0); break; + case D3D11Chunk::CSSetSamplers: ret = Serialise_CSSetSamplers(ser, 0, 0, 0x0); break; + case D3D11Chunk::CSSetShader: ret = Serialise_CSSetShader(ser, 0x0, 0x0, 0); break; - case D3D11Chunk::RSSetViewports: Serialise_RSSetViewports(ser, 0, 0x0); break; - case D3D11Chunk::RSSetScissorRects: Serialise_RSSetScissorRects(ser, 0, 0x0); break; - case D3D11Chunk::RSSetState: Serialise_RSSetState(ser, 0x0); break; + case D3D11Chunk::RSSetViewports: ret = Serialise_RSSetViewports(ser, 0, 0x0); break; + case D3D11Chunk::RSSetScissorRects: ret = Serialise_RSSetScissorRects(ser, 0, 0x0); break; + case D3D11Chunk::RSSetState: ret = Serialise_RSSetState(ser, 0x0); break; - case D3D11Chunk::OMSetRenderTargets: Serialise_OMSetRenderTargets(ser, 0, 0x0, 0x0); break; + case D3D11Chunk::OMSetRenderTargets: + ret = Serialise_OMSetRenderTargets(ser, 0, 0x0, 0x0); + break; case D3D11Chunk::OMSetRenderTargetsAndUnorderedAccessViews: - Serialise_OMSetRenderTargetsAndUnorderedAccessViews(ser, 0, 0x0, 0x0, 0, 0, 0x0, 0x0); + ret = Serialise_OMSetRenderTargetsAndUnorderedAccessViews(ser, 0, 0x0, 0x0, 0, 0, 0x0, 0x0); + break; + case D3D11Chunk::OMSetBlendState: + ret = Serialise_OMSetBlendState(ser, 0x0, (FLOAT *)0x0, 0); + break; + case D3D11Chunk::OMSetDepthStencilState: + ret = Serialise_OMSetDepthStencilState(ser, 0x0, 0); break; - case D3D11Chunk::OMSetBlendState: Serialise_OMSetBlendState(ser, 0x0, (FLOAT *)0x0, 0); break; - case D3D11Chunk::OMSetDepthStencilState: Serialise_OMSetDepthStencilState(ser, 0x0, 0); break; case D3D11Chunk::DrawIndexedInstanced: - Serialise_DrawIndexedInstanced(ser, 0, 0, 0, 0, 0); + ret = Serialise_DrawIndexedInstanced(ser, 0, 0, 0, 0, 0); break; - case D3D11Chunk::DrawInstanced: Serialise_DrawInstanced(ser, 0, 0, 0, 0); break; - case D3D11Chunk::DrawIndexed: Serialise_DrawIndexed(ser, 0, 0, 0); break; - case D3D11Chunk::Draw: Serialise_Draw(ser, 0, 0); break; - case D3D11Chunk::DrawAuto: Serialise_DrawAuto(ser); break; + case D3D11Chunk::DrawInstanced: ret = Serialise_DrawInstanced(ser, 0, 0, 0, 0); break; + case D3D11Chunk::DrawIndexed: ret = Serialise_DrawIndexed(ser, 0, 0, 0); break; + case D3D11Chunk::Draw: ret = Serialise_Draw(ser, 0, 0); break; + case D3D11Chunk::DrawAuto: ret = Serialise_DrawAuto(ser); break; case D3D11Chunk::DrawIndexedInstancedIndirect: - Serialise_DrawIndexedInstancedIndirect(ser, 0x0, 0); + ret = Serialise_DrawIndexedInstancedIndirect(ser, 0x0, 0); + break; + case D3D11Chunk::DrawInstancedIndirect: + ret = Serialise_DrawInstancedIndirect(ser, 0x0, 0); break; - case D3D11Chunk::DrawInstancedIndirect: Serialise_DrawInstancedIndirect(ser, 0x0, 0); break; - case D3D11Chunk::Map: Serialise_Map(ser, 0, 0, (D3D11_MAP)0, 0, 0); break; - case D3D11Chunk::Unmap: Serialise_Unmap(ser, 0, 0); break; + case D3D11Chunk::Map: ret = Serialise_Map(ser, 0, 0, (D3D11_MAP)0, 0, 0); break; + case D3D11Chunk::Unmap: ret = Serialise_Unmap(ser, 0, 0); break; case D3D11Chunk::CopySubresourceRegion: - Serialise_CopySubresourceRegion(ser, 0x0, 0, 0, 0, 0, 0x0, 0, 0x0); + ret = Serialise_CopySubresourceRegion(ser, 0x0, 0, 0, 0, 0, 0x0, 0, 0x0); break; - case D3D11Chunk::CopyResource: Serialise_CopyResource(ser, 0x0, 0x0); break; + case D3D11Chunk::CopyResource: ret = Serialise_CopyResource(ser, 0x0, 0x0); break; case D3D11Chunk::UpdateSubresource: - Serialise_UpdateSubresource(ser, 0x0, 0, 0x0, 0x0, 0, 0); + ret = Serialise_UpdateSubresource(ser, 0x0, 0, 0x0, 0x0, 0, 0); + break; + case D3D11Chunk::CopyStructureCount: + ret = Serialise_CopyStructureCount(ser, 0x0, 0, 0x0); break; - case D3D11Chunk::CopyStructureCount: Serialise_CopyStructureCount(ser, 0x0, 0, 0x0); break; case D3D11Chunk::ResolveSubresource: - Serialise_ResolveSubresource(ser, 0x0, 0, 0x0, 0, DXGI_FORMAT_UNKNOWN); + ret = Serialise_ResolveSubresource(ser, 0x0, 0, 0x0, 0, DXGI_FORMAT_UNKNOWN); break; - case D3D11Chunk::GenerateMips: Serialise_GenerateMips(ser, 0x0); break; + case D3D11Chunk::GenerateMips: ret = Serialise_GenerateMips(ser, 0x0); break; case D3D11Chunk::ClearDepthStencilView: - Serialise_ClearDepthStencilView(ser, 0x0, 0, 0.0f, 0); + ret = Serialise_ClearDepthStencilView(ser, 0x0, 0, 0.0f, 0); break; case D3D11Chunk::ClearRenderTargetView: - Serialise_ClearRenderTargetView(ser, 0x0, (FLOAT *)0x0); + ret = Serialise_ClearRenderTargetView(ser, 0x0, (FLOAT *)0x0); break; case D3D11Chunk::ClearUnorderedAccessViewUint: - Serialise_ClearUnorderedAccessViewUint(ser, 0x0, (UINT *)0x0); + ret = Serialise_ClearUnorderedAccessViewUint(ser, 0x0, (UINT *)0x0); break; case D3D11Chunk::ClearUnorderedAccessViewFloat: - Serialise_ClearUnorderedAccessViewFloat(ser, 0x0, (FLOAT *)0x0); + ret = Serialise_ClearUnorderedAccessViewFloat(ser, 0x0, (FLOAT *)0x0); break; - case D3D11Chunk::ClearState: Serialise_ClearState(ser); break; + case D3D11Chunk::ClearState: ret = Serialise_ClearState(ser); break; - case D3D11Chunk::ExecuteCommandList: Serialise_ExecuteCommandList(ser, 0x0, 0); break; - case D3D11Chunk::Dispatch: Serialise_Dispatch(ser, 0, 0, 0); break; - case D3D11Chunk::DispatchIndirect: Serialise_DispatchIndirect(ser, 0x0, 0); break; - case D3D11Chunk::FinishCommandList: Serialise_FinishCommandList(ser, 0, 0x0); break; - case D3D11Chunk::Flush: Serialise_Flush(ser); break; + case D3D11Chunk::ExecuteCommandList: ret = Serialise_ExecuteCommandList(ser, 0x0, 0); break; + case D3D11Chunk::Dispatch: ret = Serialise_Dispatch(ser, 0, 0, 0); break; + case D3D11Chunk::DispatchIndirect: ret = Serialise_DispatchIndirect(ser, 0x0, 0); break; + case D3D11Chunk::FinishCommandList: ret = Serialise_FinishCommandList(ser, 0, 0x0); break; + case D3D11Chunk::Flush: ret = Serialise_Flush(ser); break; - case D3D11Chunk::SetPredication: Serialise_SetPredication(ser, 0x0, 0x0); break; - case D3D11Chunk::SetResourceMinLOD: Serialise_SetResourceMinLOD(ser, 0x0, 0); break; + case D3D11Chunk::SetPredication: ret = Serialise_SetPredication(ser, 0x0, 0x0); break; + case D3D11Chunk::SetResourceMinLOD: ret = Serialise_SetResourceMinLOD(ser, 0x0, 0); break; - case D3D11Chunk::Begin: Serialise_Begin(ser, 0x0); break; - case D3D11Chunk::End: Serialise_End(ser, 0x0); break; + case D3D11Chunk::Begin: ret = Serialise_Begin(ser, 0x0); break; + case D3D11Chunk::End: ret = Serialise_End(ser, 0x0); break; case D3D11Chunk::CopySubresourceRegion1: - Serialise_CopySubresourceRegion1(ser, 0x0, 0, 0, 0, 0, 0x0, 0, 0x0, 0); + ret = Serialise_CopySubresourceRegion1(ser, 0x0, 0, 0, 0, 0, 0x0, 0, 0x0, 0); break; case D3D11Chunk::UpdateSubresource1: - Serialise_UpdateSubresource1(ser, 0x0, 0, 0x0, 0x0, 0, 0, 0); + ret = Serialise_UpdateSubresource1(ser, 0x0, 0, 0x0, 0x0, 0, 0, 0); break; - case D3D11Chunk::ClearView: Serialise_ClearView(ser, 0x0, 0x0, 0x0, 0); break; + case D3D11Chunk::ClearView: ret = Serialise_ClearView(ser, 0x0, 0x0, 0x0, 0); break; case D3D11Chunk::VSSetConstantBuffers1: - Serialise_VSSetConstantBuffers1(ser, 0, 0, 0x0, 0x0, 0x0); + ret = Serialise_VSSetConstantBuffers1(ser, 0, 0, 0x0, 0x0, 0x0); break; case D3D11Chunk::HSSetConstantBuffers1: - Serialise_HSSetConstantBuffers1(ser, 0, 0, 0x0, 0x0, 0x0); + ret = Serialise_HSSetConstantBuffers1(ser, 0, 0, 0x0, 0x0, 0x0); break; case D3D11Chunk::DSSetConstantBuffers1: - Serialise_DSSetConstantBuffers1(ser, 0, 0, 0x0, 0x0, 0x0); + ret = Serialise_DSSetConstantBuffers1(ser, 0, 0, 0x0, 0x0, 0x0); break; case D3D11Chunk::GSSetConstantBuffers1: - Serialise_GSSetConstantBuffers1(ser, 0, 0, 0x0, 0x0, 0x0); + ret = Serialise_GSSetConstantBuffers1(ser, 0, 0, 0x0, 0x0, 0x0); break; case D3D11Chunk::PSSetConstantBuffers1: - Serialise_PSSetConstantBuffers1(ser, 0, 0, 0x0, 0x0, 0x0); + ret = Serialise_PSSetConstantBuffers1(ser, 0, 0, 0x0, 0x0, 0x0); break; case D3D11Chunk::CSSetConstantBuffers1: - Serialise_CSSetConstantBuffers1(ser, 0, 0, 0x0, 0x0, 0x0); + ret = Serialise_CSSetConstantBuffers1(ser, 0, 0, 0x0, 0x0, 0x0); break; - case D3D11Chunk::PushMarker: Serialise_PushMarker(ser, 0, L""); break; - case D3D11Chunk::SetMarker: Serialise_SetMarker(ser, 0, L""); break; - case D3D11Chunk::PopMarker: Serialise_PopMarker(ser); break; + case D3D11Chunk::PushMarker: ret = Serialise_PushMarker(ser, 0, L""); break; + case D3D11Chunk::SetMarker: ret = Serialise_SetMarker(ser, 0, L""); break; + case D3D11Chunk::PopMarker: ret = Serialise_PopMarker(ser); break; - case D3D11Chunk::DiscardResource: Serialise_DiscardResource(ser, NULL); break; - case D3D11Chunk::DiscardView: Serialise_DiscardView(ser, NULL); break; - case D3D11Chunk::DiscardView1: Serialise_DiscardView1(ser, NULL, NULL, 0); break; + case D3D11Chunk::DiscardResource: ret = Serialise_DiscardResource(ser, NULL); break; + case D3D11Chunk::DiscardView: ret = Serialise_DiscardView(ser, NULL); break; + case D3D11Chunk::DiscardView1: ret = Serialise_DiscardView1(ser, NULL, NULL, 0); break; case D3D11Chunk::PostExecuteCommandListRestore: - Serialise_PostExecuteCommandListRestore(ser); + ret = Serialise_PostExecuteCommandListRestore(ser); break; - case D3D11Chunk::PostFinishCommandListSet: Serialise_PostFinishCommandListSet(ser); break; + case D3D11Chunk::PostFinishCommandListSet: ret = Serialise_PostFinishCommandListSet(ser); break; case D3D11Chunk::SwapDeviceContextState: - Serialise_SwapDeviceContextState(ser, NULL, NULL); + ret = Serialise_SwapDeviceContextState(ser, NULL, NULL); break; case D3D11Chunk::SwapchainPresent: @@ -796,6 +836,11 @@ void WrappedID3D11DeviceContext::ProcessChunk(ReadSerialiser &ser, D3D11Chunk ch UINT SyncInterval = 0, Flags = 0; SERIALISE_ELEMENT(SyncInterval); SERIALISE_ELEMENT(Flags); + + SERIALISE_CHECK_READ_ERRORS(); + + ret = true; + m_PresentChunk = true; break; } @@ -815,6 +860,8 @@ void WrappedID3D11DeviceContext::ProcessChunk(ReadSerialiser &ser, D3D11Chunk ch AddDrawcall(draw, true); } + + ret = true; } break; default: RDCERR("Unrecognised Chunk type %d", chunk); break; @@ -845,6 +892,8 @@ void WrappedID3D11DeviceContext::ProcessChunk(ReadSerialiser &ser, D3D11Chunk ch } m_AddedDrawcall = false; + + return ret; } void WrappedID3D11DeviceContext::AddUsage(const DrawcallDescription &d) @@ -1034,15 +1083,15 @@ void WrappedID3D11DeviceContext::ReplayFakeContext(ResourceId id) m_FakeContext = id; } -void WrappedID3D11DeviceContext::ReplayLog(CaptureState readType, uint32_t startEventID, - uint32_t endEventID, bool partial) +ReplayStatus WrappedID3D11DeviceContext::ReplayLog(CaptureState readType, uint32_t startEventID, + uint32_t endEventID, bool partial) { m_State = readType; if(!m_FrameReader) { RDCERR("Can't replay context capture without frame reader"); - return; + return ReplayStatus::InternalError; } m_FrameReader->SetOffset(0); @@ -1112,12 +1161,23 @@ void WrappedID3D11DeviceContext::ReplayLog(CaptureState readType, uint32_t start D3D11Chunk chunktype = ser.ReadChunk(); + if(ser.GetReader()->IsErrored()) + return ReplayStatus::APIDataCorrupted; + m_ChunkMetadata = ser.ChunkMetadata(); - ProcessChunk(ser, chunktype); + bool success = ProcessChunk(ser, chunktype); ser.EndChunk(); + if(ser.GetReader()->IsErrored()) + return ReplayStatus::APIDataCorrupted; + + // if there wasn't a serialisation error, but the chunk didn't succeed, then it's an API replay + // failure. + if(!success) + return m_FailedReplayStatus; + RenderDoc::Inst().SetProgress( FrameEventsRead, float(m_CurChunkOffset - startOffset) / float(ser.GetReader()->GetSize())); @@ -1218,6 +1278,8 @@ void WrappedID3D11DeviceContext::ReplayLog(CaptureState readType, uint32_t start m_pDevice->GetResourceManager()->MarkInFrame(false); m_DoStateVerify = false; + + return ReplayStatus::Succeeded; } void WrappedID3D11DeviceContext::ClearMaps() diff --git a/renderdoc/driver/d3d11/d3d11_context.h b/renderdoc/driver/d3d11/d3d11_context.h index 8dada8991..38b558891 100644 --- a/renderdoc/driver/d3d11/d3d11_context.h +++ b/renderdoc/driver/d3d11/d3d11_context.h @@ -200,6 +200,8 @@ private: SDChunkMetaData m_ChunkMetadata; uint32_t m_CurEventID, m_CurDrawcallID; + ReplayStatus m_FailedReplayStatus = ReplayStatus::APIReplayFailed; + DrawcallDescription m_ParentDrawcall; map m_CmdLists; @@ -293,9 +295,10 @@ public: ID3D11DeviceContext1 *GetReal1() { return m_pRealContext1; } bool IsFL11_1(); - void ProcessChunk(ReadSerialiser &ser, D3D11Chunk chunk); + bool ProcessChunk(ReadSerialiser &ser, D3D11Chunk chunk); void ReplayFakeContext(ResourceId id); - void ReplayLog(CaptureState readType, uint32_t startEventID, uint32_t endEventID, bool partial); + ReplayStatus ReplayLog(CaptureState readType, uint32_t startEventID, uint32_t endEventID, + bool partial); void SetFrameReader(StreamReader *reader) { m_FrameReader = reader; } void MarkResourceReferenced(ResourceId id, FrameRefType refType); diff --git a/renderdoc/driver/d3d11/d3d11_context1_wrap.cpp b/renderdoc/driver/d3d11/d3d11_context1_wrap.cpp index c1fcff0c8..68419e793 100644 --- a/renderdoc/driver/d3d11/d3d11_context1_wrap.cpp +++ b/renderdoc/driver/d3d11/d3d11_context1_wrap.cpp @@ -146,10 +146,11 @@ bool WrappedID3D11DeviceContext::Serialise_UpdateSubresource1( SERIALISE_ELEMENT_ARRAY(pSrcData, SourceDataLength); - if(ser.IsReading() && pDstResource) + SERIALISE_CHECK_READ_ERRORS(); + + if(IsReplayingAndReading() && pDstResource) { - if(IsReplayingAndReading()) - RecordUpdateStats(pDstResource, SourceDataLength, true); + RecordUpdateStats(pDstResource, SourceDataLength, true); if(CopyFlags == ~0U) { @@ -214,7 +215,9 @@ bool WrappedID3D11DeviceContext::Serialise_UpdateSubresource1( // data pointer and either marking the resource as dirty or updating the backing store with // pSrcData passed in - if(ser.IsReading() && pDstResource) + SERIALISE_CHECK_READ_ERRORS(); + + if(IsReplayingAndReading() && pDstResource) { WrappedID3D11Texture1D *tex1 = WrappedID3D11Texture1D::IsAlloc(pDstResource) ? (WrappedID3D11Texture1D *)pDstResource @@ -356,6 +359,8 @@ bool WrappedID3D11DeviceContext::Serialise_CopySubresourceRegion1( SERIALISE_ELEMENT_OPT(pSrcBox); SERIALISE_ELEMENT_TYPED(D3D11_COPY_FLAGS, CopyFlags); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading() && pDstResource && pSrcResource) { if(m_pRealContext1) @@ -435,6 +440,8 @@ bool WrappedID3D11DeviceContext::Serialise_ClearView(SerialiserType &ser, ID3D11 Serialise_DebugMessages(ser); + SERIALISE_CHECK_READ_ERRORS(); + if(ser.IsReading()) { ResourceId resid; @@ -563,6 +570,8 @@ bool WrappedID3D11DeviceContext::Serialise_VSSetConstantBuffers1( SERIALISE_ELEMENT_ARRAY(pNumConstants, NumBuffers); SERIALISE_ELEMENT(NumBuffers); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(IsLoading(m_State)) @@ -688,6 +697,8 @@ bool WrappedID3D11DeviceContext::Serialise_HSSetConstantBuffers1( SERIALISE_ELEMENT_ARRAY(pNumConstants, NumBuffers); SERIALISE_ELEMENT(NumBuffers); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(IsLoading(m_State)) @@ -813,6 +824,8 @@ bool WrappedID3D11DeviceContext::Serialise_DSSetConstantBuffers1( SERIALISE_ELEMENT_ARRAY(pNumConstants, NumBuffers); SERIALISE_ELEMENT(NumBuffers); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(IsLoading(m_State)) @@ -938,6 +951,8 @@ bool WrappedID3D11DeviceContext::Serialise_GSSetConstantBuffers1( SERIALISE_ELEMENT_ARRAY(pNumConstants, NumBuffers); SERIALISE_ELEMENT(NumBuffers); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(IsLoading(m_State)) @@ -1063,6 +1078,8 @@ bool WrappedID3D11DeviceContext::Serialise_PSSetConstantBuffers1( SERIALISE_ELEMENT_ARRAY(pNumConstants, NumBuffers); SERIALISE_ELEMENT(NumBuffers); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(IsLoading(m_State)) @@ -1188,6 +1205,8 @@ bool WrappedID3D11DeviceContext::Serialise_CSSetConstantBuffers1( SERIALISE_ELEMENT_ARRAY(pNumConstants, NumBuffers); SERIALISE_ELEMENT(NumBuffers); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(IsLoading(m_State)) @@ -1556,6 +1575,8 @@ bool WrappedID3D11DeviceContext::Serialise_DiscardResource(SerialiserType &ser, Serialise_DebugMessages(ser); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(pResource) @@ -1646,6 +1667,8 @@ bool WrappedID3D11DeviceContext::Serialise_DiscardView(SerialiserType &ser, ID3D Serialise_DebugMessages(ser); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(pResourceView) @@ -1781,6 +1804,8 @@ bool WrappedID3D11DeviceContext::Serialise_DiscardView1(SerialiserType &ser, Serialise_DebugMessages(ser); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(pResourceView) @@ -1922,6 +1947,8 @@ bool WrappedID3D11DeviceContext::Serialise_SwapDeviceContextState( SERIALISE_ELEMENT(state).Named("pState"); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_DoStateVerify = false; diff --git a/renderdoc/driver/d3d11/d3d11_context_wrap.cpp b/renderdoc/driver/d3d11/d3d11_context_wrap.cpp index 6fbcd897b..6b8b059c7 100644 --- a/renderdoc/driver/d3d11/d3d11_context_wrap.cpp +++ b/renderdoc/driver/d3d11/d3d11_context_wrap.cpp @@ -46,6 +46,8 @@ bool WrappedID3D11DeviceContext::Serialise_SetMarker(SerialiserType &ser, uint32 SERIALISE_ELEMENT(Color); SERIALISE_ELEMENT_LOCAL(MarkerName, StringFormat::Wide2UTF8(MarkerNameW ? MarkerNameW : L"")); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { D3D11MarkerRegion::Set(MarkerName); @@ -80,6 +82,8 @@ bool WrappedID3D11DeviceContext::Serialise_PushMarker(SerialiserType &ser, uint3 SERIALISE_ELEMENT(Color); SERIALISE_ELEMENT_LOCAL(MarkerName, StringFormat::Wide2UTF8(MarkerNameW ? MarkerNameW : L"")); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { D3D11MarkerRegion::Begin(MarkerName); @@ -329,6 +333,8 @@ bool WrappedID3D11DeviceContext::Serialise_IASetPrimitiveTopology(SerialiserType { SERIALISE_ELEMENT(Topology); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_CurrentPipelineState->Change(m_CurrentPipelineState->IA.Topo, Topology); @@ -366,6 +372,8 @@ bool WrappedID3D11DeviceContext::Serialise_IASetInputLayout(SerialiserType &ser, { SERIALISE_ELEMENT(pInputLayout); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(IsLoading(m_State)) @@ -416,6 +424,8 @@ bool WrappedID3D11DeviceContext::Serialise_IASetVertexBuffers(SerialiserType &se // serialise NumBuffers here, because if any of the above were NULL it would be set to 0 SERIALISE_ELEMENT(NumBuffers); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(IsLoading(m_State)) @@ -484,6 +494,8 @@ bool WrappedID3D11DeviceContext::Serialise_IASetIndexBuffer(SerialiserType &ser, SERIALISE_ELEMENT(Format); SERIALISE_ELEMENT(Offset); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(IsLoading(m_State)) @@ -638,6 +650,8 @@ bool WrappedID3D11DeviceContext::Serialise_VSSetConstantBuffers(SerialiserType & SERIALISE_ELEMENT(StartSlot); SERIALISE_ELEMENT_ARRAY(ppConstantBuffers, NumBuffers); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(IsLoading(m_State)) @@ -706,6 +720,8 @@ bool WrappedID3D11DeviceContext::Serialise_VSSetShaderResources( SERIALISE_ELEMENT(StartSlot); SERIALISE_ELEMENT_ARRAY(ppShaderResourceViews, NumViews); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(IsLoading(m_State)) @@ -769,6 +785,8 @@ bool WrappedID3D11DeviceContext::Serialise_VSSetSamplers(SerialiserType &ser, UI SERIALISE_ELEMENT(StartSlot); SERIALISE_ELEMENT_ARRAY(ppSamplers, NumSamplers); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(IsLoading(m_State)) @@ -825,6 +843,8 @@ bool WrappedID3D11DeviceContext::Serialise_VSSetShader(SerialiserType &ser, SERIALISE_ELEMENT(pShader); SERIALISE_ELEMENT_ARRAY(ppClassInstances, NumClassInstances); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(IsLoading(m_State)) @@ -996,6 +1016,8 @@ bool WrappedID3D11DeviceContext::Serialise_HSSetConstantBuffers(SerialiserType & SERIALISE_ELEMENT(StartSlot); SERIALISE_ELEMENT_ARRAY(ppConstantBuffers, NumBuffers); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(IsLoading(m_State)) @@ -1064,6 +1086,8 @@ bool WrappedID3D11DeviceContext::Serialise_HSSetShaderResources( SERIALISE_ELEMENT(StartSlot); SERIALISE_ELEMENT_ARRAY(ppShaderResourceViews, NumViews); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(IsLoading(m_State)) @@ -1127,6 +1151,8 @@ bool WrappedID3D11DeviceContext::Serialise_HSSetSamplers(SerialiserType &ser, UI SERIALISE_ELEMENT(StartSlot); SERIALISE_ELEMENT_ARRAY(ppSamplers, NumSamplers); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(IsLoading(m_State)) @@ -1182,6 +1208,8 @@ bool WrappedID3D11DeviceContext::Serialise_HSSetShader(SerialiserType &ser, ID3D SERIALISE_ELEMENT(pShader); SERIALISE_ELEMENT_ARRAY(ppClassInstances, NumClassInstances); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(IsLoading(m_State)) @@ -1353,6 +1381,8 @@ bool WrappedID3D11DeviceContext::Serialise_DSSetConstantBuffers(SerialiserType & SERIALISE_ELEMENT(StartSlot); SERIALISE_ELEMENT_ARRAY(ppConstantBuffers, NumBuffers); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(IsLoading(m_State)) @@ -1421,6 +1451,8 @@ bool WrappedID3D11DeviceContext::Serialise_DSSetShaderResources( SERIALISE_ELEMENT(StartSlot); SERIALISE_ELEMENT_ARRAY(ppShaderResourceViews, NumViews); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(IsLoading(m_State)) @@ -1484,6 +1516,8 @@ bool WrappedID3D11DeviceContext::Serialise_DSSetSamplers(SerialiserType &ser, UI SERIALISE_ELEMENT(StartSlot); SERIALISE_ELEMENT_ARRAY(ppSamplers, NumSamplers); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(IsLoading(m_State)) @@ -1540,6 +1574,8 @@ bool WrappedID3D11DeviceContext::Serialise_DSSetShader(SerialiserType &ser, SERIALISE_ELEMENT(pShader); SERIALISE_ELEMENT_ARRAY(ppClassInstances, NumClassInstances); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(IsLoading(m_State)) @@ -1712,6 +1748,8 @@ bool WrappedID3D11DeviceContext::Serialise_GSSetConstantBuffers(SerialiserType & SERIALISE_ELEMENT(StartSlot); SERIALISE_ELEMENT_ARRAY(ppConstantBuffers, NumBuffers); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(IsLoading(m_State)) @@ -1780,6 +1818,8 @@ bool WrappedID3D11DeviceContext::Serialise_GSSetShaderResources( SERIALISE_ELEMENT(StartSlot); SERIALISE_ELEMENT_ARRAY(ppShaderResourceViews, NumViews); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(IsLoading(m_State)) @@ -1843,6 +1883,8 @@ bool WrappedID3D11DeviceContext::Serialise_GSSetSamplers(SerialiserType &ser, UI SERIALISE_ELEMENT(StartSlot); SERIALISE_ELEMENT_ARRAY(ppSamplers, NumSamplers); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(IsLoading(m_State)) @@ -1899,6 +1941,8 @@ bool WrappedID3D11DeviceContext::Serialise_GSSetShader(SerialiserType &ser, SERIALISE_ELEMENT(pShader); SERIALISE_ELEMENT_ARRAY(ppClassInstances, NumClassInstances); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(IsLoading(m_State)) @@ -1990,6 +2034,8 @@ bool WrappedID3D11DeviceContext::Serialise_SOSetTargets(SerialiserType &ser, UIN // serialise NumBuffers here, because if either of the above were NULL it would be set to 0 SERIALISE_ELEMENT(NumBuffers); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { // "If less than four [buffers] are defined by the call, the remaining buffer slots are set to @@ -2214,6 +2260,8 @@ bool WrappedID3D11DeviceContext::Serialise_RSSetViewports(SerialiserType &ser, U { SERIALISE_ELEMENT_ARRAY(pViewports, NumViewports); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(IsLoading(m_State)) @@ -2257,6 +2305,8 @@ bool WrappedID3D11DeviceContext::Serialise_RSSetScissorRects(SerialiserType &ser { SERIALISE_ELEMENT_ARRAY(pRects, NumRects); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(IsLoading(m_State)) @@ -2300,6 +2350,8 @@ bool WrappedID3D11DeviceContext::Serialise_RSSetState(SerialiserType &ser, { SERIALISE_ELEMENT(pRasterizerState); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(IsLoading(m_State)) @@ -2449,6 +2501,8 @@ bool WrappedID3D11DeviceContext::Serialise_PSSetConstantBuffers(SerialiserType & SERIALISE_ELEMENT(StartSlot); SERIALISE_ELEMENT_ARRAY(ppConstantBuffers, NumBuffers); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(IsLoading(m_State)) @@ -2517,6 +2571,8 @@ bool WrappedID3D11DeviceContext::Serialise_PSSetShaderResources( SERIALISE_ELEMENT(StartSlot); SERIALISE_ELEMENT_ARRAY(ppShaderResourceViews, NumViews); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(IsLoading(m_State)) @@ -2580,6 +2636,8 @@ bool WrappedID3D11DeviceContext::Serialise_PSSetSamplers(SerialiserType &ser, UI SERIALISE_ELEMENT(StartSlot); SERIALISE_ELEMENT_ARRAY(ppSamplers, NumSamplers); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(IsLoading(m_State)) @@ -2636,6 +2694,8 @@ bool WrappedID3D11DeviceContext::Serialise_PSSetShader(SerialiserType &ser, SERIALISE_ELEMENT(pShader); SERIALISE_ELEMENT_ARRAY(ppClassInstances, NumClassInstances); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(IsLoading(m_State)) @@ -2855,6 +2915,8 @@ bool WrappedID3D11DeviceContext::Serialise_OMSetRenderTargets( SERIALISE_ELEMENT_ARRAY(ppRenderTargetViews, NumViews); SERIALISE_ELEMENT(pDepthStencilView); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { ID3D11RenderTargetView *RTs[D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT] = {0}; @@ -3013,6 +3075,8 @@ bool WrappedID3D11DeviceContext::Serialise_OMSetRenderTargetsAndUnorderedAccessV RDCASSERT(ModifyRTVs || ModifyUAVs); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { // any bind of RTVs or UAVs implicitly NULLs out the remaining slots, so we don't want to just @@ -3261,6 +3325,8 @@ bool WrappedID3D11DeviceContext::Serialise_OMSetBlendState(SerialiserType &ser, SERIALISE_ELEMENT_ARRAY(BlendFactor, FIXED_COUNT(4)); SERIALISE_ELEMENT(SampleMask); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { FLOAT DefaultBlendFactor[4] = {1.0f, 1.0f, 1.0f, 1.0f}; @@ -3321,6 +3387,8 @@ bool WrappedID3D11DeviceContext::Serialise_OMSetDepthStencilState( SERIALISE_ELEMENT(pDepthStencilState); SERIALISE_ELEMENT(StencilRef); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(IsLoading(m_State)) @@ -3409,6 +3477,8 @@ bool WrappedID3D11DeviceContext::Serialise_DrawIndexedInstanced( Serialise_DebugMessages(GET_SERIALISER); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_pRealContext->DrawIndexedInstanced(IndexCountPerInstance, InstanceCount, StartIndexLocation, @@ -3477,6 +3547,8 @@ bool WrappedID3D11DeviceContext::Serialise_DrawInstanced(SerialiserType &ser, Serialise_DebugMessages(GET_SERIALISER); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_pRealContext->DrawInstanced(VertexCountPerInstance, InstanceCount, StartVertexLocation, @@ -3540,6 +3612,8 @@ bool WrappedID3D11DeviceContext::Serialise_DrawIndexed(SerialiserType &ser, UINT Serialise_DebugMessages(GET_SERIALISER); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_pRealContext->DrawIndexed(IndexCount, StartIndexLocation, BaseVertexLocation); @@ -3597,6 +3671,8 @@ bool WrappedID3D11DeviceContext::Serialise_Draw(SerialiserType &ser, UINT Vertex Serialise_DebugMessages(GET_SERIALISER); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_pRealContext->Draw(VertexCount, StartVertexLocation); @@ -3648,6 +3724,8 @@ bool WrappedID3D11DeviceContext::Serialise_DrawAuto(SerialiserType &ser) { Serialise_DebugMessages(GET_SERIALISER); + SERIALISE_CHECK_READ_ERRORS(); + uint64_t numVerts = 0; if(IsReplayingAndReading()) @@ -3760,6 +3838,8 @@ bool WrappedID3D11DeviceContext::Serialise_DrawIndexedInstancedIndirect(Serialis Serialise_DebugMessages(GET_SERIALISER); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(pBufferForArgs) @@ -3885,6 +3965,8 @@ bool WrappedID3D11DeviceContext::Serialise_DrawInstancedIndirect(SerialiserType Serialise_DebugMessages(GET_SERIALISER); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(pBufferForArgs) @@ -4129,6 +4211,8 @@ bool WrappedID3D11DeviceContext::Serialise_CSSetConstantBuffers(SerialiserType & SERIALISE_ELEMENT(StartSlot); SERIALISE_ELEMENT_ARRAY(ppConstantBuffers, NumBuffers); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(IsLoading(m_State)) @@ -4197,6 +4281,8 @@ bool WrappedID3D11DeviceContext::Serialise_CSSetShaderResources( SERIALISE_ELEMENT(StartSlot); SERIALISE_ELEMENT_ARRAY(ppShaderResourceViews, NumViews); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(IsLoading(m_State)) @@ -4262,6 +4348,8 @@ bool WrappedID3D11DeviceContext::Serialise_CSSetUnorderedAccessViews( SERIALISE_ELEMENT_ARRAY(pUAVInitialCounts, NumUAVs); SERIALISE_ELEMENT(NumUAVs); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_CurrentPipelineState->ChangeRefWrite(m_CurrentPipelineState->CSUAVs, ppUnorderedAccessViews, @@ -4336,6 +4424,8 @@ bool WrappedID3D11DeviceContext::Serialise_CSSetSamplers(SerialiserType &ser, UI SERIALISE_ELEMENT(StartSlot); SERIALISE_ELEMENT_ARRAY(ppSamplers, NumSamplers); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(IsLoading(m_State)) @@ -4392,6 +4482,8 @@ bool WrappedID3D11DeviceContext::Serialise_CSSetShader(SerialiserType &ser, SERIALISE_ELEMENT(pShader); SERIALISE_ELEMENT_ARRAY(ppClassInstances, NumClassInstances); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(IsLoading(m_State)) @@ -4465,6 +4557,8 @@ bool WrappedID3D11DeviceContext::Serialise_Dispatch(SerialiserType &ser, UINT Th Serialise_DebugMessages(GET_SERIALISER); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_pRealContext->Dispatch(ThreadGroupCountX, ThreadGroupCountY, ThreadGroupCountZ); @@ -4540,6 +4634,8 @@ bool WrappedID3D11DeviceContext::Serialise_DispatchIndirect(SerialiserType &ser, Serialise_DebugMessages(GET_SERIALISER); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(pBufferForArgs) @@ -4662,6 +4758,8 @@ bool WrappedID3D11DeviceContext::Serialise_ExecuteCommandList(SerialiserType &se Serialise_DebugMessages(GET_SERIALISER); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { // The serialise of exec happens at the start of the inserted linearised commands from the @@ -4814,6 +4912,8 @@ bool WrappedID3D11DeviceContext::Serialise_PostFinishCommandListSet(SerialiserTy SERIALISE_ELEMENT(RenderState).Named("Initial Pipeline State"); + SERIALISE_CHECK_READ_ERRORS(); + // this is a 'fake' call we insert after finishing in a fresh deferred context, to allow us to // preserve the state after a previous finish stole all the serialised chunks. if(IsReplayingAndReading()) @@ -5003,6 +5103,8 @@ bool WrappedID3D11DeviceContext::Serialise_CopySubresourceRegion( Serialise_DebugMessages(GET_SERIALISER); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(pDstResource && pSrcResource) @@ -5152,6 +5254,8 @@ bool WrappedID3D11DeviceContext::Serialise_CopyResource(SerialiserType &ser, Serialise_DebugMessages(GET_SERIALISER); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(pDstResource && pSrcResource) @@ -5594,6 +5698,8 @@ bool WrappedID3D11DeviceContext::Serialise_CopyStructureCount(SerialiserType &se SERIALISE_ELEMENT(DstAlignedByteOffset); SERIALISE_ELEMENT(pSrcView); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading() && pDstBuffer && pSrcView) { m_pRealContext->CopyStructureCount(UNWRAP(WrappedID3D11Buffer, pDstBuffer), DstAlignedByteOffset, @@ -5662,6 +5768,8 @@ bool WrappedID3D11DeviceContext::Serialise_ResolveSubresource(SerialiserType &se Serialise_DebugMessages(GET_SERIALISER); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(pDstResource && pSrcResource) @@ -5757,6 +5865,8 @@ bool WrappedID3D11DeviceContext::Serialise_GenerateMips(SerialiserType &ser, Serialise_DebugMessages(GET_SERIALISER); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(pShaderResourceView) @@ -5874,6 +5984,8 @@ bool WrappedID3D11DeviceContext::Serialise_ClearRenderTargetView( Serialise_DebugMessages(GET_SERIALISER); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(pRenderTargetView) @@ -5954,6 +6066,8 @@ bool WrappedID3D11DeviceContext::Serialise_ClearUnorderedAccessViewUint( Serialise_DebugMessages(GET_SERIALISER); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(pUnorderedAccessView) @@ -6030,6 +6144,8 @@ bool WrappedID3D11DeviceContext::Serialise_ClearUnorderedAccessViewFloat( Serialise_DebugMessages(GET_SERIALISER); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(pUnorderedAccessView) @@ -6109,6 +6225,8 @@ bool WrappedID3D11DeviceContext::Serialise_ClearDepthStencilView( Serialise_DebugMessages(GET_SERIALISER); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(pDepthStencilView) @@ -6195,6 +6313,8 @@ bool WrappedID3D11DeviceContext::Serialise_Begin(SerialiserType &ser, ID3D11Asyn { SERIALISE_ELEMENT(pAsync); + SERIALISE_CHECK_READ_ERRORS(); + return true; } @@ -6229,6 +6349,8 @@ bool WrappedID3D11DeviceContext::Serialise_End(SerialiserType &ser, ID3D11Asynch { SERIALISE_ELEMENT(pAsync); + SERIALISE_CHECK_READ_ERRORS(); + return true; } @@ -6283,6 +6405,8 @@ bool WrappedID3D11DeviceContext::Serialise_SetPredication(SerialiserType &ser, SERIALISE_ELEMENT(pPredicate); SERIALISE_ELEMENT_LOCAL(PredicateValue, PredicateValue_ == TRUE); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_pRealContext->SetPredication(pPredicate, PredicateValue ? TRUE : FALSE); @@ -6320,6 +6444,8 @@ bool WrappedID3D11DeviceContext::Serialise_SetResourceMinLOD(SerialiserType &ser SERIALISE_ELEMENT(pResource); SERIALISE_ELEMENT(MinLOD); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(pResource) @@ -6596,6 +6722,8 @@ bool WrappedID3D11DeviceContext::Serialise_Map(SerialiserType &ser, ID3D11Resour SERIALISE_ELEMENT(MapType); SERIALISE_ELEMENT_TYPED(D3D11_MAP_FLAG, MapFlags); + SERIALISE_CHECK_READ_ERRORS(); + // nothing to do on replay, all the work happens in Unmap. if(ser.IsReading()) return true; @@ -7051,6 +7179,13 @@ bool WrappedID3D11DeviceContext::Serialise_Unmap(SerialiserType &ser, ID3D11Reso } } + if(IsReplayingAndReading() && ser.IsErrored()) + { + FreeAlignedBuffer(MapWrittenData); + } + + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading() && pResource) { MapWrittenData = (byte *)intercept.app.pData; diff --git a/renderdoc/driver/d3d11/d3d11_device.cpp b/renderdoc/driver/d3d11/d3d11_device.cpp index 01d78e2a4..cdd0a4eb2 100644 --- a/renderdoc/driver/d3d11/d3d11_device.cpp +++ b/renderdoc/driver/d3d11/d3d11_device.cpp @@ -743,7 +743,7 @@ std::vector WrappedID3D11Device::GetDebugMessages() return ret; } -void WrappedID3D11Device::ProcessChunk(ReadSerialiser &ser, D3D11Chunk context) +bool WrappedID3D11Device::ProcessChunk(ReadSerialiser &ser, D3D11Chunk context) { switch(context) { @@ -751,6 +751,8 @@ void WrappedID3D11Device::ProcessChunk(ReadSerialiser &ser, D3D11Chunk context) { SERIALISE_ELEMENT_LOCAL(ImmediateContext, ResourceId()); + SERIALISE_CHECK_READ_ERRORS(); + // add a reference for the resource manager - normally it takes ownership of the resource on // creation and releases it // to destruction, but we want to control our immediate context ourselves. @@ -765,82 +767,92 @@ void WrappedID3D11Device::ProcessChunk(ReadSerialiser &ser, D3D11Chunk context) desc.name = "Immediate Context"; desc.initialisationChunks.clear(); } - break; + + return true; } - case D3D11Chunk::SetResourceName: Serialise_SetResourceName(ser, 0x0, ""); break; - case D3D11Chunk::ReleaseResource: Serialise_ReleaseResource(ser, 0x0); break; - case D3D11Chunk::CreateSwapBuffer: Serialise_WrapSwapchainBuffer(ser, 0x0, 0x0, 0, 0x0); break; - case D3D11Chunk::CreateTexture1D: Serialise_CreateTexture1D(ser, 0x0, 0x0, 0x0); break; - case D3D11Chunk::CreateTexture2D: Serialise_CreateTexture2D(ser, 0x0, 0x0, 0x0); break; - case D3D11Chunk::CreateTexture2D1: Serialise_CreateTexture2D1(ser, 0x0, 0x0, 0x0); break; - case D3D11Chunk::CreateTexture3D: Serialise_CreateTexture3D(ser, 0x0, 0x0, 0x0); break; - case D3D11Chunk::CreateTexture3D1: Serialise_CreateTexture3D1(ser, 0x0, 0x0, 0x0); break; - case D3D11Chunk::CreateBuffer: Serialise_CreateBuffer(ser, 0x0, 0x0, 0x0); break; - case D3D11Chunk::CreateVertexShader: Serialise_CreateVertexShader(ser, 0x0, 0, 0x0, 0x0); break; - case D3D11Chunk::CreateHullShader: Serialise_CreateHullShader(ser, 0x0, 0, 0x0, 0x0); break; - case D3D11Chunk::CreateDomainShader: Serialise_CreateDomainShader(ser, 0x0, 0, 0x0, 0x0); break; + case D3D11Chunk::SetResourceName: return Serialise_SetResourceName(ser, 0x0, ""); + case D3D11Chunk::ReleaseResource: return Serialise_ReleaseResource(ser, 0x0); + case D3D11Chunk::CreateSwapBuffer: return Serialise_WrapSwapchainBuffer(ser, 0x0, 0x0, 0, 0x0); + + case D3D11Chunk::CreateTexture1D: return Serialise_CreateTexture1D(ser, 0x0, 0x0, 0x0); + case D3D11Chunk::CreateTexture2D: return Serialise_CreateTexture2D(ser, 0x0, 0x0, 0x0); + case D3D11Chunk::CreateTexture2D1: return Serialise_CreateTexture2D1(ser, 0x0, 0x0, 0x0); + case D3D11Chunk::CreateTexture3D: return Serialise_CreateTexture3D(ser, 0x0, 0x0, 0x0); + case D3D11Chunk::CreateTexture3D1: return Serialise_CreateTexture3D1(ser, 0x0, 0x0, 0x0); + case D3D11Chunk::CreateBuffer: return Serialise_CreateBuffer(ser, 0x0, 0x0, 0x0); + case D3D11Chunk::CreateVertexShader: return Serialise_CreateVertexShader(ser, 0x0, 0, 0x0, 0x0); + + case D3D11Chunk::CreateHullShader: return Serialise_CreateHullShader(ser, 0x0, 0, 0x0, 0x0); + + case D3D11Chunk::CreateDomainShader: return Serialise_CreateDomainShader(ser, 0x0, 0, 0x0, 0x0); + case D3D11Chunk::CreateGeometryShader: - Serialise_CreateGeometryShader(ser, 0x0, 0, 0x0, 0x0); - break; + return Serialise_CreateGeometryShader(ser, 0x0, 0, 0x0, 0x0); + case D3D11Chunk::CreateGeometryShaderWithStreamOutput: - Serialise_CreateGeometryShaderWithStreamOutput(ser, 0x0, 0, 0x0, 0, 0x0, 0, 0, 0x0, 0x0); - break; - case D3D11Chunk::CreatePixelShader: Serialise_CreatePixelShader(ser, 0x0, 0, 0x0, 0x0); break; + return Serialise_CreateGeometryShaderWithStreamOutput(ser, 0x0, 0, 0x0, 0, 0x0, 0, 0, 0x0, 0x0); + + case D3D11Chunk::CreatePixelShader: return Serialise_CreatePixelShader(ser, 0x0, 0, 0x0, 0x0); + case D3D11Chunk::CreateComputeShader: - Serialise_CreateComputeShader(ser, 0x0, 0, 0x0, 0x0); - break; - case D3D11Chunk::GetClassInstance: Serialise_GetClassInstance(ser, 0x0, 0, 0x0, 0x0); break; + return Serialise_CreateComputeShader(ser, 0x0, 0, 0x0, 0x0); + + case D3D11Chunk::GetClassInstance: return Serialise_GetClassInstance(ser, 0x0, 0, 0x0, 0x0); + case D3D11Chunk::CreateClassInstance: - Serialise_CreateClassInstance(ser, 0x0, 0, 0, 0, 0, 0x0, 0x0); - break; - case D3D11Chunk::CreateClassLinkage: Serialise_CreateClassLinkage(ser, 0x0); break; + return Serialise_CreateClassInstance(ser, 0x0, 0, 0, 0, 0, 0x0, 0x0); + + case D3D11Chunk::CreateClassLinkage: return Serialise_CreateClassLinkage(ser, 0x0); case D3D11Chunk::CreateShaderResourceView: - Serialise_CreateShaderResourceView(ser, 0x0, 0x0, 0x0); - break; + return Serialise_CreateShaderResourceView(ser, 0x0, 0x0, 0x0); + case D3D11Chunk::CreateShaderResourceView1: - Serialise_CreateShaderResourceView1(ser, 0x0, 0x0, 0x0); - break; + return Serialise_CreateShaderResourceView1(ser, 0x0, 0x0, 0x0); + case D3D11Chunk::CreateRenderTargetView: - Serialise_CreateRenderTargetView(ser, 0x0, 0x0, 0x0); - break; + return Serialise_CreateRenderTargetView(ser, 0x0, 0x0, 0x0); + case D3D11Chunk::CreateRenderTargetView1: - Serialise_CreateRenderTargetView1(ser, 0x0, 0x0, 0x0); - break; + return Serialise_CreateRenderTargetView1(ser, 0x0, 0x0, 0x0); + case D3D11Chunk::CreateDepthStencilView: - Serialise_CreateDepthStencilView(ser, 0x0, 0x0, 0x0); - break; + return Serialise_CreateDepthStencilView(ser, 0x0, 0x0, 0x0); + case D3D11Chunk::CreateUnorderedAccessView: - Serialise_CreateUnorderedAccessView(ser, 0x0, 0x0, 0x0); - break; + return Serialise_CreateUnorderedAccessView(ser, 0x0, 0x0, 0x0); + case D3D11Chunk::CreateUnorderedAccessView1: - Serialise_CreateUnorderedAccessView1(ser, 0x0, 0x0, 0x0); - break; + return Serialise_CreateUnorderedAccessView1(ser, 0x0, 0x0, 0x0); + case D3D11Chunk::CreateInputLayout: - Serialise_CreateInputLayout(ser, 0x0, 0, 0x0, 0, 0x0); - break; - case D3D11Chunk::CreateBlendState: Serialise_CreateBlendState(ser, 0x0, 0x0); break; - case D3D11Chunk::CreateBlendState1: Serialise_CreateBlendState1(ser, 0x0, 0x0); break; + return Serialise_CreateInputLayout(ser, 0x0, 0, 0x0, 0, 0x0); + + case D3D11Chunk::CreateBlendState: return Serialise_CreateBlendState(ser, 0x0, 0x0); + case D3D11Chunk::CreateBlendState1: return Serialise_CreateBlendState1(ser, 0x0, 0x0); case D3D11Chunk::CreateDepthStencilState: - Serialise_CreateDepthStencilState(ser, 0x0, 0x0); - break; - case D3D11Chunk::CreateRasterizerState: Serialise_CreateRasterizerState(ser, 0x0, 0x0); break; - case D3D11Chunk::CreateRasterizerState1: Serialise_CreateRasterizerState1(ser, 0x0, 0x0); break; - case D3D11Chunk::CreateRasterizerState2: Serialise_CreateRasterizerState2(ser, 0x0, 0x0); break; - case D3D11Chunk::CreateSamplerState: Serialise_CreateSamplerState(ser, 0x0, 0x0); break; - case D3D11Chunk::CreateQuery: Serialise_CreateQuery(ser, 0x0, 0x0); break; - case D3D11Chunk::CreateQuery1: Serialise_CreateQuery1(ser, 0x0, 0x0); break; - case D3D11Chunk::CreatePredicate: Serialise_CreatePredicate(ser, 0x0, 0x0); break; - case D3D11Chunk::CreateCounter: Serialise_CreateCounter(ser, 0x0, 0x0); break; - case D3D11Chunk::CreateDeferredContext: Serialise_CreateDeferredContext(ser, 0, 0x0); break; - case D3D11Chunk::SetExceptionMode: Serialise_SetExceptionMode(ser, 0); break; + return Serialise_CreateDepthStencilState(ser, 0x0, 0x0); + + case D3D11Chunk::CreateRasterizerState: return Serialise_CreateRasterizerState(ser, 0x0, 0x0); + + case D3D11Chunk::CreateRasterizerState1: return Serialise_CreateRasterizerState1(ser, 0x0, 0x0); + + case D3D11Chunk::CreateRasterizerState2: return Serialise_CreateRasterizerState2(ser, 0x0, 0x0); + + case D3D11Chunk::CreateSamplerState: return Serialise_CreateSamplerState(ser, 0x0, 0x0); + case D3D11Chunk::CreateQuery: return Serialise_CreateQuery(ser, 0x0, 0x0); + case D3D11Chunk::CreateQuery1: return Serialise_CreateQuery1(ser, 0x0, 0x0); + case D3D11Chunk::CreatePredicate: return Serialise_CreatePredicate(ser, 0x0, 0x0); + case D3D11Chunk::CreateCounter: return Serialise_CreateCounter(ser, 0x0, 0x0); + case D3D11Chunk::CreateDeferredContext: return Serialise_CreateDeferredContext(ser, 0, 0x0); + + case D3D11Chunk::SetExceptionMode: return Serialise_SetExceptionMode(ser, 0); case D3D11Chunk::OpenSharedResource: { IID nul; - Serialise_OpenSharedResource(ser, 0, nul, NULL); - break; + return Serialise_OpenSharedResource(ser, 0, nul, NULL); } - case D3D11Chunk::CaptureScope: Serialise_CaptureScope(ser); break; - case D3D11Chunk::SetShaderDebugPath: Serialise_SetShaderDebugPath(ser, NULL, NULL); break; + case D3D11Chunk::CaptureScope: return Serialise_CaptureScope(ser); + case D3D11Chunk::SetShaderDebugPath: return Serialise_SetShaderDebugPath(ser, NULL, NULL); default: { SystemChunk system = (SystemChunk)context; @@ -848,34 +860,45 @@ void WrappedID3D11Device::ProcessChunk(ReadSerialiser &ser, D3D11Chunk context) { D3D11InitParams InitParams; SERIALISE_ELEMENT(InitParams); + + SERIALISE_CHECK_READ_ERRORS(); } else if(system == SystemChunk::InitialContentsList) { GetResourceManager()->CreateInitialContents(ser); + + SERIALISE_CHECK_READ_ERRORS(); } else if(system == SystemChunk::InitialContents) { - Serialise_InitialState(ser, ResourceId(), NULL); + return Serialise_InitialState(ser, ResourceId(), NULL); } else if(system < SystemChunk::FirstDriverChunk) { RDCERR("Unexpected system chunk in capture data: %u", system); ser.SkipCurrentChunk(); + + SERIALISE_CHECK_READ_ERRORS(); } else { - m_pImmediateContext->ProcessChunk(ser, context); + return m_pImmediateContext->ProcessChunk(ser, context); } + break; } } + + return true; } template -void WrappedID3D11Device::Serialise_CaptureScope(SerialiserType &ser) +bool WrappedID3D11Device::Serialise_CaptureScope(SerialiserType &ser) { SERIALISE_ELEMENT(m_FrameCounter); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayMode(m_State)) { m_FrameRecord.frameInfo.frameNumber = m_FrameCounter; @@ -910,6 +933,8 @@ void WrappedID3D11Device::Serialise_CaptureScope(SerialiserType &ser) stats.outputs.bindslots.resize(D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT + D3D11_1_UAV_SLOT_COUNT + 1); } + + return true; } ReplayStatus WrappedID3D11Device::ReadLogInitialisation(RDCFile *rdc, bool storeStructuredBuffers) @@ -964,13 +989,18 @@ ReplayStatus WrappedID3D11Device::ReadLogInitialisation(RDCFile *rdc, bool store if(reader->IsErrored()) return ReplayStatus::APIDataCorrupted; - ProcessChunk(ser, context); + bool success = ProcessChunk(ser, context); ser.EndChunk(); if(reader->IsErrored()) return ReplayStatus::APIDataCorrupted; + // if there wasn't a serialisation error, but the chunk didn't succeed, then it's an API replay + // failure. + if(!success) + return m_FailedReplayStatus; + uint64_t offsetEnd = reader->GetOffset(); RenderDoc::Inst().SetProgress(FileInitialRead, float(offsetEnd) / float(reader->GetSize())); @@ -987,7 +1017,10 @@ ReplayStatus WrappedID3D11Device::ReadLogInitialisation(RDCFile *rdc, bool store if(!IsStructuredExporting(m_State)) GetResourceManager()->ApplyInitialContents(); - m_pImmediateContext->ReplayLog(m_State, 0, 0, false); + ReplayStatus status = m_pImmediateContext->ReplayLog(m_State, 0, 0, false); + + if(status != ReplayStatus::Succeeded) + return status; } chunkInfos[context].total += timer.GetMilliseconds(); @@ -1062,15 +1095,20 @@ void WrappedID3D11Device::ReplayLog(uint32_t startEventID, uint32_t endEventID, m_ReplayEventCount = 0; + ReplayStatus status = ReplayStatus::Succeeded; + if(replayType == eReplay_Full) - m_pImmediateContext->ReplayLog(m_State, startEventID, endEventID, partial); + status = m_pImmediateContext->ReplayLog(m_State, startEventID, endEventID, partial); else if(replayType == eReplay_WithoutDraw) - m_pImmediateContext->ReplayLog(m_State, startEventID, RDCMAX(1U, endEventID) - 1, partial); + status = + m_pImmediateContext->ReplayLog(m_State, startEventID, RDCMAX(1U, endEventID) - 1, partial); else if(replayType == eReplay_OnlyDraw) - m_pImmediateContext->ReplayLog(m_State, endEventID, endEventID, partial); + status = m_pImmediateContext->ReplayLog(m_State, endEventID, endEventID, partial); else RDCFATAL("Unexpected replay type"); + RDCASSERTEQUAL(status, ReplayStatus::Succeeded); + // make sure to end any unbalanced replay events if we stopped in the middle of a frame for(int i = 0; i < m_ReplayEventCount; i++) D3D11MarkerRegion::End(); @@ -1153,6 +1191,8 @@ bool WrappedID3D11Device::Serialise_WrapSwapchainBuffer(SerialiserType &ser, SERIALISE_ELEMENT(BackbufferDescriptor); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { ID3D11Texture2D *fakeBB; @@ -2095,6 +2135,8 @@ bool WrappedID3D11Device::Serialise_SetShaderDebugPath(SerialiserType &ser, SERIALISE_ELEMENT(pResource); SERIALISE_ELEMENT(Path); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading() && pResource) { ResourceId resId = GetResourceManager()->GetOriginalID(GetIDForResource(pResource)); @@ -2146,6 +2188,8 @@ bool WrappedID3D11Device::Serialise_SetResourceName(SerialiserType &ser, SERIALISE_ELEMENT(pResource); SERIALISE_ELEMENT(Name); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading() && pResource) { ResourceDescription &descr = GetReplay()->GetResourceDesc( @@ -2213,6 +2257,8 @@ bool WrappedID3D11Device::Serialise_ReleaseResource(SerialiserType &ser, ID3D11D { SERIALISE_ELEMENT(pResource); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading() && pResource) { GetResourceManager()->EraseLiveResource( diff --git a/renderdoc/driver/d3d11/d3d11_device.h b/renderdoc/driver/d3d11/d3d11_device.h index 7375b0910..a6a0e2fa4 100644 --- a/renderdoc/driver/d3d11/d3d11_device.h +++ b/renderdoc/driver/d3d11/d3d11_device.h @@ -363,6 +363,8 @@ private: CaptureState m_State; bool m_AppControlledCapture; + ReplayStatus m_FailedReplayStatus = ReplayStatus::APIReplayFailed; + set m_CachedStateObjects; // This function will check if m_CachedStateObjects is growing too large, and if so @@ -461,7 +463,7 @@ public: vector *GetShaderDebugInfoSearchPaths() { return &m_ShaderSearchPaths; } template - void Serialise_CaptureScope(SerialiserType &ser); + bool Serialise_CaptureScope(SerialiserType &ser); void StartFrameCapture(void *dev, void *wnd); bool EndFrameCapture(void *dev, void *wnd); @@ -515,7 +517,7 @@ public: m_State = CaptureState::StructuredExport; } ReplayStatus ReadLogInitialisation(RDCFile *rdc, bool storeStructuredBuffers); - void ProcessChunk(ReadSerialiser &ser, D3D11Chunk context); + bool ProcessChunk(ReadSerialiser &ser, D3D11Chunk context); void ReplayLog(uint32_t startEventID, uint32_t endEventID, ReplayLogType replayType); //////////////////////////////////////////////////////////////// diff --git a/renderdoc/driver/d3d11/d3d11_device1_wrap.cpp b/renderdoc/driver/d3d11/d3d11_device1_wrap.cpp index 938aad8ca..4c7a2e5b0 100644 --- a/renderdoc/driver/d3d11/d3d11_device1_wrap.cpp +++ b/renderdoc/driver/d3d11/d3d11_device1_wrap.cpp @@ -75,6 +75,8 @@ bool WrappedID3D11Device::Serialise_CreateBlendState1(SerialiserType &ser, SERIALISE_ELEMENT_LOCAL(Descriptor, *pBlendStateDesc); SERIALISE_ELEMENT_LOCAL(pState, GetIDForResource(*ppBlendState)); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { ID3D11BlendState1 *ret = NULL; @@ -171,6 +173,8 @@ bool WrappedID3D11Device::Serialise_CreateRasterizerState1( SERIALISE_ELEMENT_LOCAL(Descriptor, *pRasterizerDesc); SERIALISE_ELEMENT_LOCAL(pState, GetIDForResource(*ppRasterizerState)); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { ID3D11RasterizerState1 *ret = NULL; diff --git a/renderdoc/driver/d3d11/d3d11_device3_wrap.cpp b/renderdoc/driver/d3d11/d3d11_device3_wrap.cpp index 727a148b4..4302476b1 100644 --- a/renderdoc/driver/d3d11/d3d11_device3_wrap.cpp +++ b/renderdoc/driver/d3d11/d3d11_device3_wrap.cpp @@ -51,6 +51,14 @@ bool WrappedID3D11Device::Serialise_CreateTexture2D1(SerialiserType &ser, Descriptor.Width, Descriptor.Height, 1, Descriptor.Format, Descriptor.MipLevels, Descriptor.ArraySize, HasInitialData); + if(IsReplayingAndReading() && ser.IsErrored()) + { + // need to manually free the serialised buffers we stole in Serialise_CreateTextureData here, + // before the SERIALISE_CHECK_READ_ERRORS macro below returns out of the function + for(size_t i = 0; i < descs.size(); i++) + FreeAlignedBuffer((byte *)descs[i].pSysMem); + } + if(IsReplayingAndReading()) { ID3D11Texture2D1 *ret = NULL; @@ -178,6 +186,14 @@ bool WrappedID3D11Device::Serialise_CreateTexture3D1(SerialiserType &ser, Descriptor.Width, Descriptor.Height, Descriptor.Depth, Descriptor.Format, Descriptor.MipLevels, 1, HasInitialData); + if(IsReplayingAndReading() && ser.IsErrored()) + { + // need to manually free the serialised buffers we stole in Serialise_CreateTextureData here, + // before the SERIALISE_CHECK_READ_ERRORS macro below returns out of the function + for(size_t i = 0; i < descs.size(); i++) + FreeAlignedBuffer((byte *)descs[i].pSysMem); + } + if(IsReplayingAndReading()) { ID3D11Texture3D1 *ret = NULL; @@ -292,6 +308,8 @@ bool WrappedID3D11Device::Serialise_CreateShaderResourceView1( SERIALISE_ELEMENT_OPT(pDesc); SERIALISE_ELEMENT_LOCAL(pView, GetIDForResource(*ppSRView)); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading() && pResource) { ID3D11ShaderResourceView1 *ret = NULL; @@ -437,6 +455,8 @@ bool WrappedID3D11Device::Serialise_CreateRenderTargetView1(SerialiserType &ser, SERIALISE_ELEMENT_OPT(pDesc); SERIALISE_ELEMENT_LOCAL(pView, GetIDForResource(*ppRTView)); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading() && pResource) { ID3D11RenderTargetView1 *ret = NULL; @@ -578,6 +598,8 @@ bool WrappedID3D11Device::Serialise_CreateUnorderedAccessView1( SERIALISE_ELEMENT_OPT(pDesc); SERIALISE_ELEMENT_LOCAL(pView, GetIDForResource(*ppUAView)); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading() && pResource) { ID3D11UnorderedAccessView1 *ret = NULL; @@ -686,6 +708,8 @@ bool WrappedID3D11Device::Serialise_CreateRasterizerState2( SERIALISE_ELEMENT_LOCAL(Descriptor, *pRasterizerDesc); SERIALISE_ELEMENT_LOCAL(pState, GetIDForResource(*ppRasterizerState)); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { ID3D11RasterizerState2 *ret = NULL; @@ -783,6 +807,8 @@ bool WrappedID3D11Device::Serialise_CreateQuery1(SerialiserType &ser, SERIALISE_ELEMENT_LOCAL(Descriptor, *pQueryDesc); SERIALISE_ELEMENT_LOCAL(pQuery, GetIDForResource(*ppQuery)); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { ID3D11Query1 *ret = NULL; diff --git a/renderdoc/driver/d3d11/d3d11_device_wrap.cpp b/renderdoc/driver/d3d11/d3d11_device_wrap.cpp index f3879deda..72c006e61 100644 --- a/renderdoc/driver/d3d11/d3d11_device_wrap.cpp +++ b/renderdoc/driver/d3d11/d3d11_device_wrap.cpp @@ -91,6 +91,8 @@ bool WrappedID3D11Device::Serialise_CreateBuffer(SerialiserType &ser, const D3D1 record->Length = Descriptor.ByteWidth; } + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { ID3D11Buffer *ret; @@ -347,6 +349,16 @@ bool WrappedID3D11Device::Serialise_CreateTexture1D(SerialiserType &ser, ser, ppTexture1D ? *ppTexture1D : NULL, pTexture, pInitialData, Descriptor.Width, 1, 1, Descriptor.Format, Descriptor.MipLevels, Descriptor.ArraySize, HasInitialData); + if(IsReplayingAndReading() && ser.IsErrored()) + { + // need to manually free the serialised buffers we stole in Serialise_CreateTextureData here, + // before the SERIALISE_CHECK_READ_ERRORS macro below returns out of the function + for(size_t i = 0; i < descs.size(); i++) + FreeAlignedBuffer((byte *)descs[i].pSysMem); + } + + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { ID3D11Texture1D *ret; @@ -464,6 +476,16 @@ bool WrappedID3D11Device::Serialise_CreateTexture2D(SerialiserType &ser, Descriptor.Width, Descriptor.Height, 1, Descriptor.Format, Descriptor.MipLevels, Descriptor.ArraySize, HasInitialData); + if(IsReplayingAndReading() && ser.IsErrored()) + { + // need to manually free the serialised buffers we stole in Serialise_CreateTextureData here, + // before the SERIALISE_CHECK_READ_ERRORS macro below returns out of the function + for(size_t i = 0; i < descs.size(); i++) + FreeAlignedBuffer((byte *)descs[i].pSysMem); + } + + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { ID3D11Texture2D *ret; @@ -581,6 +603,16 @@ bool WrappedID3D11Device::Serialise_CreateTexture3D(SerialiserType &ser, Descriptor.Width, Descriptor.Height, Descriptor.Depth, Descriptor.Format, Descriptor.MipLevels, 1, HasInitialData); + if(IsReplayingAndReading() && ser.IsErrored()) + { + // need to manually free the serialised buffers we stole in Serialise_CreateTextureData here, + // before the SERIALISE_CHECK_READ_ERRORS macro below returns out of the function + for(size_t i = 0; i < descs.size(); i++) + FreeAlignedBuffer((byte *)descs[i].pSysMem); + } + + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { ID3D11Texture3D *ret; @@ -685,6 +717,8 @@ bool WrappedID3D11Device::Serialise_CreateShaderResourceView( SERIALISE_ELEMENT_OPT(pDesc); SERIALISE_ELEMENT_LOCAL(pView, GetIDForResource(*ppSRView)); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading() && pResource) { ID3D11ShaderResourceView *ret; @@ -817,6 +851,8 @@ bool WrappedID3D11Device::Serialise_CreateUnorderedAccessView( SERIALISE_ELEMENT_OPT(pDesc); SERIALISE_ELEMENT_LOCAL(pView, GetIDForResource(*ppUAView)); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading() && pResource) { ID3D11UnorderedAccessView *ret; @@ -915,6 +951,8 @@ bool WrappedID3D11Device::Serialise_CreateRenderTargetView(SerialiserType &ser, SERIALISE_ELEMENT_OPT(pDesc); SERIALISE_ELEMENT_LOCAL(pView, GetIDForResource(*ppRTView)); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading() && pResource) { ID3D11RenderTargetView *ret; @@ -1043,6 +1081,8 @@ bool WrappedID3D11Device::Serialise_CreateDepthStencilView( SERIALISE_ELEMENT_OPT(pDesc); SERIALISE_ELEMENT_LOCAL(pView, GetIDForResource(*ppDepthStencilView)); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading() && pResource) { ID3D11DepthStencilView *ret; @@ -1142,6 +1182,8 @@ bool WrappedID3D11Device::Serialise_CreateInputLayout( SERIALISE_ELEMENT_ARRAY(pShaderBytecodeWithInputSignature, BytecodeLength); SERIALISE_ELEMENT_LOCAL(pInputLayout, GetIDForResource(*ppInputLayout)); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { ID3D11InputLayout *ret = NULL; @@ -1230,6 +1272,8 @@ bool WrappedID3D11Device::Serialise_CreateVertexShader(SerialiserType &ser, SERIALISE_ELEMENT(pClassLinkage); SERIALISE_ELEMENT_LOCAL(pShader, GetIDForResource(*ppVertexShader)); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { ID3D11VertexShader *ret; @@ -1317,6 +1361,8 @@ bool WrappedID3D11Device::Serialise_CreateGeometryShader(SerialiserType &ser, SERIALISE_ELEMENT(pClassLinkage); SERIALISE_ELEMENT_LOCAL(pShader, GetIDForResource(*ppGeometryShader)); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { ID3D11GeometryShader *ret; @@ -1408,6 +1454,8 @@ bool WrappedID3D11Device::Serialise_CreateGeometryShaderWithStreamOutput( SERIALISE_ELEMENT(pClassLinkage); SERIALISE_ELEMENT_LOCAL(pShader, GetIDForResource(*ppGeometryShader)); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { ID3D11GeometryShader *ret; @@ -1502,6 +1550,8 @@ bool WrappedID3D11Device::Serialise_CreatePixelShader(SerialiserType &ser, SERIALISE_ELEMENT(pClassLinkage); SERIALISE_ELEMENT_LOCAL(pShader, GetIDForResource(*ppPixelShader)); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { ID3D11PixelShader *ret; @@ -1587,6 +1637,8 @@ bool WrappedID3D11Device::Serialise_CreateHullShader(SerialiserType &ser, const SERIALISE_ELEMENT(pClassLinkage); SERIALISE_ELEMENT_LOCAL(pShader, GetIDForResource(*ppHullShader)); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { ID3D11HullShader *ret; @@ -1673,6 +1725,8 @@ bool WrappedID3D11Device::Serialise_CreateDomainShader(SerialiserType &ser, SERIALISE_ELEMENT(pClassLinkage); SERIALISE_ELEMENT_LOCAL(pShader, GetIDForResource(*ppDomainShader)); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { ID3D11DomainShader *ret; @@ -1760,6 +1814,8 @@ bool WrappedID3D11Device::Serialise_CreateComputeShader(SerialiserType &ser, SERIALISE_ELEMENT(pClassLinkage); SERIALISE_ELEMENT_LOCAL(pShader, GetIDForResource(*ppComputeShader)); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { ID3D11ComputeShader *ret; @@ -1854,6 +1910,8 @@ bool WrappedID3D11Device::Serialise_CreateClassInstance(SerialiserType &ser, LPC SERIALISE_ELEMENT(pClassLinkage); SERIALISE_ELEMENT_LOCAL(pInstance, GetIDForResource(*ppInstance)); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading() && pClassLinkage) { ID3D11ClassInstance *real = NULL; @@ -1920,6 +1978,8 @@ bool WrappedID3D11Device::Serialise_GetClassInstance(SerialiserType &ser, LPCSTR SERIALISE_ELEMENT(pClassLinkage); SERIALISE_ELEMENT_LOCAL(pInstance, GetIDForResource(*ppInstance)); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading() && pClassLinkage) { ID3D11ClassInstance *real = NULL; @@ -1980,6 +2040,8 @@ bool WrappedID3D11Device::Serialise_CreateClassLinkage(SerialiserType &ser, { SERIALISE_ELEMENT_LOCAL(pLinkage, GetIDForResource(*ppLinkage)); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { ID3D11ClassLinkage *ret; @@ -2041,6 +2103,8 @@ bool WrappedID3D11Device::Serialise_CreateBlendState(SerialiserType &ser, SERIALISE_ELEMENT_LOCAL(Descriptor, *pBlendStateDesc); SERIALISE_ELEMENT_LOCAL(pState, GetIDForResource(*ppBlendState)); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { ID3D11BlendState *ret; @@ -2131,6 +2195,8 @@ bool WrappedID3D11Device::Serialise_CreateDepthStencilState( SERIALISE_ELEMENT_LOCAL(Descriptor, *pDepthStencilDesc); SERIALISE_ELEMENT_LOCAL(pState, GetIDForResource(*ppDepthStencilState)); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { ID3D11DepthStencilState *ret; @@ -2221,6 +2287,8 @@ bool WrappedID3D11Device::Serialise_CreateRasterizerState(SerialiserType &ser, SERIALISE_ELEMENT_LOCAL(Descriptor, *pRasterizerDesc); SERIALISE_ELEMENT_LOCAL(pState, GetIDForResource(*ppRasterizerState)); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { ID3D11RasterizerState *ret; @@ -2311,6 +2379,8 @@ bool WrappedID3D11Device::Serialise_CreateSamplerState(SerialiserType &ser, SERIALISE_ELEMENT_LOCAL(Descriptor, *pSamplerDesc); SERIALISE_ELEMENT_LOCAL(pState, GetIDForResource(*ppSamplerState)); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { ID3D11SamplerState *ret; @@ -2401,6 +2471,8 @@ bool WrappedID3D11Device::Serialise_CreateQuery(SerialiserType &ser, SERIALISE_ELEMENT_LOCAL(Descriptor, *pQueryDesc); SERIALISE_ELEMENT_LOCAL(pQuery, GetIDForResource(*ppQuery)); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { ID3D11Query *ret; @@ -2462,6 +2534,8 @@ bool WrappedID3D11Device::Serialise_CreatePredicate(SerialiserType &ser, SERIALISE_ELEMENT_LOCAL(Descriptor, *pPredicateDesc); SERIALISE_ELEMENT_LOCAL(pPredicate, GetIDForResource(*ppPredicate)); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { ID3D11Predicate *ret; @@ -2524,6 +2598,8 @@ bool WrappedID3D11Device::Serialise_CreateCounter(SerialiserType &ser, SERIALISE_ELEMENT_LOCAL(Descriptor, *pCounterDesc); SERIALISE_ELEMENT_LOCAL(pCounter, GetIDForResource(*ppCounter)); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { ID3D11Counter *ret; @@ -2586,6 +2662,8 @@ bool WrappedID3D11Device::Serialise_CreateDeferredContext(SerialiserType &ser, SERIALISE_ELEMENT(ContextFlags); SERIALISE_ELEMENT_LOCAL(pDeferredContext, GetIDForDeviceChild(*ppDeferredContext)); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { ID3D11DeviceContext *ret; @@ -2693,6 +2771,8 @@ bool WrappedID3D11Device::Serialise_OpenSharedResource(SerialiserType &ser, HAND record->Length = Descriptor.ByteWidth; } + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { ID3D11Buffer *ret; @@ -2770,6 +2850,8 @@ bool WrappedID3D11Device::Serialise_OpenSharedResource(SerialiserType &ser, HAND Serialise_CreateTextureData(ser, tex, pResource, NULL, Descriptor.Width, 1, 1, Descriptor.Format, Descriptor.MipLevels, Descriptor.ArraySize, false); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { ID3D11Texture1D *ret; @@ -2813,6 +2895,8 @@ bool WrappedID3D11Device::Serialise_OpenSharedResource(SerialiserType &ser, HAND Serialise_CreateTextureData(ser, tex, pResource, NULL, Descriptor.Width, Descriptor.Height, 1, Descriptor.Format, Descriptor.MipLevels, Descriptor.ArraySize, false); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { ID3D11Texture2D *ret; @@ -2856,6 +2940,8 @@ bool WrappedID3D11Device::Serialise_OpenSharedResource(SerialiserType &ser, HAND Serialise_CreateTextureData(ser, tex, pResource, NULL, Descriptor.Width, Descriptor.Height, Descriptor.Depth, Descriptor.Format, Descriptor.MipLevels, 1, false); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { ID3D11Texture3D *ret; @@ -3120,6 +3206,8 @@ bool WrappedID3D11Device::Serialise_SetExceptionMode(SerialiserType &ser, UINT R { SERIALISE_ELEMENT(RaiseFlags); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) m_pDevice->SetExceptionMode(RaiseFlags); diff --git a/renderdoc/driver/d3d11/d3d11_initstate.cpp b/renderdoc/driver/d3d11/d3d11_initstate.cpp index 795276c6d..e4563dc3c 100644 --- a/renderdoc/driver/d3d11/d3d11_initstate.cpp +++ b/renderdoc/driver/d3d11/d3d11_initstate.cpp @@ -494,6 +494,8 @@ bool WrappedID3D11Device::Serialise_InitialState(SerialiserType &ser, ResourceId SERIALISE_ELEMENT(InitialHiddenCount); + SERIALISE_CHECK_READ_ERRORS(); + if(bufferUAVWithCounter && IsReplayingAndReading()) { m_ResourceManager->SetInitialContents( @@ -615,6 +617,18 @@ bool WrappedID3D11Device::Serialise_InitialState(SerialiserType &ser, ResourceId } } + // need to manually do cleanup here if we're about to bail on errors + if(IsReplayingAndReading() && tex && ser.IsErrored()) + { + // free the buffers we stole + for(UINT sub = 0; sub < NumSubresources; sub++) + FreeAlignedBuffer((byte *)subData[sub].pSysMem); + + SAFE_DELETE_ARRAY(subData); + } + + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading() && tex) { // We don't need to bind this, but IMMUTABLE requires at least one @@ -752,6 +766,18 @@ bool WrappedID3D11Device::Serialise_InitialState(SerialiserType &ser, ResourceId } } + // need to manually do cleanup here if we're about to bail on errors + if(IsReplayingAndReading() && tex && ser.IsErrored()) + { + // free the buffers we stole + for(UINT sub = 0; sub < NumSubresources; sub++) + FreeAlignedBuffer((byte *)subData[sub].pSysMem); + + SAFE_DELETE_ARRAY(subData); + } + + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading() && tex) { // We don't need to bind this, but IMMUTABLE requires at least one @@ -915,6 +941,18 @@ bool WrappedID3D11Device::Serialise_InitialState(SerialiserType &ser, ResourceId } } + // need to manually do cleanup here if we're about to bail on errors + if(IsReplayingAndReading() && tex && ser.IsErrored()) + { + // free the buffers we stole + for(UINT sub = 0; sub < NumSubresources; sub++) + FreeAlignedBuffer((byte *)subData[sub].pSysMem); + + SAFE_DELETE_ARRAY(subData); + } + + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading() && tex) { // We don't need to bind this, but IMMUTABLE requires at least one diff --git a/renderdoc/driver/d3d12/d3d12_command_list_wrap.cpp b/renderdoc/driver/d3d12/d3d12_command_list_wrap.cpp index 33ef39f68..ea9757e2f 100644 --- a/renderdoc/driver/d3d12/d3d12_command_list_wrap.cpp +++ b/renderdoc/driver/d3d12/d3d12_command_list_wrap.cpp @@ -55,6 +55,8 @@ bool WrappedID3D12GraphicsCommandList::Serialise_Close(SerialiserType &ser) SERIALISE_ELEMENT_LOCAL(CommandList, GetResourceID()); SERIALISE_ELEMENT(BakedCommandList); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Cmd->m_LastCmdListID = BakedCommandList; @@ -170,6 +172,8 @@ bool WrappedID3D12GraphicsCommandList::Serialise_Reset(SerialiserType &ser, SERIALISE_ELEMENT(pAllocator); SERIALISE_ELEMENT(pInitialState); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Cmd->m_LastCmdListID = BakedCommandList; @@ -387,6 +391,8 @@ bool WrappedID3D12GraphicsCommandList::Serialise_ResourceBarrier( SERIALISE_ELEMENT(pCommandList); SERIALISE_ELEMENT_ARRAY(pBarriers, NumBarriers); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Cmd->m_LastCmdListID = GetResourceManager()->GetOriginalID(GetResID(pCommandList)); @@ -510,6 +516,8 @@ bool WrappedID3D12GraphicsCommandList::Serialise_IASetPrimitiveTopology( SERIALISE_ELEMENT(pCommandList); SERIALISE_ELEMENT(PrimitiveTopology); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Cmd->m_LastCmdListID = GetResourceManager()->GetOriginalID(GetResID(pCommandList)); @@ -559,6 +567,8 @@ bool WrappedID3D12GraphicsCommandList::Serialise_RSSetViewports(SerialiserType & SERIALISE_ELEMENT(pCommandList); SERIALISE_ELEMENT_ARRAY(pViewports, NumViewports); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Cmd->m_LastCmdListID = GetResourceManager()->GetOriginalID(GetResID(pCommandList)); @@ -618,6 +628,8 @@ bool WrappedID3D12GraphicsCommandList::Serialise_RSSetScissorRects(SerialiserTyp SERIALISE_ELEMENT(pCommandList); SERIALISE_ELEMENT_ARRAY(pRects, NumRects); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Cmd->m_LastCmdListID = GetResourceManager()->GetOriginalID(GetResID(pCommandList)); @@ -676,6 +688,8 @@ bool WrappedID3D12GraphicsCommandList::Serialise_OMSetBlendFactor(SerialiserType SERIALISE_ELEMENT(pCommandList); SERIALISE_ELEMENT_ARRAY(BlendFactor, FIXED_COUNT(4)); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Cmd->m_LastCmdListID = GetResourceManager()->GetOriginalID(GetResID(pCommandList)); @@ -724,6 +738,8 @@ bool WrappedID3D12GraphicsCommandList::Serialise_OMSetStencilRef(SerialiserType SERIALISE_ELEMENT(pCommandList); SERIALISE_ELEMENT(StencilRef); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Cmd->m_LastCmdListID = GetResourceManager()->GetOriginalID(GetResID(pCommandList)); @@ -772,6 +788,8 @@ bool WrappedID3D12GraphicsCommandList::Serialise_SetDescriptorHeaps( SERIALISE_ELEMENT(pCommandList); SERIALISE_ELEMENT_ARRAY(ppDescriptorHeaps, NumDescriptorHeaps); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Cmd->m_LastCmdListID = GetResourceManager()->GetOriginalID(GetResID(pCommandList)); @@ -844,6 +862,8 @@ bool WrappedID3D12GraphicsCommandList::Serialise_IASetIndexBuffer(SerialiserType SERIALISE_ELEMENT(pCommandList); SERIALISE_ELEMENT_OPT(pView); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Cmd->m_LastCmdListID = GetResourceManager()->GetOriginalID(GetResID(pCommandList)); @@ -927,6 +947,8 @@ bool WrappedID3D12GraphicsCommandList::Serialise_IASetVertexBuffers( SERIALISE_ELEMENT(StartSlot); SERIALISE_ELEMENT_ARRAY(pViews, NumViews); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Cmd->m_LastCmdListID = GetResourceManager()->GetOriginalID(GetResID(pCommandList)); @@ -1005,6 +1027,8 @@ bool WrappedID3D12GraphicsCommandList::Serialise_SOSetTargets( SERIALISE_ELEMENT(StartSlot); SERIALISE_ELEMENT_ARRAY(pViews, NumViews); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Cmd->m_LastCmdListID = GetResourceManager()->GetOriginalID(GetResID(pCommandList)); @@ -1085,6 +1109,8 @@ bool WrappedID3D12GraphicsCommandList::Serialise_SetPipelineState(SerialiserType SERIALISE_ELEMENT(pCommandList); SERIALISE_ELEMENT(pPipelineState); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Cmd->m_LastCmdListID = GetResourceManager()->GetOriginalID(GetResID(pCommandList)); @@ -1144,6 +1170,8 @@ bool WrappedID3D12GraphicsCommandList::Serialise_OMSetRenderTargets( SERIALISE_ELEMENT_ARRAY(pRenderTargetDescriptors, numHandles); SERIALISE_ELEMENT_OPT(pDepthStencilDescriptor); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Cmd->m_LastCmdListID = GetResourceManager()->GetOriginalID(GetResID(pCommandList)); @@ -1257,6 +1285,8 @@ bool WrappedID3D12GraphicsCommandList::Serialise_SetComputeRootSignature( SERIALISE_ELEMENT(pCommandList); SERIALISE_ELEMENT(pRootSignature); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Cmd->m_LastCmdListID = GetResourceManager()->GetOriginalID(GetResID(pCommandList)); @@ -1324,6 +1354,8 @@ bool WrappedID3D12GraphicsCommandList::Serialise_SetComputeRootDescriptorTable( SERIALISE_ELEMENT(RootParameterIndex); SERIALISE_ELEMENT(BaseDescriptor); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Cmd->m_LastCmdListID = GetResourceManager()->GetOriginalID(GetResID(pCommandList)); @@ -1428,6 +1460,8 @@ bool WrappedID3D12GraphicsCommandList::Serialise_SetComputeRoot32BitConstant( SERIALISE_ELEMENT(SrcData); SERIALISE_ELEMENT(DestOffsetIn32BitValues); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Cmd->m_LastCmdListID = GetResourceManager()->GetOriginalID(GetResID(pCommandList)); @@ -1495,6 +1529,8 @@ bool WrappedID3D12GraphicsCommandList::Serialise_SetComputeRoot32BitConstants( const UINT *pSrcData = (const UINT *)pSrcVoidData; SERIALISE_ELEMENT_ARRAY(pSrcData, Num32BitValuesToSet); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Cmd->m_LastCmdListID = GetResourceManager()->GetOriginalID(GetResID(pCommandList)); @@ -1564,6 +1600,8 @@ bool WrappedID3D12GraphicsCommandList::Serialise_SetComputeRootConstantBufferVie SERIALISE_ELEMENT(RootParameterIndex); SERIALISE_ELEMENT_TYPED(D3D12BufferLocation, BufferLocation); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Cmd->m_LastCmdListID = GetResourceManager()->GetOriginalID(GetResID(pCommandList)); @@ -1638,6 +1676,8 @@ bool WrappedID3D12GraphicsCommandList::Serialise_SetComputeRootShaderResourceVie SERIALISE_ELEMENT(RootParameterIndex); SERIALISE_ELEMENT_TYPED(D3D12BufferLocation, BufferLocation); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Cmd->m_LastCmdListID = GetResourceManager()->GetOriginalID(GetResID(pCommandList)); @@ -1712,6 +1752,8 @@ bool WrappedID3D12GraphicsCommandList::Serialise_SetComputeRootUnorderedAccessVi SERIALISE_ELEMENT(RootParameterIndex); SERIALISE_ELEMENT_TYPED(D3D12BufferLocation, BufferLocation); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Cmd->m_LastCmdListID = GetResourceManager()->GetOriginalID(GetResID(pCommandList)); @@ -1789,6 +1831,8 @@ bool WrappedID3D12GraphicsCommandList::Serialise_SetGraphicsRootSignature( SERIALISE_ELEMENT(pCommandList); SERIALISE_ELEMENT(pRootSignature); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Cmd->m_LastCmdListID = GetResourceManager()->GetOriginalID(GetResID(pCommandList)); @@ -1856,6 +1900,8 @@ bool WrappedID3D12GraphicsCommandList::Serialise_SetGraphicsRootDescriptorTable( SERIALISE_ELEMENT(RootParameterIndex); SERIALISE_ELEMENT(BaseDescriptor); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Cmd->m_LastCmdListID = GetResourceManager()->GetOriginalID(GetResID(pCommandList)); @@ -1960,6 +2006,8 @@ bool WrappedID3D12GraphicsCommandList::Serialise_SetGraphicsRoot32BitConstant( SERIALISE_ELEMENT(SrcData); SERIALISE_ELEMENT(DestOffsetIn32BitValues); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Cmd->m_LastCmdListID = GetResourceManager()->GetOriginalID(GetResID(pCommandList)); @@ -2027,6 +2075,8 @@ bool WrappedID3D12GraphicsCommandList::Serialise_SetGraphicsRoot32BitConstants( const UINT *pSrcData = (const UINT *)pSrcVoidData; SERIALISE_ELEMENT_ARRAY(pSrcData, Num32BitValuesToSet); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Cmd->m_LastCmdListID = GetResourceManager()->GetOriginalID(GetResID(pCommandList)); @@ -2096,6 +2146,8 @@ bool WrappedID3D12GraphicsCommandList::Serialise_SetGraphicsRootConstantBufferVi SERIALISE_ELEMENT(RootParameterIndex); SERIALISE_ELEMENT_TYPED(D3D12BufferLocation, BufferLocation); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Cmd->m_LastCmdListID = GetResourceManager()->GetOriginalID(GetResID(pCommandList)); @@ -2170,6 +2222,8 @@ bool WrappedID3D12GraphicsCommandList::Serialise_SetGraphicsRootShaderResourceVi SERIALISE_ELEMENT(RootParameterIndex); SERIALISE_ELEMENT_TYPED(D3D12BufferLocation, BufferLocation); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Cmd->m_LastCmdListID = GetResourceManager()->GetOriginalID(GetResID(pCommandList)); @@ -2244,6 +2298,8 @@ bool WrappedID3D12GraphicsCommandList::Serialise_SetGraphicsRootUnorderedAccessV SERIALISE_ELEMENT(RootParameterIndex); SERIALISE_ELEMENT_TYPED(D3D12BufferLocation, BufferLocation); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Cmd->m_LastCmdListID = GetResourceManager()->GetOriginalID(GetResID(pCommandList)); @@ -2324,6 +2380,8 @@ bool WrappedID3D12GraphicsCommandList::Serialise_BeginQuery(SerialiserType &ser, SERIALISE_ELEMENT(Type); SERIALISE_ELEMENT(Index); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Cmd->m_LastCmdListID = GetResourceManager()->GetOriginalID(GetResID(pCommandList)); @@ -2371,6 +2429,8 @@ bool WrappedID3D12GraphicsCommandList::Serialise_EndQuery(SerialiserType &ser, SERIALISE_ELEMENT(Type); SERIALISE_ELEMENT(Index); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Cmd->m_LastCmdListID = GetResourceManager()->GetOriginalID(GetResID(pCommandList)); @@ -2422,6 +2482,8 @@ bool WrappedID3D12GraphicsCommandList::Serialise_ResolveQueryData( SERIALISE_ELEMENT(pDestinationBuffer); SERIALISE_ELEMENT(AlignedDestinationBufferOffset); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Cmd->m_LastCmdListID = GetResourceManager()->GetOriginalID(GetResID(pCommandList)); @@ -2476,6 +2538,8 @@ bool WrappedID3D12GraphicsCommandList::Serialise_SetPredication(SerialiserType & SERIALISE_ELEMENT(AlignedBufferOffset); SERIALISE_ELEMENT(Operation); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Cmd->m_LastCmdListID = GetResourceManager()->GetOriginalID(GetResID(pCommandList)); @@ -2704,6 +2768,8 @@ bool WrappedID3D12GraphicsCommandList::Serialise_SetMarker(SerialiserType &ser, SERIALISE_ELEMENT(pCommandList); SERIALISE_ELEMENT(MarkerText); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Cmd->m_LastCmdListID = GetResourceManager()->GetOriginalID(GetResID(pCommandList)); @@ -2784,6 +2850,8 @@ bool WrappedID3D12GraphicsCommandList::Serialise_BeginEvent(SerialiserType &ser, SERIALISE_ELEMENT(pCommandList); SERIALISE_ELEMENT(MarkerText); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Cmd->m_LastCmdListID = GetResourceManager()->GetOriginalID(GetResID(pCommandList)); @@ -2840,6 +2908,8 @@ bool WrappedID3D12GraphicsCommandList::Serialise_EndEvent(SerialiserType &ser) ID3D12GraphicsCommandList *pCommandList = this; SERIALISE_ELEMENT(pCommandList); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Cmd->m_LastCmdListID = GetResourceManager()->GetOriginalID(GetResID(pCommandList)); @@ -2920,6 +2990,8 @@ bool WrappedID3D12GraphicsCommandList::Serialise_DrawInstanced(SerialiserType &s SERIALISE_ELEMENT(StartVertexLocation); SERIALISE_ELEMENT(StartInstanceLocation); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Cmd->m_LastCmdListID = GetResourceManager()->GetOriginalID(GetResID(pCommandList)); @@ -3003,6 +3075,8 @@ bool WrappedID3D12GraphicsCommandList::Serialise_DrawIndexedInstanced( SERIALISE_ELEMENT(BaseVertexLocation); SERIALISE_ELEMENT(StartInstanceLocation); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Cmd->m_LastCmdListID = GetResourceManager()->GetOriginalID(GetResID(pCommandList)); @@ -3087,6 +3161,8 @@ bool WrappedID3D12GraphicsCommandList::Serialise_Dispatch(SerialiserType &ser, U SERIALISE_ELEMENT(ThreadGroupCountY); SERIALISE_ELEMENT(ThreadGroupCountZ); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Cmd->m_LastCmdListID = GetResourceManager()->GetOriginalID(GetResID(pCommandList)); @@ -3156,6 +3232,8 @@ bool WrappedID3D12GraphicsCommandList::Serialise_ExecuteBundle(SerialiserType &s SERIALISE_ELEMENT(pCommandList); SERIALISE_ELEMENT(pBundle); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Cmd->m_LastCmdListID = GetResourceManager()->GetOriginalID(GetResID(pCommandList)); @@ -3917,6 +3995,8 @@ bool WrappedID3D12GraphicsCommandList::Serialise_ExecuteIndirect( SERIALISE_ELEMENT(pCountBuffer); SERIALISE_ELEMENT(CountBufferOffset); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Cmd->m_LastCmdListID = GetResourceManager()->GetOriginalID(GetResID(pCommandList)); @@ -4078,6 +4158,8 @@ bool WrappedID3D12GraphicsCommandList::Serialise_ClearDepthStencilView( SERIALISE_ELEMENT(Stencil); SERIALISE_ELEMENT_ARRAY(pRects, NumRects); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Cmd->m_LastCmdListID = GetResourceManager()->GetOriginalID(GetResID(pCommandList)); @@ -4161,6 +4243,8 @@ bool WrappedID3D12GraphicsCommandList::Serialise_ClearRenderTargetView( SERIALISE_ELEMENT_ARRAY(ColorRGBA, FIXED_COUNT(4)); SERIALISE_ELEMENT_ARRAY(pRects, NumRects); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Cmd->m_LastCmdListID = GetResourceManager()->GetOriginalID(GetResID(pCommandList)); @@ -4242,6 +4326,8 @@ bool WrappedID3D12GraphicsCommandList::Serialise_ClearUnorderedAccessViewUint( SERIALISE_ELEMENT_ARRAY(Values, FIXED_COUNT(4)); SERIALISE_ELEMENT_ARRAY(pRects, NumRects); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Cmd->m_LastCmdListID = GetResourceManager()->GetOriginalID(GetResID(pCommandList)); @@ -4332,6 +4418,8 @@ bool WrappedID3D12GraphicsCommandList::Serialise_ClearUnorderedAccessViewFloat( SERIALISE_ELEMENT_ARRAY(Values, FIXED_COUNT(4)); SERIALISE_ELEMENT_ARRAY(pRects, NumRects); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Cmd->m_LastCmdListID = GetResourceManager()->GetOriginalID(GetResID(pCommandList)); @@ -4418,6 +4506,8 @@ bool WrappedID3D12GraphicsCommandList::Serialise_DiscardResource(SerialiserType SERIALISE_ELEMENT(pResource); SERIALISE_ELEMENT_OPT(pRegion); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Cmd->m_LastCmdListID = GetResourceManager()->GetOriginalID(GetResID(pCommandList)); @@ -4476,6 +4566,8 @@ bool WrappedID3D12GraphicsCommandList::Serialise_CopyBufferRegion(SerialiserType SERIALISE_ELEMENT(SrcOffset); SERIALISE_ELEMENT(NumBytes); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Cmd->m_LastCmdListID = GetResourceManager()->GetOriginalID(GetResID(pCommandList)); @@ -4564,6 +4656,8 @@ bool WrappedID3D12GraphicsCommandList::Serialise_CopyTextureRegion( SERIALISE_ELEMENT_LOCAL(src, *pSrc); SERIALISE_ELEMENT_OPT(pSrcBox); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Cmd->m_LastCmdListID = GetResourceManager()->GetOriginalID(GetResID(pCommandList)); @@ -4663,6 +4757,8 @@ bool WrappedID3D12GraphicsCommandList::Serialise_CopyResource(SerialiserType &se SERIALISE_ELEMENT(pDstResource); SERIALISE_ELEMENT(pSrcResource); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Cmd->m_LastCmdListID = GetResourceManager()->GetOriginalID(GetResID(pCommandList)); @@ -4746,6 +4842,8 @@ bool WrappedID3D12GraphicsCommandList::Serialise_ResolveSubresource( SERIALISE_ELEMENT(SrcSubresource); SERIALISE_ELEMENT(Format); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Cmd->m_LastCmdListID = GetResourceManager()->GetOriginalID(GetResID(pCommandList)); diff --git a/renderdoc/driver/d3d12/d3d12_command_queue.h b/renderdoc/driver/d3d12/d3d12_command_queue.h index 783c32626..1bcee3017 100644 --- a/renderdoc/driver/d3d12/d3d12_command_queue.h +++ b/renderdoc/driver/d3d12/d3d12_command_queue.h @@ -85,6 +85,8 @@ class WrappedID3D12CommandQueue : public ID3D12CommandQueue, CaptureState &m_State; + ReplayStatus m_FailedReplayStatus = ReplayStatus::APIReplayFailed; + WrappedID3D12DebugCommandQueue m_WrappedDebug; vector m_CmdListRecords; @@ -105,7 +107,7 @@ class WrappedID3D12CommandQueue : public ID3D12CommandQueue, ResourceId m_PrevQueueId; ResourceId m_BackbufferID; - void ProcessChunk(ReadSerialiser &ser, D3D12Chunk context); + bool ProcessChunk(ReadSerialiser &ser, D3D12Chunk context); static std::string GetChunkName(uint32_t idx); D3D12ResourceManager *GetResourceManager() { return m_pDevice->GetResourceManager(); } @@ -128,7 +130,8 @@ public: ResourceId GetBackbufferResourceID() { return m_BackbufferID; } void ClearAfterCapture(); - void ReplayLog(CaptureState readType, uint32_t startEventID, uint32_t endEventID, bool partial); + ReplayStatus ReplayLog(CaptureState readType, uint32_t startEventID, uint32_t endEventID, + bool partial); void SetFrameReader(StreamReader *reader) { m_FrameReader = reader; } D3D12CommandData *GetCommandData() { return &m_Cmd; } const vector &GetUsage(ResourceId id) { return m_Cmd.m_ResourceUses[id]; } diff --git a/renderdoc/driver/d3d12/d3d12_command_queue_wrap.cpp b/renderdoc/driver/d3d12/d3d12_command_queue_wrap.cpp index b0ca849ca..1a76764ee 100644 --- a/renderdoc/driver/d3d12/d3d12_command_queue_wrap.cpp +++ b/renderdoc/driver/d3d12/d3d12_command_queue_wrap.cpp @@ -96,6 +96,8 @@ bool WrappedID3D12CommandQueue::Serialise_ExecuteCommandLists(SerialiserType &se } } + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { ID3D12CommandQueue *real = Unwrap(pQueue); @@ -609,6 +611,8 @@ bool WrappedID3D12CommandQueue::Serialise_Signal(SerialiserType &ser, ID3D12Fenc SERIALISE_ELEMENT(pFence); SERIALISE_ELEMENT(Value); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading() && pFence) { m_pReal->Signal(Unwrap(pFence), Value); @@ -640,6 +644,8 @@ bool WrappedID3D12CommandQueue::Serialise_Wait(SerialiserType &ser, ID3D12Fence SERIALISE_ELEMENT(pFence); SERIALISE_ELEMENT(Value); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading() && pFence) { m_pDevice->GPUSync(); diff --git a/renderdoc/driver/d3d12/d3d12_commands.cpp b/renderdoc/driver/d3d12/d3d12_commands.cpp index 7c9629e17..bc91d9e6b 100644 --- a/renderdoc/driver/d3d12/d3d12_commands.cpp +++ b/renderdoc/driver/d3d12/d3d12_commands.cpp @@ -269,10 +269,12 @@ const APIEvent &WrappedID3D12CommandQueue::GetEvent(uint32_t eventID) return m_Cmd.m_Events.back(); } -void WrappedID3D12CommandQueue::ProcessChunk(ReadSerialiser &ser, D3D12Chunk chunk) +bool WrappedID3D12CommandQueue::ProcessChunk(ReadSerialiser &ser, D3D12Chunk chunk) { m_Cmd.m_AddedDrawcall = false; + bool ret = false; + switch(chunk) { case D3D12Chunk::Device_CreateConstantBufferView: @@ -281,175 +283,193 @@ void WrappedID3D12CommandQueue::ProcessChunk(ReadSerialiser &ser, D3D12Chunk chu case D3D12Chunk::Device_CreateRenderTargetView: case D3D12Chunk::Device_CreateDepthStencilView: case D3D12Chunk::Device_CreateSampler: - m_pDevice->Serialise_DynamicDescriptorWrite(ser, NULL); + ret = m_pDevice->Serialise_DynamicDescriptorWrite(ser, NULL); break; case D3D12Chunk::Device_CopyDescriptors: case D3D12Chunk::Device_CopyDescriptorsSimple: - m_pDevice->Serialise_DynamicDescriptorCopies(ser, std::vector()); + ret = m_pDevice->Serialise_DynamicDescriptorCopies(ser, std::vector()); break; - case D3D12Chunk::Queue_ExecuteCommandLists: Serialise_ExecuteCommandLists(ser, 0, NULL); break; - case D3D12Chunk::Queue_Signal: Serialise_Signal(ser, NULL, 0); break; - case D3D12Chunk::Queue_Wait: Serialise_Wait(ser, NULL, 0); break; + case D3D12Chunk::Queue_ExecuteCommandLists: + ret = Serialise_ExecuteCommandLists(ser, 0, NULL); + break; + case D3D12Chunk::Queue_Signal: ret = Serialise_Signal(ser, NULL, 0); break; + case D3D12Chunk::Queue_Wait: ret = Serialise_Wait(ser, NULL, 0); break; case D3D12Chunk::Queue_UpdateTileMappings: - Serialise_UpdateTileMappings(ser, NULL, 0, NULL, NULL, NULL, 0, NULL, NULL, NULL, - D3D12_TILE_MAPPING_FLAGS(0)); + ret = Serialise_UpdateTileMappings(ser, NULL, 0, NULL, NULL, NULL, 0, NULL, NULL, NULL, + D3D12_TILE_MAPPING_FLAGS(0)); break; case D3D12Chunk::Queue_CopyTileMappings: - Serialise_CopyTileMappings(ser, NULL, NULL, NULL, NULL, NULL, D3D12_TILE_MAPPING_FLAGS(0)); + ret = + Serialise_CopyTileMappings(ser, NULL, NULL, NULL, NULL, NULL, D3D12_TILE_MAPPING_FLAGS(0)); break; - case D3D12Chunk::List_Close: m_ReplayList->Serialise_Close(ser); break; - case D3D12Chunk::List_Reset: m_ReplayList->Serialise_Reset(ser, NULL, NULL); break; + case D3D12Chunk::List_Close: ret = m_ReplayList->Serialise_Close(ser); break; + case D3D12Chunk::List_Reset: ret = m_ReplayList->Serialise_Reset(ser, NULL, NULL); break; case D3D12Chunk::List_ResourceBarrier: - m_ReplayList->Serialise_ResourceBarrier(ser, 0, NULL); + ret = m_ReplayList->Serialise_ResourceBarrier(ser, 0, NULL); break; case D3D12Chunk::List_BeginQuery: - m_ReplayList->Serialise_BeginQuery(ser, NULL, D3D12_QUERY_TYPE(0), 0); + ret = m_ReplayList->Serialise_BeginQuery(ser, NULL, D3D12_QUERY_TYPE(0), 0); break; case D3D12Chunk::List_EndQuery: - m_ReplayList->Serialise_EndQuery(ser, NULL, D3D12_QUERY_TYPE(0), 0); + ret = m_ReplayList->Serialise_EndQuery(ser, NULL, D3D12_QUERY_TYPE(0), 0); break; case D3D12Chunk::List_ResolveQueryData: - m_ReplayList->Serialise_ResolveQueryData(ser, NULL, D3D12_QUERY_TYPE(0), 0, 0, NULL, 0); + ret = m_ReplayList->Serialise_ResolveQueryData(ser, NULL, D3D12_QUERY_TYPE(0), 0, 0, NULL, 0); break; case D3D12Chunk::List_SetPredication: - m_ReplayList->Serialise_SetPredication(ser, NULL, 0, D3D12_PREDICATION_OP(0)); + ret = m_ReplayList->Serialise_SetPredication(ser, NULL, 0, D3D12_PREDICATION_OP(0)); break; case D3D12Chunk::List_DrawIndexedInstanced: - m_ReplayList->Serialise_DrawIndexedInstanced(ser, 0, 0, 0, 0, 0); + ret = m_ReplayList->Serialise_DrawIndexedInstanced(ser, 0, 0, 0, 0, 0); break; case D3D12Chunk::List_DrawInstanced: - m_ReplayList->Serialise_DrawInstanced(ser, 0, 0, 0, 0); + ret = m_ReplayList->Serialise_DrawInstanced(ser, 0, 0, 0, 0); break; - case D3D12Chunk::List_Dispatch: m_ReplayList->Serialise_Dispatch(ser, 0, 0, 0); break; + case D3D12Chunk::List_Dispatch: ret = m_ReplayList->Serialise_Dispatch(ser, 0, 0, 0); break; case D3D12Chunk::List_ExecuteIndirect: - m_ReplayList->Serialise_ExecuteIndirect(ser, NULL, 0, NULL, 0, NULL, 0); + ret = m_ReplayList->Serialise_ExecuteIndirect(ser, NULL, 0, NULL, 0, NULL, 0); + break; + case D3D12Chunk::List_ExecuteBundle: + ret = m_ReplayList->Serialise_ExecuteBundle(ser, NULL); break; - case D3D12Chunk::List_ExecuteBundle: m_ReplayList->Serialise_ExecuteBundle(ser, NULL); break; case D3D12Chunk::List_CopyBufferRegion: - m_ReplayList->Serialise_CopyBufferRegion(ser, NULL, 0, NULL, 0, 0); + ret = m_ReplayList->Serialise_CopyBufferRegion(ser, NULL, 0, NULL, 0, 0); break; case D3D12Chunk::List_CopyTextureRegion: - m_ReplayList->Serialise_CopyTextureRegion(ser, NULL, 0, 0, 0, NULL, NULL); + ret = m_ReplayList->Serialise_CopyTextureRegion(ser, NULL, 0, 0, 0, NULL, NULL); break; case D3D12Chunk::List_CopyResource: - m_ReplayList->Serialise_CopyResource(ser, NULL, NULL); + ret = m_ReplayList->Serialise_CopyResource(ser, NULL, NULL); break; case D3D12Chunk::List_ResolveSubresource: - m_ReplayList->Serialise_ResolveSubresource(ser, NULL, 0, NULL, 0, DXGI_FORMAT_UNKNOWN); + ret = m_ReplayList->Serialise_ResolveSubresource(ser, NULL, 0, NULL, 0, DXGI_FORMAT_UNKNOWN); break; case D3D12Chunk::List_ClearRenderTargetView: - m_ReplayList->Serialise_ClearRenderTargetView(ser, D3D12_CPU_DESCRIPTOR_HANDLE(), - (FLOAT *)NULL, 0, NULL); + ret = m_ReplayList->Serialise_ClearRenderTargetView(ser, D3D12_CPU_DESCRIPTOR_HANDLE(), + (FLOAT *)NULL, 0, NULL); break; case D3D12Chunk::List_ClearDepthStencilView: - m_ReplayList->Serialise_ClearDepthStencilView(ser, D3D12_CPU_DESCRIPTOR_HANDLE(), - D3D12_CLEAR_FLAGS(0), 0.0f, 0, 0, NULL); + ret = m_ReplayList->Serialise_ClearDepthStencilView(ser, D3D12_CPU_DESCRIPTOR_HANDLE(), + D3D12_CLEAR_FLAGS(0), 0.0f, 0, 0, NULL); break; case D3D12Chunk::List_ClearUnorderedAccessViewUint: - m_ReplayList->Serialise_ClearUnorderedAccessViewUint( + ret = m_ReplayList->Serialise_ClearUnorderedAccessViewUint( ser, D3D12_GPU_DESCRIPTOR_HANDLE(), D3D12_CPU_DESCRIPTOR_HANDLE(), NULL, NULL, 0, NULL); break; case D3D12Chunk::List_ClearUnorderedAccessViewFloat: - m_ReplayList->Serialise_ClearUnorderedAccessViewFloat( + ret = m_ReplayList->Serialise_ClearUnorderedAccessViewFloat( ser, D3D12_GPU_DESCRIPTOR_HANDLE(), D3D12_CPU_DESCRIPTOR_HANDLE(), NULL, NULL, 0, NULL); break; case D3D12Chunk::List_DiscardResource: - m_ReplayList->Serialise_DiscardResource(ser, NULL, NULL); + ret = m_ReplayList->Serialise_DiscardResource(ser, NULL, NULL); break; case D3D12Chunk::List_IASetPrimitiveTopology: - m_ReplayList->Serialise_IASetPrimitiveTopology(ser, D3D_PRIMITIVE_TOPOLOGY_UNDEFINED); + ret = m_ReplayList->Serialise_IASetPrimitiveTopology(ser, D3D_PRIMITIVE_TOPOLOGY_UNDEFINED); break; case D3D12Chunk::List_IASetIndexBuffer: - m_ReplayList->Serialise_IASetIndexBuffer(ser, NULL); + ret = m_ReplayList->Serialise_IASetIndexBuffer(ser, NULL); break; case D3D12Chunk::List_IASetVertexBuffers: - m_ReplayList->Serialise_IASetVertexBuffers(ser, 0, 0, NULL); + ret = m_ReplayList->Serialise_IASetVertexBuffers(ser, 0, 0, NULL); break; case D3D12Chunk::List_SOSetTargets: - m_ReplayList->Serialise_SOSetTargets(ser, 0, 0, NULL); + ret = m_ReplayList->Serialise_SOSetTargets(ser, 0, 0, NULL); break; case D3D12Chunk::List_RSSetViewports: - m_ReplayList->Serialise_RSSetViewports(ser, 0, NULL); + ret = m_ReplayList->Serialise_RSSetViewports(ser, 0, NULL); break; case D3D12Chunk::List_RSSetScissorRects: - m_ReplayList->Serialise_RSSetScissorRects(ser, 0, NULL); + ret = m_ReplayList->Serialise_RSSetScissorRects(ser, 0, NULL); break; case D3D12Chunk::List_SetPipelineState: - m_ReplayList->Serialise_SetPipelineState(ser, NULL); + ret = m_ReplayList->Serialise_SetPipelineState(ser, NULL); break; case D3D12Chunk::List_SetDescriptorHeaps: - m_ReplayList->Serialise_SetDescriptorHeaps(ser, 0, NULL); + ret = m_ReplayList->Serialise_SetDescriptorHeaps(ser, 0, NULL); break; case D3D12Chunk::List_OMSetRenderTargets: - m_ReplayList->Serialise_OMSetRenderTargets(ser, 0, NULL, FALSE, NULL); + ret = m_ReplayList->Serialise_OMSetRenderTargets(ser, 0, NULL, FALSE, NULL); + break; + case D3D12Chunk::List_OMSetStencilRef: + ret = m_ReplayList->Serialise_OMSetStencilRef(ser, 0); break; - case D3D12Chunk::List_OMSetStencilRef: m_ReplayList->Serialise_OMSetStencilRef(ser, 0); break; case D3D12Chunk::List_OMSetBlendFactor: - m_ReplayList->Serialise_OMSetBlendFactor(ser, NULL); + ret = m_ReplayList->Serialise_OMSetBlendFactor(ser, NULL); break; case D3D12Chunk::List_SetGraphicsRootDescriptorTable: - m_ReplayList->Serialise_SetGraphicsRootDescriptorTable(ser, 0, D3D12_GPU_DESCRIPTOR_HANDLE()); + ret = m_ReplayList->Serialise_SetGraphicsRootDescriptorTable(ser, 0, + D3D12_GPU_DESCRIPTOR_HANDLE()); break; case D3D12Chunk::List_SetGraphicsRootSignature: - m_ReplayList->Serialise_SetGraphicsRootSignature(ser, NULL); + ret = m_ReplayList->Serialise_SetGraphicsRootSignature(ser, NULL); break; case D3D12Chunk::List_SetGraphicsRoot32BitConstant: - m_ReplayList->Serialise_SetGraphicsRoot32BitConstant(ser, 0, 0, 0); + ret = m_ReplayList->Serialise_SetGraphicsRoot32BitConstant(ser, 0, 0, 0); break; case D3D12Chunk::List_SetGraphicsRoot32BitConstants: - m_ReplayList->Serialise_SetGraphicsRoot32BitConstants(ser, 0, 0, NULL, 0); + ret = m_ReplayList->Serialise_SetGraphicsRoot32BitConstants(ser, 0, 0, NULL, 0); break; case D3D12Chunk::List_SetGraphicsRootConstantBufferView: - m_ReplayList->Serialise_SetGraphicsRootConstantBufferView(ser, 0, D3D12_GPU_VIRTUAL_ADDRESS()); + ret = m_ReplayList->Serialise_SetGraphicsRootConstantBufferView(ser, 0, + D3D12_GPU_VIRTUAL_ADDRESS()); break; case D3D12Chunk::List_SetGraphicsRootShaderResourceView: - m_ReplayList->Serialise_SetGraphicsRootShaderResourceView(ser, 0, D3D12_GPU_VIRTUAL_ADDRESS()); + ret = m_ReplayList->Serialise_SetGraphicsRootShaderResourceView(ser, 0, + D3D12_GPU_VIRTUAL_ADDRESS()); break; case D3D12Chunk::List_SetGraphicsRootUnorderedAccessView: - m_ReplayList->Serialise_SetGraphicsRootUnorderedAccessView(ser, 0, D3D12_GPU_VIRTUAL_ADDRESS()); + ret = m_ReplayList->Serialise_SetGraphicsRootUnorderedAccessView(ser, 0, + D3D12_GPU_VIRTUAL_ADDRESS()); break; case D3D12Chunk::List_SetComputeRootDescriptorTable: - m_ReplayList->Serialise_SetComputeRootDescriptorTable(ser, 0, D3D12_GPU_DESCRIPTOR_HANDLE()); + ret = m_ReplayList->Serialise_SetComputeRootDescriptorTable(ser, 0, + D3D12_GPU_DESCRIPTOR_HANDLE()); break; case D3D12Chunk::List_SetComputeRootSignature: - m_ReplayList->Serialise_SetComputeRootSignature(ser, NULL); + ret = m_ReplayList->Serialise_SetComputeRootSignature(ser, NULL); break; case D3D12Chunk::List_SetComputeRoot32BitConstant: - m_ReplayList->Serialise_SetComputeRoot32BitConstant(ser, 0, 0, 0); + ret = m_ReplayList->Serialise_SetComputeRoot32BitConstant(ser, 0, 0, 0); break; case D3D12Chunk::List_SetComputeRoot32BitConstants: - m_ReplayList->Serialise_SetComputeRoot32BitConstants(ser, 0, 0, NULL, 0); + ret = m_ReplayList->Serialise_SetComputeRoot32BitConstants(ser, 0, 0, NULL, 0); break; case D3D12Chunk::List_SetComputeRootConstantBufferView: - m_ReplayList->Serialise_SetComputeRootConstantBufferView(ser, 0, D3D12_GPU_VIRTUAL_ADDRESS()); + ret = m_ReplayList->Serialise_SetComputeRootConstantBufferView(ser, 0, + D3D12_GPU_VIRTUAL_ADDRESS()); break; case D3D12Chunk::List_SetComputeRootShaderResourceView: - m_ReplayList->Serialise_SetComputeRootShaderResourceView(ser, 0, D3D12_GPU_VIRTUAL_ADDRESS()); + ret = m_ReplayList->Serialise_SetComputeRootShaderResourceView(ser, 0, + D3D12_GPU_VIRTUAL_ADDRESS()); break; case D3D12Chunk::List_SetComputeRootUnorderedAccessView: - m_ReplayList->Serialise_SetComputeRootUnorderedAccessView(ser, 0, D3D12_GPU_VIRTUAL_ADDRESS()); + ret = m_ReplayList->Serialise_SetComputeRootUnorderedAccessView(ser, 0, + D3D12_GPU_VIRTUAL_ADDRESS()); break; case D3D12Chunk::List_CopyTiles: - m_ReplayList->Serialise_CopyTiles(ser, NULL, NULL, NULL, NULL, 0, D3D12_TILE_COPY_FLAGS(0)); + ret = m_ReplayList->Serialise_CopyTiles(ser, NULL, NULL, NULL, NULL, 0, + D3D12_TILE_COPY_FLAGS(0)); break; - case D3D12Chunk::PushMarker: m_ReplayList->Serialise_BeginEvent(ser, 0, NULL, 0); break; - case D3D12Chunk::PopMarker: m_ReplayList->Serialise_EndEvent(ser); break; - case D3D12Chunk::SetMarker: m_ReplayList->Serialise_SetMarker(ser, 0, NULL, 0); break; + case D3D12Chunk::PushMarker: ret = m_ReplayList->Serialise_BeginEvent(ser, 0, NULL, 0); break; + case D3D12Chunk::PopMarker: ret = m_ReplayList->Serialise_EndEvent(ser); break; + case D3D12Chunk::SetMarker: ret = m_ReplayList->Serialise_SetMarker(ser, 0, NULL, 0); break; case D3D12Chunk::Resource_Unmap: - m_pDevice->Serialise_MapDataWrite(ser, NULL, 0, NULL, D3D12_RANGE()); + ret = m_pDevice->Serialise_MapDataWrite(ser, NULL, 0, NULL, D3D12_RANGE()); break; case D3D12Chunk::Resource_WriteToSubresource: - m_pDevice->Serialise_WriteToSubresource(ser, NULL, 0, NULL, NULL, 0, 0); + ret = m_pDevice->Serialise_WriteToSubresource(ser, NULL, 0, NULL, NULL, 0, 0); break; case D3D12Chunk::CaptureEnd: { SERIALISE_ELEMENT_LOCAL(PresentedImage, ResourceId()); + SERIALISE_CHECK_READ_ERRORS(); + m_BackbufferID = PresentedImage; if(IsLoading(m_State)) @@ -464,7 +484,8 @@ void WrappedID3D12CommandQueue::ProcessChunk(ReadSerialiser &ser, D3D12Chunk chu m_Cmd.AddDrawcall(draw, true); } - break; + + ret = true; } default: RDCERR("Unrecognised Chunk type %s", ToStr(chunk).c_str()); break; } @@ -487,17 +508,19 @@ void WrappedID3D12CommandQueue::ProcessChunk(ReadSerialiser &ser, D3D12Chunk chu } m_Cmd.m_AddedDrawcall = false; + + return ret; } -void WrappedID3D12CommandQueue::ReplayLog(CaptureState readType, uint32_t startEventID, - uint32_t endEventID, bool partial) +ReplayStatus WrappedID3D12CommandQueue::ReplayLog(CaptureState readType, uint32_t startEventID, + uint32_t endEventID, bool partial) { m_State = readType; if(!m_FrameReader) { RDCERR("Can't replay context capture without frame reader"); - return; + return ReplayStatus::InternalError; } m_FrameReader->SetOffset(0); @@ -587,14 +610,25 @@ void WrappedID3D12CommandQueue::ReplayLog(CaptureState readType, uint32_t startE D3D12Chunk context = ser.ReadChunk(); + if(ser.GetReader()->IsErrored()) + return ReplayStatus::APIDataCorrupted; + m_Cmd.m_ChunkMetadata = ser.ChunkMetadata(); m_Cmd.m_LastCmdListID = ResourceId(); - ProcessChunk(ser, context); + bool success = ProcessChunk(ser, context); ser.EndChunk(); + if(ser.GetReader()->IsErrored()) + return ReplayStatus::APIDataCorrupted; + + // if there wasn't a serialisation error, but the chunk didn't succeed, then it's an API replay + // failure. + if(!success) + return m_FailedReplayStatus; + RenderDoc::Inst().SetProgress(FileInitialRead, float(m_Cmd.m_CurChunkOffset - startOffset) / float(ser.GetReader()->GetSize())); @@ -648,6 +682,8 @@ void WrappedID3D12CommandQueue::ReplayLog(CaptureState readType, uint32_t startE SAFE_RELEASE(it->second); m_Cmd.m_RerecordCmds.clear(); + + return ReplayStatus::Succeeded; } WrappedID3D12GraphicsCommandList::WrappedID3D12GraphicsCommandList(ID3D12GraphicsCommandList *real, diff --git a/renderdoc/driver/d3d12/d3d12_device.cpp b/renderdoc/driver/d3d12/d3d12_device.cpp index 0796b62fc..6d29ae25b 100644 --- a/renderdoc/driver/d3d12/d3d12_device.cpp +++ b/renderdoc/driver/d3d12/d3d12_device.cpp @@ -661,6 +661,8 @@ bool WrappedID3D12Device::Serialise_WrapSwapchainBuffer(SerialiserType &ser, SERIALISE_ELEMENT_LOCAL(SwapbufferID, GetResID(pRes)); SERIALISE_ELEMENT_LOCAL(BackbufferDescriptor, pRes->GetDesc()); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { ID3D12Resource *fakeBB = NULL; @@ -865,6 +867,8 @@ bool WrappedID3D12Device::Serialise_MapDataWrite(SerialiserType &ser, ID3D12Reso SERIALISE_ELEMENT_ARRAY(MappedData, rangeSize); + SERIALISE_CHECK_READ_ERRORS(); + // don't do anything if end <= begin because the range is empty. if(IsReplayingAndReading() && Resource && range.End > range.Begin) { @@ -988,6 +992,8 @@ bool WrappedID3D12Device::Serialise_WriteToSubresource(SerialiserType &ser, ID3D SERIALISE_ELEMENT_ARRAY(pSrcData, dataSize); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading() && Resource) { ResourceId origid = GetResourceManager()->GetOriginalID(GetResID(Resource)); @@ -1172,15 +1178,19 @@ HRESULT WrappedID3D12Device::Present(WrappedIDXGISwapChain4 *swap, UINT SyncInte } template -void WrappedID3D12Device::Serialise_CaptureScope(SerialiserType &ser) +bool WrappedID3D12Device::Serialise_CaptureScope(SerialiserType &ser) { SERIALISE_ELEMENT(m_FrameCounter); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayMode(m_State)) { m_FrameRecord.frameInfo.frameNumber = m_FrameCounter; RDCEraseEl(m_FrameRecord.frameInfo.stats); } + + return true; } template @@ -1193,6 +1203,8 @@ bool WrappedID3D12Device::Serialise_BeginCaptureFrame(SerialiserType &ser, bool GetResourceManager()->SerialiseResourceStates(ser, barriers, m_ResourceStates); } + SERIALISE_CHECK_READ_ERRORS(); + if(applyInitialState && !barriers.empty()) { // apply initial resource states @@ -1863,6 +1875,8 @@ bool WrappedID3D12Device::Serialise_SetShaderDebugPath(SerialiserType &ser, SERIALISE_ELEMENT(pResource); SERIALISE_ELEMENT(Path); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading() && pResource) { RDCERR("SetDebugInfoPath doesn't work as-is because it can't specify a shader specific path"); @@ -1909,6 +1923,8 @@ bool WrappedID3D12Device::Serialise_SetName(SerialiserType &ser, ID3D12DeviceChi SERIALISE_ELEMENT(pResource); SERIALISE_ELEMENT(Name); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading() && pResource) { ResourceId origId = GetResourceManager()->GetOriginalID(GetResID(pResource)); @@ -2247,61 +2263,65 @@ const DrawcallDescription *WrappedID3D12Device::GetDrawcall(uint32_t eventID) return m_Drawcalls[eventID]; } -void WrappedID3D12Device::ProcessChunk(ReadSerialiser &ser, D3D12Chunk context) +bool WrappedID3D12Device::ProcessChunk(ReadSerialiser &ser, D3D12Chunk context) { switch(context) { case D3D12Chunk::Device_CreateCommandQueue: - Serialise_CreateCommandQueue(ser, NULL, IID(), NULL); + return Serialise_CreateCommandQueue(ser, NULL, IID(), NULL); break; case D3D12Chunk::Device_CreateCommandAllocator: - Serialise_CreateCommandAllocator(ser, D3D12_COMMAND_LIST_TYPE_DIRECT, IID(), NULL); + return Serialise_CreateCommandAllocator(ser, D3D12_COMMAND_LIST_TYPE_DIRECT, IID(), NULL); break; case D3D12Chunk::Device_CreateCommandList: - Serialise_CreateCommandList(ser, 0, D3D12_COMMAND_LIST_TYPE_DIRECT, NULL, NULL, IID(), NULL); + return Serialise_CreateCommandList(ser, 0, D3D12_COMMAND_LIST_TYPE_DIRECT, NULL, NULL, IID(), + NULL); break; case D3D12Chunk::Device_CreateGraphicsPipeline: - Serialise_CreateGraphicsPipelineState(ser, NULL, IID(), NULL); + return Serialise_CreateGraphicsPipelineState(ser, NULL, IID(), NULL); break; case D3D12Chunk::Device_CreateComputePipeline: - Serialise_CreateComputePipelineState(ser, NULL, IID(), NULL); + return Serialise_CreateComputePipelineState(ser, NULL, IID(), NULL); break; case D3D12Chunk::Device_CreateDescriptorHeap: - Serialise_CreateDescriptorHeap(ser, NULL, IID(), NULL); + return Serialise_CreateDescriptorHeap(ser, NULL, IID(), NULL); break; case D3D12Chunk::Device_CreateRootSignature: - Serialise_CreateRootSignature(ser, 0, NULL, 0, IID(), NULL); + return Serialise_CreateRootSignature(ser, 0, NULL, 0, IID(), NULL); break; case D3D12Chunk::Device_CreateCommandSignature: - Serialise_CreateCommandSignature(ser, NULL, NULL, IID(), NULL); + return Serialise_CreateCommandSignature(ser, NULL, NULL, IID(), NULL); break; - case D3D12Chunk::Device_CreateHeap: Serialise_CreateHeap(ser, NULL, IID(), NULL); break; + case D3D12Chunk::Device_CreateHeap: return Serialise_CreateHeap(ser, NULL, IID(), NULL); break; case D3D12Chunk::Device_CreateCommittedResource: - Serialise_CreateCommittedResource(ser, NULL, D3D12_HEAP_FLAG_NONE, NULL, - D3D12_RESOURCE_STATE_COMMON, NULL, IID(), NULL); + return Serialise_CreateCommittedResource(ser, NULL, D3D12_HEAP_FLAG_NONE, NULL, + D3D12_RESOURCE_STATE_COMMON, NULL, IID(), NULL); break; case D3D12Chunk::Device_CreatePlacedResource: - Serialise_CreatePlacedResource(ser, NULL, 0, NULL, D3D12_RESOURCE_STATE_COMMON, NULL, IID(), - NULL); + return Serialise_CreatePlacedResource(ser, NULL, 0, NULL, D3D12_RESOURCE_STATE_COMMON, NULL, + IID(), NULL); break; case D3D12Chunk::Device_CreateReservedResource: - Serialise_CreateReservedResource(ser, NULL, D3D12_RESOURCE_STATE_COMMON, NULL, IID(), NULL); + return Serialise_CreateReservedResource(ser, NULL, D3D12_RESOURCE_STATE_COMMON, NULL, IID(), + NULL); break; case D3D12Chunk::Device_CreateQueryHeap: - Serialise_CreateQueryHeap(ser, NULL, IID(), NULL); + return Serialise_CreateQueryHeap(ser, NULL, IID(), NULL); break; case D3D12Chunk::Device_CreateFence: - Serialise_CreateFence(ser, 0, D3D12_FENCE_FLAG_NONE, IID(), NULL); + return Serialise_CreateFence(ser, 0, D3D12_FENCE_FLAG_NONE, IID(), NULL); + break; + case D3D12Chunk::SetName: return Serialise_SetName(ser, 0x0, ""); break; + case D3D12Chunk::SetShaderDebugPath: + return Serialise_SetShaderDebugPath(ser, NULL, NULL); break; - case D3D12Chunk::SetName: Serialise_SetName(ser, 0x0, ""); break; - case D3D12Chunk::SetShaderDebugPath: Serialise_SetShaderDebugPath(ser, NULL, NULL); break; case D3D12Chunk::CreateSwapBuffer: - Serialise_WrapSwapchainBuffer(ser, NULL, NULL, 0, NULL); + return Serialise_WrapSwapchainBuffer(ser, NULL, NULL, 0, NULL); break; - case D3D12Chunk::CaptureScope: Serialise_CaptureScope(ser); break; + case D3D12Chunk::CaptureScope: return Serialise_CaptureScope(ser); break; default: { SystemChunk system = (SystemChunk)context; @@ -2309,27 +2329,36 @@ void WrappedID3D12Device::ProcessChunk(ReadSerialiser &ser, D3D12Chunk context) { D3D12InitParams InitParams; SERIALISE_ELEMENT(InitParams); + + SERIALISE_CHECK_READ_ERRORS(); } else if(system == SystemChunk::InitialContentsList) { GetResourceManager()->CreateInitialContents(ser); + + SERIALISE_CHECK_READ_ERRORS(); } else if(system == SystemChunk::InitialContents) { - GetResourceManager()->Serialise_InitialState(ser, ResourceId(), NULL); + return GetResourceManager()->Serialise_InitialState(ser, ResourceId(), NULL); } else if(system < SystemChunk::FirstDriverChunk) { RDCERR("Unexpected system chunk in capture data: %u", system); ser.SkipCurrentChunk(); + + SERIALISE_CHECK_READ_ERRORS(); } else { RDCERR("Unexpected chunk %s", ToStr(context).c_str()); + return false; } break; } } + + return true; } void WrappedID3D12Device::AddResource(ResourceId id, ResourceType type, const char *defaultNamePrefix) @@ -2419,13 +2448,18 @@ ReplayStatus WrappedID3D12Device::ReadLogInitialisation(RDCFile *rdc, bool store if(reader->IsErrored()) return ReplayStatus::APIDataCorrupted; - ProcessChunk(ser, context); + bool success = ProcessChunk(ser, context); ser.EndChunk(); if(reader->IsErrored()) return ReplayStatus::APIDataCorrupted; + // if there wasn't a serialisation error, but the chunk didn't succeed, then it's an API replay + // failure. + if(!success) + return m_FailedReplayStatus; + uint64_t offsetEnd = reader->GetOffset(); RenderDoc::Inst().SetProgress(FileInitialRead, float(offsetEnd) / float(reader->GetSize())); @@ -2442,7 +2476,10 @@ ReplayStatus WrappedID3D12Device::ReadLogInitialisation(RDCFile *rdc, bool store if(!IsStructuredExporting(m_State)) ApplyInitialContents(); - m_Queue->ReplayLog(m_State, 0, 0, false); + ReplayStatus status = m_Queue->ReplayLog(m_State, 0, 0, false); + + if(status != ReplayStatus::Succeeded) + return status; } chunkInfos[context].total += timer.GetMilliseconds(); @@ -2570,15 +2607,19 @@ void WrappedID3D12Device::ReplayLog(uint32_t startEventID, uint32_t endEventID, cmd.m_RenderState.ApplyState(list); } + ReplayStatus status = ReplayStatus::Succeeded; + if(replayType == eReplay_Full) - m_Queue->ReplayLog(m_State, startEventID, endEventID, partial); + status = m_Queue->ReplayLog(m_State, startEventID, endEventID, partial); else if(replayType == eReplay_WithoutDraw) - m_Queue->ReplayLog(m_State, startEventID, RDCMAX(1U, endEventID) - 1, partial); + status = m_Queue->ReplayLog(m_State, startEventID, RDCMAX(1U, endEventID) - 1, partial); else if(replayType == eReplay_OnlyDraw) - m_Queue->ReplayLog(m_State, endEventID, endEventID, partial); + status = m_Queue->ReplayLog(m_State, endEventID, endEventID, partial); else RDCFATAL("Unexpected replay type"); + RDCASSERTEQUAL(status, ReplayStatus::Succeeded); + if(cmd.m_Partial[D3D12CommandData::Primary].outsideCmdList != NULL) { ID3D12GraphicsCommandList *list = cmd.m_Partial[D3D12CommandData::Primary].outsideCmdList; diff --git a/renderdoc/driver/d3d12/d3d12_device.h b/renderdoc/driver/d3d12/d3d12_device.h index 0e422a328..8e1e82ae0 100644 --- a/renderdoc/driver/d3d12/d3d12_device.h +++ b/renderdoc/driver/d3d12/d3d12_device.h @@ -260,7 +260,7 @@ private: Threading::CriticalSection m_MapsLock; vector m_Maps; - void ProcessChunk(ReadSerialiser &ser, D3D12Chunk context); + bool ProcessChunk(ReadSerialiser &ser, D3D12Chunk context); unsigned int m_InternalRefcount; RefCounter12 m_RefCounter; @@ -292,6 +292,8 @@ private: FrameRecord m_FrameRecord; vector m_Drawcalls; + ReplayStatus m_FailedReplayStatus = ReplayStatus::APIReplayFailed; + bool m_AppControlledCapture; Threading::CriticalSection m_CapTransitionLock; @@ -346,7 +348,7 @@ private: UINT m_DescriptorIncrements[D3D12_DESCRIPTOR_HEAP_TYPE_NUM_TYPES]; template - void Serialise_CaptureScope(SerialiserType &ser); + bool Serialise_CaptureScope(SerialiserType &ser); void EndCaptureFrame(ID3D12Resource *presentImage); public: diff --git a/renderdoc/driver/d3d12/d3d12_device_wrap.cpp b/renderdoc/driver/d3d12/d3d12_device_wrap.cpp index 5d9dfc178..627d70dc1 100644 --- a/renderdoc/driver/d3d12/d3d12_device_wrap.cpp +++ b/renderdoc/driver/d3d12/d3d12_device_wrap.cpp @@ -43,6 +43,8 @@ bool WrappedID3D12Device::Serialise_CreateCommandQueue(SerialiserType &ser, SERIALISE_ELEMENT_LOCAL(pCommandQueue, ((WrappedID3D12CommandQueue *)*ppCommandQueue)->GetResourceID()); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { ID3D12CommandQueue *ret = NULL; @@ -139,6 +141,8 @@ bool WrappedID3D12Device::Serialise_CreateCommandAllocator(SerialiserType &ser, SERIALISE_ELEMENT_LOCAL(pCommandAllocator, ((WrappedID3D12CommandAllocator *)*ppCommandAllocator)->GetResourceID()); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { ID3D12CommandAllocator *ret = NULL; @@ -220,6 +224,8 @@ bool WrappedID3D12Device::Serialise_CreateCommandList(SerialiserType &ser, UINT // this chunk is purely for user information and consistency, the command buffer we allocate is // a dummy and is not used for anything. + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { ID3D12GraphicsCommandList *list = NULL; @@ -318,6 +324,8 @@ bool WrappedID3D12Device::Serialise_CreateGraphicsPipelineState( SERIALISE_ELEMENT_LOCAL(pPipelineState, ((WrappedID3D12PipelineState *)*ppPipelineState)->GetResourceID()); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { D3D12_GRAPHICS_PIPELINE_STATE_DESC unwrappedDesc = Descriptor; @@ -520,6 +528,8 @@ bool WrappedID3D12Device::Serialise_CreateComputePipelineState( SERIALISE_ELEMENT_LOCAL(pPipelineState, ((WrappedID3D12PipelineState *)*ppPipelineState)->GetResourceID()); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { D3D12_COMPUTE_PIPELINE_STATE_DESC unwrappedDesc = Descriptor; @@ -617,6 +627,8 @@ bool WrappedID3D12Device::Serialise_CreateDescriptorHeap( SERIALISE_ELEMENT_LOCAL(guid, riid).Named("riid"); SERIALISE_ELEMENT_LOCAL(pHeap, ((WrappedID3D12DescriptorHeap *)*ppvHeap)->GetResourceID()); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { // inflate the heap so we can insert our own descriptors at the end @@ -715,6 +727,8 @@ bool WrappedID3D12Device::Serialise_CreateRootSignature(SerialiserType &ser, UIN SERIALISE_ELEMENT_LOCAL(pRootSignature, ((WrappedID3D12RootSignature *)*ppvRootSignature)->GetResourceID()); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { ID3D12RootSignature *ret = NULL; @@ -818,6 +832,8 @@ bool WrappedID3D12Device::Serialise_DynamicDescriptorWrite(SerialiserType &ser, SERIALISE_ELEMENT_LOCAL(desc, write->desc); SERIALISE_ELEMENT_LOCAL(dst, ToPortableHandle(write->dest)); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { D3D12Descriptor *handle = DescriptorFromPortableHandle(GetResourceManager(), dst); @@ -1120,6 +1136,8 @@ bool WrappedID3D12Device::Serialise_CreateCommittedResource( ((WrappedID3D12Resource *)*ppvResource)->GetGPUVirtualAddressIfBuffer()) .Hidden(); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(props.Type == D3D12_HEAP_TYPE_UPLOAD && desc.Dimension == D3D12_RESOURCE_DIMENSION_BUFFER) @@ -1284,6 +1302,8 @@ bool WrappedID3D12Device::Serialise_CreateHeap(SerialiserType &ser, const D3D12_ SERIALISE_ELEMENT_LOCAL(guid, riid).Named("riid"); SERIALISE_ELEMENT_LOCAL(pHeap, ((WrappedID3D12Heap *)*ppvHeap)->GetResourceID()); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { ID3D12Heap *ret = NULL; @@ -1363,6 +1383,8 @@ bool WrappedID3D12Device::Serialise_CreatePlacedResource( SERIALISE_ELEMENT_LOCAL(gpuAddress, ((WrappedID3D12Resource *)*ppvResource)->GetGPUVirtualAddress()) .Hidden(); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(Descriptor.Dimension == D3D12_RESOURCE_DIMENSION_BUFFER) @@ -1535,6 +1557,8 @@ bool WrappedID3D12Device::Serialise_CreateFence(SerialiserType &ser, UINT64 Init SERIALISE_ELEMENT_LOCAL(guid, riid).Named("riid"); SERIALISE_ELEMENT_LOCAL(pFence, ((WrappedID3D12Fence *)*ppFence)->GetResourceID()); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { ID3D12Fence *ret = NULL; @@ -1607,6 +1631,8 @@ bool WrappedID3D12Device::Serialise_CreateQueryHeap(SerialiserType &ser, SERIALISE_ELEMENT_LOCAL(guid, riid).Named("riid"); SERIALISE_ELEMENT_LOCAL(pQueryHeap, ((WrappedID3D12QueryHeap *)*ppvHeap)->GetResourceID()); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { ID3D12QueryHeap *ret = NULL; @@ -1682,6 +1708,8 @@ bool WrappedID3D12Device::Serialise_CreateCommandSignature(SerialiserType &ser, SERIALISE_ELEMENT_LOCAL(pCommandSignature, ((WrappedID3D12CommandSignature *)*ppvCommandSignature)->GetResourceID()); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { ID3D12CommandSignature *ret = NULL; @@ -1801,6 +1829,8 @@ bool WrappedID3D12Device::Serialise_DynamicDescriptorCopies( { SERIALISE_ELEMENT(DescriptorCopies); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { // not optimal, but simple for now. Do a wrapped copy so that internal tracking is also updated diff --git a/renderdoc/driver/d3d12/d3d12_initstate.cpp b/renderdoc/driver/d3d12/d3d12_initstate.cpp index e6606b283..53ebe0e3b 100644 --- a/renderdoc/driver/d3d12/d3d12_initstate.cpp +++ b/renderdoc/driver/d3d12/d3d12_initstate.cpp @@ -321,6 +321,8 @@ bool D3D12ResourceManager::Serialise_InitialState(SerialiserType &ser, ResourceI SERIALISE_ELEMENT_ARRAY(Descriptors, numElems); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { WrappedID3D12DescriptorHeap *heap = (WrappedID3D12DescriptorHeap *)liveRes; @@ -406,7 +408,8 @@ bool D3D12ResourceManager::Serialise_InitialState(SerialiserType &ser, ResourceI // serialise the size separately so we can recreate on replay SERIALISE_ELEMENT(ContentsLength); - if(IsReplayingAndReading()) + // only map on replay if we haven't encountered any errors so far + if(IsReplayingAndReading() && !ser.IsErrored()) { D3D12_RESOURCE_DESC resDesc = ((ID3D12Resource *)liveRes)->GetDesc(); @@ -479,6 +482,8 @@ bool D3D12ResourceManager::Serialise_InitialState(SerialiserType &ser, ResourceI SAFE_DELETE_ARRAY(dummy); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading() && mappedBuffer) SetInitialContents(id, D3D12ResourceManager::InitialContentData(type, mappedBuffer, 1, NULL)); diff --git a/renderdoc/driver/gl/gl_driver.cpp b/renderdoc/driver/gl/gl_driver.cpp index 28914a62d..c84e19f7c 100644 --- a/renderdoc/driver/gl/gl_driver.cpp +++ b/renderdoc/driver/gl/gl_driver.cpp @@ -2751,15 +2751,19 @@ WrappedOpenGL::BackbufferImage *WrappedOpenGL::SaveBackbufferImage() } template -void WrappedOpenGL::Serialise_CaptureScope(SerialiserType &ser) +bool WrappedOpenGL::Serialise_CaptureScope(SerialiserType &ser) { SERIALISE_ELEMENT(m_FrameCounter); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_FrameRecord.frameInfo.frameNumber = m_FrameCounter; RDCEraseEl(m_FrameRecord.frameInfo.stats); } + + return true; } void WrappedOpenGL::ContextEndFrame() @@ -2849,6 +2853,8 @@ bool WrappedOpenGL::Serialise_BeginCaptureFrame(SerialiserType &ser) SERIALISE_ELEMENT(state); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { state.ApplyState(this); @@ -3106,13 +3112,18 @@ ReplayStatus WrappedOpenGL::ReadLogInitialisation(RDCFile *rdc, bool storeStruct if(reader->IsErrored()) return ReplayStatus::APIDataCorrupted; - ProcessChunk(ser, context); + bool success = ProcessChunk(ser, context); ser.EndChunk(); if(reader->IsErrored()) return ReplayStatus::APIDataCorrupted; + // if there wasn't a serialisation error, but the chunk didn't succeed, then it's an API replay + // failure. + if(!success) + return m_FailedReplayStatus; + uint64_t offsetEnd = reader->GetOffset(); RenderDoc::Inst().SetProgress(FileInitialRead, float(offsetEnd) / float(reader->GetSize())); @@ -3128,7 +3139,10 @@ ReplayStatus WrappedOpenGL::ReadLogInitialisation(RDCFile *rdc, bool storeStruct GetResourceManager()->ApplyInitialContents(); - ContextReplayLog(m_State, 0, 0, false); + ReplayStatus status = ContextReplayLog(m_State, 0, 0, false); + + if(status != ReplayStatus::Succeeded) + return status; } chunkInfos[context].total += timer.GetMilliseconds(); @@ -3171,7 +3185,7 @@ ReplayStatus WrappedOpenGL::ReadLogInitialisation(RDCFile *rdc, bool storeStruct return ReplayStatus::Succeeded; } -void WrappedOpenGL::ProcessChunk(ReadSerialiser &ser, GLChunk chunk) +bool WrappedOpenGL::ProcessChunk(ReadSerialiser &ser, GLChunk chunk) { gl_CurChunk = chunk; @@ -3190,6 +3204,8 @@ void WrappedOpenGL::ProcessChunk(ReadSerialiser &ser, GLChunk chunk) GLInitParams InitParams; SERIALISE_ELEMENT(InitParams); + SERIALISE_CHECK_READ_ERRORS(); + ResourceId fboId = GetResourceManager()->GetID(FramebufferRes(GetCtx(), m_FakeBB_FBO)); ResourceId colorId = GetResourceManager()->GetID(TextureRes(GetCtx(), m_FakeBB_Color)); ResourceId depthId; @@ -3199,19 +3215,30 @@ void WrappedOpenGL::ProcessChunk(ReadSerialiser &ser, GLChunk chunk) AddResourceCurChunk(fboId); AddResourceCurChunk(colorId); AddResourceCurChunk(depthId); + + return true; } else if(system == SystemChunk::InitialContentsList) { GetResourceManager()->CreateInitialContents(ser); + + SERIALISE_CHECK_READ_ERRORS(); + + return true; } else if(system == SystemChunk::InitialContents) { - GetResourceManager()->Serialise_InitialState(ser, ResourceId(), GLResource(MakeNullResource)); + return GetResourceManager()->Serialise_InitialState(ser, ResourceId(), + GLResource(MakeNullResource)); } else if(system < SystemChunk::FirstDriverChunk) { RDCERR("Unexpected system chunk in capture data: %u", system); ser.SkipCurrentChunk(); + + SERIALISE_CHECK_READ_ERRORS(); + + return true; } } @@ -3221,159 +3248,136 @@ void WrappedOpenGL::ProcessChunk(ReadSerialiser &ser, GLChunk chunk) { SERIALISE_ELEMENT(m_FakeVAOID).Named("VAO 0 ID"); + SERIALISE_CHECK_READ_ERRORS(); + GetResourceManager()->AddLiveResource(m_FakeVAOID, VertexArrayRes(NULL, 0)); AddResource(m_FakeVAOID, ResourceType::StateObject, ""); GetReplay()->GetResourceDesc(m_FakeVAOID).SetCustomName("Special VAO 0"); - break; + return true; } case GLChunk::glGenBuffersARB: - case GLChunk::glGenBuffers: Serialise_glGenBuffers(ser, 0, 0); break; - case GLChunk::glCreateBuffers: Serialise_glCreateBuffers(ser, 0, 0); break; + case GLChunk::glGenBuffers: return Serialise_glGenBuffers(ser, 0, 0); + case GLChunk::glCreateBuffers: return Serialise_glCreateBuffers(ser, 0, 0); case GLChunk::glBufferStorage: case GLChunk::glNamedBufferStorage: case GLChunk::glNamedBufferStorageEXT: - Serialise_glNamedBufferStorageEXT(ser, 0, 0, 0, 0); - break; + return Serialise_glNamedBufferStorageEXT(ser, 0, 0, 0, 0); case GLChunk::glBufferData: case GLChunk::glBufferDataARB: case GLChunk::glNamedBufferData: case GLChunk::glNamedBufferDataEXT: - Serialise_glNamedBufferDataEXT(ser, 0, 0, 0, eGL_NONE); - break; + return Serialise_glNamedBufferDataEXT(ser, 0, 0, 0, eGL_NONE); case GLChunk::glBufferSubData: case GLChunk::glBufferSubDataARB: case GLChunk::glNamedBufferSubData: case GLChunk::glNamedBufferSubDataEXT: - Serialise_glNamedBufferSubDataEXT(ser, 0, 0, 0, 0); - break; + return Serialise_glNamedBufferSubDataEXT(ser, 0, 0, 0, 0); case GLChunk::glCopyBufferSubData: case GLChunk::glCopyNamedBufferSubData: case GLChunk::glNamedCopyBufferSubDataEXT: - Serialise_glNamedCopyBufferSubDataEXT(ser, 0, 0, 0, 0, 0); - break; + return Serialise_glNamedCopyBufferSubDataEXT(ser, 0, 0, 0, 0, 0); case GLChunk::glBindBufferARB: - case GLChunk::glBindBuffer: Serialise_glBindBuffer(ser, eGL_NONE, 0); break; + case GLChunk::glBindBuffer: return Serialise_glBindBuffer(ser, eGL_NONE, 0); case GLChunk::glBindBufferBaseEXT: - case GLChunk::glBindBufferBase: Serialise_glBindBufferBase(ser, eGL_NONE, 0, 0); break; + case GLChunk::glBindBufferBase: return Serialise_glBindBufferBase(ser, eGL_NONE, 0, 0); case GLChunk::glBindBufferRangeEXT: - case GLChunk::glBindBufferRange: Serialise_glBindBufferRange(ser, eGL_NONE, 0, 0, 0, 0); break; - case GLChunk::glBindBuffersBase: Serialise_glBindBuffersBase(ser, eGL_NONE, 0, 0, 0); break; + case GLChunk::glBindBufferRange: return Serialise_glBindBufferRange(ser, eGL_NONE, 0, 0, 0, 0); + case GLChunk::glBindBuffersBase: return Serialise_glBindBuffersBase(ser, eGL_NONE, 0, 0, 0); case GLChunk::glBindBuffersRange: - Serialise_glBindBuffersRange(ser, eGL_NONE, 0, 0, 0, 0, 0); - break; + return Serialise_glBindBuffersRange(ser, eGL_NONE, 0, 0, 0, 0, 0); case GLChunk::glUnmapBuffer: case GLChunk::glUnmapBufferARB: case GLChunk::glUnmapBufferOES: case GLChunk::glUnmapNamedBuffer: - case GLChunk::glUnmapNamedBufferEXT: Serialise_glUnmapNamedBufferEXT(ser, 0); break; + case GLChunk::glUnmapNamedBufferEXT: return Serialise_glUnmapNamedBufferEXT(ser, 0); case GLChunk::glFlushMappedBufferRange: case GLChunk::glFlushMappedNamedBufferRange: case GLChunk::glFlushMappedNamedBufferRangeEXT: - Serialise_glFlushMappedNamedBufferRangeEXT(ser, 0, 0, 0); - break; + return Serialise_glFlushMappedNamedBufferRangeEXT(ser, 0, 0, 0); - case GLChunk::glGenTransformFeedbacks: Serialise_glGenTransformFeedbacks(ser, 0, 0); break; + case GLChunk::glGenTransformFeedbacks: return Serialise_glGenTransformFeedbacks(ser, 0, 0); case GLChunk::glCreateTransformFeedbacks: - Serialise_glCreateTransformFeedbacks(ser, 0, 0); - break; + return Serialise_glCreateTransformFeedbacks(ser, 0, 0); case GLChunk::glTransformFeedbackBufferBase: - Serialise_glTransformFeedbackBufferBase(ser, 0, 0, 0); - break; + return Serialise_glTransformFeedbackBufferBase(ser, 0, 0, 0); case GLChunk::glTransformFeedbackBufferRange: - Serialise_glTransformFeedbackBufferRange(ser, 0, 0, 0, 0, 0); - break; + return Serialise_glTransformFeedbackBufferRange(ser, 0, 0, 0, 0, 0); case GLChunk::glBindTransformFeedback: - Serialise_glBindTransformFeedback(ser, eGL_NONE, 0); - break; + return Serialise_glBindTransformFeedback(ser, eGL_NONE, 0); case GLChunk::glBeginTransformFeedbackEXT: case GLChunk::glBeginTransformFeedback: - Serialise_glBeginTransformFeedback(ser, eGL_NONE); - break; - case GLChunk::glPauseTransformFeedback: Serialise_glPauseTransformFeedback(ser); break; - case GLChunk::glResumeTransformFeedback: Serialise_glResumeTransformFeedback(ser); break; + return Serialise_glBeginTransformFeedback(ser, eGL_NONE); + case GLChunk::glPauseTransformFeedback: return Serialise_glPauseTransformFeedback(ser); + case GLChunk::glResumeTransformFeedback: return Serialise_glResumeTransformFeedback(ser); case GLChunk::glEndTransformFeedbackEXT: - case GLChunk::glEndTransformFeedback: Serialise_glEndTransformFeedback(ser); break; + case GLChunk::glEndTransformFeedback: return Serialise_glEndTransformFeedback(ser); case GLChunk::glVertexAttribPointer: case GLChunk::glVertexAttribPointerARB: case GLChunk::glVertexArrayVertexAttribOffsetEXT: - Serialise_glVertexArrayVertexAttribOffsetEXT(ser, 0, 0, 0, 0, eGL_NONE, 0, 0, 0); - break; + return Serialise_glVertexArrayVertexAttribOffsetEXT(ser, 0, 0, 0, 0, eGL_NONE, 0, 0, 0); case GLChunk::glVertexAttribIPointer: case GLChunk::glVertexAttribIPointerEXT: case GLChunk::glVertexArrayVertexAttribIOffsetEXT: - Serialise_glVertexArrayVertexAttribIOffsetEXT(ser, 0, 0, 0, 0, eGL_NONE, 0, 0); - break; + return Serialise_glVertexArrayVertexAttribIOffsetEXT(ser, 0, 0, 0, 0, eGL_NONE, 0, 0); case GLChunk::glVertexAttribLPointer: case GLChunk::glVertexAttribLPointerEXT: case GLChunk::glVertexArrayVertexAttribLOffsetEXT: - Serialise_glVertexArrayVertexAttribLOffsetEXT(ser, 0, 0, 0, 0, eGL_NONE, 0, 0); - break; + return Serialise_glVertexArrayVertexAttribLOffsetEXT(ser, 0, 0, 0, 0, eGL_NONE, 0, 0); case GLChunk::glVertexAttribBinding: case GLChunk::glVertexArrayAttribBinding: case GLChunk::glVertexArrayVertexAttribBindingEXT: - Serialise_glVertexArrayVertexAttribBindingEXT(ser, 0, 0, 0); - break; + return Serialise_glVertexArrayVertexAttribBindingEXT(ser, 0, 0, 0); case GLChunk::glVertexAttribFormat: case GLChunk::glVertexArrayAttribFormat: case GLChunk::glVertexArrayVertexAttribFormatEXT: - Serialise_glVertexArrayVertexAttribFormatEXT(ser, 0, 0, 0, eGL_NONE, 0, 0); - break; + return Serialise_glVertexArrayVertexAttribFormatEXT(ser, 0, 0, 0, eGL_NONE, 0, 0); case GLChunk::glVertexAttribIFormat: case GLChunk::glVertexArrayAttribIFormat: case GLChunk::glVertexArrayVertexAttribIFormatEXT: - Serialise_glVertexArrayVertexAttribIFormatEXT(ser, 0, 0, 0, eGL_NONE, 0); - break; + return Serialise_glVertexArrayVertexAttribIFormatEXT(ser, 0, 0, 0, eGL_NONE, 0); case GLChunk::glVertexAttribLFormat: case GLChunk::glVertexArrayAttribLFormat: case GLChunk::glVertexArrayVertexAttribLFormatEXT: - Serialise_glVertexArrayVertexAttribLFormatEXT(ser, 0, 0, 0, eGL_NONE, 0); - break; + return Serialise_glVertexArrayVertexAttribLFormatEXT(ser, 0, 0, 0, eGL_NONE, 0); case GLChunk::glVertexAttribDivisor: case GLChunk::glVertexAttribDivisorARB: case GLChunk::glVertexArrayVertexAttribDivisorEXT: - Serialise_glVertexArrayVertexAttribDivisorEXT(ser, 0, 0, 0); - break; + return Serialise_glVertexArrayVertexAttribDivisorEXT(ser, 0, 0, 0); case GLChunk::glEnableVertexAttribArray: case GLChunk::glEnableVertexAttribArrayARB: case GLChunk::glEnableVertexArrayAttrib: case GLChunk::glEnableVertexArrayAttribEXT: - Serialise_glEnableVertexArrayAttribEXT(ser, 0, 0); - break; + return Serialise_glEnableVertexArrayAttribEXT(ser, 0, 0); case GLChunk::glDisableVertexAttribArray: case GLChunk::glDisableVertexAttribArrayARB: case GLChunk::glDisableVertexArrayAttrib: case GLChunk::glDisableVertexArrayAttribEXT: - Serialise_glDisableVertexArrayAttribEXT(ser, 0, 0); - break; + return Serialise_glDisableVertexArrayAttribEXT(ser, 0, 0); case GLChunk::glGenVertexArraysOES: - case GLChunk::glGenVertexArrays: Serialise_glGenVertexArrays(ser, 0, 0); break; - case GLChunk::glCreateVertexArrays: Serialise_glCreateVertexArrays(ser, 0, 0); break; + case GLChunk::glGenVertexArrays: return Serialise_glGenVertexArrays(ser, 0, 0); + case GLChunk::glCreateVertexArrays: return Serialise_glCreateVertexArrays(ser, 0, 0); case GLChunk::glBindVertexArrayOES: - case GLChunk::glBindVertexArray: Serialise_glBindVertexArray(ser, 0); break; + case GLChunk::glBindVertexArray: return Serialise_glBindVertexArray(ser, 0); case GLChunk::glVertexArrayElementBuffer: - Serialise_glVertexArrayElementBuffer(ser, 0, 0); - break; + return Serialise_glVertexArrayElementBuffer(ser, 0, 0); case GLChunk::glBindVertexBuffer: case GLChunk::glVertexArrayVertexBuffer: case GLChunk::glVertexArrayBindVertexBufferEXT: - Serialise_glVertexArrayBindVertexBufferEXT(ser, 0, 0, 0, 0, 0); - break; + return Serialise_glVertexArrayBindVertexBufferEXT(ser, 0, 0, 0, 0, 0); case GLChunk::glBindVertexBuffers: case GLChunk::glVertexArrayVertexBuffers: - Serialise_glVertexArrayVertexBuffers(ser, 0, 0, 0, 0, 0, 0); - break; + return Serialise_glVertexArrayVertexBuffers(ser, 0, 0, 0, 0, 0, 0); case GLChunk::glVertexBindingDivisor: case GLChunk::glVertexArrayBindingDivisor: case GLChunk::glVertexArrayVertexBindingDivisorEXT: - Serialise_glVertexArrayVertexBindingDivisorEXT(ser, 0, 0, 0); - break; + return Serialise_glVertexArrayVertexBindingDivisorEXT(ser, 0, 0, 0); case GLChunk::glVertexAttrib1d: case GLChunk::glVertexAttrib1dARB: @@ -3510,447 +3514,386 @@ void WrappedOpenGL::ProcessChunk(ReadSerialiser &ser, GLChunk chunk) case GLChunk::glVertexAttribP3uiv: case GLChunk::glVertexAttribP4ui: case GLChunk::glVertexAttribP4uiv: - Serialise_glVertexAttrib(ser, 0, 0, eGL_NONE, 0, 0, Attrib_typemask); - break; + return Serialise_glVertexAttrib(ser, 0, 0, eGL_NONE, 0, 0, Attrib_typemask); case GLChunk::glLabelObjectEXT: case GLChunk::glObjectLabelKHR: case GLChunk::glObjectPtrLabel: case GLChunk::glObjectPtrLabelKHR: - case GLChunk::glObjectLabel: Serialise_glObjectLabel(ser, eGL_NONE, 0, 0, 0); break; + case GLChunk::glObjectLabel: return Serialise_glObjectLabel(ser, eGL_NONE, 0, 0, 0); case GLChunk::glDebugMessageInsertARB: case GLChunk::glDebugMessageInsertKHR: case GLChunk::glDebugMessageInsert: - Serialise_glDebugMessageInsert(ser, eGL_NONE, eGL_NONE, 0, eGL_NONE, 0, 0); - break; + return Serialise_glDebugMessageInsert(ser, eGL_NONE, eGL_NONE, 0, eGL_NONE, 0, 0); case GLChunk::glStringMarkerGREMEDY: - case GLChunk::glInsertEventMarkerEXT: Serialise_glInsertEventMarkerEXT(ser, 0, 0); break; + case GLChunk::glInsertEventMarkerEXT: return Serialise_glInsertEventMarkerEXT(ser, 0, 0); case GLChunk::glPushGroupMarkerEXT: case GLChunk::glPushDebugGroupKHR: - case GLChunk::glPushDebugGroup: Serialise_glPushDebugGroup(ser, eGL_NONE, 0, 0, 0); break; + case GLChunk::glPushDebugGroup: return Serialise_glPushDebugGroup(ser, eGL_NONE, 0, 0, 0); case GLChunk::glPopGroupMarkerEXT: case GLChunk::glPopDebugGroupKHR: - case GLChunk::glPopDebugGroup: Serialise_glPopDebugGroup(ser); break; + case GLChunk::glPopDebugGroup: return Serialise_glPopDebugGroup(ser); - case GLChunk::glDispatchCompute: Serialise_glDispatchCompute(ser, 0, 0, 0); break; + case GLChunk::glDispatchCompute: return Serialise_glDispatchCompute(ser, 0, 0, 0); case GLChunk::glDispatchComputeGroupSizeARB: - Serialise_glDispatchComputeGroupSizeARB(ser, 0, 0, 0, 0, 0, 0); - break; - case GLChunk::glDispatchComputeIndirect: Serialise_glDispatchComputeIndirect(ser, 0); break; + return Serialise_glDispatchComputeGroupSizeARB(ser, 0, 0, 0, 0, 0, 0); + case GLChunk::glDispatchComputeIndirect: return Serialise_glDispatchComputeIndirect(ser, 0); case GLChunk::glMemoryBarrierEXT: - case GLChunk::glMemoryBarrier: Serialise_glMemoryBarrier(ser, 0); break; - case GLChunk::glMemoryBarrierByRegion: Serialise_glMemoryBarrierByRegion(ser, 0); break; - case GLChunk::glTextureBarrier: Serialise_glTextureBarrier(ser); break; + case GLChunk::glMemoryBarrier: return Serialise_glMemoryBarrier(ser, 0); + case GLChunk::glMemoryBarrierByRegion: return Serialise_glMemoryBarrierByRegion(ser, 0); + case GLChunk::glTextureBarrier: return Serialise_glTextureBarrier(ser); case GLChunk::glDrawTransformFeedback: - Serialise_glDrawTransformFeedback(ser, eGL_NONE, 0); - break; + return Serialise_glDrawTransformFeedback(ser, eGL_NONE, 0); case GLChunk::glDrawTransformFeedbackInstanced: - Serialise_glDrawTransformFeedbackInstanced(ser, eGL_NONE, 0, 0); - break; + return Serialise_glDrawTransformFeedbackInstanced(ser, eGL_NONE, 0, 0); case GLChunk::glDrawTransformFeedbackStream: - Serialise_glDrawTransformFeedbackStream(ser, eGL_NONE, 0, 0); - break; + return Serialise_glDrawTransformFeedbackStream(ser, eGL_NONE, 0, 0); case GLChunk::glDrawTransformFeedbackStreamInstanced: - Serialise_glDrawTransformFeedbackStreamInstanced(ser, eGL_NONE, 0, 0, 0); - break; - case GLChunk::glDrawArrays: Serialise_glDrawArrays(ser, eGL_NONE, 0, 0); break; - case GLChunk::glDrawArraysIndirect: Serialise_glDrawArraysIndirect(ser, eGL_NONE, 0); break; + return Serialise_glDrawTransformFeedbackStreamInstanced(ser, eGL_NONE, 0, 0, 0); + case GLChunk::glDrawArrays: return Serialise_glDrawArrays(ser, eGL_NONE, 0, 0); + case GLChunk::glDrawArraysIndirect: return Serialise_glDrawArraysIndirect(ser, eGL_NONE, 0); case GLChunk::glDrawArraysInstancedARB: case GLChunk::glDrawArraysInstancedEXT: case GLChunk::glDrawArraysInstanced: - Serialise_glDrawArraysInstanced(ser, eGL_NONE, 0, 0, 0); - break; + return Serialise_glDrawArraysInstanced(ser, eGL_NONE, 0, 0, 0); case GLChunk::glDrawArraysInstancedBaseInstanceEXT: case GLChunk::glDrawArraysInstancedBaseInstance: - Serialise_glDrawArraysInstancedBaseInstance(ser, eGL_NONE, 0, 0, 0, 0); - break; - case GLChunk::glDrawElements: Serialise_glDrawElements(ser, eGL_NONE, 0, eGL_NONE, 0); break; + return Serialise_glDrawArraysInstancedBaseInstance(ser, eGL_NONE, 0, 0, 0, 0); + case GLChunk::glDrawElements: return Serialise_glDrawElements(ser, eGL_NONE, 0, eGL_NONE, 0); case GLChunk::glDrawElementsIndirect: - Serialise_glDrawElementsIndirect(ser, eGL_NONE, eGL_NONE, 0); - break; + return Serialise_glDrawElementsIndirect(ser, eGL_NONE, eGL_NONE, 0); case GLChunk::glDrawRangeElementsEXT: case GLChunk::glDrawRangeElements: - Serialise_glDrawRangeElements(ser, eGL_NONE, 0, 0, 0, eGL_NONE, 0); - break; + return Serialise_glDrawRangeElements(ser, eGL_NONE, 0, 0, 0, eGL_NONE, 0); case GLChunk::glDrawRangeElementsBaseVertexEXT: case GLChunk::glDrawRangeElementsBaseVertexOES: case GLChunk::glDrawRangeElementsBaseVertex: - Serialise_glDrawRangeElementsBaseVertex(ser, eGL_NONE, 0, 0, 0, eGL_NONE, 0, 0); - break; + return Serialise_glDrawRangeElementsBaseVertex(ser, eGL_NONE, 0, 0, 0, eGL_NONE, 0, 0); case GLChunk::glDrawElementsBaseVertexEXT: case GLChunk::glDrawElementsBaseVertexOES: case GLChunk::glDrawElementsBaseVertex: - Serialise_glDrawElementsBaseVertex(ser, eGL_NONE, 0, eGL_NONE, 0, 0); - break; + return Serialise_glDrawElementsBaseVertex(ser, eGL_NONE, 0, eGL_NONE, 0, 0); case GLChunk::glDrawElementsInstancedARB: case GLChunk::glDrawElementsInstancedEXT: case GLChunk::glDrawElementsInstanced: - Serialise_glDrawElementsInstanced(ser, eGL_NONE, 0, eGL_NONE, 0, 0); - break; + return Serialise_glDrawElementsInstanced(ser, eGL_NONE, 0, eGL_NONE, 0, 0); case GLChunk::glDrawElementsInstancedBaseInstanceEXT: case GLChunk::glDrawElementsInstancedBaseInstance: - Serialise_glDrawElementsInstancedBaseInstance(ser, eGL_NONE, 0, eGL_NONE, 0, 0, 0); - break; + return Serialise_glDrawElementsInstancedBaseInstance(ser, eGL_NONE, 0, eGL_NONE, 0, 0, 0); case GLChunk::glDrawElementsInstancedBaseVertexEXT: case GLChunk::glDrawElementsInstancedBaseVertexOES: case GLChunk::glDrawElementsInstancedBaseVertex: - Serialise_glDrawElementsInstancedBaseVertex(ser, eGL_NONE, 0, eGL_NONE, 0, 0, 0); - break; + return Serialise_glDrawElementsInstancedBaseVertex(ser, eGL_NONE, 0, eGL_NONE, 0, 0, 0); case GLChunk::glDrawElementsInstancedBaseVertexBaseInstanceEXT: case GLChunk::glDrawElementsInstancedBaseVertexBaseInstance: - Serialise_glDrawElementsInstancedBaseVertexBaseInstance(ser, eGL_NONE, 0, eGL_NONE, 0, 0, 0, 0); - break; + return Serialise_glDrawElementsInstancedBaseVertexBaseInstance(ser, eGL_NONE, 0, eGL_NONE, 0, + 0, 0, 0); case GLChunk::glMultiDrawArraysEXT: - case GLChunk::glMultiDrawArrays: Serialise_glMultiDrawArrays(ser, eGL_NONE, 0, 0, 0); break; + case GLChunk::glMultiDrawArrays: return Serialise_glMultiDrawArrays(ser, eGL_NONE, 0, 0, 0); case GLChunk::glMultiDrawElements: - Serialise_glMultiDrawElements(ser, eGL_NONE, 0, eGL_NONE, 0, 0); - break; + return Serialise_glMultiDrawElements(ser, eGL_NONE, 0, eGL_NONE, 0, 0); case GLChunk::glMultiDrawElementsBaseVertexEXT: case GLChunk::glMultiDrawElementsBaseVertexOES: case GLChunk::glMultiDrawElementsBaseVertex: - Serialise_glMultiDrawElementsBaseVertex(ser, eGL_NONE, 0, eGL_NONE, 0, 0, 0); - break; + return Serialise_glMultiDrawElementsBaseVertex(ser, eGL_NONE, 0, eGL_NONE, 0, 0, 0); case GLChunk::glMultiDrawArraysIndirect: - Serialise_glMultiDrawArraysIndirect(ser, eGL_NONE, 0, 0, 0); - break; + return Serialise_glMultiDrawArraysIndirect(ser, eGL_NONE, 0, 0, 0); case GLChunk::glMultiDrawElementsIndirect: - Serialise_glMultiDrawElementsIndirect(ser, eGL_NONE, eGL_NONE, 0, 0, 0); - break; + return Serialise_glMultiDrawElementsIndirect(ser, eGL_NONE, eGL_NONE, 0, 0, 0); case GLChunk::glMultiDrawArraysIndirectCountARB: - Serialise_glMultiDrawArraysIndirectCountARB(ser, eGL_NONE, 0, 0, 0, 0); - break; + return Serialise_glMultiDrawArraysIndirectCountARB(ser, eGL_NONE, 0, 0, 0, 0); case GLChunk::glMultiDrawElementsIndirectCountARB: - Serialise_glMultiDrawElementsIndirectCountARB(ser, eGL_NONE, eGL_NONE, 0, 0, 0, 0); - break; + return Serialise_glMultiDrawElementsIndirectCountARB(ser, eGL_NONE, eGL_NONE, 0, 0, 0, 0); case GLChunk::glClearBufferfv: case GLChunk::glClearNamedFramebufferfv: - Serialise_glClearNamedFramebufferfv(ser, 0, eGL_NONE, 0, 0); - break; + return Serialise_glClearNamedFramebufferfv(ser, 0, eGL_NONE, 0, 0); case GLChunk::glClearBufferiv: case GLChunk::glClearNamedFramebufferiv: - Serialise_glClearNamedFramebufferiv(ser, 0, eGL_NONE, 0, 0); - break; + return Serialise_glClearNamedFramebufferiv(ser, 0, eGL_NONE, 0, 0); case GLChunk::glClearBufferuiv: case GLChunk::glClearNamedFramebufferuiv: - Serialise_glClearNamedFramebufferuiv(ser, 0, eGL_NONE, 0, 0); - break; + return Serialise_glClearNamedFramebufferuiv(ser, 0, eGL_NONE, 0, 0); case GLChunk::glClearBufferfi: case GLChunk::glClearNamedFramebufferfi: - Serialise_glClearNamedFramebufferfi(ser, 0, eGL_NONE, 0, 0); - break; + return Serialise_glClearNamedFramebufferfi(ser, 0, eGL_NONE, 0, 0); case GLChunk::glClearBufferData: case GLChunk::glClearNamedBufferData: case GLChunk::glClearNamedBufferDataEXT: - Serialise_glClearNamedBufferDataEXT(ser, 0, eGL_NONE, eGL_NONE, eGL_NONE, 0); - break; + return Serialise_glClearNamedBufferDataEXT(ser, 0, eGL_NONE, eGL_NONE, eGL_NONE, 0); case GLChunk::glClearBufferSubData: case GLChunk::glClearNamedBufferSubData: case GLChunk::glClearNamedBufferSubDataEXT: - Serialise_glClearNamedBufferSubDataEXT(ser, 0, eGL_NONE, 0, 0, eGL_NONE, eGL_NONE, 0); - break; - case GLChunk::glClear: Serialise_glClear(ser, 0); break; + return Serialise_glClearNamedBufferSubDataEXT(ser, 0, eGL_NONE, 0, 0, eGL_NONE, eGL_NONE, 0); + case GLChunk::glClear: return Serialise_glClear(ser, 0); case GLChunk::glClearTexImage: - Serialise_glClearTexImage(ser, 0, 0, eGL_NONE, eGL_NONE, 0); - break; + return Serialise_glClearTexImage(ser, 0, 0, eGL_NONE, eGL_NONE, 0); case GLChunk::glClearTexSubImage: - Serialise_glClearTexSubImage(ser, 0, 0, 0, 0, 0, 0, 0, 0, eGL_NONE, eGL_NONE, 0); - break; + return Serialise_glClearTexSubImage(ser, 0, 0, 0, 0, 0, 0, 0, 0, eGL_NONE, eGL_NONE, 0); case GLChunk::glGenFramebuffersEXT: - case GLChunk::glGenFramebuffers: Serialise_glGenFramebuffers(ser, 0, 0); break; - case GLChunk::glCreateFramebuffers: Serialise_glCreateFramebuffers(ser, 0, 0); break; + case GLChunk::glGenFramebuffers: return Serialise_glGenFramebuffers(ser, 0, 0); + case GLChunk::glCreateFramebuffers: return Serialise_glCreateFramebuffers(ser, 0, 0); case GLChunk::glFramebufferTexture: case GLChunk::glFramebufferTextureOES: case GLChunk::glFramebufferTextureARB: case GLChunk::glFramebufferTextureEXT: case GLChunk::glNamedFramebufferTexture: case GLChunk::glNamedFramebufferTextureEXT: - Serialise_glNamedFramebufferTextureEXT(ser, 0, eGL_NONE, 0, 0); - break; + return Serialise_glNamedFramebufferTextureEXT(ser, 0, eGL_NONE, 0, 0); case GLChunk::glFramebufferTexture1D: case GLChunk::glFramebufferTexture1DEXT: case GLChunk::glNamedFramebufferTexture1DEXT: - Serialise_glNamedFramebufferTexture1DEXT(ser, 0, eGL_NONE, eGL_NONE, 0, 0); - break; + return Serialise_glNamedFramebufferTexture1DEXT(ser, 0, eGL_NONE, eGL_NONE, 0, 0); case GLChunk::glFramebufferTexture2D: case GLChunk::glFramebufferTexture2DEXT: case GLChunk::glNamedFramebufferTexture2DEXT: - Serialise_glNamedFramebufferTexture2DEXT(ser, 0, eGL_NONE, eGL_NONE, 0, 0); - break; + return Serialise_glNamedFramebufferTexture2DEXT(ser, 0, eGL_NONE, eGL_NONE, 0, 0); case GLChunk::glFramebufferTexture2DMultisampleEXT: - Serialise_glFramebufferTexture2DMultisampleEXT(ser, 0, eGL_NONE, eGL_NONE, eGL_NONE, 0, 0, 0); - break; + return Serialise_glFramebufferTexture2DMultisampleEXT(ser, 0, eGL_NONE, eGL_NONE, eGL_NONE, 0, + 0, 0); case GLChunk::glFramebufferTexture3D: case GLChunk::glFramebufferTexture3DEXT: case GLChunk::glFramebufferTexture3DOES: case GLChunk::glNamedFramebufferTexture3DEXT: - Serialise_glNamedFramebufferTexture3DEXT(ser, 0, eGL_NONE, eGL_NONE, 0, 0, 0); - break; + return Serialise_glNamedFramebufferTexture3DEXT(ser, 0, eGL_NONE, eGL_NONE, 0, 0, 0); case GLChunk::glFramebufferRenderbuffer: case GLChunk::glFramebufferRenderbufferEXT: case GLChunk::glNamedFramebufferRenderbuffer: case GLChunk::glNamedFramebufferRenderbufferEXT: - Serialise_glNamedFramebufferRenderbufferEXT(ser, 0, eGL_NONE, eGL_NONE, 0); - break; + return Serialise_glNamedFramebufferRenderbufferEXT(ser, 0, eGL_NONE, eGL_NONE, 0); case GLChunk::glFramebufferTextureLayer: case GLChunk::glFramebufferTextureLayerARB: case GLChunk::glFramebufferTextureLayerEXT: case GLChunk::glNamedFramebufferTextureLayer: case GLChunk::glNamedFramebufferTextureLayerEXT: - Serialise_glNamedFramebufferTextureLayerEXT(ser, 0, eGL_NONE, 0, 0, 0); - break; + return Serialise_glNamedFramebufferTextureLayerEXT(ser, 0, eGL_NONE, 0, 0, 0); case GLChunk::glFramebufferTextureMultiviewOVR: - Serialise_glFramebufferTextureMultiviewOVR(ser, eGL_NONE, eGL_NONE, 0, 0, 0, 0); - break; + return Serialise_glFramebufferTextureMultiviewOVR(ser, eGL_NONE, eGL_NONE, 0, 0, 0, 0); case GLChunk::glFramebufferTextureMultisampleMultiviewOVR: - Serialise_glFramebufferTextureMultisampleMultiviewOVR(ser, eGL_NONE, eGL_NONE, 0, 0, 0, 0, 0); - break; + return Serialise_glFramebufferTextureMultisampleMultiviewOVR(ser, eGL_NONE, eGL_NONE, 0, 0, 0, + 0, 0); case GLChunk::glFramebufferParameteri: case GLChunk::glNamedFramebufferParameteri: case GLChunk::glNamedFramebufferParameteriEXT: - Serialise_glNamedFramebufferParameteriEXT(ser, 0, eGL_NONE, 0); - break; + return Serialise_glNamedFramebufferParameteriEXT(ser, 0, eGL_NONE, 0); case GLChunk::glReadBuffer: case GLChunk::glNamedFramebufferReadBuffer: case GLChunk::glFramebufferReadBufferEXT: - Serialise_glFramebufferReadBufferEXT(ser, 0, eGL_NONE); - break; + return Serialise_glFramebufferReadBufferEXT(ser, 0, eGL_NONE); case GLChunk::glBindFramebufferEXT: - case GLChunk::glBindFramebuffer: Serialise_glBindFramebuffer(ser, eGL_NONE, 0); break; + case GLChunk::glBindFramebuffer: return Serialise_glBindFramebuffer(ser, eGL_NONE, 0); case GLChunk::glDrawBuffer: case GLChunk::glNamedFramebufferDrawBuffer: case GLChunk::glFramebufferDrawBufferEXT: - Serialise_glFramebufferDrawBufferEXT(ser, 0, eGL_NONE); - break; + return Serialise_glFramebufferDrawBufferEXT(ser, 0, eGL_NONE); case GLChunk::glDrawBuffers: case GLChunk::glDrawBuffersARB: case GLChunk::glDrawBuffersEXT: case GLChunk::glNamedFramebufferDrawBuffers: case GLChunk::glFramebufferDrawBuffersEXT: - Serialise_glFramebufferDrawBuffersEXT(ser, 0, 0, 0); - break; + return Serialise_glFramebufferDrawBuffersEXT(ser, 0, 0, 0); case GLChunk::glBlitFramebuffer: case GLChunk::glBlitFramebufferEXT: case GLChunk::glBlitNamedFramebuffer: - Serialise_glBlitNamedFramebuffer(ser, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, eGL_NONE); - break; + return Serialise_glBlitNamedFramebuffer(ser, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, eGL_NONE); case GLChunk::glGenRenderbuffersEXT: - case GLChunk::glGenRenderbuffers: Serialise_glGenRenderbuffers(ser, 0, 0); break; - case GLChunk::glCreateRenderbuffers: Serialise_glCreateRenderbuffers(ser, 0, 0); break; + case GLChunk::glGenRenderbuffers: return Serialise_glGenRenderbuffers(ser, 0, 0); + case GLChunk::glCreateRenderbuffers: return Serialise_glCreateRenderbuffers(ser, 0, 0); case GLChunk::glRenderbufferStorage: case GLChunk::glRenderbufferStorageEXT: case GLChunk::glNamedRenderbufferStorage: case GLChunk::glNamedRenderbufferStorageEXT: - Serialise_glNamedRenderbufferStorageEXT(ser, 0, eGL_NONE, 0, 0); - break; + return Serialise_glNamedRenderbufferStorageEXT(ser, 0, eGL_NONE, 0, 0); case GLChunk::glRenderbufferStorageMultisample: case GLChunk::glRenderbufferStorageMultisampleEXT: case GLChunk::glNamedRenderbufferStorageMultisample: case GLChunk::glNamedRenderbufferStorageMultisampleEXT: - Serialise_glNamedRenderbufferStorageMultisampleEXT(ser, 0, 0, eGL_NONE, 0, 0); - break; + return Serialise_glNamedRenderbufferStorageMultisampleEXT(ser, 0, 0, eGL_NONE, 0, 0); case GLChunk::wglDXRegisterObjectNV: - Serialise_wglDXRegisterObjectNV(ser, GLResource(MakeNullResource), eGL_NONE, 0); - break; + return Serialise_wglDXRegisterObjectNV(ser, GLResource(MakeNullResource), eGL_NONE, 0); case GLChunk::wglDXLockObjectsNV: - Serialise_wglDXLockObjectsNV(ser, GLResource(MakeNullResource)); - break; + return Serialise_wglDXLockObjectsNV(ser, GLResource(MakeNullResource)); - case GLChunk::glFenceSync: Serialise_glFenceSync(ser, 0, eGL_NONE, 0); break; - case GLChunk::glClientWaitSync: Serialise_glClientWaitSync(ser, 0, 0, 0); break; - case GLChunk::glWaitSync: Serialise_glWaitSync(ser, 0, 0, 0); break; + case GLChunk::glFenceSync: return Serialise_glFenceSync(ser, 0, eGL_NONE, 0); + case GLChunk::glClientWaitSync: return Serialise_glClientWaitSync(ser, 0, 0, 0); + case GLChunk::glWaitSync: return Serialise_glWaitSync(ser, 0, 0, 0); case GLChunk::glGenQueriesARB: case GLChunk::glGenQueriesEXT: - case GLChunk::glGenQueries: Serialise_glGenQueries(ser, 0, 0); break; - case GLChunk::glCreateQueries: Serialise_glCreateQueries(ser, eGL_NONE, 0, 0); break; + case GLChunk::glGenQueries: return Serialise_glGenQueries(ser, 0, 0); + case GLChunk::glCreateQueries: return Serialise_glCreateQueries(ser, eGL_NONE, 0, 0); case GLChunk::glBeginQueryARB: case GLChunk::glBeginQueryEXT: - case GLChunk::glBeginQuery: Serialise_glBeginQuery(ser, eGL_NONE, 0); break; - case GLChunk::glBeginQueryIndexed: Serialise_glBeginQueryIndexed(ser, eGL_NONE, 0, 0); break; + case GLChunk::glBeginQuery: return Serialise_glBeginQuery(ser, eGL_NONE, 0); + case GLChunk::glBeginQueryIndexed: return Serialise_glBeginQueryIndexed(ser, eGL_NONE, 0, 0); case GLChunk::glEndQueryARB: case GLChunk::glEndQueryEXT: - case GLChunk::glEndQuery: Serialise_glEndQuery(ser, eGL_NONE); break; - case GLChunk::glEndQueryIndexed: Serialise_glEndQueryIndexed(ser, eGL_NONE, 0); break; + case GLChunk::glEndQuery: return Serialise_glEndQuery(ser, eGL_NONE); + case GLChunk::glEndQueryIndexed: return Serialise_glEndQueryIndexed(ser, eGL_NONE, 0); case GLChunk::glBeginConditionalRender: - Serialise_glBeginConditionalRender(ser, 0, eGL_NONE); - break; - case GLChunk::glEndConditionalRender: Serialise_glEndConditionalRender(ser); break; + return Serialise_glBeginConditionalRender(ser, 0, eGL_NONE); + case GLChunk::glEndConditionalRender: return Serialise_glEndConditionalRender(ser); case GLChunk::glQueryCounterEXT: - case GLChunk::glQueryCounter: Serialise_glQueryCounter(ser, 0, eGL_NONE); break; + case GLChunk::glQueryCounter: return Serialise_glQueryCounter(ser, 0, eGL_NONE); - case GLChunk::glGenSamplers: Serialise_glGenSamplers(ser, 0, 0); break; - case GLChunk::glCreateSamplers: Serialise_glCreateSamplers(ser, 0, 0); break; - case GLChunk::glBindSampler: Serialise_glBindSampler(ser, 0, 0); break; - case GLChunk::glBindSamplers: Serialise_glBindSamplers(ser, 0, 0, 0); break; - case GLChunk::glSamplerParameteri: Serialise_glSamplerParameteri(ser, 0, eGL_NONE, 0); break; - case GLChunk::glSamplerParameterf: Serialise_glSamplerParameterf(ser, 0, eGL_NONE, 0); break; - case GLChunk::glSamplerParameteriv: Serialise_glSamplerParameteriv(ser, 0, eGL_NONE, 0); break; - case GLChunk::glSamplerParameterfv: Serialise_glSamplerParameterfv(ser, 0, eGL_NONE, 0); break; + case GLChunk::glGenSamplers: return Serialise_glGenSamplers(ser, 0, 0); + case GLChunk::glCreateSamplers: return Serialise_glCreateSamplers(ser, 0, 0); + case GLChunk::glBindSampler: return Serialise_glBindSampler(ser, 0, 0); + case GLChunk::glBindSamplers: return Serialise_glBindSamplers(ser, 0, 0, 0); + case GLChunk::glSamplerParameteri: return Serialise_glSamplerParameteri(ser, 0, eGL_NONE, 0); + case GLChunk::glSamplerParameterf: return Serialise_glSamplerParameterf(ser, 0, eGL_NONE, 0); + case GLChunk::glSamplerParameteriv: return Serialise_glSamplerParameteriv(ser, 0, eGL_NONE, 0); + case GLChunk::glSamplerParameterfv: return Serialise_glSamplerParameterfv(ser, 0, eGL_NONE, 0); case GLChunk::glSamplerParameterIivEXT: case GLChunk::glSamplerParameterIivOES: case GLChunk::glSamplerParameterIiv: - Serialise_glSamplerParameterIiv(ser, 0, eGL_NONE, 0); - break; + return Serialise_glSamplerParameterIiv(ser, 0, eGL_NONE, 0); case GLChunk::glSamplerParameterIuivEXT: case GLChunk::glSamplerParameterIuivOES: case GLChunk::glSamplerParameterIuiv: - Serialise_glSamplerParameterIuiv(ser, 0, eGL_NONE, 0); - break; + return Serialise_glSamplerParameterIuiv(ser, 0, eGL_NONE, 0); - case GLChunk::glCreateShader: Serialise_glCreateShader(ser, 0, eGL_NONE); break; - case GLChunk::glShaderSource: Serialise_glShaderSource(ser, 0, 0, 0, 0); break; - case GLChunk::glCompileShader: Serialise_glCompileShader(ser, 0); break; - case GLChunk::glAttachShader: Serialise_glAttachShader(ser, 0, 0); break; - case GLChunk::glDetachShader: Serialise_glDetachShader(ser, 0, 0); break; + case GLChunk::glCreateShader: return Serialise_glCreateShader(ser, 0, eGL_NONE); + case GLChunk::glShaderSource: return Serialise_glShaderSource(ser, 0, 0, 0, 0); + case GLChunk::glCompileShader: return Serialise_glCompileShader(ser, 0); + case GLChunk::glAttachShader: return Serialise_glAttachShader(ser, 0, 0); + case GLChunk::glDetachShader: return Serialise_glDetachShader(ser, 0, 0); case GLChunk::glCreateShaderProgramvEXT: case GLChunk::glCreateShaderProgramv: - Serialise_glCreateShaderProgramv(ser, 0, eGL_NONE, 0, 0); - break; - case GLChunk::glCreateProgram: Serialise_glCreateProgram(ser, 0); break; - case GLChunk::glLinkProgram: Serialise_glLinkProgram(ser, 0); break; - case GLChunk::glUniformBlockBinding: Serialise_glUniformBlockBinding(ser, 0, 0, 0); break; + return Serialise_glCreateShaderProgramv(ser, 0, eGL_NONE, 0, 0); + case GLChunk::glCreateProgram: return Serialise_glCreateProgram(ser, 0); + case GLChunk::glLinkProgram: return Serialise_glLinkProgram(ser, 0); + case GLChunk::glUniformBlockBinding: return Serialise_glUniformBlockBinding(ser, 0, 0, 0); case GLChunk::glShaderStorageBlockBinding: - Serialise_glShaderStorageBlockBinding(ser, 0, 0, 0); - break; - case GLChunk::glBindAttribLocation: Serialise_glBindAttribLocation(ser, 0, 0, 0); break; + return Serialise_glShaderStorageBlockBinding(ser, 0, 0, 0); + case GLChunk::glBindAttribLocation: return Serialise_glBindAttribLocation(ser, 0, 0, 0); case GLChunk::glBindFragDataLocationEXT: - case GLChunk::glBindFragDataLocation: Serialise_glBindFragDataLocation(ser, 0, 0, 0); break; + case GLChunk::glBindFragDataLocation: return Serialise_glBindFragDataLocation(ser, 0, 0, 0); case GLChunk::glUniformSubroutinesuiv: - Serialise_glUniformSubroutinesuiv(ser, eGL_NONE, 0, 0); - break; + return Serialise_glUniformSubroutinesuiv(ser, eGL_NONE, 0, 0); case GLChunk::glBindFragDataLocationIndexed: - Serialise_glBindFragDataLocationIndexed(ser, 0, 0, 0, 0); - break; + return Serialise_glBindFragDataLocationIndexed(ser, 0, 0, 0, 0); case GLChunk::glTransformFeedbackVaryingsEXT: case GLChunk::glTransformFeedbackVaryings: - Serialise_glTransformFeedbackVaryings(ser, 0, 0, 0, eGL_NONE); - break; + return Serialise_glTransformFeedbackVaryings(ser, 0, 0, 0, eGL_NONE); case GLChunk::glProgramParameteriARB: case GLChunk::glProgramParameteriEXT: - case GLChunk::glProgramParameteri: Serialise_glProgramParameteri(ser, 0, eGL_NONE, 0); break; - case GLChunk::glUseProgram: Serialise_glUseProgram(ser, 0); break; + case GLChunk::glProgramParameteri: return Serialise_glProgramParameteri(ser, 0, eGL_NONE, 0); + case GLChunk::glUseProgram: return Serialise_glUseProgram(ser, 0); case GLChunk::glUseProgramStagesEXT: - case GLChunk::glUseProgramStages: Serialise_glUseProgramStages(ser, 0, 0, 0); break; + case GLChunk::glUseProgramStages: return Serialise_glUseProgramStages(ser, 0, 0, 0); case GLChunk::glGenProgramPipelinesEXT: - case GLChunk::glGenProgramPipelines: Serialise_glGenProgramPipelines(ser, 0, 0); break; - case GLChunk::glCreateProgramPipelines: Serialise_glCreateProgramPipelines(ser, 0, 0); break; + case GLChunk::glGenProgramPipelines: return Serialise_glGenProgramPipelines(ser, 0, 0); + case GLChunk::glCreateProgramPipelines: return Serialise_glCreateProgramPipelines(ser, 0, 0); case GLChunk::glBindProgramPipelineEXT: - case GLChunk::glBindProgramPipeline: Serialise_glBindProgramPipeline(ser, 0); break; + case GLChunk::glBindProgramPipeline: return Serialise_glBindProgramPipeline(ser, 0); case GLChunk::glCompileShaderIncludeARB: - Serialise_glCompileShaderIncludeARB(ser, 0, 0, 0, 0); - break; - case GLChunk::glNamedStringARB: Serialise_glNamedStringARB(ser, eGL_NONE, 0, 0, 0, 0); break; - case GLChunk::glDeleteNamedStringARB: Serialise_glDeleteNamedStringARB(ser, 0, 0); break; + return Serialise_glCompileShaderIncludeARB(ser, 0, 0, 0, 0); + case GLChunk::glNamedStringARB: return Serialise_glNamedStringARB(ser, eGL_NONE, 0, 0, 0, 0); + case GLChunk::glDeleteNamedStringARB: return Serialise_glDeleteNamedStringARB(ser, 0, 0); - case GLChunk::glBlendFunc: Serialise_glBlendFunc(ser, eGL_NONE, eGL_NONE); break; + case GLChunk::glBlendFunc: return Serialise_glBlendFunc(ser, eGL_NONE, eGL_NONE); case GLChunk::glBlendFunciARB: case GLChunk::glBlendFunciEXT: case GLChunk::glBlendFunciOES: - case GLChunk::glBlendFunci: Serialise_glBlendFunci(ser, 0, eGL_NONE, eGL_NONE); break; + case GLChunk::glBlendFunci: return Serialise_glBlendFunci(ser, 0, eGL_NONE, eGL_NONE); case GLChunk::glBlendColorEXT: - case GLChunk::glBlendColor: Serialise_glBlendColor(ser, 0, 0, 0, 0); break; + case GLChunk::glBlendColor: return Serialise_glBlendColor(ser, 0, 0, 0, 0); case GLChunk::glBlendFuncSeparateARB: case GLChunk::glBlendFuncSeparate: - Serialise_glBlendFuncSeparate(ser, eGL_NONE, eGL_NONE, eGL_NONE, eGL_NONE); - break; + return Serialise_glBlendFuncSeparate(ser, eGL_NONE, eGL_NONE, eGL_NONE, eGL_NONE); case GLChunk::glBlendFuncSeparateiARB: case GLChunk::glBlendFuncSeparateiEXT: case GLChunk::glBlendFuncSeparateiOES: case GLChunk::glBlendFuncSeparatei: - Serialise_glBlendFuncSeparatei(ser, 0, eGL_NONE, eGL_NONE, eGL_NONE, eGL_NONE); - break; + return Serialise_glBlendFuncSeparatei(ser, 0, eGL_NONE, eGL_NONE, eGL_NONE, eGL_NONE); case GLChunk::glBlendEquationEXT: - case GLChunk::glBlendEquation: Serialise_glBlendEquation(ser, eGL_NONE); break; + case GLChunk::glBlendEquation: return Serialise_glBlendEquation(ser, eGL_NONE); case GLChunk::glBlendEquationiARB: case GLChunk::glBlendEquationiEXT: case GLChunk::glBlendEquationiOES: - case GLChunk::glBlendEquationi: Serialise_glBlendEquationi(ser, 0, eGL_NONE); break; + case GLChunk::glBlendEquationi: return Serialise_glBlendEquationi(ser, 0, eGL_NONE); case GLChunk::glBlendEquationSeparateARB: case GLChunk::glBlendEquationSeparateEXT: case GLChunk::glBlendEquationSeparate: - Serialise_glBlendEquationSeparate(ser, eGL_NONE, eGL_NONE); - break; + return Serialise_glBlendEquationSeparate(ser, eGL_NONE, eGL_NONE); case GLChunk::glBlendEquationSeparateiARB: case GLChunk::glBlendEquationSeparateiEXT: case GLChunk::glBlendEquationSeparateiOES: case GLChunk::glBlendEquationSeparatei: - Serialise_glBlendEquationSeparatei(ser, 0, eGL_NONE, eGL_NONE); - break; + return Serialise_glBlendEquationSeparatei(ser, 0, eGL_NONE, eGL_NONE); case GLChunk::glBlendBarrier: - case GLChunk::glBlendBarrierKHR: Serialise_glBlendBarrierKHR(ser); break; - case GLChunk::glLogicOp: Serialise_glLogicOp(ser, eGL_NONE); break; - case GLChunk::glStencilFunc: Serialise_glStencilFunc(ser, eGL_NONE, 0, 0); break; + case GLChunk::glBlendBarrierKHR: return Serialise_glBlendBarrierKHR(ser); + case GLChunk::glLogicOp: return Serialise_glLogicOp(ser, eGL_NONE); + case GLChunk::glStencilFunc: return Serialise_glStencilFunc(ser, eGL_NONE, 0, 0); case GLChunk::glStencilFuncSeparate: - Serialise_glStencilFuncSeparate(ser, eGL_NONE, eGL_NONE, 0, 0); - break; - case GLChunk::glStencilMask: Serialise_glStencilMask(ser, 0); break; - case GLChunk::glStencilMaskSeparate: Serialise_glStencilMaskSeparate(ser, eGL_NONE, 0); break; - case GLChunk::glStencilOp: Serialise_glStencilOp(ser, eGL_NONE, eGL_NONE, eGL_NONE); break; + return Serialise_glStencilFuncSeparate(ser, eGL_NONE, eGL_NONE, 0, 0); + case GLChunk::glStencilMask: return Serialise_glStencilMask(ser, 0); + case GLChunk::glStencilMaskSeparate: return Serialise_glStencilMaskSeparate(ser, eGL_NONE, 0); + case GLChunk::glStencilOp: return Serialise_glStencilOp(ser, eGL_NONE, eGL_NONE, eGL_NONE); case GLChunk::glStencilOpSeparate: - Serialise_glStencilOpSeparate(ser, eGL_NONE, eGL_NONE, eGL_NONE, eGL_NONE); - break; - case GLChunk::glClearColor: Serialise_glClearColor(ser, 0, 0, 0, 0); break; - case GLChunk::glClearStencil: Serialise_glClearStencil(ser, 0); break; + return Serialise_glStencilOpSeparate(ser, eGL_NONE, eGL_NONE, eGL_NONE, eGL_NONE); + case GLChunk::glClearColor: return Serialise_glClearColor(ser, 0, 0, 0, 0); + case GLChunk::glClearStencil: return Serialise_glClearStencil(ser, 0); case GLChunk::glClearDepthf: - case GLChunk::glClearDepth: Serialise_glClearDepth(ser, 0); break; - case GLChunk::glDepthFunc: Serialise_glDepthFunc(ser, eGL_NONE); break; - case GLChunk::glDepthMask: Serialise_glDepthMask(ser, 0); break; - case GLChunk::glDepthRange: Serialise_glDepthRange(ser, 0, 0); break; - case GLChunk::glDepthRangef: Serialise_glDepthRangef(ser, 0, 0); break; + case GLChunk::glClearDepth: return Serialise_glClearDepth(ser, 0); + case GLChunk::glDepthFunc: return Serialise_glDepthFunc(ser, eGL_NONE); + case GLChunk::glDepthMask: return Serialise_glDepthMask(ser, 0); + case GLChunk::glDepthRange: return Serialise_glDepthRange(ser, 0, 0); + case GLChunk::glDepthRangef: return Serialise_glDepthRangef(ser, 0, 0); case GLChunk::glDepthRangeIndexedfNV: case GLChunk::glDepthRangeIndexedfOES: - case GLChunk::glDepthRangeIndexed: Serialise_glDepthRangeIndexed(ser, 0, 0, 0); break; + case GLChunk::glDepthRangeIndexed: return Serialise_glDepthRangeIndexed(ser, 0, 0, 0); case GLChunk::glDepthRangeArrayfvNV: case GLChunk::glDepthRangeArrayfvOES: - case GLChunk::glDepthRangeArrayv: Serialise_glDepthRangeArrayv(ser, 0, 0, 0); break; - case GLChunk::glDepthBoundsEXT: Serialise_glDepthBoundsEXT(ser, 0, 0); break; - case GLChunk::glClipControl: Serialise_glClipControl(ser, eGL_NONE, eGL_NONE); break; + case GLChunk::glDepthRangeArrayv: return Serialise_glDepthRangeArrayv(ser, 0, 0, 0); + case GLChunk::glDepthBoundsEXT: return Serialise_glDepthBoundsEXT(ser, 0, 0); + case GLChunk::glClipControl: return Serialise_glClipControl(ser, eGL_NONE, eGL_NONE); case GLChunk::glProvokingVertexEXT: - case GLChunk::glProvokingVertex: Serialise_glProvokingVertex(ser, eGL_NONE); break; - case GLChunk::glPrimitiveRestartIndex: Serialise_glPrimitiveRestartIndex(ser, 0); break; - case GLChunk::glDisable: Serialise_glDisable(ser, eGL_NONE); break; - case GLChunk::glEnable: Serialise_glEnable(ser, eGL_NONE); break; + case GLChunk::glProvokingVertex: return Serialise_glProvokingVertex(ser, eGL_NONE); + case GLChunk::glPrimitiveRestartIndex: return Serialise_glPrimitiveRestartIndex(ser, 0); + case GLChunk::glDisable: return Serialise_glDisable(ser, eGL_NONE); + case GLChunk::glEnable: return Serialise_glEnable(ser, eGL_NONE); case GLChunk::glDisableiEXT: case GLChunk::glDisableIndexedEXT: case GLChunk::glDisableiNV: case GLChunk::glDisableiOES: - case GLChunk::glDisablei: Serialise_glDisablei(ser, eGL_NONE, 0); break; + case GLChunk::glDisablei: return Serialise_glDisablei(ser, eGL_NONE, 0); case GLChunk::glEnableiEXT: case GLChunk::glEnableIndexedEXT: case GLChunk::glEnableiNV: case GLChunk::glEnableiOES: - case GLChunk::glEnablei: Serialise_glEnablei(ser, eGL_NONE, 0); break; - case GLChunk::glFrontFace: Serialise_glFrontFace(ser, eGL_NONE); break; - case GLChunk::glCullFace: Serialise_glCullFace(ser, eGL_NONE); break; - case GLChunk::glHint: Serialise_glHint(ser, eGL_NONE, eGL_NONE); break; - case GLChunk::glColorMask: Serialise_glColorMask(ser, 0, 0, 0, 0); break; + case GLChunk::glEnablei: return Serialise_glEnablei(ser, eGL_NONE, 0); + case GLChunk::glFrontFace: return Serialise_glFrontFace(ser, eGL_NONE); + case GLChunk::glCullFace: return Serialise_glCullFace(ser, eGL_NONE); + case GLChunk::glHint: return Serialise_glHint(ser, eGL_NONE, eGL_NONE); + case GLChunk::glColorMask: return Serialise_glColorMask(ser, 0, 0, 0, 0); case GLChunk::glColorMaskiEXT: case GLChunk::glColorMaskIndexedEXT: case GLChunk::glColorMaskiOES: - case GLChunk::glColorMaski: Serialise_glColorMaski(ser, 0, 0, 0, 0, 0); break; - case GLChunk::glSampleMaski: Serialise_glSampleMaski(ser, 0, 0); break; + case GLChunk::glColorMaski: return Serialise_glColorMaski(ser, 0, 0, 0, 0, 0); + case GLChunk::glSampleMaski: return Serialise_glSampleMaski(ser, 0, 0); case GLChunk::glSampleCoverageARB: - case GLChunk::glSampleCoverage: Serialise_glSampleCoverage(ser, 0, 0); break; + case GLChunk::glSampleCoverage: return Serialise_glSampleCoverage(ser, 0, 0); case GLChunk::glMinSampleShadingARB: case GLChunk::glMinSampleShadingOES: - case GLChunk::glMinSampleShading: Serialise_glMinSampleShading(ser, 0); break; - case GLChunk::glRasterSamplesEXT: Serialise_glRasterSamplesEXT(ser, 0, 0); break; - case GLChunk::glPatchParameteri: Serialise_glPatchParameteri(ser, eGL_NONE, 0); break; - case GLChunk::glPatchParameterfv: Serialise_glPatchParameterfv(ser, eGL_NONE, 0); break; - case GLChunk::glLineWidth: Serialise_glLineWidth(ser, 0); break; - case GLChunk::glPointSize: Serialise_glPointSize(ser, 0); break; + case GLChunk::glMinSampleShading: return Serialise_glMinSampleShading(ser, 0); + case GLChunk::glRasterSamplesEXT: return Serialise_glRasterSamplesEXT(ser, 0, 0); + case GLChunk::glPatchParameteri: return Serialise_glPatchParameteri(ser, eGL_NONE, 0); + case GLChunk::glPatchParameterfv: return Serialise_glPatchParameterfv(ser, eGL_NONE, 0); + case GLChunk::glLineWidth: return Serialise_glLineWidth(ser, 0); + case GLChunk::glPointSize: return Serialise_glPointSize(ser, 0); case GLChunk::glPatchParameteriEXT: case GLChunk::glPatchParameteriOES: - case GLChunk::glPointParameteri: Serialise_glPointParameteri(ser, eGL_NONE, 0); break; - case GLChunk::glPointParameteriv: Serialise_glPointParameteriv(ser, eGL_NONE, 0); break; + case GLChunk::glPointParameteri: return Serialise_glPointParameteri(ser, eGL_NONE, 0); + case GLChunk::glPointParameteriv: return Serialise_glPointParameteriv(ser, eGL_NONE, 0); case GLChunk::glPointParameterfARB: case GLChunk::glPointParameterfEXT: - case GLChunk::glPointParameterf: Serialise_glPointParameterf(ser, eGL_NONE, 0); break; + case GLChunk::glPointParameterf: return Serialise_glPointParameterf(ser, eGL_NONE, 0); case GLChunk::glPointParameterfvARB: case GLChunk::glPointParameterfvEXT: - case GLChunk::glPointParameterfv: Serialise_glPointParameterfv(ser, eGL_NONE, 0); break; - case GLChunk::glViewport: Serialise_glViewport(ser, 0, 0, 0, 0); break; + case GLChunk::glPointParameterfv: return Serialise_glPointParameterfv(ser, eGL_NONE, 0); + case GLChunk::glViewport: return Serialise_glViewport(ser, 0, 0, 0, 0); case GLChunk::glViewportArrayvNV: case GLChunk::glViewportArrayvOES: case GLChunk::glViewportIndexedf: @@ -3959,8 +3902,8 @@ void WrappedOpenGL::ProcessChunk(ReadSerialiser &ser, GLChunk chunk) case GLChunk::glViewportIndexedfv: case GLChunk::glViewportIndexedfvNV: case GLChunk::glViewportIndexedfvOES: - case GLChunk::glViewportArrayv: Serialise_glViewportArrayv(ser, 0, 0, 0); break; - case GLChunk::glScissor: Serialise_glScissor(ser, 0, 0, 0, 0); break; + case GLChunk::glViewportArrayv: return Serialise_glViewportArrayv(ser, 0, 0, 0); + case GLChunk::glScissor: return Serialise_glScissor(ser, 0, 0, 0, 0); case GLChunk::glScissorArrayvNV: case GLChunk::glScissorArrayvOES: case GLChunk::glScissorIndexed: @@ -3969,183 +3912,157 @@ void WrappedOpenGL::ProcessChunk(ReadSerialiser &ser, GLChunk chunk) case GLChunk::glScissorIndexedv: case GLChunk::glScissorIndexedvNV: case GLChunk::glScissorIndexedvOES: - case GLChunk::glScissorArrayv: Serialise_glScissorArrayv(ser, 0, 0, 0); break; - case GLChunk::glPolygonMode: Serialise_glPolygonMode(ser, eGL_NONE, eGL_NONE); break; - case GLChunk::glPolygonOffset: Serialise_glPolygonOffset(ser, 0, 0); break; - case GLChunk::glPolygonOffsetClampEXT: Serialise_glPolygonOffsetClampEXT(ser, 0, 0, 0); break; + case GLChunk::glScissorArrayv: return Serialise_glScissorArrayv(ser, 0, 0, 0); + case GLChunk::glPolygonMode: return Serialise_glPolygonMode(ser, eGL_NONE, eGL_NONE); + case GLChunk::glPolygonOffset: return Serialise_glPolygonOffset(ser, 0, 0); + case GLChunk::glPolygonOffsetClampEXT: return Serialise_glPolygonOffsetClampEXT(ser, 0, 0, 0); case GLChunk::glPrimitiveBoundingBoxEXT: case GLChunk::glPrimitiveBoundingBoxOES: case GLChunk::glPrimitiveBoundingBox: - Serialise_glPrimitiveBoundingBox(ser, 0, 0, 0, 0, 0, 0, 0, 0); - break; + return Serialise_glPrimitiveBoundingBox(ser, 0, 0, 0, 0, 0, 0, 0, 0); - case GLChunk::glGenTextures: Serialise_glGenTextures(ser, 0, 0); break; - case GLChunk::glCreateTextures: Serialise_glCreateTextures(ser, eGL_NONE, 0, 0); break; - case GLChunk::glBindTexture: Serialise_glBindTexture(ser, eGL_NONE, 0); break; - case GLChunk::glBindTextures: Serialise_glBindTextures(ser, 0, 0, 0); break; + case GLChunk::glGenTextures: return Serialise_glGenTextures(ser, 0, 0); + case GLChunk::glCreateTextures: return Serialise_glCreateTextures(ser, eGL_NONE, 0, 0); + case GLChunk::glBindTexture: return Serialise_glBindTexture(ser, eGL_NONE, 0); + case GLChunk::glBindTextures: return Serialise_glBindTextures(ser, 0, 0, 0); case GLChunk::glBindMultiTextureEXT: - Serialise_glBindMultiTextureEXT(ser, eGL_NONE, eGL_NONE, 0); - break; - case GLChunk::glBindTextureUnit: Serialise_glBindTextureUnit(ser, 0, 0); break; + return Serialise_glBindMultiTextureEXT(ser, eGL_NONE, eGL_NONE, 0); + case GLChunk::glBindTextureUnit: return Serialise_glBindTextureUnit(ser, 0, 0); case GLChunk::glBindImageTextureEXT: case GLChunk::glBindImageTexture: - Serialise_glBindImageTexture(ser, 0, 0, 0, 0, 0, eGL_NONE, eGL_NONE); - break; - case GLChunk::glBindImageTextures: Serialise_glBindImageTextures(ser, 0, 0, 0); break; + return Serialise_glBindImageTexture(ser, 0, 0, 0, 0, 0, eGL_NONE, eGL_NONE); + case GLChunk::glBindImageTextures: return Serialise_glBindImageTextures(ser, 0, 0, 0); case GLChunk::glTextureViewEXT: case GLChunk::glTextureViewOES: case GLChunk::glTextureView: - Serialise_glTextureView(ser, 0, eGL_NONE, 0, eGL_NONE, 0, 0, 0, 0); - break; + return Serialise_glTextureView(ser, 0, eGL_NONE, 0, eGL_NONE, 0, 0, 0, 0); case GLChunk::glGenerateMipmap: case GLChunk::glGenerateMipmapEXT: case GLChunk::glGenerateMultiTexMipmapEXT: case GLChunk::glGenerateTextureMipmap: case GLChunk::glGenerateTextureMipmapEXT: - Serialise_glGenerateTextureMipmapEXT(ser, 0, eGL_NONE); - break; + return Serialise_glGenerateTextureMipmapEXT(ser, 0, eGL_NONE); case GLChunk::glCopyImageSubDataEXT: case GLChunk::glCopyImageSubDataOES: case GLChunk::glCopyImageSubData: - Serialise_glCopyImageSubData(ser, 0, eGL_NONE, 0, 0, 0, 0, 0, eGL_NONE, 0, 0, 0, 0, 0, 0, 0); - break; + return Serialise_glCopyImageSubData(ser, 0, eGL_NONE, 0, 0, 0, 0, 0, eGL_NONE, 0, 0, 0, 0, 0, + 0, 0); case GLChunk::glCopyMultiTexSubImage1DEXT: case GLChunk::glCopyTexSubImage1D: case GLChunk::glCopyTextureSubImage1D: case GLChunk::glCopyTextureSubImage1DEXT: - Serialise_glCopyTextureSubImage1DEXT(ser, 0, eGL_NONE, 0, 0, 0, 0, 0); - break; + return Serialise_glCopyTextureSubImage1DEXT(ser, 0, eGL_NONE, 0, 0, 0, 0, 0); case GLChunk::glCopyTexSubImage2D: case GLChunk::glCopyTextureSubImage2D: case GLChunk::glCopyMultiTexSubImage2DEXT: case GLChunk::glCopyTextureSubImage2DEXT: - Serialise_glCopyTextureSubImage2DEXT(ser, 0, eGL_NONE, 0, 0, 0, 0, 0, 0, 0); - break; + return Serialise_glCopyTextureSubImage2DEXT(ser, 0, eGL_NONE, 0, 0, 0, 0, 0, 0, 0); case GLChunk::glCopyMultiTexSubImage3DEXT: case GLChunk::glCopyTexSubImage3D: case GLChunk::glCopyTexSubImage3DOES: case GLChunk::glCopyTextureSubImage3D: case GLChunk::glCopyTextureSubImage3DEXT: - Serialise_glCopyTextureSubImage3DEXT(ser, 0, eGL_NONE, 0, 0, 0, 0, 0, 0, 0, 0); - break; + return Serialise_glCopyTextureSubImage3DEXT(ser, 0, eGL_NONE, 0, 0, 0, 0, 0, 0, 0, 0); case GLChunk::glMultiTexParameteriEXT: case GLChunk::glTexParameteri: case GLChunk::glTextureParameteri: case GLChunk::glTextureParameteriEXT: - Serialise_glTextureParameteriEXT(ser, 0, eGL_NONE, eGL_NONE, 0); - break; + return Serialise_glTextureParameteriEXT(ser, 0, eGL_NONE, eGL_NONE, 0); case GLChunk::glMultiTexParameterivEXT: case GLChunk::glTexParameteriv: case GLChunk::glTextureParameteriv: case GLChunk::glTextureParameterivEXT: - Serialise_glTextureParameterivEXT(ser, 0, eGL_NONE, eGL_NONE, 0); - break; + return Serialise_glTextureParameterivEXT(ser, 0, eGL_NONE, eGL_NONE, 0); case GLChunk::glMultiTexParameterIivEXT: case GLChunk::glTexParameterIiv: case GLChunk::glTexParameterIivEXT: case GLChunk::glTexParameterIivOES: case GLChunk::glTextureParameterIiv: case GLChunk::glTextureParameterIivEXT: - Serialise_glTextureParameterIivEXT(ser, 0, eGL_NONE, eGL_NONE, 0); - break; + return Serialise_glTextureParameterIivEXT(ser, 0, eGL_NONE, eGL_NONE, 0); case GLChunk::glMultiTexParameterIuivEXT: case GLChunk::glTexParameterIuiv: case GLChunk::glTexParameterIuivEXT: case GLChunk::glTexParameterIuivOES: case GLChunk::glTextureParameterIuiv: case GLChunk::glTextureParameterIuivEXT: - Serialise_glTextureParameterIuivEXT(ser, 0, eGL_NONE, eGL_NONE, 0); - break; + return Serialise_glTextureParameterIuivEXT(ser, 0, eGL_NONE, eGL_NONE, 0); case GLChunk::glMultiTexParameterfEXT: case GLChunk::glTexParameterf: case GLChunk::glTextureParameterf: case GLChunk::glTextureParameterfEXT: - Serialise_glTextureParameterfEXT(ser, 0, eGL_NONE, eGL_NONE, 0); - break; + return Serialise_glTextureParameterfEXT(ser, 0, eGL_NONE, eGL_NONE, 0); case GLChunk::glMultiTexParameterfvEXT: case GLChunk::glTexParameterfv: case GLChunk::glTextureParameterfv: case GLChunk::glTextureParameterfvEXT: - Serialise_glTextureParameterfvEXT(ser, 0, eGL_NONE, eGL_NONE, 0); - break; + return Serialise_glTextureParameterfvEXT(ser, 0, eGL_NONE, eGL_NONE, 0); case GLChunk::glPixelStoref: - case GLChunk::glPixelStorei: Serialise_glPixelStorei(ser, eGL_NONE, 0); break; + case GLChunk::glPixelStorei: return Serialise_glPixelStorei(ser, eGL_NONE, 0); case GLChunk::glActiveTextureARB: - case GLChunk::glActiveTexture: Serialise_glActiveTexture(ser, eGL_NONE); break; + case GLChunk::glActiveTexture: return Serialise_glActiveTexture(ser, eGL_NONE); case GLChunk::glMultiTexImage1DEXT: case GLChunk::glTexImage1D: case GLChunk::glTextureImage1DEXT: - Serialise_glTextureImage1DEXT(ser, 0, eGL_NONE, 0, 0, 0, 0, eGL_NONE, eGL_NONE, 0); - break; + return Serialise_glTextureImage1DEXT(ser, 0, eGL_NONE, 0, 0, 0, 0, eGL_NONE, eGL_NONE, 0); case GLChunk::glMultiTexImage2DEXT: case GLChunk::glTexImage2D: case GLChunk::glTextureImage2DEXT: - Serialise_glTextureImage2DEXT(ser, 0, eGL_NONE, 0, 0, 0, 0, 0, eGL_NONE, eGL_NONE, 0); - break; + return Serialise_glTextureImage2DEXT(ser, 0, eGL_NONE, 0, 0, 0, 0, 0, eGL_NONE, eGL_NONE, 0); case GLChunk::glMultiTexImage3DEXT: case GLChunk::glTexImage3D: case GLChunk::glTexImage3DEXT: case GLChunk::glTexImage3DOES: case GLChunk::glTextureImage3DEXT: - Serialise_glTextureImage3DEXT(ser, 0, eGL_NONE, 0, 0, 0, 0, 0, 0, eGL_NONE, eGL_NONE, 0); - break; + return Serialise_glTextureImage3DEXT(ser, 0, eGL_NONE, 0, 0, 0, 0, 0, 0, eGL_NONE, eGL_NONE, 0); case GLChunk::glCompressedMultiTexImage1DEXT: case GLChunk::glCompressedTexImage1D: case GLChunk::glCompressedTexImage1DARB: case GLChunk::glCompressedTextureImage1DEXT: - Serialise_glCompressedTextureImage1DEXT(ser, 0, eGL_NONE, 0, eGL_NONE, 0, 0, 0, 0); - break; + return Serialise_glCompressedTextureImage1DEXT(ser, 0, eGL_NONE, 0, eGL_NONE, 0, 0, 0, 0); case GLChunk::glCompressedMultiTexImage2DEXT: case GLChunk::glCompressedTexImage2D: case GLChunk::glCompressedTexImage2DARB: case GLChunk::glCompressedTextureImage2DEXT: - Serialise_glCompressedTextureImage2DEXT(ser, 0, eGL_NONE, 0, eGL_NONE, 0, 0, 0, 0, 0); - break; + return Serialise_glCompressedTextureImage2DEXT(ser, 0, eGL_NONE, 0, eGL_NONE, 0, 0, 0, 0, 0); case GLChunk::glCompressedMultiTexImage3DEXT: case GLChunk::glCompressedTexImage3D: case GLChunk::glCompressedTexImage3DARB: case GLChunk::glCompressedTexImage3DOES: case GLChunk::glCompressedTextureImage3DEXT: - Serialise_glCompressedTextureImage3DEXT(ser, 0, eGL_NONE, 0, eGL_NONE, 0, 0, 0, 0, 0, 0); - break; + return Serialise_glCompressedTextureImage3DEXT(ser, 0, eGL_NONE, 0, eGL_NONE, 0, 0, 0, 0, 0, 0); case GLChunk::glCopyTexImage1D: case GLChunk::glCopyMultiTexImage1DEXT: case GLChunk::glCopyTextureImage1DEXT: - Serialise_glCopyTextureImage1DEXT(ser, 0, eGL_NONE, 0, eGL_NONE, 0, 0, 0, 0); - break; + return Serialise_glCopyTextureImage1DEXT(ser, 0, eGL_NONE, 0, eGL_NONE, 0, 0, 0, 0); case GLChunk::glCopyTexImage2D: case GLChunk::glCopyMultiTexImage2DEXT: case GLChunk::glCopyTextureImage2DEXT: - Serialise_glCopyTextureImage2DEXT(ser, 0, eGL_NONE, 0, eGL_NONE, 0, 0, 0, 0, 0); - break; + return Serialise_glCopyTextureImage2DEXT(ser, 0, eGL_NONE, 0, eGL_NONE, 0, 0, 0, 0, 0); case GLChunk::glTexStorage1D: case GLChunk::glTexStorage1DEXT: case GLChunk::glTextureStorage1D: case GLChunk::glTextureStorage1DEXT: - Serialise_glTextureStorage1DEXT(ser, 0, eGL_NONE, 0, eGL_NONE, 0); - break; + return Serialise_glTextureStorage1DEXT(ser, 0, eGL_NONE, 0, eGL_NONE, 0); case GLChunk::glTexStorage2D: case GLChunk::glTexStorage2DEXT: case GLChunk::glTextureStorage2D: case GLChunk::glTextureStorage2DEXT: - Serialise_glTextureStorage2DEXT(ser, 0, eGL_NONE, 0, eGL_NONE, 0, 0); - break; + return Serialise_glTextureStorage2DEXT(ser, 0, eGL_NONE, 0, eGL_NONE, 0, 0); case GLChunk::glTexStorage3D: case GLChunk::glTexStorage3DEXT: case GLChunk::glTextureStorage3D: case GLChunk::glTextureStorage3DEXT: - Serialise_glTextureStorage3DEXT(ser, 0, eGL_NONE, 0, eGL_NONE, 0, 0, 0); - break; + return Serialise_glTextureStorage3DEXT(ser, 0, eGL_NONE, 0, eGL_NONE, 0, 0, 0); case GLChunk::glTexImage2DMultisample: // technically this isn't equivalent to storage, but we treat it as such because there's no DSA // variant of this teximage case GLChunk::glTexStorage2DMultisample: case GLChunk::glTextureStorage2DMultisample: case GLChunk::glTextureStorage2DMultisampleEXT: - Serialise_glTextureStorage2DMultisampleEXT(ser, 0, eGL_NONE, 0, eGL_NONE, 0, 0, 0); - break; + return Serialise_glTextureStorage2DMultisampleEXT(ser, 0, eGL_NONE, 0, eGL_NONE, 0, 0, 0); case GLChunk::glTexImage3DMultisample: // technically this isn't equivalent to storage, but we treat it as such because there's no DSA // variant of this teximage @@ -4153,57 +4070,51 @@ void WrappedOpenGL::ProcessChunk(ReadSerialiser &ser, GLChunk chunk) case GLChunk::glTexStorage3DMultisampleOES: case GLChunk::glTextureStorage3DMultisample: case GLChunk::glTextureStorage3DMultisampleEXT: - Serialise_glTextureStorage3DMultisampleEXT(ser, 0, eGL_NONE, 0, eGL_NONE, 0, 0, 0, 0); - break; + return Serialise_glTextureStorage3DMultisampleEXT(ser, 0, eGL_NONE, 0, eGL_NONE, 0, 0, 0, 0); case GLChunk::glMultiTexSubImage1DEXT: case GLChunk::glTexSubImage1D: case GLChunk::glTextureSubImage1D: case GLChunk::glTextureSubImage1DEXT: - Serialise_glTextureSubImage1DEXT(ser, 0, eGL_NONE, 0, 0, 0, eGL_NONE, eGL_NONE, 0); - break; + return Serialise_glTextureSubImage1DEXT(ser, 0, eGL_NONE, 0, 0, 0, eGL_NONE, eGL_NONE, 0); case GLChunk::glMultiTexSubImage2DEXT: case GLChunk::glTexSubImage2D: case GLChunk::glTextureSubImage2D: case GLChunk::glTextureSubImage2DEXT: - Serialise_glTextureSubImage2DEXT(ser, 0, eGL_NONE, 0, 0, 0, 0, 0, eGL_NONE, eGL_NONE, 0); - break; + return Serialise_glTextureSubImage2DEXT(ser, 0, eGL_NONE, 0, 0, 0, 0, 0, eGL_NONE, eGL_NONE, 0); case GLChunk::glMultiTexSubImage3DEXT: case GLChunk::glTexSubImage3D: case GLChunk::glTexSubImage3DOES: case GLChunk::glTextureSubImage3D: case GLChunk::glTextureSubImage3DEXT: - Serialise_glTextureSubImage3DEXT(ser, 0, eGL_NONE, 0, 0, 0, 0, 0, 0, 0, eGL_NONE, eGL_NONE, 0); - break; + return Serialise_glTextureSubImage3DEXT(ser, 0, eGL_NONE, 0, 0, 0, 0, 0, 0, 0, eGL_NONE, + eGL_NONE, 0); case GLChunk::glCompressedMultiTexSubImage1DEXT: case GLChunk::glCompressedTexSubImage1D: case GLChunk::glCompressedTexSubImage1DARB: case GLChunk::glCompressedTextureSubImage1D: case GLChunk::glCompressedTextureSubImage1DEXT: - Serialise_glCompressedTextureSubImage1DEXT(ser, 0, eGL_NONE, 0, 0, 0, eGL_NONE, 0, 0); - break; + return Serialise_glCompressedTextureSubImage1DEXT(ser, 0, eGL_NONE, 0, 0, 0, eGL_NONE, 0, 0); case GLChunk::glCompressedMultiTexSubImage2DEXT: case GLChunk::glCompressedTexSubImage2D: case GLChunk::glCompressedTexSubImage2DARB: case GLChunk::glCompressedTextureSubImage2D: case GLChunk::glCompressedTextureSubImage2DEXT: - Serialise_glCompressedTextureSubImage2DEXT(ser, 0, eGL_NONE, 0, 0, 0, 0, 0, eGL_NONE, 0, 0); - break; + return Serialise_glCompressedTextureSubImage2DEXT(ser, 0, eGL_NONE, 0, 0, 0, 0, 0, eGL_NONE, + 0, 0); case GLChunk::glCompressedMultiTexSubImage3DEXT: case GLChunk::glCompressedTexSubImage3D: case GLChunk::glCompressedTexSubImage3DARB: case GLChunk::glCompressedTexSubImage3DOES: case GLChunk::glCompressedTextureSubImage3D: case GLChunk::glCompressedTextureSubImage3DEXT: - Serialise_glCompressedTextureSubImage3DEXT(ser, 0, eGL_NONE, 0, 0, 0, 0, 0, 0, 0, eGL_NONE, 0, - 0); - break; + return Serialise_glCompressedTextureSubImage3DEXT(ser, 0, eGL_NONE, 0, 0, 0, 0, 0, 0, 0, + eGL_NONE, 0, 0); case GLChunk::glTexBufferRange: case GLChunk::glTexBufferRangeEXT: case GLChunk::glTexBufferRangeOES: case GLChunk::glTextureBufferRange: case GLChunk::glTextureBufferRangeEXT: - Serialise_glTextureBufferRangeEXT(ser, 0, eGL_NONE, eGL_NONE, 0, 0, 0); - break; + return Serialise_glTextureBufferRangeEXT(ser, 0, eGL_NONE, eGL_NONE, 0, 0, 0); case GLChunk::glMultiTexBufferEXT: case GLChunk::glTexBuffer: case GLChunk::glTexBufferARB: @@ -4211,8 +4122,7 @@ void WrappedOpenGL::ProcessChunk(ReadSerialiser &ser, GLChunk chunk) case GLChunk::glTexBufferOES: case GLChunk::glTextureBuffer: case GLChunk::glTextureBufferEXT: - Serialise_glTextureBufferEXT(ser, 0, eGL_NONE, eGL_NONE, 0); - break; + return Serialise_glTextureBufferEXT(ser, 0, eGL_NONE, eGL_NONE, 0); case GLChunk::glProgramUniform1d: case GLChunk::glProgramUniform1dEXT: @@ -4318,8 +4228,7 @@ void WrappedOpenGL::ProcessChunk(ReadSerialiser &ser, GLChunk chunk) case GLChunk::glUniform4uiEXT: case GLChunk::glUniform4uiv: case GLChunk::glUniform4uivEXT: - Serialise_glProgramUniformVector(ser, 0, 0, 0, 0, UNIFORM_UNKNOWN); - break; + return Serialise_glProgramUniformVector(ser, 0, 0, 0, 0, UNIFORM_UNKNOWN); case GLChunk::glProgramUniformMatrix2dv: case GLChunk::glProgramUniformMatrix2dvEXT: @@ -4375,13 +4284,12 @@ void WrappedOpenGL::ProcessChunk(ReadSerialiser &ser, GLChunk chunk) case GLChunk::glUniformMatrix4x2fv: case GLChunk::glUniformMatrix4x3dv: case GLChunk::glUniformMatrix4x3fv: - Serialise_glProgramUniformMatrix(ser, 0, 0, 0, 0, 0, UNIFORM_UNKNOWN); - break; + return Serialise_glProgramUniformMatrix(ser, 0, 0, 0, 0, 0, UNIFORM_UNKNOWN); case GLChunk::vrapi_CreateTextureSwapChain: case GLChunk::vrapi_CreateTextureSwapChain2: // nothing to do, these chunks are just markers - break; + return true; // these functions are not currently serialised - they do nothing on replay and are not // serialised for information (it would be harmless and perhaps useful for the user to see @@ -4701,15 +4609,14 @@ void WrappedOpenGL::ProcessChunk(ReadSerialiser &ser, GLChunk chunk) case GLChunk::Max: RDCERR("Unexpected chunk, or missing case for processing! Skipping..."); ser.SkipCurrentChunk(); - break; + return false; - case GLChunk::CaptureScope: Serialise_CaptureScope(ser); break; + case GLChunk::CaptureScope: return Serialise_CaptureScope(ser); case GLChunk::CaptureBegin: // normally this would be handled as a special case when we start processing the frame, // but it can be emitted mid-frame if MakeCurrent is called on a different context. // when processed here, we always want to apply the contents - Serialise_BeginCaptureFrame(ser); - break; + return Serialise_BeginCaptureFrame(ser); case GLChunk::CaptureEnd: { if(IsLoading(m_State)) @@ -4725,13 +4632,15 @@ void WrappedOpenGL::ProcessChunk(ReadSerialiser &ser, GLChunk chunk) AddDrawcall(draw, true); } - break; + return true; } } + + return false; } -void WrappedOpenGL::ContextReplayLog(CaptureState readType, uint32_t startEventID, - uint32_t endEventID, bool partial) +ReplayStatus WrappedOpenGL::ContextReplayLog(CaptureState readType, uint32_t startEventID, + uint32_t endEventID, bool partial) { m_FrameReader->SetOffset(0); @@ -4831,12 +4740,23 @@ void WrappedOpenGL::ContextReplayLog(CaptureState readType, uint32_t startEventI GLChunk chunktype = ser.ReadChunk(); + if(ser.GetReader()->IsErrored()) + return ReplayStatus::APIDataCorrupted; + m_ChunkMetadata = ser.ChunkMetadata(); - ContextProcessChunk(ser, chunktype); + bool success = ContextProcessChunk(ser, chunktype); ser.EndChunk(); + if(ser.GetReader()->IsErrored()) + return ReplayStatus::APIDataCorrupted; + + // if there wasn't a serialisation error, but the chunk didn't succeed, then it's an API replay + // failure. + if(!success) + return m_FailedReplayStatus; + RenderDoc::Inst().SetProgress( FileInitialRead, float(m_CurChunkOffset - startOffset) / float(ser.GetReader()->GetSize())); @@ -4872,13 +4792,18 @@ void WrappedOpenGL::ContextReplayLog(CaptureState readType, uint32_t startEventI } GetResourceManager()->MarkInFrame(false); + + return ReplayStatus::Succeeded; } -void WrappedOpenGL::ContextProcessChunk(ReadSerialiser &ser, GLChunk chunk) +bool WrappedOpenGL::ContextProcessChunk(ReadSerialiser &ser, GLChunk chunk) { m_AddedDrawcall = false; - ProcessChunk(ser, chunk); + bool success = ProcessChunk(ser, chunk); + + if(!success) + return false; if(IsLoading(m_State)) { @@ -4917,6 +4842,8 @@ void WrappedOpenGL::ContextProcessChunk(ReadSerialiser &ser, GLChunk chunk) } m_AddedDrawcall = false; + + return true; } void WrappedOpenGL::AddUsage(const DrawcallDescription &d) @@ -5302,15 +5229,19 @@ void WrappedOpenGL::ReplayLog(uint32_t startEventID, uint32_t endEventID, Replay m_ReplayEventCount = 0; + ReplayStatus status = ReplayStatus::Succeeded; + if(replayType == eReplay_Full) - ContextReplayLog(m_State, startEventID, endEventID, partial); + status = ContextReplayLog(m_State, startEventID, endEventID, partial); else if(replayType == eReplay_WithoutDraw) - ContextReplayLog(m_State, startEventID, RDCMAX(1U, endEventID) - 1, partial); + status = ContextReplayLog(m_State, startEventID, RDCMAX(1U, endEventID) - 1, partial); else if(replayType == eReplay_OnlyDraw) - ContextReplayLog(m_State, endEventID, endEventID, partial); + status = ContextReplayLog(m_State, endEventID, endEventID, partial); else RDCFATAL("Unexpected replay type"); + RDCASSERTEQUAL(status, ReplayStatus::Succeeded); + // make sure to end any unbalanced replay events if we stopped in the middle of a frame for(int i = 0; i < m_ReplayEventCount; i++) GLMarkerRegion::End(); diff --git a/renderdoc/driver/gl/gl_driver.h b/renderdoc/driver/gl/gl_driver.h index f95a8bfc4..2082131a6 100644 --- a/renderdoc/driver/gl/gl_driver.h +++ b/renderdoc/driver/gl/gl_driver.h @@ -211,6 +211,8 @@ private: uint32_t m_FirstEventID; uint32_t m_LastEventID; + ReplayStatus m_FailedReplayStatus = ReplayStatus::APIReplayFailed; + DrawcallDescription m_ParentDrawcall; list m_DrawcallStack; @@ -339,16 +341,16 @@ private: ResourceId m_FakeVAOID; - void ProcessChunk(ReadSerialiser &ser, GLChunk chunk); - void ContextReplayLog(CaptureState readType, uint32_t startEventID, uint32_t endEventID, - bool partial); - void ContextProcessChunk(ReadSerialiser &ser, GLChunk chunk); + bool ProcessChunk(ReadSerialiser &ser, GLChunk chunk); + ReplayStatus ContextReplayLog(CaptureState readType, uint32_t startEventID, uint32_t endEventID, + bool partial); + bool ContextProcessChunk(ReadSerialiser &ser, GLChunk chunk); void AddUsage(const DrawcallDescription &d); void AddDrawcall(const DrawcallDescription &d, bool hasEvents); void AddEvent(); template - void Serialise_CaptureScope(SerialiserType &ser); + bool Serialise_CaptureScope(SerialiserType &ser); bool HasSuccessfulCapture(CaptureFailReason &reason) { diff --git a/renderdoc/driver/gl/gl_initstate.cpp b/renderdoc/driver/gl/gl_initstate.cpp index 2dfea80df..3947ce2d4 100644 --- a/renderdoc/driver/gl/gl_initstate.cpp +++ b/renderdoc/driver/gl/gl_initstate.cpp @@ -1147,13 +1147,20 @@ bool GLResourceManager::Serialise_InitialState(SerialiserType &ser, ResourceId r if(IsReplayingAndReading()) { - gl.glGenBuffers(1, &res.name); - gl.glBindBuffer(eGL_COPY_WRITE_BUFFER, res.name); - gl.glNamedBufferDataEXT(res.name, (GLsizeiptr)BufferContentsSize, NULL, eGL_STATIC_DRAW); - BufferContents = (byte *)gl.glMapNamedBufferEXT(res.name, eGL_WRITE_ONLY); + if(!ser.IsErrored()) + { + gl.glGenBuffers(1, &res.name); + gl.glBindBuffer(eGL_COPY_WRITE_BUFFER, res.name); + gl.glNamedBufferDataEXT(res.name, (GLsizeiptr)BufferContentsSize, NULL, eGL_STATIC_DRAW); + BufferContents = (byte *)gl.glMapNamedBufferEXT(res.name, eGL_WRITE_ONLY); - SetInitialContents(Id, InitialContentData(res.Namespace, BufferRes(m_GL->GetCtx(), res.name), - BufferContentsSize, NULL)); + SetInitialContents(Id, InitialContentData(res.Namespace, BufferRes(m_GL->GetCtx(), res.name), + BufferContentsSize, NULL)); + } + else + { + res = GLResource(MakeNullResource); + } } // not using SERIALISE_ELEMENT_ARRAY so we can deliberately avoid allocation - we serialise @@ -1162,6 +1169,8 @@ bool GLResourceManager::Serialise_InitialState(SerialiserType &ser, ResourceId r if(res.name) gl.glUnmapNamedBufferEXT(res.name); + + SERIALISE_CHECK_READ_ERRORS(); } else if(Type == eResProgram) { @@ -1283,11 +1292,13 @@ bool GLResourceManager::Serialise_InitialState(SerialiserType &ser, ResourceId r SerialiseProgramBindings(ser, m_State, gl, bindingsProgram); // re-link the program to set the new attrib bindings - if(IsReplayingAndReading()) + if(IsReplayingAndReading() && !ser.IsErrored()) gl.glLinkProgram(bindingsProgram); SerialiseProgramUniforms(ser, m_State, gl, uniformsProgram, translationTable); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { // see above for why we're copying this back @@ -1333,14 +1344,14 @@ bool GLResourceManager::Serialise_InitialState(SerialiserType &ser, ResourceId r // only continue with serialising the contents if the format is valid (storage allocated). // Otherwise this texture has no initial state to apply - if(TextureState.internalformat != eGL_NONE) + if(TextureState.internalformat != eGL_NONE && !ser.IsErrored()) { WrappedOpenGL::TextureData &details = m_GL->m_Textures[GetID(res)]; TextureStateInitialData *state = NULL; // on replay we need the state as an initial contents blob, so copy it off - if(IsReplayingAndReading()) + if(IsReplayingAndReading() && !ser.IsErrored()) { state = (TextureStateInitialData *)AllocAlignedBuffer(sizeof(TextureStateInitialData)); memcpy(state, &TextureState, sizeof(TextureStateInitialData)); @@ -1351,7 +1362,7 @@ bool GLResourceManager::Serialise_InitialState(SerialiserType &ser, ResourceId r // no contents to copy for texture buffer (it's copied under the buffer) // same applies for texture views, their data is copies under the aliased texture. // We just set the metadata blob. - if(IsReplayingAndReading()) + if(IsReplayingAndReading() && !ser.IsErrored()) { SetInitialContents( Id, InitialContentData(res.Namespace, GLResource(MakeNullResource), 0, (byte *)state)); @@ -1382,7 +1393,7 @@ bool GLResourceManager::Serialise_InitialState(SerialiserType &ser, ResourceId r // For real textures, if number of mips isn't sufficient, make sure to initialise the lower // levels. This could happen if e.g. a texture is init'd with glTexImage(level = 0), then // after we stop tracking it glGenerateMipmap is called. - if(IsReplayingAndReading()) + if(IsReplayingAndReading() && !ser.IsErrored()) { // this is only relevant for non-immutable textures GLint immut = 0; @@ -1470,11 +1481,11 @@ bool GLResourceManager::Serialise_InitialState(SerialiserType &ser, ResourceId r GLuint prevtex = 0; // push the texture binding - if(!IsStructuredExporting(m_State)) + if(!IsStructuredExporting(m_State) && !ser.IsErrored()) gl.glGetIntegerv(TextureBinding(TextureState.type), (GLint *)&prevtex); // create texture of identical format/size as the live resource to store initial contents - if(IsReplayingAndReading()) + if(IsReplayingAndReading() && !ser.IsErrored()) { gl.glGenTextures(1, &tex); gl.glBindTexture(TextureState.type, tex); @@ -1566,7 +1577,7 @@ bool GLResourceManager::Serialise_InitialState(SerialiserType &ser, ResourceId r ser.Serialise("SubresourceContents", scratchBuf, size, SerialiserFlags::NoFlags); // on replay, restore the data into the initial contents texture - if(IsReplayingAndReading()) + if(IsReplayingAndReading() && !ser.IsErrored()) { if(isCompressed) { @@ -1609,10 +1620,10 @@ bool GLResourceManager::Serialise_InitialState(SerialiserType &ser, ResourceId r } // restore the previous texture binding - if(!IsStructuredExporting(m_State)) + if(!IsStructuredExporting(m_State) && !ser.IsErrored()) gl.glBindTexture(TextureState.type, prevtex); - if(IsReplayingAndReading()) + if(IsReplayingAndReading() && !ser.IsErrored()) { SetInitialContents(Id, InitialContentData(res.Namespace, TextureRes(m_GL->GetCtx(), tex), 0, (byte *)state)); @@ -1628,6 +1639,8 @@ bool GLResourceManager::Serialise_InitialState(SerialiserType &ser, ResourceId r pack.Apply(&gl, false); unpack.Apply(&gl, false); } + + SERIALISE_CHECK_READ_ERRORS(); } else if(Type == eResFramebuffer) { @@ -1641,6 +1654,8 @@ bool GLResourceManager::Serialise_InitialState(SerialiserType &ser, ResourceId r SERIALISE_ELEMENT(FramebufferState); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { byte *blob = AllocAlignedBuffer(sizeof(FramebufferState)); @@ -1662,6 +1677,8 @@ bool GLResourceManager::Serialise_InitialState(SerialiserType &ser, ResourceId r SERIALISE_ELEMENT(TransformFeedbackState); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { byte *blob = AllocAlignedBuffer(sizeof(TransformFeedbackState)); @@ -1683,6 +1700,8 @@ bool GLResourceManager::Serialise_InitialState(SerialiserType &ser, ResourceId r SERIALISE_ELEMENT(ProgramPipelineState); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { byte *blob = AllocAlignedBuffer(sizeof(ProgramPipelineState)); @@ -1704,6 +1723,8 @@ bool GLResourceManager::Serialise_InitialState(SerialiserType &ser, ResourceId r SERIALISE_ELEMENT(VAOState); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { byte *blob = AllocAlignedBuffer(sizeof(VAOState)); diff --git a/renderdoc/driver/gl/wrappers/gl_buffer_funcs.cpp b/renderdoc/driver/gl/wrappers/gl_buffer_funcs.cpp index 535a552b9..f41ffc007 100644 --- a/renderdoc/driver/gl/wrappers/gl_buffer_funcs.cpp +++ b/renderdoc/driver/gl/wrappers/gl_buffer_funcs.cpp @@ -60,6 +60,8 @@ bool WrappedOpenGL::Serialise_glGenBuffers(SerialiserType &ser, GLsizei n, GLuin { SERIALISE_ELEMENT_LOCAL(buffer, GetResourceManager()->GetID(BufferRes(GetCtx(), *buffers))); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { GLuint real = 0; @@ -121,6 +123,8 @@ bool WrappedOpenGL::Serialise_glCreateBuffers(SerialiserType &ser, GLsizei n, GL { SERIALISE_ELEMENT_LOCAL(buffer, GetResourceManager()->GetID(BufferRes(GetCtx(), *buffers))); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { GLuint real = 0; @@ -183,6 +187,8 @@ bool WrappedOpenGL::Serialise_glBindBuffer(SerialiserType &ser, GLenum target, G SERIALISE_ELEMENT(target); SERIALISE_ELEMENT_LOCAL(buffer, BufferRes(GetCtx(), bufferHandle)); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(target == eGL_NONE) @@ -375,6 +381,8 @@ bool WrappedOpenGL::Serialise_glNamedBufferStorageEXT(SerialiserType &ser, GLuin uint64_t bytesize = (uint64_t)size; SERIALISE_ELEMENT_ARRAY(data, bytesize); + SERIALISE_CHECK_READ_ERRORS(); + if(ser.IsWriting()) { uint64_t offs = ser.GetWriter()->GetOffset() - bytesize; @@ -517,6 +525,8 @@ bool WrappedOpenGL::Serialise_glNamedBufferDataEXT(SerialiserType &ser, GLuint b SERIALISE_ELEMENT_ARRAY(data, bytesize); + SERIALISE_CHECK_READ_ERRORS(); + if(ser.IsWriting()) { uint64_t offs = ser.GetWriter()->GetOffset() - bytesize; @@ -826,6 +836,8 @@ bool WrappedOpenGL::Serialise_glNamedBufferSubDataEXT(SerialiserType &ser, GLuin uint64_t bytesize = (uint64_t)size; SERIALISE_ELEMENT_ARRAY(data, bytesize); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Real.glNamedBufferSubDataEXT(buffer.name, (GLintptr)offset, (GLsizeiptr)bytesize, data); @@ -944,6 +956,8 @@ bool WrappedOpenGL::Serialise_glNamedCopyBufferSubDataEXT(SerialiserType &ser, SERIALISE_ELEMENT_LOCAL(writeOffset, (uint64_t)writeOffsetPtr); SERIALISE_ELEMENT_LOCAL(size, (uint64_t)sizePtr); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Real.glNamedCopyBufferSubDataEXT(readBuffer.name, writeBuffer.name, (GLintptr)readOffset, @@ -1079,6 +1093,8 @@ bool WrappedOpenGL::Serialise_glBindBufferBase(SerialiserType &ser, GLenum targe SERIALISE_ELEMENT(index); SERIALISE_ELEMENT_LOCAL(buffer, BufferRes(GetCtx(), bufferHandle)); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Real.glBindBufferBase(target, index, buffer.name); @@ -1186,6 +1202,8 @@ bool WrappedOpenGL::Serialise_glBindBufferRange(SerialiserType &ser, GLenum targ SERIALISE_ELEMENT_LOCAL(offset, (uint64_t)offsetPtr); SERIALISE_ELEMENT_LOCAL(size, (uint64_t)sizePtr); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Real.glBindBufferRange(target, index, buffer.name, (GLintptr)offset, (GLsizeiptr)size); @@ -1303,6 +1321,8 @@ bool WrappedOpenGL::Serialise_glBindBuffersBase(SerialiserType &ser, GLenum targ SERIALISE_ELEMENT(buffers); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { std::vector bufs; @@ -1464,6 +1484,8 @@ bool WrappedOpenGL::Serialise_glBindBuffersRange(SerialiserType &ser, GLenum tar SERIALISE_ELEMENT(offsets); SERIALISE_ELEMENT(sizes); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { std::vector bufs; @@ -2213,6 +2235,8 @@ bool WrappedOpenGL::Serialise_glUnmapNamedBufferEXT(SerialiserType &ser, GLuint SERIALISE_ELEMENT_ARRAY(MapWrittenData, length); + SERIALISE_CHECK_READ_ERRORS(); + if(!IsStructuredExporting(m_State) && diffEnd > diffStart) { if(record && record->Map.persistentPtr) @@ -2414,6 +2438,8 @@ bool WrappedOpenGL::Serialise_glFlushMappedNamedBufferRangeEXT(SerialiserType &s SERIALISE_ELEMENT_ARRAY(FlushedData, length); + SERIALISE_CHECK_READ_ERRORS(); + if(record && record->Map.persistentPtr) { // if we have a persistent mapped pointer, copy the range into the 'real' memory and @@ -2586,6 +2612,8 @@ bool WrappedOpenGL::Serialise_glGenTransformFeedbacks(SerialiserType &ser, GLsiz { SERIALISE_ELEMENT_LOCAL(feedback, GetResourceManager()->GetID(FeedbackRes(GetCtx(), *ids))); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { GLuint real = 0; @@ -2642,6 +2670,8 @@ bool WrappedOpenGL::Serialise_glCreateTransformFeedbacks(SerialiserType &ser, GL { SERIALISE_ELEMENT_LOCAL(feedback, GetResourceManager()->GetID(FeedbackRes(GetCtx(), *ids))); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { GLuint real = 0; @@ -2716,6 +2746,8 @@ bool WrappedOpenGL::Serialise_glTransformFeedbackBufferBase(SerialiserType &ser, SERIALISE_ELEMENT(index); SERIALISE_ELEMENT_LOCAL(buffer, BufferRes(GetCtx(), bufferHandle)); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { // use ARB_direct_state_access functions here as we use EXT_direct_state_access elsewhere. If @@ -2768,6 +2800,8 @@ bool WrappedOpenGL::Serialise_glTransformFeedbackBufferRange(SerialiserType &ser SERIALISE_ELEMENT_LOCAL(offset, (uint64_t)offsetPtr); SERIALISE_ELEMENT_LOCAL(size, (uint64_t)sizePtr); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { // use ARB_direct_state_access functions here as we use EXT_direct_state_access elsewhere. If @@ -2818,6 +2852,8 @@ bool WrappedOpenGL::Serialise_glBindTransformFeedback(SerialiserType &ser, GLenu SERIALISE_ELEMENT(target); SERIALISE_ELEMENT_LOCAL(xfb, FeedbackRes(GetCtx(), xfbHandle)); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Real.glBindTransformFeedback(target, xfb.name); @@ -2863,6 +2899,8 @@ bool WrappedOpenGL::Serialise_glBeginTransformFeedback(SerialiserType &ser, GLen { SERIALISE_ELEMENT(primitiveMode); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Real.glBeginTransformFeedback(primitiveMode); @@ -2990,6 +3028,8 @@ bool WrappedOpenGL::Serialise_glVertexArrayVertexAttribOffsetEXT( SERIALISE_ELEMENT(stride); SERIALISE_ELEMENT_LOCAL(offset, (uint64_t)offsetPtr); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(vaobj.name == 0) @@ -3114,6 +3154,8 @@ bool WrappedOpenGL::Serialise_glVertexArrayVertexAttribIOffsetEXT(SerialiserType SERIALISE_ELEMENT(stride); SERIALISE_ELEMENT_LOCAL(offset, (uint64_t)offsetPtr); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(vaobj.name == 0) @@ -3237,6 +3279,8 @@ bool WrappedOpenGL::Serialise_glVertexArrayVertexAttribLOffsetEXT(SerialiserType SERIALISE_ELEMENT(stride); SERIALISE_ELEMENT_LOCAL(offset, (uint64_t)offsetPtr); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(vaobj.name == 0) @@ -3355,6 +3399,8 @@ bool WrappedOpenGL::Serialise_glVertexArrayVertexAttribBindingEXT(SerialiserType SERIALISE_ELEMENT(attribindex); SERIALISE_ELEMENT(bindingindex); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(vaobj.name == 0) @@ -3438,6 +3484,8 @@ bool WrappedOpenGL::Serialise_glVertexArrayVertexAttribFormatEXT(SerialiserType SERIALISE_ELEMENT_TYPED(bool, normalized); SERIALISE_ELEMENT(relativeoffset); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(vaobj.name == 0) @@ -3526,6 +3574,8 @@ bool WrappedOpenGL::Serialise_glVertexArrayVertexAttribIFormatEXT(SerialiserType SERIALISE_ELEMENT(type); SERIALISE_ELEMENT(relativeoffset); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(vaobj.name == 0) @@ -3610,6 +3660,8 @@ bool WrappedOpenGL::Serialise_glVertexArrayVertexAttribLFormatEXT(SerialiserType SERIALISE_ELEMENT(type); SERIALISE_ELEMENT(relativeoffset); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(vaobj.name == 0) @@ -3691,6 +3743,8 @@ bool WrappedOpenGL::Serialise_glVertexArrayVertexAttribDivisorEXT(SerialiserType SERIALISE_ELEMENT(index); SERIALISE_ELEMENT(divisor); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(vaobj.name == 0) @@ -3779,6 +3833,8 @@ bool WrappedOpenGL::Serialise_glEnableVertexArrayAttribEXT(SerialiserType &ser, SERIALISE_ELEMENT_LOCAL(vaobj, VertexArrayRes(GetCtx(), vaobjHandle)); SERIALISE_ELEMENT(index); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(vaobj.name == 0) @@ -3860,6 +3916,8 @@ bool WrappedOpenGL::Serialise_glDisableVertexArrayAttribEXT(SerialiserType &ser, SERIALISE_ELEMENT_LOCAL(vaobj, VertexArrayRes(GetCtx(), vaobjHandle)); SERIALISE_ELEMENT(index); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(vaobj.name == 0) @@ -3939,6 +3997,8 @@ bool WrappedOpenGL::Serialise_glGenVertexArrays(SerialiserType &ser, GLsizei n, { SERIALISE_ELEMENT_LOCAL(array, GetResourceManager()->GetID(VertexArrayRes(GetCtx(), *arrays))); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { GLuint real = 0; @@ -3995,6 +4055,8 @@ bool WrappedOpenGL::Serialise_glCreateVertexArrays(SerialiserType &ser, GLsizei { SERIALISE_ELEMENT_LOCAL(array, GetResourceManager()->GetID(VertexArrayRes(GetCtx(), *arrays))); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { GLuint real = 0; @@ -4049,6 +4111,8 @@ bool WrappedOpenGL::Serialise_glBindVertexArray(SerialiserType &ser, GLuint vaob { SERIALISE_ELEMENT_LOCAL(vaobj, VertexArrayRes(GetCtx(), vaobjHandle)); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(vaobj.name == 0) @@ -4098,6 +4162,8 @@ bool WrappedOpenGL::Serialise_glVertexArrayElementBuffer(SerialiserType &ser, GL SERIALISE_ELEMENT_LOCAL(vaobj, VertexArrayRes(GetCtx(), vaobjHandle)); SERIALISE_ELEMENT_LOCAL(buffer, BufferRes(GetCtx(), bufferHandle)); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(vaobj.name == 0) @@ -4167,6 +4233,8 @@ bool WrappedOpenGL::Serialise_glVertexArrayBindVertexBufferEXT(SerialiserType &s SERIALISE_ELEMENT_LOCAL(offset, (uint64_t)offsetPtr); SERIALISE_ELEMENT(stride); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(vaobj.name == 0) @@ -4286,6 +4354,8 @@ bool WrappedOpenGL::Serialise_glVertexArrayVertexBuffers(SerialiserType &ser, GL SERIALISE_ELEMENT_ARRAY(strides, (uint32_t &)count); SERIALISE_ELEMENT(count); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { std::vector bufs; @@ -4427,6 +4497,8 @@ bool WrappedOpenGL::Serialise_glVertexArrayVertexBindingDivisorEXT(SerialiserTyp SERIALISE_ELEMENT(bindingindex); SERIALISE_ELEMENT(divisor); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(vaobj.name == 0) @@ -4625,6 +4697,8 @@ bool WrappedOpenGL::Serialise_glVertexAttrib(SerialiserType &ser, GLuint index, case Attrib_GLubyte: ser.Serialise("values", v.u8, SerialiserFlags::NoFlags); break; } + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(attr == Attrib_packed) diff --git a/renderdoc/driver/gl/wrappers/gl_debug_funcs.cpp b/renderdoc/driver/gl/wrappers/gl_debug_funcs.cpp index 98df0e70e..34a088f4d 100644 --- a/renderdoc/driver/gl/wrappers/gl_debug_funcs.cpp +++ b/renderdoc/driver/gl/wrappers/gl_debug_funcs.cpp @@ -68,6 +68,8 @@ bool WrappedOpenGL::Serialise_glObjectLabel(SerialiserType &ser, GLenum identifi SERIALISE_ELEMENT(length); SERIALISE_ELEMENT(Label); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading() && Resource.name) { ResourceId origId = GetResourceManager()->GetOriginalID(GetResourceManager()->GetID(Resource)); @@ -156,6 +158,8 @@ bool WrappedOpenGL::Serialise_glDebugMessageInsert(SerialiserType &ser, GLenum s SERIALISE_ELEMENT(severity); SERIALISE_ELEMENT(name); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { GLMarkerRegion::Set(name); @@ -222,6 +226,8 @@ bool WrappedOpenGL::Serialise_glInsertEventMarkerEXT(SerialiserType &ser, GLsize SERIALISE_ELEMENT(marker); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { GLMarkerRegion::Set(marker); @@ -281,6 +287,8 @@ bool WrappedOpenGL::Serialise_glPushDebugGroup(SerialiserType &ser, GLenum sourc SERIALISE_ELEMENT(id); SERIALISE_ELEMENT(name); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { GLMarkerRegion::Begin(name, source, id); diff --git a/renderdoc/driver/gl/wrappers/gl_draw_funcs.cpp b/renderdoc/driver/gl/wrappers/gl_draw_funcs.cpp index 4ce158882..da0c53003 100644 --- a/renderdoc/driver/gl/wrappers/gl_draw_funcs.cpp +++ b/renderdoc/driver/gl/wrappers/gl_draw_funcs.cpp @@ -76,6 +76,8 @@ bool WrappedOpenGL::Serialise_glDispatchCompute(SerialiserType &ser, GLuint num_ Serialise_DebugMessages(ser); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Real.glDispatchCompute(num_groups_x, num_groups_y, num_groups_z); @@ -157,6 +159,8 @@ bool WrappedOpenGL::Serialise_glDispatchComputeGroupSizeARB(SerialiserType &ser, Serialise_DebugMessages(ser); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Real.glDispatchComputeGroupSizeARB(num_groups_x, num_groups_y, num_groups_z, group_size_x, @@ -255,6 +259,8 @@ bool WrappedOpenGL::Serialise_glDispatchComputeIndirect(SerialiserType &ser, GLi Serialise_DebugMessages(ser); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Real.glDispatchComputeIndirect((GLintptr)offset); @@ -320,6 +326,8 @@ bool WrappedOpenGL::Serialise_glMemoryBarrier(SerialiserType &ser, GLbitfield ba { SERIALISE_ELEMENT_TYPED(GLbarrierbitfield, barriers); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Real.glMemoryBarrier(barriers); @@ -354,6 +362,8 @@ bool WrappedOpenGL::Serialise_glMemoryBarrierByRegion(SerialiserType &ser, GLbit { SERIALISE_ELEMENT_TYPED(GLbarrierbitfield, barriers); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Real.glMemoryBarrierByRegion(barriers); @@ -419,6 +429,8 @@ bool WrappedOpenGL::Serialise_glDrawTransformFeedback(SerialiserType &ser, GLenu Serialise_DebugMessages(ser); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Real.glDrawTransformFeedback(mode, xfb.name); @@ -486,6 +498,8 @@ bool WrappedOpenGL::Serialise_glDrawTransformFeedbackInstanced(SerialiserType &s Serialise_DebugMessages(ser); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Real.glDrawTransformFeedbackInstanced(mode, xfb.name, instancecount); @@ -552,6 +566,8 @@ bool WrappedOpenGL::Serialise_glDrawTransformFeedbackStream(SerialiserType &ser, Serialise_DebugMessages(ser); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Real.glDrawTransformFeedbackStream(mode, xfb.name, stream); @@ -620,6 +636,8 @@ bool WrappedOpenGL::Serialise_glDrawTransformFeedbackStreamInstanced(SerialiserT Serialise_DebugMessages(ser); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Real.glDrawTransformFeedbackStreamInstanced(mode, xfb.name, stream, instancecount); @@ -689,6 +707,8 @@ bool WrappedOpenGL::Serialise_glDrawArrays(SerialiserType &ser, GLenum mode, GLi Serialise_DebugMessages(ser); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Real.glDrawArrays(mode, first, count); @@ -919,6 +939,8 @@ bool WrappedOpenGL::Serialise_glDrawArraysIndirect(SerialiserType &ser, GLenum m Serialise_DebugMessages(ser); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Real.glDrawArraysIndirect(mode, (const void *)offset); @@ -993,6 +1015,8 @@ bool WrappedOpenGL::Serialise_glDrawArraysInstanced(SerialiserType &ser, GLenum Serialise_DebugMessages(ser); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Real.glDrawArraysInstanced(mode, first, count, instancecount); @@ -1067,6 +1091,8 @@ bool WrappedOpenGL::Serialise_glDrawArraysInstancedBaseInstance(SerialiserType & Serialise_DebugMessages(ser); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Real.glDrawArraysInstancedBaseInstance(mode, first, count, instancecount, baseinstance); @@ -1153,6 +1179,8 @@ bool WrappedOpenGL::Serialise_glDrawElements(SerialiserType &ser, GLenum mode, G Serialise_DebugMessages(ser); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(Check_preElements()) @@ -1225,6 +1253,8 @@ bool WrappedOpenGL::Serialise_glDrawElementsIndirect(SerialiserType &ser, GLenum Serialise_DebugMessages(ser); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Real.glDrawElementsIndirect(mode, type, (const void *)offset); @@ -1307,6 +1337,8 @@ bool WrappedOpenGL::Serialise_glDrawRangeElements(SerialiserType &ser, GLenum mo Serialise_DebugMessages(ser); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(Check_preElements()) @@ -1386,6 +1418,8 @@ bool WrappedOpenGL::Serialise_glDrawRangeElementsBaseVertex(SerialiserType &ser, Serialise_DebugMessages(ser); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(Check_preElements()) @@ -1464,6 +1498,8 @@ bool WrappedOpenGL::Serialise_glDrawElementsBaseVertex(SerialiserType &ser, GLen Serialise_DebugMessages(ser); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(Check_preElements()) @@ -1540,6 +1576,8 @@ bool WrappedOpenGL::Serialise_glDrawElementsInstanced(SerialiserType &ser, GLenu Serialise_DebugMessages(ser); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(Check_preElements()) @@ -1619,6 +1657,8 @@ bool WrappedOpenGL::Serialise_glDrawElementsInstancedBaseInstance(SerialiserType Serialise_DebugMessages(ser); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(Check_preElements()) @@ -1701,6 +1741,8 @@ bool WrappedOpenGL::Serialise_glDrawElementsInstancedBaseVertex(SerialiserType & Serialise_DebugMessages(ser); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(Check_preElements()) @@ -1782,6 +1824,8 @@ bool WrappedOpenGL::Serialise_glDrawElementsInstancedBaseVertexBaseInstance( Serialise_DebugMessages(ser); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(Check_preElements()) @@ -1862,6 +1906,8 @@ bool WrappedOpenGL::Serialise_glMultiDrawArrays(SerialiserType &ser, GLenum mode Serialise_DebugMessages(ser); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(IsLoading(m_State)) @@ -1997,6 +2043,8 @@ bool WrappedOpenGL::Serialise_glMultiDrawElements(SerialiserType &ser, GLenum mo Serialise_DebugMessages(ser); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { std::vector inds; @@ -2148,6 +2196,8 @@ bool WrappedOpenGL::Serialise_glMultiDrawElementsBaseVertex(SerialiserType &ser, Serialise_DebugMessages(ser); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { std::vector inds; @@ -2289,6 +2339,8 @@ bool WrappedOpenGL::Serialise_glMultiDrawArraysIndirect(SerialiserType &ser, GLe Serialise_DebugMessages(ser); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(IsLoading(m_State)) @@ -2449,6 +2501,8 @@ bool WrappedOpenGL::Serialise_glMultiDrawElementsIndirect(SerialiserType &ser, G Serialise_DebugMessages(ser); + SERIALISE_CHECK_READ_ERRORS(); + uint32_t IdxSize = GetIdxSize(type); if(IsReplayingAndReading()) @@ -2620,6 +2674,8 @@ bool WrappedOpenGL::Serialise_glMultiDrawArraysIndirectCountARB(SerialiserType & Serialise_DebugMessages(ser); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { GLsizei realdrawcount = 0; @@ -2792,6 +2848,8 @@ bool WrappedOpenGL::Serialise_glMultiDrawElementsIndirectCountARB(SerialiserType Serialise_DebugMessages(ser); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { uint32_t IdxSize = GetIdxSize(type); @@ -2984,6 +3042,8 @@ bool WrappedOpenGL::Serialise_glClearNamedFramebufferfv(SerialiserType &ser, ser.Serialise("value", value); } + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(framebuffer.name == 0) @@ -3239,6 +3299,8 @@ bool WrappedOpenGL::Serialise_glClearNamedFramebufferuiv(SerialiserType &ser, Serialise_DebugMessages(ser); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(framebuffer.name == 0) @@ -3341,6 +3403,8 @@ bool WrappedOpenGL::Serialise_glClearNamedFramebufferfi(SerialiserType &ser, GLu Serialise_DebugMessages(ser); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(framebuffer.name == 0) @@ -3518,6 +3582,8 @@ bool WrappedOpenGL::Serialise_glClearNamedBufferDataEXT(SerialiserType &ser, GLu SERIALISE_ELEMENT(data); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Real.glClearNamedBufferDataEXT(buffer.name, internalformat, format, type, @@ -3655,6 +3721,8 @@ bool WrappedOpenGL::Serialise_glClearNamedBufferSubDataEXT(SerialiserType &ser, SERIALISE_ELEMENT(data); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Real.glClearNamedBufferSubDataEXT(buffer.name, internalformat, (GLintptr)offset, @@ -3739,6 +3807,8 @@ bool WrappedOpenGL::Serialise_glClear(SerialiserType &ser, GLbitfield mask) Serialise_DebugMessages(ser); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Real.glClear(mask); @@ -3949,6 +4019,8 @@ bool WrappedOpenGL::Serialise_glClearTexImage(SerialiserType &ser, GLuint textur SERIALISE_ELEMENT(data); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Real.glClearTexImage(texture.name, level, format, type, (const void *)&data[0]); @@ -4057,6 +4129,8 @@ bool WrappedOpenGL::Serialise_glClearTexSubImage(SerialiserType &ser, GLuint tex SERIALISE_ELEMENT(data); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Real.glClearTexSubImage(texture.name, level, xoffset, yoffset, zoffset, width, height, depth, diff --git a/renderdoc/driver/gl/wrappers/gl_framebuffer_funcs.cpp b/renderdoc/driver/gl/wrappers/gl_framebuffer_funcs.cpp index 8f5f31e24..7867871bd 100644 --- a/renderdoc/driver/gl/wrappers/gl_framebuffer_funcs.cpp +++ b/renderdoc/driver/gl/wrappers/gl_framebuffer_funcs.cpp @@ -33,6 +33,8 @@ bool WrappedOpenGL::Serialise_glGenFramebuffers(SerialiserType &ser, GLsizei n, SERIALISE_ELEMENT_LOCAL(framebuffer, GetResourceManager()->GetID(FramebufferRes(GetCtx(), *framebuffers))); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { GLuint real = 0; @@ -91,6 +93,8 @@ bool WrappedOpenGL::Serialise_glCreateFramebuffers(SerialiserType &ser, GLsizei SERIALISE_ELEMENT_LOCAL(framebuffer, GetResourceManager()->GetID(FramebufferRes(GetCtx(), *framebuffers))); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { GLuint real = 0; @@ -151,6 +155,8 @@ bool WrappedOpenGL::Serialise_glNamedFramebufferTextureEXT(SerialiserType &ser, SERIALISE_ELEMENT_LOCAL(texture, TextureRes(GetCtx(), textureHandle)); SERIALISE_ELEMENT(level); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(framebuffer.name == 0) @@ -290,6 +296,8 @@ bool WrappedOpenGL::Serialise_glNamedFramebufferTexture1DEXT(SerialiserType &ser SERIALISE_ELEMENT_LOCAL(texture, TextureRes(GetCtx(), textureHandle)); SERIALISE_ELEMENT(level); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(framebuffer.name == 0) @@ -432,6 +440,8 @@ bool WrappedOpenGL::Serialise_glNamedFramebufferTexture2DEXT(SerialiserType &ser SERIALISE_ELEMENT_LOCAL(texture, TextureRes(GetCtx(), textureHandle)); SERIALISE_ELEMENT(level); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(framebuffer.name == 0) @@ -575,6 +585,8 @@ bool WrappedOpenGL::Serialise_glFramebufferTexture2DMultisampleEXT( SERIALISE_ELEMENT(level); SERIALISE_ELEMENT(samples); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { GLuint prevread = 0, prevdraw = 0; @@ -677,6 +689,8 @@ bool WrappedOpenGL::Serialise_glNamedFramebufferTexture3DEXT(SerialiserType &ser SERIALISE_ELEMENT(level); SERIALISE_ELEMENT(zoffset); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(framebuffer.name == 0) @@ -821,6 +835,8 @@ bool WrappedOpenGL::Serialise_glNamedFramebufferRenderbufferEXT(SerialiserType & SERIALISE_ELEMENT(renderbuffertarget); SERIALISE_ELEMENT_LOCAL(renderbuffer, RenderbufferRes(GetCtx(), renderbufferHandle)); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(framebuffer.name == 0) @@ -946,6 +962,8 @@ bool WrappedOpenGL::Serialise_glNamedFramebufferTextureLayerEXT(SerialiserType & SERIALISE_ELEMENT(level); SERIALISE_ELEMENT(layer); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(framebuffer.name == 0) @@ -1089,6 +1107,8 @@ bool WrappedOpenGL::Serialise_glFramebufferTextureMultiviewOVR(SerialiserType &s SERIALISE_ELEMENT(baseViewIndex); SERIALISE_ELEMENT(numViews); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Real.glFramebufferTextureMultiviewOVR(target, attachment, texture.name, level, baseViewIndex, @@ -1282,6 +1302,8 @@ bool WrappedOpenGL::Serialise_glNamedFramebufferParameteriEXT(SerialiserType &se SERIALISE_ELEMENT(pname); SERIALISE_ELEMENT(param); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(framebuffer.name) @@ -1345,6 +1367,8 @@ bool WrappedOpenGL::Serialise_glFramebufferReadBufferEXT(SerialiserType &ser, SERIALISE_ELEMENT_LOCAL(framebuffer, FramebufferRes(GetCtx(), framebufferHandle)); SERIALISE_ELEMENT(mode); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(framebuffer.name == 0) @@ -1424,6 +1448,8 @@ bool WrappedOpenGL::Serialise_glBindFramebuffer(SerialiserType &ser, GLenum targ SERIALISE_ELEMENT(target); SERIALISE_ELEMENT_LOCAL(framebuffer, FramebufferRes(GetCtx(), framebufferHandle)); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Real.glBindFramebuffer(target, framebuffer.name ? framebuffer.name : m_FakeBB_FBO); @@ -1465,6 +1491,8 @@ bool WrappedOpenGL::Serialise_glFramebufferDrawBufferEXT(SerialiserType &ser, SERIALISE_ELEMENT_LOCAL(framebuffer, FramebufferRes(GetCtx(), framebufferHandle)); SERIALISE_ELEMENT(buf); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(framebuffer.name == 0) @@ -1545,6 +1573,8 @@ bool WrappedOpenGL::Serialise_glFramebufferDrawBuffersEXT(SerialiserType &ser, SERIALISE_ELEMENT_LOCAL(framebuffer, FramebufferRes(GetCtx(), framebufferHandle)); SERIALISE_ELEMENT_ARRAY(bufs, (uint32_t &)n); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { GLenum *buffers = (GLenum *)bufs; @@ -1755,6 +1785,8 @@ bool WrappedOpenGL::Serialise_glBlitNamedFramebuffer(SerialiserType &ser, SERIALISE_ELEMENT(mask); SERIALISE_ELEMENT(filter); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(readFramebuffer.name == 0) @@ -1953,6 +1985,8 @@ bool WrappedOpenGL::Serialise_glGenRenderbuffers(SerialiserType &ser, GLsizei n, SERIALISE_ELEMENT_LOCAL(renderbuffer, GetResourceManager()->GetID(RenderbufferRes(GetCtx(), *renderbuffers))); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { GLuint real = 0; @@ -2013,6 +2047,8 @@ bool WrappedOpenGL::Serialise_glCreateRenderbuffers(SerialiserType &ser, GLsizei SERIALISE_ELEMENT_LOCAL(renderbuffer, GetResourceManager()->GetID(RenderbufferRes(GetCtx(), *renderbuffers))); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { GLuint real = 0; @@ -2104,6 +2140,8 @@ bool WrappedOpenGL::Serialise_glNamedRenderbufferStorageEXT(SerialiserType &ser, SERIALISE_ELEMENT(width); SERIALISE_ELEMENT(height); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { ResourceId liveId = GetResourceManager()->GetID(renderbuffer); @@ -2237,6 +2275,8 @@ bool WrappedOpenGL::Serialise_glNamedRenderbufferStorageMultisampleEXT(Serialise SERIALISE_ELEMENT(width); SERIALISE_ELEMENT(height); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { ResourceId liveId = GetResourceManager()->GetID(renderbuffer); diff --git a/renderdoc/driver/gl/wrappers/gl_interop_funcs.cpp b/renderdoc/driver/gl/wrappers/gl_interop_funcs.cpp index aae0c2a6d..52ecbf942 100644 --- a/renderdoc/driver/gl/wrappers/gl_interop_funcs.cpp +++ b/renderdoc/driver/gl/wrappers/gl_interop_funcs.cpp @@ -276,6 +276,8 @@ bool WrappedOpenGL::Serialise_wglDXRegisterObjectNV(SerialiserType &ser, GLResou SERIALISE_ELEMENT(layers); SERIALISE_ELEMENT(samples); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { GLuint name = Resource.name; @@ -377,6 +379,8 @@ bool WrappedOpenGL::Serialise_wglDXLockObjectsNV(SerialiserType &ser, GLResource SERIALISE_ELEMENT_ARRAY(Contents, length); + SERIALISE_CHECK_READ_ERRORS(); + // restore on replay if(IsReplayingAndReading()) { @@ -483,7 +487,7 @@ bool WrappedOpenGL::Serialise_wglDXLockObjectsNV(SerialiserType &ser, GLResource // serialise without allocating memory as we already have our scratch buf sized. ser.Serialise("SubresourceContents", scratchBuf, size, SerialiserFlags::NoFlags); - if(IsReplayingAndReading()) + if(IsReplayingAndReading() && !ser.IsErrored()) { if(dim == 1) gl.glTextureSubImage1DEXT(tex, targets[trg], i, 0, w, fmt, type, scratchBuf); @@ -508,6 +512,8 @@ bool WrappedOpenGL::Serialise_wglDXLockObjectsNV(SerialiserType &ser, GLResource if(!IsStructuredExporting(m_State)) gl.glBindTexture(textype, prevtex); + + SERIALISE_CHECK_READ_ERRORS(); } return true; diff --git a/renderdoc/driver/gl/wrappers/gl_query_funcs.cpp b/renderdoc/driver/gl/wrappers/gl_query_funcs.cpp index 347062d70..7013cc690 100644 --- a/renderdoc/driver/gl/wrappers/gl_query_funcs.cpp +++ b/renderdoc/driver/gl/wrappers/gl_query_funcs.cpp @@ -55,6 +55,8 @@ bool WrappedOpenGL::Serialise_glFenceSync(SerialiserType &ser, GLsync real, GLen SERIALISE_ELEMENT_TYPED(GLsyncbitfield, flags); SERIALISE_ELEMENT_LOCAL(sync, GetResourceManager()->GetSyncID(real)); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { real = m_Real.glFenceSync(condition, flags); @@ -113,6 +115,8 @@ bool WrappedOpenGL::Serialise_glClientWaitSync(SerialiserType &ser, GLsync sync_ SERIALISE_ELEMENT_TYPED(GLsyncbitfield, flags); SERIALISE_ELEMENT(timeout); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading() && GetResourceManager()->HasLiveResource(sync)) { GLResource res = GetResourceManager()->GetLiveResource(sync); @@ -146,6 +150,8 @@ bool WrappedOpenGL::Serialise_glWaitSync(SerialiserType &ser, GLsync sync_, GLbi SERIALISE_ELEMENT_TYPED(GLsyncbitfield, flags); SERIALISE_ELEMENT(timeout); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading() && GetResourceManager()->HasLiveResource(sync)) { GLResource res = GetResourceManager()->GetLiveResource(sync); @@ -184,6 +190,8 @@ bool WrappedOpenGL::Serialise_glGenQueries(SerialiserType &ser, GLsizei n, GLuin { SERIALISE_ELEMENT_LOCAL(query, GetResourceManager()->GetID(QueryRes(GetCtx(), *ids))); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { GLuint real = 0; @@ -240,6 +248,8 @@ bool WrappedOpenGL::Serialise_glCreateQueries(SerialiserType &ser, GLenum target SERIALISE_ELEMENT_LOCAL(query, GetResourceManager()->GetID(SamplerRes(GetCtx(), *ids))); SERIALISE_ELEMENT(target); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { GLuint real = 0; @@ -295,6 +305,8 @@ bool WrappedOpenGL::Serialise_glBeginQuery(SerialiserType &ser, GLenum target, G SERIALISE_ELEMENT(target); SERIALISE_ELEMENT_LOCAL(query, QueryRes(GetCtx(), qid)); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { // Queries in the log interfere with the queries from FetchCounters. @@ -334,6 +346,8 @@ bool WrappedOpenGL::Serialise_glBeginQueryIndexed(SerialiserType &ser, GLenum ta SERIALISE_ELEMENT(index); SERIALISE_ELEMENT_LOCAL(query, QueryRes(GetCtx(), qid)); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Real.glBeginQueryIndexed(target, index, query.name); @@ -364,6 +378,8 @@ bool WrappedOpenGL::Serialise_glEndQuery(SerialiserType &ser, GLenum target) { SERIALISE_ELEMENT(target); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { // Queries in the log interfere with the queries from FetchCounters. @@ -398,6 +414,8 @@ bool WrappedOpenGL::Serialise_glEndQueryIndexed(SerialiserType &ser, GLenum targ SERIALISE_ELEMENT(target); SERIALISE_ELEMENT(index); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Real.glEndQueryIndexed(target, index); @@ -428,6 +446,8 @@ bool WrappedOpenGL::Serialise_glBeginConditionalRender(SerialiserType &ser, GLui SERIALISE_ELEMENT_LOCAL(query, QueryRes(GetCtx(), id)); SERIALISE_ELEMENT(mode); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_ActiveConditional = true; @@ -487,6 +507,8 @@ bool WrappedOpenGL::Serialise_glQueryCounter(SerialiserType &ser, GLuint query_, SERIALISE_ELEMENT_LOCAL(query, QueryRes(GetCtx(), query_)); SERIALISE_ELEMENT(target); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) m_Real.glQueryCounter(query.name, target); diff --git a/renderdoc/driver/gl/wrappers/gl_sampler_funcs.cpp b/renderdoc/driver/gl/wrappers/gl_sampler_funcs.cpp index 507e4ce93..5a5eb18b5 100644 --- a/renderdoc/driver/gl/wrappers/gl_sampler_funcs.cpp +++ b/renderdoc/driver/gl/wrappers/gl_sampler_funcs.cpp @@ -37,6 +37,8 @@ bool WrappedOpenGL::Serialise_glGenSamplers(SerialiserType &ser, GLsizei n, GLui { SERIALISE_ELEMENT_LOCAL(sampler, GetResourceManager()->GetID(SamplerRes(GetCtx(), *samplers))); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { GLuint real = 0; @@ -93,6 +95,8 @@ bool WrappedOpenGL::Serialise_glCreateSamplers(SerialiserType &ser, GLsizei n, G { SERIALISE_ELEMENT_LOCAL(sampler, GetResourceManager()->GetID(SamplerRes(GetCtx(), *samplers))); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { GLuint real = 0; @@ -148,6 +152,8 @@ bool WrappedOpenGL::Serialise_glBindSampler(SerialiserType &ser, GLuint unit, GL SERIALISE_ELEMENT(unit); SERIALISE_ELEMENT_LOCAL(sampler, SamplerRes(GetCtx(), samplerHandle)); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) m_Real.glBindSampler(unit, sampler.name); @@ -187,6 +193,8 @@ bool WrappedOpenGL::Serialise_glBindSamplers(SerialiserType &ser, GLuint first, SERIALISE_ELEMENT(count); SERIALISE_ELEMENT(samplers); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { std::vector samps; @@ -239,6 +247,8 @@ bool WrappedOpenGL::Serialise_glSamplerParameteri(SerialiserType &ser, GLuint sa SERIALISE_ELEMENT(param); } + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) m_Real.glSamplerParameteri(sampler.name, pname, param); @@ -280,6 +290,8 @@ bool WrappedOpenGL::Serialise_glSamplerParameterf(SerialiserType &ser, GLuint sa SERIALISE_ELEMENT(pname); SERIALISE_ELEMENT(param); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) m_Real.glSamplerParameterf(sampler.name, pname, param); @@ -321,6 +333,8 @@ bool WrappedOpenGL::Serialise_glSamplerParameteriv(SerialiserType &ser, GLuint s SERIALISE_ELEMENT(pname); SERIALISE_ELEMENT_ARRAY(params, FIXED_COUNT(numParams(pname))); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) m_Real.glSamplerParameteriv(sampler.name, pname, params); @@ -363,6 +377,8 @@ bool WrappedOpenGL::Serialise_glSamplerParameterfv(SerialiserType &ser, GLuint s SERIALISE_ELEMENT(pname); SERIALISE_ELEMENT_ARRAY(params, FIXED_COUNT(numParams(pname))); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) m_Real.glSamplerParameterfv(sampler.name, pname, params); @@ -405,6 +421,8 @@ bool WrappedOpenGL::Serialise_glSamplerParameterIiv(SerialiserType &ser, GLuint SERIALISE_ELEMENT(pname); SERIALISE_ELEMENT_ARRAY(params, FIXED_COUNT(numParams(pname))); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) m_Real.glSamplerParameterIiv(sampler.name, pname, params); @@ -447,6 +465,8 @@ bool WrappedOpenGL::Serialise_glSamplerParameterIuiv(SerialiserType &ser, GLuint SERIALISE_ELEMENT(pname); SERIALISE_ELEMENT_ARRAY(params, FIXED_COUNT(numParams(pname))); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) m_Real.glSamplerParameterIuiv(sampler.name, pname, params); diff --git a/renderdoc/driver/gl/wrappers/gl_shader_funcs.cpp b/renderdoc/driver/gl/wrappers/gl_shader_funcs.cpp index 920c8ad67..b934dec10 100644 --- a/renderdoc/driver/gl/wrappers/gl_shader_funcs.cpp +++ b/renderdoc/driver/gl/wrappers/gl_shader_funcs.cpp @@ -137,6 +137,8 @@ bool WrappedOpenGL::Serialise_glCreateShader(SerialiserType &ser, GLuint shader, SERIALISE_ELEMENT(type); SERIALISE_ELEMENT_LOCAL(Shader, GetResourceManager()->GetID(ShaderRes(GetCtx(), shader))); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { GLuint real = m_Real.glCreateShader(type); @@ -211,6 +213,8 @@ bool WrappedOpenGL::Serialise_glShaderSource(SerialiserType &ser, GLuint shaderH SERIALISE_ELEMENT(sources); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { std::vector strs; @@ -279,6 +283,8 @@ bool WrappedOpenGL::Serialise_glCompileShader(SerialiserType &ser, GLuint shader { SERIALISE_ELEMENT_LOCAL(shader, ShaderRes(GetCtx(), shaderHandle)); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { ResourceId liveId = GetResourceManager()->GetID(shader); @@ -343,6 +349,8 @@ bool WrappedOpenGL::Serialise_glAttachShader(SerialiserType &ser, GLuint program SERIALISE_ELEMENT_LOCAL(program, ProgramRes(GetCtx(), programHandle)); SERIALISE_ELEMENT_LOCAL(shader, ShaderRes(GetCtx(), shaderHandle)); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { ResourceId liveProgId = GetResourceManager()->GetID(program); @@ -398,6 +406,8 @@ bool WrappedOpenGL::Serialise_glDetachShader(SerialiserType &ser, GLuint program SERIALISE_ELEMENT_LOCAL(program, ProgramRes(GetCtx(), programHandle)); SERIALISE_ELEMENT_LOCAL(shader, ShaderRes(GetCtx(), shaderHandle)); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { ResourceId liveProgId = GetResourceManager()->GetID(program); @@ -481,6 +491,8 @@ bool WrappedOpenGL::Serialise_glCreateShaderProgramv(SerialiserType &ser, GLuint SERIALISE_ELEMENT_ARRAY(strings, (uint32_t &)count); SERIALISE_ELEMENT_LOCAL(Program, GetResourceManager()->GetID(ProgramRes(GetCtx(), program))); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { std::vector src; @@ -583,6 +595,8 @@ bool WrappedOpenGL::Serialise_glCreateProgram(SerialiserType &ser, GLuint progra { SERIALISE_ELEMENT_LOCAL(Program, GetResourceManager()->GetID(ProgramRes(GetCtx(), program))); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { GLuint real = m_Real.glCreateProgram(); @@ -644,6 +658,8 @@ bool WrappedOpenGL::Serialise_glLinkProgram(SerialiserType &ser, GLuint programH { SERIALISE_ELEMENT_LOCAL(program, ProgramRes(GetCtx(), programHandle)); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { ResourceId progid = GetResourceManager()->GetID(program); @@ -715,6 +731,8 @@ bool WrappedOpenGL::Serialise_glUniformBlockBinding(SerialiserType &ser, GLuint SERIALISE_ELEMENT(uniformBlockIndex); SERIALISE_ELEMENT(uniformBlockBinding); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Real.glUniformBlockBinding(program.name, uniformBlockIndex, uniformBlockBinding); @@ -753,6 +771,8 @@ bool WrappedOpenGL::Serialise_glShaderStorageBlockBinding(SerialiserType &ser, G SERIALISE_ELEMENT(storageBlockIndex); SERIALISE_ELEMENT(storageBlockBinding); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Real.glShaderStorageBlockBinding(program.name, storageBlockIndex, storageBlockBinding); @@ -790,6 +810,8 @@ bool WrappedOpenGL::Serialise_glBindAttribLocation(SerialiserType &ser, GLuint p SERIALISE_ELEMENT(index); SERIALISE_ELEMENT(name); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Real.glBindAttribLocation(program.name, index, name); @@ -826,6 +848,8 @@ bool WrappedOpenGL::Serialise_glBindFragDataLocation(SerialiserType &ser, GLuint SERIALISE_ELEMENT(color); SERIALISE_ELEMENT(name); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Real.glBindFragDataLocation(program.name, color, name); @@ -861,6 +885,8 @@ bool WrappedOpenGL::Serialise_glUniformSubroutinesuiv(SerialiserType &ser, GLenu SERIALISE_ELEMENT(shadertype); SERIALISE_ELEMENT_ARRAY(indices, (uint32_t &)count); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) m_Real.glUniformSubroutinesuiv(shadertype, count, indices); @@ -891,6 +917,8 @@ bool WrappedOpenGL::Serialise_glBindFragDataLocationIndexed(SerialiserType &ser, SERIALISE_ELEMENT(index); SERIALISE_ELEMENT(name); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Real.glBindFragDataLocationIndexed(program.name, colorNumber, index, name); @@ -930,6 +958,8 @@ bool WrappedOpenGL::Serialise_glTransformFeedbackVaryings(SerialiserType &ser, G SERIALISE_ELEMENT_ARRAY(varyings, (uint32_t &)count); SERIALISE_ELEMENT(bufferMode); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Real.glTransformFeedbackVaryings(program.name, count, varyings, bufferMode); @@ -967,6 +997,8 @@ bool WrappedOpenGL::Serialise_glProgramParameteri(SerialiserType &ser, GLuint pr SERIALISE_ELEMENT(pname); SERIALISE_ELEMENT(value); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Real.glProgramParameteri(program.name, pname, value); @@ -1014,6 +1046,8 @@ bool WrappedOpenGL::Serialise_glUseProgram(SerialiserType &ser, GLuint programHa { SERIALISE_ELEMENT_LOCAL(program, ProgramRes(GetCtx(), programHandle)); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Real.glUseProgram(program.name); @@ -1083,6 +1117,8 @@ bool WrappedOpenGL::Serialise_glUseProgramStages(SerialiserType &ser, GLuint pip SERIALISE_ELEMENT_TYPED(GLshaderbitfield, stages); SERIALISE_ELEMENT_LOCAL(program, ProgramRes(GetCtx(), programHandle)); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(program.name) @@ -1232,6 +1268,8 @@ bool WrappedOpenGL::Serialise_glGenProgramPipelines(SerialiserType &ser, GLsizei SERIALISE_ELEMENT_LOCAL(pipeline, GetResourceManager()->GetID(ProgramPipeRes(GetCtx(), *pipelines))); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { GLuint real = 0; @@ -1290,6 +1328,8 @@ bool WrappedOpenGL::Serialise_glCreateProgramPipelines(SerialiserType &ser, GLsi SERIALISE_ELEMENT_LOCAL(pipeline, GetResourceManager()->GetID(ProgramPipeRes(GetCtx(), *pipelines))); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { GLuint real = 0; @@ -1344,6 +1384,8 @@ bool WrappedOpenGL::Serialise_glBindProgramPipeline(SerialiserType &ser, GLuint { SERIALISE_ELEMENT_LOCAL(pipeline, ProgramPipeRes(GetCtx(), pipelineHandle)); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Real.glBindProgramPipeline(pipeline.name); @@ -1433,6 +1475,8 @@ bool WrappedOpenGL::Serialise_glCompileShaderIncludeARB(SerialiserType &ser, GLu SERIALISE_ELEMENT_ARRAY(length, (uint32_t &)count); SERIALISE_ELEMENT(count); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { ResourceId liveId = GetResourceManager()->GetID(shader); @@ -1502,6 +1546,8 @@ bool WrappedOpenGL::Serialise_glNamedStringARB(SerialiserType &ser, GLenum type, value, valStr ? std::string(valStr, valStr + (stringlen > 0 ? stringlen : strlen(valStr))) : ""); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Real.glNamedStringARB(type, (GLint)name.length(), name.c_str(), (GLint)value.length(), @@ -1536,6 +1582,8 @@ bool WrappedOpenGL::Serialise_glDeleteNamedStringARB(SerialiserType &ser, GLint SERIALISE_ELEMENT_LOCAL( name, nameStr ? std::string(nameStr, nameStr + (namelen > 0 ? namelen : strlen(nameStr))) : ""); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Real.glDeleteNamedStringARB((GLint)name.length(), name.c_str()); diff --git a/renderdoc/driver/gl/wrappers/gl_state_funcs.cpp b/renderdoc/driver/gl/wrappers/gl_state_funcs.cpp index ecfb89198..26a9baa94 100644 --- a/renderdoc/driver/gl/wrappers/gl_state_funcs.cpp +++ b/renderdoc/driver/gl/wrappers/gl_state_funcs.cpp @@ -33,6 +33,8 @@ bool WrappedOpenGL::Serialise_glBlendFunc(SerialiserType &ser, GLenum sfactor, G SERIALISE_ELEMENT(sfactor); SERIALISE_ELEMENT(dfactor); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Real.glBlendFunc(sfactor, dfactor); @@ -62,6 +64,8 @@ bool WrappedOpenGL::Serialise_glBlendFunci(SerialiserType &ser, GLuint buf, GLen SERIALISE_ELEMENT(src); SERIALISE_ELEMENT(dst); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Real.glBlendFunci(buf, src, dst); @@ -93,6 +97,8 @@ bool WrappedOpenGL::Serialise_glBlendColor(SerialiserType &ser, GLfloat red, GLf SERIALISE_ELEMENT(blue); SERIALISE_ELEMENT(alpha); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Real.glBlendColor(red, green, blue, alpha); @@ -125,6 +131,8 @@ bool WrappedOpenGL::Serialise_glBlendFuncSeparate(SerialiserType &ser, GLenum sf SERIALISE_ELEMENT(sfactorAlpha); SERIALISE_ELEMENT(dfactorAlpha); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Real.glBlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha); @@ -159,6 +167,8 @@ bool WrappedOpenGL::Serialise_glBlendFuncSeparatei(SerialiserType &ser, GLuint b SERIALISE_ELEMENT(sfactorAlpha); SERIALISE_ELEMENT(dfactorAlpha); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Real.glBlendFuncSeparatei(buf, sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha); @@ -187,6 +197,8 @@ bool WrappedOpenGL::Serialise_glBlendEquation(SerialiserType &ser, GLenum mode) { SERIALISE_ELEMENT(mode); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Real.glBlendEquation(mode); @@ -215,6 +227,8 @@ bool WrappedOpenGL::Serialise_glBlendEquationi(SerialiserType &ser, GLuint buf, SERIALISE_ELEMENT(buf); SERIALISE_ELEMENT(mode); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Real.glBlendEquationi(buf, mode); @@ -244,6 +258,8 @@ bool WrappedOpenGL::Serialise_glBlendEquationSeparate(SerialiserType &ser, GLenu SERIALISE_ELEMENT(modeRGB); SERIALISE_ELEMENT(modeAlpha); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Real.glBlendEquationSeparate(modeRGB, modeAlpha); @@ -274,6 +290,8 @@ bool WrappedOpenGL::Serialise_glBlendEquationSeparatei(SerialiserType &ser, GLui SERIALISE_ELEMENT(modeRGB); SERIALISE_ELEMENT(modeAlpha); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Real.glBlendEquationSeparatei(buf, modeRGB, modeAlpha); @@ -347,6 +365,8 @@ bool WrappedOpenGL::Serialise_glLogicOp(SerialiserType &ser, GLenum opcode) { SERIALISE_ELEMENT(opcode); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Real.glLogicOp(opcode); @@ -376,6 +396,8 @@ bool WrappedOpenGL::Serialise_glStencilFunc(SerialiserType &ser, GLenum func, GL SERIALISE_ELEMENT(ref); SERIALISE_ELEMENT(mask); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Real.glStencilFunc(func, ref, mask); @@ -407,6 +429,8 @@ bool WrappedOpenGL::Serialise_glStencilFuncSeparate(SerialiserType &ser, GLenum SERIALISE_ELEMENT(ref); SERIALISE_ELEMENT(mask); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Real.glStencilFuncSeparate(face, func, ref, mask); @@ -434,6 +458,8 @@ bool WrappedOpenGL::Serialise_glStencilMask(SerialiserType &ser, GLuint mask) { SERIALISE_ELEMENT(mask); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Real.glStencilMask(mask); @@ -462,6 +488,8 @@ bool WrappedOpenGL::Serialise_glStencilMaskSeparate(SerialiserType &ser, GLenum SERIALISE_ELEMENT(face); SERIALISE_ELEMENT(mask); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Real.glStencilMaskSeparate(face, mask); @@ -491,6 +519,8 @@ bool WrappedOpenGL::Serialise_glStencilOp(SerialiserType &ser, GLenum fail, GLen SERIALISE_ELEMENT(zfail); SERIALISE_ELEMENT(zpass); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Real.glStencilOp(fail, zfail, zpass); @@ -522,6 +552,8 @@ bool WrappedOpenGL::Serialise_glStencilOpSeparate(SerialiserType &ser, GLenum fa SERIALISE_ELEMENT(dpfail); SERIALISE_ELEMENT(dppass); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Real.glStencilOpSeparate(face, sfail, dpfail, dppass); @@ -553,6 +585,8 @@ bool WrappedOpenGL::Serialise_glClearColor(SerialiserType &ser, GLclampf red, GL SERIALISE_ELEMENT(blue); SERIALISE_ELEMENT(alpha); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Real.glClearColor(red, green, blue, alpha); @@ -580,6 +614,8 @@ bool WrappedOpenGL::Serialise_glClearStencil(SerialiserType &ser, GLint stencil) { SERIALISE_ELEMENT_TYPED(int32_t, stencil); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Real.glClearStencil(stencil); @@ -607,6 +643,8 @@ bool WrappedOpenGL::Serialise_glClearDepth(SerialiserType &ser, GLdouble depth) { SERIALISE_ELEMENT(depth); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(IsGLES) @@ -651,6 +689,8 @@ bool WrappedOpenGL::Serialise_glDepthFunc(SerialiserType &ser, GLenum func) { SERIALISE_ELEMENT(func); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Real.glDepthFunc(func); @@ -678,6 +718,8 @@ bool WrappedOpenGL::Serialise_glDepthMask(SerialiserType &ser, GLboolean flag) { SERIALISE_ELEMENT_TYPED(bool, flag); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Real.glDepthMask(flag ? GL_TRUE : GL_FALSE); @@ -706,6 +748,8 @@ bool WrappedOpenGL::Serialise_glDepthRange(SerialiserType &ser, GLdouble nearVal SERIALISE_ELEMENT(nearVal); SERIALISE_ELEMENT(farVal); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) m_Real.glDepthRange(nearVal, farVal); @@ -732,6 +776,8 @@ bool WrappedOpenGL::Serialise_glDepthRangef(SerialiserType &ser, GLfloat nearVal SERIALISE_ELEMENT(nearVal); SERIALISE_ELEMENT(farVal); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) m_Real.glDepthRangef(nearVal, farVal); @@ -760,6 +806,8 @@ bool WrappedOpenGL::Serialise_glDepthRangeIndexed(SerialiserType &ser, GLuint in SERIALISE_ELEMENT(nearVal); SERIALISE_ELEMENT(farVal); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(IsGLES) @@ -808,6 +856,8 @@ bool WrappedOpenGL::Serialise_glDepthRangeArrayv(SerialiserType &ser, GLuint fir uint32_t numValues = count * 2; SERIALISE_ELEMENT_ARRAY(v, numValues); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(IsGLES) @@ -869,6 +919,8 @@ bool WrappedOpenGL::Serialise_glDepthBoundsEXT(SerialiserType &ser, GLclampd nea SERIALISE_ELEMENT(nearVal); SERIALISE_ELEMENT(farVal); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Real.glDepthBoundsEXT(nearVal, farVal); @@ -897,6 +949,8 @@ bool WrappedOpenGL::Serialise_glClipControl(SerialiserType &ser, GLenum origin, SERIALISE_ELEMENT(origin); SERIALISE_ELEMENT(depth); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Real.glClipControl(origin, depth); @@ -924,6 +978,8 @@ bool WrappedOpenGL::Serialise_glProvokingVertex(SerialiserType &ser, GLenum mode { SERIALISE_ELEMENT(mode); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Real.glProvokingVertex(mode); @@ -951,6 +1007,8 @@ bool WrappedOpenGL::Serialise_glPrimitiveRestartIndex(SerialiserType &ser, GLuin { SERIALISE_ELEMENT(index); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Real.glPrimitiveRestartIndex(index); @@ -978,6 +1036,8 @@ bool WrappedOpenGL::Serialise_glDisable(SerialiserType &ser, GLenum cap) { SERIALISE_ELEMENT(cap); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Real.glDisable(cap); @@ -1016,6 +1076,8 @@ bool WrappedOpenGL::Serialise_glEnable(SerialiserType &ser, GLenum cap) { SERIALISE_ELEMENT(cap); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Real.glEnable(cap); @@ -1044,6 +1106,8 @@ bool WrappedOpenGL::Serialise_glDisablei(SerialiserType &ser, GLenum cap, GLuint SERIALISE_ELEMENT(cap); SERIALISE_ELEMENT(index); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Real.glDisablei(cap, index); @@ -1072,6 +1136,8 @@ bool WrappedOpenGL::Serialise_glEnablei(SerialiserType &ser, GLenum cap, GLuint SERIALISE_ELEMENT(cap); SERIALISE_ELEMENT(index); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Real.glEnablei(cap, index); @@ -1099,6 +1165,8 @@ bool WrappedOpenGL::Serialise_glFrontFace(SerialiserType &ser, GLenum mode) { SERIALISE_ELEMENT(mode); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Real.glFrontFace(mode); @@ -1126,6 +1194,8 @@ bool WrappedOpenGL::Serialise_glCullFace(SerialiserType &ser, GLenum mode) { SERIALISE_ELEMENT(mode); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Real.glCullFace(mode); @@ -1154,6 +1224,8 @@ bool WrappedOpenGL::Serialise_glHint(SerialiserType &ser, GLenum target, GLenum SERIALISE_ELEMENT(target); SERIALISE_ELEMENT(mode); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Real.glHint(target, mode); @@ -1185,6 +1257,8 @@ bool WrappedOpenGL::Serialise_glColorMask(SerialiserType &ser, GLboolean red, GL SERIALISE_ELEMENT_TYPED(bool, blue); SERIALISE_ELEMENT_TYPED(bool, alpha); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Real.glColorMask(red ? GL_TRUE : GL_FALSE, green ? GL_TRUE : GL_FALSE, @@ -1218,6 +1292,8 @@ bool WrappedOpenGL::Serialise_glColorMaski(SerialiserType &ser, GLuint buf, GLbo SERIALISE_ELEMENT_TYPED(bool, blue); SERIALISE_ELEMENT_TYPED(bool, alpha); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Real.glColorMaski(buf, red ? GL_TRUE : GL_FALSE, green ? GL_TRUE : GL_FALSE, @@ -1248,6 +1324,8 @@ bool WrappedOpenGL::Serialise_glSampleMaski(SerialiserType &ser, GLuint maskNumb SERIALISE_ELEMENT(maskNumber); SERIALISE_ELEMENT(mask); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Real.glSampleMaski(maskNumber, mask); @@ -1276,6 +1354,8 @@ bool WrappedOpenGL::Serialise_glSampleCoverage(SerialiserType &ser, GLfloat valu SERIALISE_ELEMENT(value); SERIALISE_ELEMENT_TYPED(bool, invert); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Real.glSampleCoverage(value, invert ? GL_TRUE : GL_FALSE); @@ -1303,6 +1383,8 @@ bool WrappedOpenGL::Serialise_glMinSampleShading(SerialiserType &ser, GLfloat va { SERIALISE_ELEMENT(value); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Real.glMinSampleShading(value); @@ -1332,6 +1414,8 @@ bool WrappedOpenGL::Serialise_glRasterSamplesEXT(SerialiserType &ser, GLuint sam SERIALISE_ELEMENT(samples); SERIALISE_ELEMENT_TYPED(bool, fixedsamplelocations); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Real.glRasterSamplesEXT(samples, fixedsamplelocations ? GL_TRUE : GL_FALSE); @@ -1360,6 +1444,8 @@ bool WrappedOpenGL::Serialise_glPatchParameteri(SerialiserType &ser, GLenum pnam SERIALISE_ELEMENT(pname); SERIALISE_ELEMENT(value); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Real.glPatchParameteri(pname, value); @@ -1389,6 +1475,8 @@ bool WrappedOpenGL::Serialise_glPatchParameterfv(SerialiserType &ser, GLenum pna SERIALISE_ELEMENT(pname); SERIALISE_ELEMENT_ARRAY(values, FIXED_COUNT(pname == eGL_PATCH_DEFAULT_OUTER_LEVEL ? 4U : 2U)); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Real.glPatchParameterfv(pname, values); @@ -1416,6 +1504,8 @@ bool WrappedOpenGL::Serialise_glLineWidth(SerialiserType &ser, GLfloat width) { SERIALISE_ELEMENT(width); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Real.glLineWidth(width); @@ -1443,6 +1533,8 @@ bool WrappedOpenGL::Serialise_glPointSize(SerialiserType &ser, GLfloat size) { SERIALISE_ELEMENT(size); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Real.glPointSize(size); @@ -1482,6 +1574,8 @@ bool WrappedOpenGL::Serialise_glPointParameteri(SerialiserType &ser, GLenum pnam SERIALISE_ELEMENT(param); } + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Real.glPointParameteri(pname, param); @@ -1511,6 +1605,8 @@ bool WrappedOpenGL::Serialise_glPointParameteriv(SerialiserType &ser, GLenum pna SERIALISE_ELEMENT(pname); SERIALISE_ELEMENT_LOCAL(Param, *params); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Real.glPointParameteriv(pname, &Param); @@ -1539,6 +1635,8 @@ bool WrappedOpenGL::Serialise_glPointParameterf(SerialiserType &ser, GLenum pnam SERIALISE_ELEMENT(pname); SERIALISE_ELEMENT(param); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Real.glPointParameterf(pname, param); @@ -1568,6 +1666,8 @@ bool WrappedOpenGL::Serialise_glPointParameterfv(SerialiserType &ser, GLenum pna SERIALISE_ELEMENT(pname); SERIALISE_ELEMENT_LOCAL(Param, *params); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Real.glPointParameterfv(pname, &Param); @@ -1599,6 +1699,8 @@ bool WrappedOpenGL::Serialise_glViewport(SerialiserType &ser, GLint x, GLint y, SERIALISE_ELEMENT(width); SERIALISE_ELEMENT(height); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Real.glViewport(x, y, width, height); @@ -1630,6 +1732,8 @@ bool WrappedOpenGL::Serialise_glViewportArrayv(SerialiserType &ser, GLuint index uint32_t numValues = count * 4; SERIALISE_ELEMENT_ARRAY(v, numValues); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Real.glViewportArrayv(index, count, v); @@ -1672,6 +1776,8 @@ bool WrappedOpenGL::Serialise_glScissor(SerialiserType &ser, GLint x, GLint y, G SERIALISE_ELEMENT(width); SERIALISE_ELEMENT(height); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Real.glScissor(x, y, width, height); @@ -1703,6 +1809,8 @@ bool WrappedOpenGL::Serialise_glScissorArrayv(SerialiserType &ser, GLuint first, uint32_t numValues = count * 4; SERIALISE_ELEMENT_ARRAY(v, numValues); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Real.glScissorArrayv(first, count, v); @@ -1743,6 +1851,8 @@ bool WrappedOpenGL::Serialise_glPolygonMode(SerialiserType &ser, GLenum face, GL SERIALISE_ELEMENT(face); SERIALISE_ELEMENT(mode); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Real.glPolygonMode(face, mode); @@ -1771,6 +1881,8 @@ bool WrappedOpenGL::Serialise_glPolygonOffset(SerialiserType &ser, GLfloat facto SERIALISE_ELEMENT(factor); SERIALISE_ELEMENT(units); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Real.glPolygonOffset(factor, units); @@ -1801,6 +1913,8 @@ bool WrappedOpenGL::Serialise_glPolygonOffsetClampEXT(SerialiserType &ser, GLflo SERIALISE_ELEMENT(units); SERIALISE_ELEMENT(clamp); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Real.glPolygonOffsetClampEXT(factor, units, clamp); @@ -1837,6 +1951,8 @@ bool WrappedOpenGL::Serialise_glPrimitiveBoundingBox(SerialiserType &ser, GLfloa SERIALISE_ELEMENT(maxZ); SERIALISE_ELEMENT(maxW); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Real.glPrimitiveBoundingBox(minX, minY, minZ, minW, maxX, maxY, maxZ, maxW); diff --git a/renderdoc/driver/gl/wrappers/gl_texture_funcs.cpp b/renderdoc/driver/gl/wrappers/gl_texture_funcs.cpp index c4d66bd4b..ae768712f 100644 --- a/renderdoc/driver/gl/wrappers/gl_texture_funcs.cpp +++ b/renderdoc/driver/gl/wrappers/gl_texture_funcs.cpp @@ -68,6 +68,8 @@ bool WrappedOpenGL::Serialise_glGenTextures(SerialiserType &ser, GLsizei n, GLui { SERIALISE_ELEMENT_LOCAL(texture, GetResourceManager()->GetID(TextureRes(GetCtx(), *textures))); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { GLuint real = 0; @@ -129,6 +131,8 @@ bool WrappedOpenGL::Serialise_glCreateTextures(SerialiserType &ser, GLenum targe SERIALISE_ELEMENT_LOCAL(texture, GetResourceManager()->GetID(TextureRes(GetCtx(), *textures))); SERIALISE_ELEMENT(target); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { GLuint real = 0; @@ -212,6 +216,8 @@ bool WrappedOpenGL::Serialise_glBindTexture(SerialiserType &ser, GLenum target, SERIALISE_ELEMENT(target); SERIALISE_ELEMENT_LOCAL(texture, TextureRes(GetCtx(), textureHandle)); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Real.glBindTexture(target, texture.name); @@ -310,6 +316,8 @@ bool WrappedOpenGL::Serialise_glBindTextures(SerialiserType &ser, GLuint first, SERIALISE_ELEMENT(textures); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { std::vector texs; @@ -458,6 +466,8 @@ bool WrappedOpenGL::Serialise_glBindTextureUnit(SerialiserType &ser, GLuint texu SERIALISE_ELEMENT(texunit); SERIALISE_ELEMENT_LOCAL(texture, TextureRes(GetCtx(), textureHandle)); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Real.glBindTextureUnit(texunit, texture.name); @@ -508,6 +518,8 @@ bool WrappedOpenGL::Serialise_glBindImageTexture(SerialiserType &ser, GLuint uni SERIALISE_ELEMENT(access); SERIALISE_ELEMENT(format); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Real.glBindImageTexture(unit, texture.name, level, layered, layer, access, format); @@ -561,6 +573,8 @@ bool WrappedOpenGL::Serialise_glBindImageTextures(SerialiserType &ser, GLuint fi SERIALISE_ELEMENT(textures); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { std::vector texs; @@ -615,6 +629,8 @@ bool WrappedOpenGL::Serialise_glTextureView(SerialiserType &ser, GLuint textureH SERIALISE_ELEMENT(minlayer); SERIALISE_ELEMENT(numlayers); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Real.glTextureView(texture.name, target, origtexture.name, internalformat, minlevel, @@ -703,6 +719,8 @@ bool WrappedOpenGL::Serialise_glGenerateTextureMipmapEXT(SerialiserType &ser, GL Serialise_DebugMessages(ser); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(target != eGL_NONE) @@ -842,6 +860,8 @@ bool WrappedOpenGL::Serialise_glCopyImageSubData(SerialiserType &ser, GLuint src Serialise_DebugMessages(ser); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Real.glCopyImageSubData(srcName.name, srcTarget, srcLevel, srcX, srcY, srcZ, dstName.name, @@ -937,6 +957,8 @@ bool WrappedOpenGL::Serialise_glCopyTextureSubImage1DEXT(SerialiserType &ser, GL SERIALISE_ELEMENT(y); SERIALISE_ELEMENT(width); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(target != eGL_NONE) @@ -1038,6 +1060,8 @@ bool WrappedOpenGL::Serialise_glCopyTextureSubImage2DEXT(SerialiserType &ser, GL SERIALISE_ELEMENT(width); SERIALISE_ELEMENT(height); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(target != eGL_NONE) @@ -1143,6 +1167,8 @@ bool WrappedOpenGL::Serialise_glCopyTextureSubImage3DEXT(SerialiserType &ser, GL SERIALISE_ELEMENT(width); SERIALISE_ELEMENT(height); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(target != eGL_NONE) @@ -1262,6 +1288,8 @@ bool WrappedOpenGL::Serialise_glTextureParameteriEXT(SerialiserType &ser, GLuint SERIALISE_ELEMENT(param); } + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(target != eGL_NONE) @@ -1361,6 +1389,8 @@ bool WrappedOpenGL::Serialise_glTextureParameterivEXT(SerialiserType &ser, GLuin SERIALISE_ELEMENT(pname); SERIALISE_ELEMENT_ARRAY(params, FIXED_COUNT(numParams(pname))); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(target != eGL_NONE) @@ -1464,6 +1494,8 @@ bool WrappedOpenGL::Serialise_glTextureParameterIivEXT(SerialiserType &ser, GLui SERIALISE_ELEMENT(pname); SERIALISE_ELEMENT_ARRAY(params, FIXED_COUNT(numParams(pname))); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(target != eGL_NONE) @@ -1567,6 +1599,8 @@ bool WrappedOpenGL::Serialise_glTextureParameterIuivEXT(SerialiserType &ser, GLu SERIALISE_ELEMENT(pname); SERIALISE_ELEMENT_ARRAY(params, FIXED_COUNT(numParams(pname))); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(target != eGL_NONE) @@ -1669,6 +1703,8 @@ bool WrappedOpenGL::Serialise_glTextureParameterfEXT(SerialiserType &ser, GLuint SERIALISE_ELEMENT(pname); SERIALISE_ELEMENT(param); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(target != eGL_NONE) @@ -1768,6 +1804,8 @@ bool WrappedOpenGL::Serialise_glTextureParameterfvEXT(SerialiserType &ser, GLuin SERIALISE_ELEMENT(pname); SERIALISE_ELEMENT_ARRAY(params, FIXED_COUNT(numParams(pname))); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(target != eGL_NONE) @@ -1866,6 +1904,8 @@ bool WrappedOpenGL::Serialise_glPixelStorei(SerialiserType &ser, GLenum pname, G SERIALISE_ELEMENT(pname); SERIALISE_ELEMENT(param); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_Real.glPixelStorei(pname, param); @@ -1900,6 +1940,8 @@ bool WrappedOpenGL::Serialise_glActiveTexture(SerialiserType &ser, GLenum textur { SERIALISE_ELEMENT(texture); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) m_Real.glActiveTexture(texture); @@ -1975,6 +2017,8 @@ bool WrappedOpenGL::Serialise_glTextureImage1DEXT(SerialiserType &ser, GLuint te SAFE_DELETE_ARRAY(unpackedPixels); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { GLenum intFmt = (GLenum)internalformat; @@ -2187,6 +2231,8 @@ bool WrappedOpenGL::Serialise_glTextureImage2DEXT(SerialiserType &ser, GLuint te SAFE_DELETE_ARRAY(unpackedPixels); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { GLenum intFmt = (GLenum)internalformat; @@ -2427,6 +2473,8 @@ bool WrappedOpenGL::Serialise_glTextureImage3DEXT(SerialiserType &ser, GLuint te SAFE_DELETE_ARRAY(unpackedPixels); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { GLenum intFmt = (GLenum)internalformat; @@ -2645,6 +2693,8 @@ bool WrappedOpenGL::Serialise_glCompressedTextureImage1DEXT(SerialiserType &ser, SAFE_DELETE_ARRAY(unpackedPixels); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { const void *databuf = pixels; @@ -2964,6 +3014,8 @@ bool WrappedOpenGL::Serialise_glCompressedTextureImage2DEXT(SerialiserType &ser, SAFE_DELETE_ARRAY(unpackedPixels); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { const void *databuf = pixels; @@ -3221,6 +3273,8 @@ bool WrappedOpenGL::Serialise_glCompressedTextureImage3DEXT(SerialiserType &ser, SAFE_DELETE_ARRAY(unpackedPixels); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { const void *databuf = pixels; @@ -3443,6 +3497,8 @@ bool WrappedOpenGL::Serialise_glCopyTextureImage1DEXT(SerialiserType &ser, GLuin SERIALISE_ELEMENT(width); SERIALISE_ELEMENT(border); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(level == 0) // assume level 0 will always get a glTexImage call @@ -3594,6 +3650,8 @@ bool WrappedOpenGL::Serialise_glCopyTextureImage2DEXT(SerialiserType &ser, GLuin SERIALISE_ELEMENT(height); SERIALISE_ELEMENT(border); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(level == 0) // assume level 0 will always get a glTexImage call @@ -3747,6 +3805,8 @@ bool WrappedOpenGL::Serialise_glTextureStorage1DEXT(SerialiserType &ser, GLuint SERIALISE_ELEMENT(internalformat); SERIALISE_ELEMENT(width); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { GLenum dummy = eGL_NONE; @@ -3876,6 +3936,8 @@ bool WrappedOpenGL::Serialise_glTextureStorage2DEXT(SerialiserType &ser, GLuint SERIALISE_ELEMENT(width); SERIALISE_ELEMENT(height); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { GLenum dummy = eGL_NONE; @@ -4008,6 +4070,8 @@ bool WrappedOpenGL::Serialise_glTextureStorage3DEXT(SerialiserType &ser, GLuint SERIALISE_ELEMENT(height); SERIALISE_ELEMENT(depth); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { GLenum dummy = eGL_NONE; @@ -4144,6 +4208,8 @@ bool WrappedOpenGL::Serialise_glTextureStorage2DMultisampleEXT(SerialiserType &s SERIALISE_ELEMENT(height); SERIALISE_ELEMENT_TYPED(bool, fixedsamplelocations); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { GLenum dummy = eGL_NONE; @@ -4321,6 +4387,8 @@ bool WrappedOpenGL::Serialise_glTextureStorage3DMultisampleEXT(SerialiserType &s SERIALISE_ELEMENT(depth); SERIALISE_ELEMENT_TYPED(bool, fixedsamplelocations); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { GLenum dummy = eGL_NONE; @@ -4541,6 +4609,8 @@ bool WrappedOpenGL::Serialise_glTextureSubImage1DEXT(SerialiserType &ser, GLuint SAFE_DELETE_ARRAY(unpackedPixels); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { PixelUnpackState unpack; @@ -4746,6 +4816,8 @@ bool WrappedOpenGL::Serialise_glTextureSubImage2DEXT(SerialiserType &ser, GLuint SAFE_DELETE_ARRAY(unpackedPixels); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { PixelUnpackState unpack; @@ -4959,6 +5031,8 @@ bool WrappedOpenGL::Serialise_glTextureSubImage3DEXT(SerialiserType &ser, GLuint SAFE_DELETE_ARRAY(unpackedPixels); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { PixelUnpackState unpack; @@ -5173,6 +5247,8 @@ bool WrappedOpenGL::Serialise_glCompressedTextureSubImage1DEXT(SerialiserType &s SAFE_DELETE_ARRAY(unpackedPixels); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { PixelUnpackState unpack; @@ -5368,6 +5444,8 @@ bool WrappedOpenGL::Serialise_glCompressedTextureSubImage2DEXT(SerialiserType &s SAFE_DELETE_ARRAY(unpackedPixels); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(IsLoading(m_State) && IsGLES) @@ -5582,6 +5660,8 @@ bool WrappedOpenGL::Serialise_glCompressedTextureSubImage3DEXT( SAFE_DELETE_ARRAY(unpackedPixels); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { if(IsLoading(m_State) && IsGLES) @@ -5765,6 +5845,8 @@ bool WrappedOpenGL::Serialise_glTextureBufferRangeEXT(SerialiserType &ser, GLuin SERIALISE_ELEMENT_LOCAL(offs, (uint64_t)offsetPtr); SERIALISE_ELEMENT_LOCAL(size, (uint64_t)sizePtr); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { ResourceId liveId = GetResourceManager()->GetID(texture); @@ -5937,6 +6019,8 @@ bool WrappedOpenGL::Serialise_glTextureBufferEXT(SerialiserType &ser, GLuint tex SERIALISE_ELEMENT(internalformat); SERIALISE_ELEMENT_LOCAL(buffer, BufferRes(GetCtx(), bufferHandle)); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { ResourceId liveId = GetResourceManager()->GetID(texture); diff --git a/renderdoc/driver/gl/wrappers/gl_uniform_funcs.cpp b/renderdoc/driver/gl/wrappers/gl_uniform_funcs.cpp index 2e880015d..17684a3f3 100644 --- a/renderdoc/driver/gl/wrappers/gl_uniform_funcs.cpp +++ b/renderdoc/driver/gl/wrappers/gl_uniform_funcs.cpp @@ -110,6 +110,8 @@ bool WrappedOpenGL::Serialise_glProgramUniformVector(SerialiserType &ser, GLuint else if(elemBaseType == SDBasic::UnsignedInteger) ser.Serialise("values", v.u, arrayLength, SerialiserFlags::NoFlags); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading() && Program.name) { ResourceId liveProgId = GetResourceManager()->GetID(Program); @@ -229,6 +231,8 @@ bool WrappedOpenGL::Serialise_glProgramUniformMatrix(SerialiserType &ser, GLuint else ser.Serialise("values", v.d, arrayLength, SerialiserFlags::NoFlags); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading() && Program.name) { ResourceId liveProgId = GetResourceManager()->GetID(Program); diff --git a/renderdoc/driver/vulkan/vk_core.cpp b/renderdoc/driver/vulkan/vk_core.cpp index cf33c747e..d236d0ec9 100644 --- a/renderdoc/driver/vulkan/vk_core.cpp +++ b/renderdoc/driver/vulkan/vk_core.cpp @@ -769,16 +769,21 @@ VkResult WrappedVulkan::GetProvidedExtensionProperties(uint32_t *pPropertyCount, (uint32_t)ARRAY_COUNT(renderdocProvidedExtensions), pPropertyCount, pProperties); } + template -void WrappedVulkan::Serialise_CaptureScope(SerialiserType &ser) +bool WrappedVulkan::Serialise_CaptureScope(SerialiserType &ser) { SERIALISE_ELEMENT(m_FrameCounter); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_FrameRecord.frameInfo.frameNumber = m_FrameCounter; RDCEraseEl(m_FrameRecord.frameInfo.stats); } + + return true; } void WrappedVulkan::EndCaptureFrame(VkImage presentImage) @@ -815,6 +820,8 @@ bool WrappedVulkan::Serialise_BeginCaptureFrame(SerialiserType &ser) GetResourceManager()->SerialiseImageStates(ser, m_ImageLayouts, imgBarriers); } + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading() && !imgBarriers.empty()) { VkPipelineStageFlags src_stages = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT; @@ -1472,13 +1479,18 @@ ReplayStatus WrappedVulkan::ReadLogInitialisation(RDCFile *rdc, bool storeStruct if(reader->IsErrored()) return ReplayStatus::APIDataCorrupted; - ProcessChunk(ser, context); + bool success = ProcessChunk(ser, context); ser.EndChunk(); if(reader->IsErrored()) return ReplayStatus::APIDataCorrupted; + // if there wasn't a serialisation error, but the chunk didn't succeed, then it's an API replay + // failure. + if(!success) + return m_FailedReplayStatus; + uint64_t offsetEnd = reader->GetOffset(); RenderDoc::Inst().SetProgress(FileInitialRead, float(offsetEnd) / float(reader->GetSize())); @@ -1492,7 +1504,10 @@ ReplayStatus WrappedVulkan::ReadLogInitialisation(RDCFile *rdc, bool storeStruct m_FrameReader = new StreamReader(reader, frameDataSize); - ContextReplayLog(m_State, 0, 0, false); + ReplayStatus status = ContextReplayLog(m_State, 0, 0, false); + + if(status != ReplayStatus::Succeeded) + return status; } chunkInfos[context].total += timer.GetMilliseconds(); @@ -1543,8 +1558,8 @@ ReplayStatus WrappedVulkan::ReadLogInitialisation(RDCFile *rdc, bool storeStruct return ReplayStatus::Succeeded; } -void WrappedVulkan::ContextReplayLog(CaptureState readType, uint32_t startEventID, - uint32_t endEventID, bool partial) +ReplayStatus WrappedVulkan::ContextReplayLog(CaptureState readType, uint32_t startEventID, + uint32_t endEventID, bool partial) { m_FrameReader->SetOffset(0); @@ -1632,14 +1647,25 @@ void WrappedVulkan::ContextReplayLog(CaptureState readType, uint32_t startEventI VulkanChunk chunktype = ser.ReadChunk(); + if(ser.GetReader()->IsErrored()) + return ReplayStatus::APIDataCorrupted; + m_ChunkMetadata = ser.ChunkMetadata(); m_LastCmdBufferID = ResourceId(); - ContextProcessChunk(ser, chunktype); + bool success = ContextProcessChunk(ser, chunktype); ser.EndChunk(); + if(ser.GetReader()->IsErrored()) + return ReplayStatus::APIDataCorrupted; + + // if there wasn't a serialisation error, but the chunk didn't succeed, then it's an API replay + // failure. + if(!success) + return m_FailedReplayStatus; + RenderDoc::Inst().SetProgress( FileInitialRead, float(m_CurChunkOffset - startOffset) / float(ser.GetReader()->GetSize())); @@ -1724,6 +1750,8 @@ void WrappedVulkan::ContextReplayLog(CaptureState readType, uint32_t startEventI } m_RerecordCmds.clear(); + + return ReplayStatus::Succeeded; } void WrappedVulkan::ApplyInitialContents() @@ -1774,11 +1802,14 @@ void WrappedVulkan::ApplyInitialContents() #endif } -void WrappedVulkan::ContextProcessChunk(ReadSerialiser &ser, VulkanChunk chunk) +bool WrappedVulkan::ContextProcessChunk(ReadSerialiser &ser, VulkanChunk chunk) { m_AddedDrawcall = false; - ProcessChunk(ser, chunk); + bool success = ProcessChunk(ser, chunk); + + if(!success) + return false; if(IsLoading(m_State)) { @@ -1800,313 +1831,338 @@ void WrappedVulkan::ContextProcessChunk(ReadSerialiser &ser, VulkanChunk chunk) } m_AddedDrawcall = false; + + return true; } -void WrappedVulkan::ProcessChunk(ReadSerialiser &ser, VulkanChunk chunk) +bool WrappedVulkan::ProcessChunk(ReadSerialiser &ser, VulkanChunk chunk) { switch(chunk) { case VulkanChunk::vkEnumeratePhysicalDevices: - Serialise_vkEnumeratePhysicalDevices(ser, NULL, NULL, NULL); + return Serialise_vkEnumeratePhysicalDevices(ser, NULL, NULL, NULL); break; case VulkanChunk::vkCreateDevice: - Serialise_vkCreateDevice(ser, VK_NULL_HANDLE, NULL, NULL, NULL); + return Serialise_vkCreateDevice(ser, VK_NULL_HANDLE, NULL, NULL, NULL); break; case VulkanChunk::vkGetDeviceQueue: - Serialise_vkGetDeviceQueue(ser, VK_NULL_HANDLE, 0, 0, NULL); + return Serialise_vkGetDeviceQueue(ser, VK_NULL_HANDLE, 0, 0, NULL); break; case VulkanChunk::vkAllocateMemory: - Serialise_vkAllocateMemory(ser, VK_NULL_HANDLE, NULL, NULL, NULL); + return Serialise_vkAllocateMemory(ser, VK_NULL_HANDLE, NULL, NULL, NULL); break; case VulkanChunk::vkUnmapMemory: - Serialise_vkUnmapMemory(ser, VK_NULL_HANDLE, VK_NULL_HANDLE); + return Serialise_vkUnmapMemory(ser, VK_NULL_HANDLE, VK_NULL_HANDLE); break; case VulkanChunk::vkFlushMappedMemoryRanges: - Serialise_vkFlushMappedMemoryRanges(ser, VK_NULL_HANDLE, 0, NULL); + return Serialise_vkFlushMappedMemoryRanges(ser, VK_NULL_HANDLE, 0, NULL); break; case VulkanChunk::vkCreateCommandPool: - Serialise_vkCreateCommandPool(ser, VK_NULL_HANDLE, NULL, NULL, NULL); + return Serialise_vkCreateCommandPool(ser, VK_NULL_HANDLE, NULL, NULL, NULL); break; case VulkanChunk::vkAllocateCommandBuffers: - Serialise_vkAllocateCommandBuffers(ser, VK_NULL_HANDLE, NULL, NULL); + return Serialise_vkAllocateCommandBuffers(ser, VK_NULL_HANDLE, NULL, NULL); break; case VulkanChunk::vkCreateFramebuffer: - Serialise_vkCreateFramebuffer(ser, VK_NULL_HANDLE, NULL, NULL, NULL); + return Serialise_vkCreateFramebuffer(ser, VK_NULL_HANDLE, NULL, NULL, NULL); break; case VulkanChunk::vkCreateRenderPass: - Serialise_vkCreateRenderPass(ser, VK_NULL_HANDLE, NULL, NULL, NULL); + return Serialise_vkCreateRenderPass(ser, VK_NULL_HANDLE, NULL, NULL, NULL); break; case VulkanChunk::vkCreateDescriptorPool: - Serialise_vkCreateDescriptorPool(ser, VK_NULL_HANDLE, NULL, NULL, NULL); + return Serialise_vkCreateDescriptorPool(ser, VK_NULL_HANDLE, NULL, NULL, NULL); break; case VulkanChunk::vkCreateDescriptorSetLayout: - Serialise_vkCreateDescriptorSetLayout(ser, VK_NULL_HANDLE, NULL, NULL, NULL); + return Serialise_vkCreateDescriptorSetLayout(ser, VK_NULL_HANDLE, NULL, NULL, NULL); break; case VulkanChunk::vkCreateBuffer: - Serialise_vkCreateBuffer(ser, VK_NULL_HANDLE, NULL, NULL, NULL); + return Serialise_vkCreateBuffer(ser, VK_NULL_HANDLE, NULL, NULL, NULL); break; case VulkanChunk::vkCreateBufferView: - Serialise_vkCreateBufferView(ser, VK_NULL_HANDLE, NULL, NULL, NULL); + return Serialise_vkCreateBufferView(ser, VK_NULL_HANDLE, NULL, NULL, NULL); break; case VulkanChunk::vkCreateImage: - Serialise_vkCreateImage(ser, VK_NULL_HANDLE, NULL, NULL, NULL); + return Serialise_vkCreateImage(ser, VK_NULL_HANDLE, NULL, NULL, NULL); break; case VulkanChunk::vkCreateImageView: - Serialise_vkCreateImageView(ser, VK_NULL_HANDLE, NULL, NULL, NULL); + return Serialise_vkCreateImageView(ser, VK_NULL_HANDLE, NULL, NULL, NULL); break; case VulkanChunk::vkCreateSampler: - Serialise_vkCreateSampler(ser, VK_NULL_HANDLE, NULL, NULL, NULL); + return Serialise_vkCreateSampler(ser, VK_NULL_HANDLE, NULL, NULL, NULL); break; case VulkanChunk::vkCreateShaderModule: - Serialise_vkCreateShaderModule(ser, VK_NULL_HANDLE, NULL, NULL, NULL); + return Serialise_vkCreateShaderModule(ser, VK_NULL_HANDLE, NULL, NULL, NULL); break; case VulkanChunk::vkCreatePipelineLayout: - Serialise_vkCreatePipelineLayout(ser, VK_NULL_HANDLE, NULL, NULL, NULL); + return Serialise_vkCreatePipelineLayout(ser, VK_NULL_HANDLE, NULL, NULL, NULL); break; case VulkanChunk::vkCreatePipelineCache: - Serialise_vkCreatePipelineCache(ser, VK_NULL_HANDLE, NULL, NULL, NULL); + return Serialise_vkCreatePipelineCache(ser, VK_NULL_HANDLE, NULL, NULL, NULL); break; case VulkanChunk::vkCreateGraphicsPipelines: - Serialise_vkCreateGraphicsPipelines(ser, VK_NULL_HANDLE, VK_NULL_HANDLE, 0, NULL, NULL, NULL); + return Serialise_vkCreateGraphicsPipelines(ser, VK_NULL_HANDLE, VK_NULL_HANDLE, 0, NULL, NULL, + NULL); break; case VulkanChunk::vkCreateComputePipelines: - Serialise_vkCreateComputePipelines(ser, VK_NULL_HANDLE, VK_NULL_HANDLE, 0, NULL, NULL, NULL); + return Serialise_vkCreateComputePipelines(ser, VK_NULL_HANDLE, VK_NULL_HANDLE, 0, NULL, NULL, + NULL); break; case VulkanChunk::vkGetSwapchainImagesKHR: - Serialise_vkGetSwapchainImagesKHR(ser, VK_NULL_HANDLE, VK_NULL_HANDLE, NULL, NULL); + return Serialise_vkGetSwapchainImagesKHR(ser, VK_NULL_HANDLE, VK_NULL_HANDLE, NULL, NULL); break; case VulkanChunk::vkCreateSemaphore: - Serialise_vkCreateSemaphore(ser, VK_NULL_HANDLE, NULL, NULL, NULL); + return Serialise_vkCreateSemaphore(ser, VK_NULL_HANDLE, NULL, NULL, NULL); break; case VulkanChunk::vkCreateFence: // these chunks re-use serialisation from vkCreateFence, but have separate chunks for user // identification case VulkanChunk::vkRegisterDeviceEventEXT: case VulkanChunk::vkRegisterDisplayEventEXT: - Serialise_vkCreateFence(ser, VK_NULL_HANDLE, NULL, NULL, NULL); + return Serialise_vkCreateFence(ser, VK_NULL_HANDLE, NULL, NULL, NULL); break; case VulkanChunk::vkGetFenceStatus: - Serialise_vkGetFenceStatus(ser, VK_NULL_HANDLE, VK_NULL_HANDLE); + return Serialise_vkGetFenceStatus(ser, VK_NULL_HANDLE, VK_NULL_HANDLE); + break; + case VulkanChunk::vkResetFences: + return Serialise_vkResetFences(ser, VK_NULL_HANDLE, 0, NULL); break; - case VulkanChunk::vkResetFences: Serialise_vkResetFences(ser, VK_NULL_HANDLE, 0, NULL); break; case VulkanChunk::vkWaitForFences: - Serialise_vkWaitForFences(ser, VK_NULL_HANDLE, 0, NULL, VK_FALSE, 0); + return Serialise_vkWaitForFences(ser, VK_NULL_HANDLE, 0, NULL, VK_FALSE, 0); break; case VulkanChunk::vkCreateEvent: - Serialise_vkCreateEvent(ser, VK_NULL_HANDLE, NULL, NULL, NULL); + return Serialise_vkCreateEvent(ser, VK_NULL_HANDLE, NULL, NULL, NULL); break; case VulkanChunk::vkGetEventStatus: - Serialise_vkGetEventStatus(ser, VK_NULL_HANDLE, VK_NULL_HANDLE); + return Serialise_vkGetEventStatus(ser, VK_NULL_HANDLE, VK_NULL_HANDLE); + break; + case VulkanChunk::vkSetEvent: + return Serialise_vkSetEvent(ser, VK_NULL_HANDLE, VK_NULL_HANDLE); break; - case VulkanChunk::vkSetEvent: Serialise_vkSetEvent(ser, VK_NULL_HANDLE, VK_NULL_HANDLE); break; case VulkanChunk::vkResetEvent: - Serialise_vkResetEvent(ser, VK_NULL_HANDLE, VK_NULL_HANDLE); + return Serialise_vkResetEvent(ser, VK_NULL_HANDLE, VK_NULL_HANDLE); break; case VulkanChunk::vkCreateQueryPool: - Serialise_vkCreateQueryPool(ser, VK_NULL_HANDLE, NULL, NULL, NULL); + return Serialise_vkCreateQueryPool(ser, VK_NULL_HANDLE, NULL, NULL, NULL); break; case VulkanChunk::vkAllocateDescriptorSets: - Serialise_vkAllocateDescriptorSets(ser, VK_NULL_HANDLE, NULL, NULL); + return Serialise_vkAllocateDescriptorSets(ser, VK_NULL_HANDLE, NULL, NULL); break; case VulkanChunk::vkUpdateDescriptorSets: - Serialise_vkUpdateDescriptorSets(ser, VK_NULL_HANDLE, 0, NULL, 0, NULL); + return Serialise_vkUpdateDescriptorSets(ser, VK_NULL_HANDLE, 0, NULL, 0, NULL); break; case VulkanChunk::vkBeginCommandBuffer: - Serialise_vkBeginCommandBuffer(ser, VK_NULL_HANDLE, NULL); + return Serialise_vkBeginCommandBuffer(ser, VK_NULL_HANDLE, NULL); + break; + case VulkanChunk::vkEndCommandBuffer: + return Serialise_vkEndCommandBuffer(ser, VK_NULL_HANDLE); break; - case VulkanChunk::vkEndCommandBuffer: Serialise_vkEndCommandBuffer(ser, VK_NULL_HANDLE); break; - case VulkanChunk::vkQueueWaitIdle: Serialise_vkQueueWaitIdle(ser, VK_NULL_HANDLE); break; - case VulkanChunk::vkDeviceWaitIdle: Serialise_vkDeviceWaitIdle(ser, VK_NULL_HANDLE); break; + case VulkanChunk::vkQueueWaitIdle: return Serialise_vkQueueWaitIdle(ser, VK_NULL_HANDLE); break; + case VulkanChunk::vkDeviceWaitIdle: + return Serialise_vkDeviceWaitIdle(ser, VK_NULL_HANDLE); + break; case VulkanChunk::vkQueueSubmit: - Serialise_vkQueueSubmit(ser, VK_NULL_HANDLE, 0, NULL, VK_NULL_HANDLE); + return Serialise_vkQueueSubmit(ser, VK_NULL_HANDLE, 0, NULL, VK_NULL_HANDLE); break; case VulkanChunk::vkBindBufferMemory: - Serialise_vkBindBufferMemory(ser, VK_NULL_HANDLE, VK_NULL_HANDLE, VK_NULL_HANDLE, 0); + return Serialise_vkBindBufferMemory(ser, VK_NULL_HANDLE, VK_NULL_HANDLE, VK_NULL_HANDLE, 0); break; case VulkanChunk::vkBindImageMemory: - Serialise_vkBindImageMemory(ser, VK_NULL_HANDLE, VK_NULL_HANDLE, VK_NULL_HANDLE, 0); + return Serialise_vkBindImageMemory(ser, VK_NULL_HANDLE, VK_NULL_HANDLE, VK_NULL_HANDLE, 0); break; case VulkanChunk::vkQueueBindSparse: - Serialise_vkQueueBindSparse(ser, VK_NULL_HANDLE, 0, NULL, VK_NULL_HANDLE); + return Serialise_vkQueueBindSparse(ser, VK_NULL_HANDLE, 0, NULL, VK_NULL_HANDLE); break; case VulkanChunk::vkCmdBeginRenderPass: - Serialise_vkCmdBeginRenderPass(ser, VK_NULL_HANDLE, NULL, VK_SUBPASS_CONTENTS_MAX_ENUM); + return Serialise_vkCmdBeginRenderPass(ser, VK_NULL_HANDLE, NULL, VK_SUBPASS_CONTENTS_MAX_ENUM); break; case VulkanChunk::vkCmdNextSubpass: - Serialise_vkCmdNextSubpass(ser, VK_NULL_HANDLE, VK_SUBPASS_CONTENTS_MAX_ENUM); + return Serialise_vkCmdNextSubpass(ser, VK_NULL_HANDLE, VK_SUBPASS_CONTENTS_MAX_ENUM); break; case VulkanChunk::vkCmdExecuteCommands: - Serialise_vkCmdExecuteCommands(ser, VK_NULL_HANDLE, 0, NULL); + return Serialise_vkCmdExecuteCommands(ser, VK_NULL_HANDLE, 0, NULL); + break; + case VulkanChunk::vkCmdEndRenderPass: + return Serialise_vkCmdEndRenderPass(ser, VK_NULL_HANDLE); break; - case VulkanChunk::vkCmdEndRenderPass: Serialise_vkCmdEndRenderPass(ser, VK_NULL_HANDLE); break; case VulkanChunk::vkCmdBindPipeline: - Serialise_vkCmdBindPipeline(ser, VK_NULL_HANDLE, VK_PIPELINE_BIND_POINT_MAX_ENUM, - VK_NULL_HANDLE); + return Serialise_vkCmdBindPipeline(ser, VK_NULL_HANDLE, VK_PIPELINE_BIND_POINT_MAX_ENUM, + VK_NULL_HANDLE); break; case VulkanChunk::vkCmdSetViewport: - Serialise_vkCmdSetViewport(ser, VK_NULL_HANDLE, 0, 0, NULL); + return Serialise_vkCmdSetViewport(ser, VK_NULL_HANDLE, 0, 0, NULL); break; case VulkanChunk::vkCmdSetScissor: - Serialise_vkCmdSetScissor(ser, VK_NULL_HANDLE, 0, 0, NULL); + return Serialise_vkCmdSetScissor(ser, VK_NULL_HANDLE, 0, 0, NULL); + break; + case VulkanChunk::vkCmdSetLineWidth: + return Serialise_vkCmdSetLineWidth(ser, VK_NULL_HANDLE, 0); break; - case VulkanChunk::vkCmdSetLineWidth: Serialise_vkCmdSetLineWidth(ser, VK_NULL_HANDLE, 0); break; case VulkanChunk::vkCmdSetDepthBias: - Serialise_vkCmdSetDepthBias(ser, VK_NULL_HANDLE, 0.0f, 0.0f, 0.0f); + return Serialise_vkCmdSetDepthBias(ser, VK_NULL_HANDLE, 0.0f, 0.0f, 0.0f); break; case VulkanChunk::vkCmdSetBlendConstants: - Serialise_vkCmdSetBlendConstants(ser, VK_NULL_HANDLE, NULL); + return Serialise_vkCmdSetBlendConstants(ser, VK_NULL_HANDLE, NULL); break; case VulkanChunk::vkCmdSetDepthBounds: - Serialise_vkCmdSetDepthBounds(ser, VK_NULL_HANDLE, 0.0f, 0.0f); + return Serialise_vkCmdSetDepthBounds(ser, VK_NULL_HANDLE, 0.0f, 0.0f); break; case VulkanChunk::vkCmdSetStencilCompareMask: - Serialise_vkCmdSetStencilCompareMask(ser, VK_NULL_HANDLE, 0, 0); + return Serialise_vkCmdSetStencilCompareMask(ser, VK_NULL_HANDLE, 0, 0); break; case VulkanChunk::vkCmdSetStencilWriteMask: - Serialise_vkCmdSetStencilWriteMask(ser, VK_NULL_HANDLE, 0, 0); + return Serialise_vkCmdSetStencilWriteMask(ser, VK_NULL_HANDLE, 0, 0); break; case VulkanChunk::vkCmdSetStencilReference: - Serialise_vkCmdSetStencilReference(ser, VK_NULL_HANDLE, 0, 0); + return Serialise_vkCmdSetStencilReference(ser, VK_NULL_HANDLE, 0, 0); break; case VulkanChunk::vkCmdBindDescriptorSets: - Serialise_vkCmdBindDescriptorSets(ser, VK_NULL_HANDLE, VK_PIPELINE_BIND_POINT_MAX_ENUM, - VK_NULL_HANDLE, 0, 0, NULL, 0, NULL); + return Serialise_vkCmdBindDescriptorSets(ser, VK_NULL_HANDLE, VK_PIPELINE_BIND_POINT_MAX_ENUM, + VK_NULL_HANDLE, 0, 0, NULL, 0, NULL); break; case VulkanChunk::vkCmdBindIndexBuffer: - Serialise_vkCmdBindIndexBuffer(ser, VK_NULL_HANDLE, VK_NULL_HANDLE, 0, VK_INDEX_TYPE_MAX_ENUM); + return Serialise_vkCmdBindIndexBuffer(ser, VK_NULL_HANDLE, VK_NULL_HANDLE, 0, + VK_INDEX_TYPE_MAX_ENUM); break; case VulkanChunk::vkCmdBindVertexBuffers: - Serialise_vkCmdBindVertexBuffers(ser, VK_NULL_HANDLE, 0, 0, NULL, NULL); + return Serialise_vkCmdBindVertexBuffers(ser, VK_NULL_HANDLE, 0, 0, NULL, NULL); break; case VulkanChunk::vkCmdCopyBufferToImage: - Serialise_vkCmdCopyBufferToImage(ser, VK_NULL_HANDLE, VK_NULL_HANDLE, VK_NULL_HANDLE, - VK_IMAGE_LAYOUT_MAX_ENUM, 0, NULL); + return Serialise_vkCmdCopyBufferToImage(ser, VK_NULL_HANDLE, VK_NULL_HANDLE, VK_NULL_HANDLE, + VK_IMAGE_LAYOUT_MAX_ENUM, 0, NULL); break; case VulkanChunk::vkCmdCopyImageToBuffer: - Serialise_vkCmdCopyImageToBuffer(ser, VK_NULL_HANDLE, VK_NULL_HANDLE, - VK_IMAGE_LAYOUT_MAX_ENUM, VK_NULL_HANDLE, 0, NULL); + return Serialise_vkCmdCopyImageToBuffer(ser, VK_NULL_HANDLE, VK_NULL_HANDLE, + VK_IMAGE_LAYOUT_MAX_ENUM, VK_NULL_HANDLE, 0, NULL); break; case VulkanChunk::vkCmdCopyImage: - Serialise_vkCmdCopyImage(ser, VK_NULL_HANDLE, VK_NULL_HANDLE, VK_IMAGE_LAYOUT_MAX_ENUM, - VK_NULL_HANDLE, VK_IMAGE_LAYOUT_MAX_ENUM, 0, NULL); + return Serialise_vkCmdCopyImage(ser, VK_NULL_HANDLE, VK_NULL_HANDLE, VK_IMAGE_LAYOUT_MAX_ENUM, + VK_NULL_HANDLE, VK_IMAGE_LAYOUT_MAX_ENUM, 0, NULL); break; case VulkanChunk::vkCmdBlitImage: - Serialise_vkCmdBlitImage(ser, VK_NULL_HANDLE, VK_NULL_HANDLE, VK_IMAGE_LAYOUT_MAX_ENUM, - VK_NULL_HANDLE, VK_IMAGE_LAYOUT_MAX_ENUM, 0, NULL, VK_FILTER_MAX_ENUM); + return Serialise_vkCmdBlitImage(ser, VK_NULL_HANDLE, VK_NULL_HANDLE, VK_IMAGE_LAYOUT_MAX_ENUM, + VK_NULL_HANDLE, VK_IMAGE_LAYOUT_MAX_ENUM, 0, NULL, + VK_FILTER_MAX_ENUM); break; case VulkanChunk::vkCmdResolveImage: - Serialise_vkCmdResolveImage(ser, VK_NULL_HANDLE, VK_NULL_HANDLE, VK_IMAGE_LAYOUT_MAX_ENUM, - VK_NULL_HANDLE, VK_IMAGE_LAYOUT_MAX_ENUM, 0, NULL); + return Serialise_vkCmdResolveImage(ser, VK_NULL_HANDLE, VK_NULL_HANDLE, + VK_IMAGE_LAYOUT_MAX_ENUM, VK_NULL_HANDLE, + VK_IMAGE_LAYOUT_MAX_ENUM, 0, NULL); break; case VulkanChunk::vkCmdCopyBuffer: - Serialise_vkCmdCopyBuffer(ser, VK_NULL_HANDLE, VK_NULL_HANDLE, VK_NULL_HANDLE, 0, NULL); + return Serialise_vkCmdCopyBuffer(ser, VK_NULL_HANDLE, VK_NULL_HANDLE, VK_NULL_HANDLE, 0, NULL); break; case VulkanChunk::vkCmdUpdateBuffer: - Serialise_vkCmdUpdateBuffer(ser, VK_NULL_HANDLE, VK_NULL_HANDLE, 0, 0, NULL); + return Serialise_vkCmdUpdateBuffer(ser, VK_NULL_HANDLE, VK_NULL_HANDLE, 0, 0, NULL); break; case VulkanChunk::vkCmdFillBuffer: - Serialise_vkCmdFillBuffer(ser, VK_NULL_HANDLE, VK_NULL_HANDLE, 0, 0, 0); + return Serialise_vkCmdFillBuffer(ser, VK_NULL_HANDLE, VK_NULL_HANDLE, 0, 0, 0); break; case VulkanChunk::vkCmdPushConstants: - Serialise_vkCmdPushConstants(ser, VK_NULL_HANDLE, VK_NULL_HANDLE, VK_SHADER_STAGE_ALL, 0, 0, - NULL); + return Serialise_vkCmdPushConstants(ser, VK_NULL_HANDLE, VK_NULL_HANDLE, VK_SHADER_STAGE_ALL, + 0, 0, NULL); break; case VulkanChunk::vkCmdClearColorImage: - Serialise_vkCmdClearColorImage(ser, VK_NULL_HANDLE, VK_NULL_HANDLE, VK_IMAGE_LAYOUT_MAX_ENUM, - NULL, 0, NULL); - break; - case VulkanChunk::vkCmdClearDepthStencilImage: - Serialise_vkCmdClearDepthStencilImage(ser, VK_NULL_HANDLE, VK_NULL_HANDLE, + return Serialise_vkCmdClearColorImage(ser, VK_NULL_HANDLE, VK_NULL_HANDLE, VK_IMAGE_LAYOUT_MAX_ENUM, NULL, 0, NULL); break; + case VulkanChunk::vkCmdClearDepthStencilImage: + return Serialise_vkCmdClearDepthStencilImage(ser, VK_NULL_HANDLE, VK_NULL_HANDLE, + VK_IMAGE_LAYOUT_MAX_ENUM, NULL, 0, NULL); + break; case VulkanChunk::vkCmdClearAttachments: - Serialise_vkCmdClearAttachments(ser, VK_NULL_HANDLE, 0, NULL, 0, NULL); + return Serialise_vkCmdClearAttachments(ser, VK_NULL_HANDLE, 0, NULL, 0, NULL); break; case VulkanChunk::vkCmdPipelineBarrier: - Serialise_vkCmdPipelineBarrier(ser, VK_NULL_HANDLE, 0, 0, VK_FALSE, 0, NULL, 0, NULL, 0, NULL); + return Serialise_vkCmdPipelineBarrier(ser, VK_NULL_HANDLE, 0, 0, VK_FALSE, 0, NULL, 0, NULL, + 0, NULL); break; case VulkanChunk::vkCmdWriteTimestamp: - Serialise_vkCmdWriteTimestamp(ser, VK_NULL_HANDLE, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, - VK_NULL_HANDLE, 0); + return Serialise_vkCmdWriteTimestamp(ser, VK_NULL_HANDLE, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, + VK_NULL_HANDLE, 0); break; case VulkanChunk::vkCmdCopyQueryPoolResults: - Serialise_vkCmdCopyQueryPoolResults(ser, VK_NULL_HANDLE, VK_NULL_HANDLE, 0, 0, VK_NULL_HANDLE, - 0, 0, 0); + return Serialise_vkCmdCopyQueryPoolResults(ser, VK_NULL_HANDLE, VK_NULL_HANDLE, 0, 0, + VK_NULL_HANDLE, 0, 0, 0); break; case VulkanChunk::vkCmdBeginQuery: - Serialise_vkCmdBeginQuery(ser, VK_NULL_HANDLE, VK_NULL_HANDLE, 0, 0); + return Serialise_vkCmdBeginQuery(ser, VK_NULL_HANDLE, VK_NULL_HANDLE, 0, 0); break; case VulkanChunk::vkCmdEndQuery: - Serialise_vkCmdEndQuery(ser, VK_NULL_HANDLE, VK_NULL_HANDLE, 0); + return Serialise_vkCmdEndQuery(ser, VK_NULL_HANDLE, VK_NULL_HANDLE, 0); break; case VulkanChunk::vkCmdResetQueryPool: - Serialise_vkCmdResetQueryPool(ser, VK_NULL_HANDLE, VK_NULL_HANDLE, 0, 0); + return Serialise_vkCmdResetQueryPool(ser, VK_NULL_HANDLE, VK_NULL_HANDLE, 0, 0); break; case VulkanChunk::vkCmdSetEvent: - Serialise_vkCmdSetEvent(ser, VK_NULL_HANDLE, VK_NULL_HANDLE, - VK_PIPELINE_STAGE_ALL_COMMANDS_BIT); + return Serialise_vkCmdSetEvent(ser, VK_NULL_HANDLE, VK_NULL_HANDLE, + VK_PIPELINE_STAGE_ALL_COMMANDS_BIT); break; case VulkanChunk::vkCmdResetEvent: - Serialise_vkCmdResetEvent(ser, VK_NULL_HANDLE, VK_NULL_HANDLE, - VK_PIPELINE_STAGE_ALL_COMMANDS_BIT); + return Serialise_vkCmdResetEvent(ser, VK_NULL_HANDLE, VK_NULL_HANDLE, + VK_PIPELINE_STAGE_ALL_COMMANDS_BIT); break; case VulkanChunk::vkCmdWaitEvents: - Serialise_vkCmdWaitEvents(ser, VK_NULL_HANDLE, 0, NULL, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, - VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, 0, NULL, 0, NULL, 0, NULL); + return Serialise_vkCmdWaitEvents( + ser, VK_NULL_HANDLE, 0, NULL, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, + VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, 0, NULL, 0, NULL, 0, NULL); break; - case VulkanChunk::vkCmdDraw: Serialise_vkCmdDraw(ser, VK_NULL_HANDLE, 0, 0, 0, 0); break; + case VulkanChunk::vkCmdDraw: return Serialise_vkCmdDraw(ser, VK_NULL_HANDLE, 0, 0, 0, 0); break; case VulkanChunk::vkCmdDrawIndirect: - Serialise_vkCmdDrawIndirect(ser, VK_NULL_HANDLE, VK_NULL_HANDLE, 0, 0, 0); + return Serialise_vkCmdDrawIndirect(ser, VK_NULL_HANDLE, VK_NULL_HANDLE, 0, 0, 0); break; case VulkanChunk::vkCmdDrawIndexed: - Serialise_vkCmdDrawIndexed(ser, VK_NULL_HANDLE, 0, 0, 0, 0, 0); + return Serialise_vkCmdDrawIndexed(ser, VK_NULL_HANDLE, 0, 0, 0, 0, 0); break; case VulkanChunk::vkCmdDrawIndexedIndirect: - Serialise_vkCmdDrawIndexedIndirect(ser, VK_NULL_HANDLE, VK_NULL_HANDLE, 0, 0, 0); + return Serialise_vkCmdDrawIndexedIndirect(ser, VK_NULL_HANDLE, VK_NULL_HANDLE, 0, 0, 0); + break; + case VulkanChunk::vkCmdDispatch: + return Serialise_vkCmdDispatch(ser, VK_NULL_HANDLE, 0, 0, 0); break; - case VulkanChunk::vkCmdDispatch: Serialise_vkCmdDispatch(ser, VK_NULL_HANDLE, 0, 0, 0); break; case VulkanChunk::vkCmdDispatchIndirect: - Serialise_vkCmdDispatchIndirect(ser, VK_NULL_HANDLE, VK_NULL_HANDLE, 0); + return Serialise_vkCmdDispatchIndirect(ser, VK_NULL_HANDLE, VK_NULL_HANDLE, 0); break; case VulkanChunk::vkCmdDebugMarkerBeginEXT: - Serialise_vkCmdDebugMarkerBeginEXT(ser, VK_NULL_HANDLE, NULL); + return Serialise_vkCmdDebugMarkerBeginEXT(ser, VK_NULL_HANDLE, NULL); break; case VulkanChunk::vkCmdDebugMarkerInsertEXT: - Serialise_vkCmdDebugMarkerInsertEXT(ser, VK_NULL_HANDLE, NULL); + return Serialise_vkCmdDebugMarkerInsertEXT(ser, VK_NULL_HANDLE, NULL); break; case VulkanChunk::vkCmdDebugMarkerEndEXT: - Serialise_vkCmdDebugMarkerEndEXT(ser, VK_NULL_HANDLE); + return Serialise_vkCmdDebugMarkerEndEXT(ser, VK_NULL_HANDLE); break; case VulkanChunk::vkDebugMarkerSetObjectNameEXT: - Serialise_vkDebugMarkerSetObjectNameEXT(ser, VK_NULL_HANDLE, NULL); + return Serialise_vkDebugMarkerSetObjectNameEXT(ser, VK_NULL_HANDLE, NULL); break; case VulkanChunk::SetShaderDebugPath: - Serialise_SetShaderDebugPath(ser, VK_NULL_HANDLE, NULL); + return Serialise_SetShaderDebugPath(ser, VK_NULL_HANDLE, NULL); break; case VulkanChunk::vkCreateSwapchainKHR: - Serialise_vkCreateSwapchainKHR(ser, VK_NULL_HANDLE, NULL, NULL, NULL); + return Serialise_vkCreateSwapchainKHR(ser, VK_NULL_HANDLE, NULL, NULL, NULL); break; - case VulkanChunk::CaptureScope: Serialise_CaptureScope(ser); break; + case VulkanChunk::CaptureScope: return Serialise_CaptureScope(ser); break; case VulkanChunk::CaptureEnd: { SERIALISE_ELEMENT_LOCAL(PresentedImage, ResourceId()); + SERIALISE_CHECK_READ_ERRORS(); + if(IsLoading(m_State)) { AddEvent(); @@ -2129,28 +2185,36 @@ void WrappedVulkan::ProcessChunk(ReadSerialiser &ser, VulkanChunk chunk) VkInitParams InitParams; SERIALISE_ELEMENT(InitParams); + SERIALISE_CHECK_READ_ERRORS(); + AddResourceCurChunk(InitParams.InstanceID); } else if(system == SystemChunk::InitialContentsList) { GetResourceManager()->CreateInitialContents(ser); + + SERIALISE_CHECK_READ_ERRORS(); } else if(system == SystemChunk::InitialContents) { - Serialise_InitialState(ser, ResourceId(), NULL); + return Serialise_InitialState(ser, ResourceId(), NULL); } else if(system < SystemChunk::FirstDriverChunk) { RDCERR("Unexpected system chunk in capture data: %u", system); ser.SkipCurrentChunk(); + + SERIALISE_CHECK_READ_ERRORS(); } else { RDCERR("Unrecognised Chunk type %d", chunk); + return false; } - break; } } + + return true; } void WrappedVulkan::ReplayLog(uint32_t startEventID, uint32_t endEventID, ReplayLogType replayType) @@ -2266,21 +2330,19 @@ void WrappedVulkan::ReplayLog(uint32_t startEventID, uint32_t endEventID, Replay } } + ReplayStatus status = ReplayStatus::Succeeded; + if(replayType == eReplay_Full) - { - ContextReplayLog(m_State, startEventID, endEventID, partial); - } + status = ContextReplayLog(m_State, startEventID, endEventID, partial); else if(replayType == eReplay_WithoutDraw) - { - ContextReplayLog(m_State, startEventID, RDCMAX(1U, endEventID) - 1, partial); - } + status = ContextReplayLog(m_State, startEventID, RDCMAX(1U, endEventID) - 1, partial); else if(replayType == eReplay_OnlyDraw) - { - ContextReplayLog(m_State, endEventID, endEventID, partial); - } + status = ContextReplayLog(m_State, endEventID, endEventID, partial); else RDCFATAL("Unexpected replay type"); + RDCASSERTEQUAL(status, ReplayStatus::Succeeded); + if(m_Partial[Primary].outsideCmdBuffer != VK_NULL_HANDLE) { VkCommandBuffer cmd = m_Partial[Primary].outsideCmdBuffer; diff --git a/renderdoc/driver/vulkan/vk_core.h b/renderdoc/driver/vulkan/vk_core.h index 8bd2bc845..0419f67f3 100644 --- a/renderdoc/driver/vulkan/vk_core.h +++ b/renderdoc/driver/vulkan/vk_core.h @@ -638,7 +638,7 @@ private: WriteSerialiser &GetThreadSerialiser(); template - void Serialise_CaptureScope(SerialiserType &ser); + bool Serialise_CaptureScope(SerialiserType &ser); bool HasSuccessfulCapture(); template @@ -686,6 +686,8 @@ private: uint32_t m_RootEventID, m_RootDrawcallID; uint32_t m_FirstEventID, m_LastEventID; + ReplayStatus m_FailedReplayStatus = ReplayStatus::APIReplayFailed; + VulkanDrawcallTreeNode m_ParentDrawcall; bool m_ExtensionsEnabled[VkCheckExt_Max]; @@ -706,10 +708,10 @@ private: return m_DrawcallStack; } - void ProcessChunk(ReadSerialiser &ser, VulkanChunk chunk); - void ContextReplayLog(CaptureState readType, uint32_t startEventID, uint32_t endEventID, - bool partial); - void ContextProcessChunk(ReadSerialiser &ser, VulkanChunk chunk); + bool ProcessChunk(ReadSerialiser &ser, VulkanChunk chunk); + ReplayStatus ContextReplayLog(CaptureState readType, uint32_t startEventID, uint32_t endEventID, + bool partial); + bool ContextProcessChunk(ReadSerialiser &ser, VulkanChunk chunk); void AddDrawcall(const DrawcallDescription &d, bool hasEvents); void AddEvent(); diff --git a/renderdoc/driver/vulkan/vk_initstate.cpp b/renderdoc/driver/vulkan/vk_initstate.cpp index 137afd589..39e2b65fe 100644 --- a/renderdoc/driver/vulkan/vk_initstate.cpp +++ b/renderdoc/driver/vulkan/vk_initstate.cpp @@ -558,6 +558,8 @@ bool WrappedVulkan::Serialise_InitialState(SerialiserType &ser, ResourceId id, W SERIALISE_ELEMENT_ARRAY(Bindings, NumBindings); + SERIALISE_CHECK_READ_ERRORS(); + // while reading, fetch the binding information and allocate a VkWriteDescriptorSet array if(IsReplayingAndReading()) { @@ -759,7 +761,7 @@ bool WrappedVulkan::Serialise_InitialState(SerialiserType &ser, ResourceId id, W (void **)&Contents); RDCASSERTEQUAL(vkr, VK_SUCCESS); } - else if(IsReplayingAndReading()) + else if(IsReplayingAndReading() && !ser.IsErrored()) { // create a buffer with memory attached, which we will fill with the initial contents VkBufferCreateInfo bufInfo = { @@ -802,9 +804,11 @@ bool WrappedVulkan::Serialise_InitialState(SerialiserType &ser, ResourceId id, W ser.Serialise("Contents", Contents, ContentsSize, SerialiserFlags::NoFlags); // unmap the resource we mapped before - we need to do this on read and on write. - if(!IsStructuredExporting(m_State)) + if(!IsStructuredExporting(m_State) && mappedMem) ObjDisp(d)->UnmapMemory(Unwrap(d), Unwrap(mappedMem)); + SERIALISE_CHECK_READ_ERRORS(); + // if we're handling a device memory object, we're done - we note the memory object to delete at // the end of the program, and store the buffer to copy off in Apply if(IsReplayingAndReading()) diff --git a/renderdoc/driver/vulkan/vk_sparse_initstate.cpp b/renderdoc/driver/vulkan/vk_sparse_initstate.cpp index e8f823ca7..1b66c5b48 100644 --- a/renderdoc/driver/vulkan/vk_sparse_initstate.cpp +++ b/renderdoc/driver/vulkan/vk_sparse_initstate.cpp @@ -505,7 +505,7 @@ bool WrappedVulkan::Serialise_SparseBufferInitialState( ObjDisp(d)->MapMemory(Unwrap(d), Unwrap(mappedMem), 0, VK_WHOLE_SIZE, 0, (void **)&Contents); RDCASSERTEQUAL(vkr, VK_SUCCESS); } - else if(IsReplayingAndReading()) + else if(IsReplayingAndReading() && !ser.IsErrored()) { // create a buffer with memory attached, which we will fill with the initial contents VkBufferCreateInfo bufInfo = { @@ -548,7 +548,10 @@ bool WrappedVulkan::Serialise_SparseBufferInitialState( ser.Serialise("Contents", Contents, ContentsSize, SerialiserFlags::NoFlags); // unmap the resource we mapped before - we need to do this on read and on write. - ObjDisp(d)->UnmapMemory(Unwrap(d), Unwrap(mappedMem)); + if(!IsStructuredExporting(m_State) && mappedMem) + ObjDisp(d)->UnmapMemory(Unwrap(d), Unwrap(mappedMem)); + + SERIALISE_CHECK_READ_ERRORS(); if(IsReplayingAndReading()) { @@ -607,7 +610,7 @@ bool WrappedVulkan::Serialise_SparseImageInitialState(SerialiserType &ser, Resou ObjDisp(d)->MapMemory(Unwrap(d), Unwrap(mappedMem), 0, VK_WHOLE_SIZE, 0, (void **)&Contents); RDCASSERTEQUAL(vkr, VK_SUCCESS); } - else if(IsReplayingAndReading()) + else if(IsReplayingAndReading() && !ser.IsErrored()) { // create a buffer with memory attached, which we will fill with the initial contents VkBufferCreateInfo bufInfo = { @@ -650,7 +653,10 @@ bool WrappedVulkan::Serialise_SparseImageInitialState(SerialiserType &ser, Resou ser.Serialise("Contents", Contents, ContentsSize, SerialiserFlags::NoFlags); // unmap the resource we mapped before - we need to do this on read and on write. - ObjDisp(d)->UnmapMemory(Unwrap(d), Unwrap(mappedMem)); + if(!IsStructuredExporting(m_State) && mappedMem) + ObjDisp(d)->UnmapMemory(Unwrap(d), Unwrap(mappedMem)); + + SERIALISE_CHECK_READ_ERRORS(); if(IsReplayingAndReading()) { diff --git a/renderdoc/driver/vulkan/wrappers/vk_cmd_funcs.cpp b/renderdoc/driver/vulkan/wrappers/vk_cmd_funcs.cpp index 67b1062fc..129e1e8d2 100644 --- a/renderdoc/driver/vulkan/wrappers/vk_cmd_funcs.cpp +++ b/renderdoc/driver/vulkan/wrappers/vk_cmd_funcs.cpp @@ -326,6 +326,8 @@ bool WrappedVulkan::Serialise_vkCreateCommandPool(SerialiserType &ser, VkDevice SERIALISE_ELEMENT_LOCAL(CreateInfo, *pCreateInfo); SERIALISE_ELEMENT_LOCAL(CmdPool, GetResID(*pCmdPool)); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { VkCommandPool pool = VK_NULL_HANDLE; @@ -409,6 +411,8 @@ bool WrappedVulkan::Serialise_vkAllocateCommandBuffers(SerialiserType &ser, VkDe SERIALISE_ELEMENT_LOCAL(AllocateInfo, *pAllocateInfo); SERIALISE_ELEMENT_LOCAL(CommandBuffer, GetResID(*pCommandBuffers)); + SERIALISE_CHECK_READ_ERRORS(); + // this chunk is purely for user information and consistency, the command buffer we allocate is // a dummy and is not used for anything. @@ -550,6 +554,8 @@ bool WrappedVulkan::Serialise_vkBeginCommandBuffer(SerialiserType &ser, VkComman SERIALISE_ELEMENT(device); SERIALISE_ELEMENT(AllocateInfo); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_LastCmdBufferID = CommandBuffer; @@ -800,6 +806,8 @@ bool WrappedVulkan::Serialise_vkEndCommandBuffer(SerialiserType &ser, VkCommandB SERIALISE_ELEMENT_LOCAL(CommandBuffer, GetResID(commandBuffer)); SERIALISE_ELEMENT(BakedCommandBuffer); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_LastCmdBufferID = CommandBuffer; @@ -947,6 +955,8 @@ bool WrappedVulkan::Serialise_vkCmdBeginRenderPass(SerialiserType &ser, VkComman Serialise_DebugMessages(ser); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { VkRenderPassBeginInfo unwrappedInfo = RenderPassBegin; @@ -1059,6 +1069,8 @@ bool WrappedVulkan::Serialise_vkCmdNextSubpass(SerialiserType &ser, VkCommandBuf Serialise_DebugMessages(ser); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_LastCmdBufferID = GetResourceManager()->GetOriginalID(GetResID(commandBuffer)); @@ -1135,6 +1147,8 @@ bool WrappedVulkan::Serialise_vkCmdEndRenderPass(SerialiserType &ser, VkCommandB Serialise_DebugMessages(ser); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_LastCmdBufferID = GetResourceManager()->GetOriginalID(GetResID(commandBuffer)); @@ -1231,6 +1245,8 @@ bool WrappedVulkan::Serialise_vkCmdBindPipeline(SerialiserType &ser, VkCommandBu Serialise_DebugMessages(ser); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_LastCmdBufferID = GetResourceManager()->GetOriginalID(GetResID(commandBuffer)); @@ -1351,6 +1367,8 @@ bool WrappedVulkan::Serialise_vkCmdBindDescriptorSets( Serialise_DebugMessages(ser); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_LastCmdBufferID = GetResourceManager()->GetOriginalID(GetResID(commandBuffer)); @@ -1519,6 +1537,8 @@ bool WrappedVulkan::Serialise_vkCmdBindVertexBuffers(SerialiserType &ser, Serialise_DebugMessages(ser); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_LastCmdBufferID = GetResourceManager()->GetOriginalID(GetResID(commandBuffer)); @@ -1604,6 +1624,8 @@ bool WrappedVulkan::Serialise_vkCmdBindIndexBuffer(SerialiserType &ser, Serialise_DebugMessages(ser); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_LastCmdBufferID = GetResourceManager()->GetOriginalID(GetResID(commandBuffer)); @@ -1676,6 +1698,8 @@ bool WrappedVulkan::Serialise_vkCmdUpdateBuffer(SerialiserType &ser, VkCommandBu Serialise_DebugMessages(ser); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_LastCmdBufferID = GetResourceManager()->GetOriginalID(GetResID(commandBuffer)); @@ -1743,6 +1767,8 @@ bool WrappedVulkan::Serialise_vkCmdFillBuffer(SerialiserType &ser, VkCommandBuff Serialise_DebugMessages(ser); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_LastCmdBufferID = GetResourceManager()->GetOriginalID(GetResID(commandBuffer)); @@ -1811,6 +1837,8 @@ bool WrappedVulkan::Serialise_vkCmdPushConstants(SerialiserType &ser, VkCommandB Serialise_DebugMessages(ser); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_LastCmdBufferID = GetResourceManager()->GetOriginalID(GetResID(commandBuffer)); @@ -1881,6 +1909,8 @@ bool WrappedVulkan::Serialise_vkCmdPipelineBarrier( Serialise_DebugMessages(ser); + SERIALISE_CHECK_READ_ERRORS(); + std::vector imgBarriers; std::vector bufBarriers; @@ -2019,6 +2049,8 @@ bool WrappedVulkan::Serialise_vkCmdWriteTimestamp(SerialiserType &ser, VkCommand Serialise_DebugMessages(ser); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_LastCmdBufferID = GetResourceManager()->GetOriginalID(GetResID(commandBuffer)); @@ -2082,6 +2114,8 @@ bool WrappedVulkan::Serialise_vkCmdCopyQueryPoolResults( Serialise_DebugMessages(ser); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_LastCmdBufferID = GetResourceManager()->GetOriginalID(GetResID(commandBuffer)); @@ -2153,6 +2187,8 @@ bool WrappedVulkan::Serialise_vkCmdBeginQuery(SerialiserType &ser, VkCommandBuff Serialise_DebugMessages(ser); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_LastCmdBufferID = GetResourceManager()->GetOriginalID(GetResID(commandBuffer)); @@ -2203,6 +2239,8 @@ bool WrappedVulkan::Serialise_vkCmdEndQuery(SerialiserType &ser, VkCommandBuffer Serialise_DebugMessages(ser); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_LastCmdBufferID = GetResourceManager()->GetOriginalID(GetResID(commandBuffer)); @@ -2254,6 +2292,8 @@ bool WrappedVulkan::Serialise_vkCmdResetQueryPool(SerialiserType &ser, VkCommand Serialise_DebugMessages(ser); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_LastCmdBufferID = GetResourceManager()->GetOriginalID(GetResID(commandBuffer)); @@ -2308,6 +2348,8 @@ bool WrappedVulkan::Serialise_vkCmdExecuteCommands(SerialiserType &ser, VkComman Serialise_DebugMessages(ser); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_LastCmdBufferID = GetResourceManager()->GetOriginalID(GetResID(commandBuffer)); @@ -2609,6 +2651,8 @@ bool WrappedVulkan::Serialise_vkCmdDebugMarkerBeginEXT(SerialiserType &ser, SERIALISE_ELEMENT(commandBuffer); SERIALISE_ELEMENT_LOCAL(Marker, *pMarker); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_LastCmdBufferID = GetResourceManager()->GetOriginalID(GetResID(commandBuffer)); @@ -2671,6 +2715,8 @@ bool WrappedVulkan::Serialise_vkCmdDebugMarkerEndEXT(SerialiserType &ser, { SERIALISE_ELEMENT(commandBuffer); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_LastCmdBufferID = GetResourceManager()->GetOriginalID(GetResID(commandBuffer)); @@ -2741,6 +2787,8 @@ bool WrappedVulkan::Serialise_vkCmdDebugMarkerInsertEXT(SerialiserType &ser, SERIALISE_ELEMENT(commandBuffer); SERIALISE_ELEMENT_LOCAL(Marker, *pMarker); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_LastCmdBufferID = GetResourceManager()->GetOriginalID(GetResID(commandBuffer)); diff --git a/renderdoc/driver/vulkan/wrappers/vk_descriptor_funcs.cpp b/renderdoc/driver/vulkan/wrappers/vk_descriptor_funcs.cpp index 866393181..c520a49dd 100644 --- a/renderdoc/driver/vulkan/wrappers/vk_descriptor_funcs.cpp +++ b/renderdoc/driver/vulkan/wrappers/vk_descriptor_funcs.cpp @@ -165,6 +165,8 @@ bool WrappedVulkan::Serialise_vkCreateDescriptorPool(SerialiserType &ser, VkDevi SERIALISE_ELEMENT_LOCAL(CreateInfo, *pCreateInfo); SERIALISE_ELEMENT_LOCAL(DescriptorPool, GetResID(*pDescriptorPool)); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { VkDescriptorPool pool = VK_NULL_HANDLE; @@ -234,6 +236,8 @@ bool WrappedVulkan::Serialise_vkCreateDescriptorSetLayout( SERIALISE_ELEMENT_LOCAL(CreateInfo, *pCreateInfo); SERIALISE_ELEMENT_LOCAL(SetLayout, GetResID(*pSetLayout)); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { VkDescriptorSetLayout layout = VK_NULL_HANDLE; @@ -356,6 +360,8 @@ bool WrappedVulkan::Serialise_vkAllocateDescriptorSets(SerialiserType &ser, VkDe SERIALISE_ELEMENT_LOCAL(AllocateInfo, *pAllocateInfo); SERIALISE_ELEMENT_LOCAL(DescriptorSet, GetResID(*pDescriptorSets)); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { VkDescriptorSet descset = VK_NULL_HANDLE; @@ -720,6 +726,8 @@ bool WrappedVulkan::Serialise_vkUpdateDescriptorSets(SerialiserType &ser, VkDevi Serialise_DebugMessages(ser); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { for(uint32_t i = 0; i < writeCount; i++) diff --git a/renderdoc/driver/vulkan/wrappers/vk_device_funcs.cpp b/renderdoc/driver/vulkan/wrappers/vk_device_funcs.cpp index 3405fe7d5..5c28e0a30 100644 --- a/renderdoc/driver/vulkan/wrappers/vk_device_funcs.cpp +++ b/renderdoc/driver/vulkan/wrappers/vk_device_funcs.cpp @@ -571,6 +571,8 @@ bool WrappedVulkan::Serialise_vkEnumeratePhysicalDevices(SerialiserType &ser, Vk VkPhysicalDevice pd = VK_NULL_HANDLE; + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { { @@ -882,6 +884,8 @@ bool WrappedVulkan::Serialise_vkCreateDevice(SerialiserType &ser, VkPhysicalDevi SERIALISE_ELEMENT_LOCAL(Device, GetResID(*pDevice)); SERIALISE_ELEMENT(m_SupportedQueueFamily); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { // we must make any modifications locally, so the free of pointers @@ -1562,6 +1566,8 @@ bool WrappedVulkan::Serialise_vkDeviceWaitIdle(SerialiserType &ser, VkDevice dev { SERIALISE_ELEMENT(device); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { ObjDisp(device)->DeviceWaitIdle(Unwrap(device)); diff --git a/renderdoc/driver/vulkan/wrappers/vk_draw_funcs.cpp b/renderdoc/driver/vulkan/wrappers/vk_draw_funcs.cpp index 998ac76e3..aa36f754e 100644 --- a/renderdoc/driver/vulkan/wrappers/vk_draw_funcs.cpp +++ b/renderdoc/driver/vulkan/wrappers/vk_draw_funcs.cpp @@ -78,6 +78,8 @@ bool WrappedVulkan::Serialise_vkCmdDraw(SerialiserType &ser, VkCommandBuffer com Serialise_DebugMessages(ser); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_LastCmdBufferID = GetResourceManager()->GetOriginalID(GetResID(commandBuffer)); @@ -174,6 +176,8 @@ bool WrappedVulkan::Serialise_vkCmdDrawIndexed(SerialiserType &ser, VkCommandBuf Serialise_DebugMessages(ser); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_LastCmdBufferID = GetResourceManager()->GetOriginalID(GetResID(commandBuffer)); @@ -273,6 +277,8 @@ bool WrappedVulkan::Serialise_vkCmdDrawIndirect(SerialiserType &ser, VkCommandBu Serialise_DebugMessages(ser); + SERIALISE_CHECK_READ_ERRORS(); + bool multidraw = count > 1; if(IsReplayingAndReading()) @@ -555,6 +561,8 @@ bool WrappedVulkan::Serialise_vkCmdDrawIndexedIndirect(SerialiserType &ser, Serialise_DebugMessages(ser); + SERIALISE_CHECK_READ_ERRORS(); + bool multidraw = count > 1; if(IsReplayingAndReading()) @@ -841,6 +849,8 @@ bool WrappedVulkan::Serialise_vkCmdDispatch(SerialiserType &ser, VkCommandBuffer Serialise_DebugMessages(ser); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_LastCmdBufferID = GetResourceManager()->GetOriginalID(GetResID(commandBuffer)); @@ -916,6 +926,8 @@ bool WrappedVulkan::Serialise_vkCmdDispatchIndirect(SerialiserType &ser, Serialise_DebugMessages(ser); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_LastCmdBufferID = GetResourceManager()->GetOriginalID(GetResID(commandBuffer)); @@ -1021,6 +1033,8 @@ bool WrappedVulkan::Serialise_vkCmdBlitImage(SerialiserType &ser, VkCommandBuffe Serialise_DebugMessages(ser); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_LastCmdBufferID = GetResourceManager()->GetOriginalID(GetResID(commandBuffer)); @@ -1141,6 +1155,8 @@ bool WrappedVulkan::Serialise_vkCmdResolveImage(SerialiserType &ser, VkCommandBu Serialise_DebugMessages(ser); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_LastCmdBufferID = GetResourceManager()->GetOriginalID(GetResID(commandBuffer)); @@ -1261,6 +1277,8 @@ bool WrappedVulkan::Serialise_vkCmdCopyImage(SerialiserType &ser, VkCommandBuffe Serialise_DebugMessages(ser); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_LastCmdBufferID = GetResourceManager()->GetOriginalID(GetResID(commandBuffer)); @@ -1378,6 +1396,8 @@ bool WrappedVulkan::Serialise_vkCmdCopyBufferToImage( Serialise_DebugMessages(ser); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_LastCmdBufferID = GetResourceManager()->GetOriginalID(GetResID(commandBuffer)); @@ -1489,6 +1509,8 @@ bool WrappedVulkan::Serialise_vkCmdCopyImageToBuffer(SerialiserType &ser, Serialise_DebugMessages(ser); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_LastCmdBufferID = GetResourceManager()->GetOriginalID(GetResID(commandBuffer)); @@ -1601,6 +1623,8 @@ bool WrappedVulkan::Serialise_vkCmdCopyBuffer(SerialiserType &ser, VkCommandBuff Serialise_DebugMessages(ser); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_LastCmdBufferID = GetResourceManager()->GetOriginalID(GetResID(commandBuffer)); @@ -1723,6 +1747,8 @@ bool WrappedVulkan::Serialise_vkCmdClearColorImage(SerialiserType &ser, VkComman Serialise_DebugMessages(ser); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_LastCmdBufferID = GetResourceManager()->GetOriginalID(GetResID(commandBuffer)); @@ -1824,6 +1850,8 @@ bool WrappedVulkan::Serialise_vkCmdClearDepthStencilImage( Serialise_DebugMessages(ser); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_LastCmdBufferID = GetResourceManager()->GetOriginalID(GetResID(commandBuffer)); @@ -1926,6 +1954,8 @@ bool WrappedVulkan::Serialise_vkCmdClearAttachments(SerialiserType &ser, Serialise_DebugMessages(ser); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_LastCmdBufferID = GetResourceManager()->GetOriginalID(GetResID(commandBuffer)); diff --git a/renderdoc/driver/vulkan/wrappers/vk_dynamic_funcs.cpp b/renderdoc/driver/vulkan/wrappers/vk_dynamic_funcs.cpp index 7ded3b849..f78e6e51b 100644 --- a/renderdoc/driver/vulkan/wrappers/vk_dynamic_funcs.cpp +++ b/renderdoc/driver/vulkan/wrappers/vk_dynamic_funcs.cpp @@ -35,6 +35,8 @@ bool WrappedVulkan::Serialise_vkCmdSetViewport(SerialiserType &ser, VkCommandBuf Serialise_DebugMessages(ser); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_LastCmdBufferID = GetResourceManager()->GetOriginalID(GetResID(commandBuffer)); @@ -96,6 +98,8 @@ bool WrappedVulkan::Serialise_vkCmdSetScissor(SerialiserType &ser, VkCommandBuff Serialise_DebugMessages(ser); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_LastCmdBufferID = GetResourceManager()->GetOriginalID(GetResID(commandBuffer)); @@ -154,6 +158,8 @@ bool WrappedVulkan::Serialise_vkCmdSetLineWidth(SerialiserType &ser, VkCommandBu Serialise_DebugMessages(ser); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_LastCmdBufferID = GetResourceManager()->GetOriginalID(GetResID(commandBuffer)); @@ -210,6 +216,8 @@ bool WrappedVulkan::Serialise_vkCmdSetDepthBias(SerialiserType &ser, VkCommandBu Serialise_DebugMessages(ser); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_LastCmdBufferID = GetResourceManager()->GetOriginalID(GetResID(commandBuffer)); @@ -269,6 +277,8 @@ bool WrappedVulkan::Serialise_vkCmdSetBlendConstants(SerialiserType &ser, Serialise_DebugMessages(ser); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_LastCmdBufferID = GetResourceManager()->GetOriginalID(GetResID(commandBuffer)); @@ -323,6 +333,8 @@ bool WrappedVulkan::Serialise_vkCmdSetDepthBounds(SerialiserType &ser, VkCommand Serialise_DebugMessages(ser); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_LastCmdBufferID = GetResourceManager()->GetOriginalID(GetResID(commandBuffer)); @@ -381,6 +393,8 @@ bool WrappedVulkan::Serialise_vkCmdSetStencilCompareMask(SerialiserType &ser, Serialise_DebugMessages(ser); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_LastCmdBufferID = GetResourceManager()->GetOriginalID(GetResID(commandBuffer)); @@ -441,6 +455,8 @@ bool WrappedVulkan::Serialise_vkCmdSetStencilWriteMask(SerialiserType &ser, Serialise_DebugMessages(ser); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_LastCmdBufferID = GetResourceManager()->GetOriginalID(GetResID(commandBuffer)); @@ -501,6 +517,8 @@ bool WrappedVulkan::Serialise_vkCmdSetStencilReference(SerialiserType &ser, Serialise_DebugMessages(ser); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_LastCmdBufferID = GetResourceManager()->GetOriginalID(GetResID(commandBuffer)); diff --git a/renderdoc/driver/vulkan/wrappers/vk_misc_funcs.cpp b/renderdoc/driver/vulkan/wrappers/vk_misc_funcs.cpp index 69c7b4789..39da38e5e 100644 --- a/renderdoc/driver/vulkan/wrappers/vk_misc_funcs.cpp +++ b/renderdoc/driver/vulkan/wrappers/vk_misc_funcs.cpp @@ -398,6 +398,8 @@ bool WrappedVulkan::Serialise_vkCreateSampler(SerialiserType &ser, VkDevice devi SERIALISE_ELEMENT_LOCAL(CreateInfo, *pCreateInfo); SERIALISE_ELEMENT_LOCAL(Sampler, GetResID(*pSampler)); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { VkSampler samp = VK_NULL_HANDLE; @@ -485,6 +487,8 @@ bool WrappedVulkan::Serialise_vkCreateFramebuffer(SerialiserType &ser, VkDevice SERIALISE_ELEMENT_LOCAL(CreateInfo, *pCreateInfo); SERIALISE_ELEMENT_LOCAL(Framebuffer, GetResID(*pFramebuffer)); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { VkFramebuffer fb = VK_NULL_HANDLE; @@ -666,6 +670,8 @@ bool WrappedVulkan::Serialise_vkCreateRenderPass(SerialiserType &ser, VkDevice d SERIALISE_ELEMENT_LOCAL(CreateInfo, *pCreateInfo); SERIALISE_ELEMENT_LOCAL(RenderPass, GetResID(*pRenderPass)); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { VkRenderPass rp = VK_NULL_HANDLE; @@ -874,6 +880,8 @@ bool WrappedVulkan::Serialise_vkCreateQueryPool(SerialiserType &ser, VkDevice de SERIALISE_ELEMENT_LOCAL(CreateInfo, *pCreateInfo); SERIALISE_ELEMENT_LOCAL(QueryPool, GetResID(*pQueryPool)); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { VkQueryPool pool = VK_NULL_HANDLE; @@ -1151,6 +1159,8 @@ bool WrappedVulkan::Serialise_SetShaderDebugPath(SerialiserType &ser, VkDevice d SERIALISE_ELEMENT(DebugPath); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_CreationInfo.m_ShaderModule[GetResourceManager()->GetLiveID(ShaderObject)].unstrippedPath = @@ -1227,6 +1237,8 @@ bool WrappedVulkan::Serialise_vkDebugMarkerSetObjectNameEXT( GetObjRecord(pNameInfo->objectType, pNameInfo->object)->GetResourceID()); SERIALISE_ELEMENT_LOCAL(ObjectName, pNameInfo->pObjectName); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { // if we don't have a live resource, this is probably a command buffer being named on the diff --git a/renderdoc/driver/vulkan/wrappers/vk_queue_funcs.cpp b/renderdoc/driver/vulkan/wrappers/vk_queue_funcs.cpp index b68607695..a472a418e 100644 --- a/renderdoc/driver/vulkan/wrappers/vk_queue_funcs.cpp +++ b/renderdoc/driver/vulkan/wrappers/vk_queue_funcs.cpp @@ -34,6 +34,8 @@ bool WrappedVulkan::Serialise_vkGetDeviceQueue(SerialiserType &ser, VkDevice dev SERIALISE_ELEMENT(queueIndex); SERIALISE_ELEMENT_LOCAL(Queue, GetResID(*pQueue)); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { VkQueue queue; @@ -134,6 +136,8 @@ bool WrappedVulkan::Serialise_vkQueueSubmit(SerialiserType &ser, VkQueue queue, Serialise_DebugMessages(ser); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { // if we ever waited on any semaphores, wait for idle here. @@ -852,6 +856,8 @@ bool WrappedVulkan::Serialise_vkQueueBindSparse(SerialiserType &ser, VkQueue que SERIALISE_ELEMENT_ARRAY(pBindInfo, bindInfoCount); SERIALISE_ELEMENT(fence); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { // similar to vkQueueSubmit we don't need semaphores at all, just whether we waited on any. @@ -1113,6 +1119,8 @@ bool WrappedVulkan::Serialise_vkQueueWaitIdle(SerialiserType &ser, VkQueue queue { SERIALISE_ELEMENT(queue); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { ObjDisp(queue)->QueueWaitIdle(Unwrap(queue)); diff --git a/renderdoc/driver/vulkan/wrappers/vk_resource_funcs.cpp b/renderdoc/driver/vulkan/wrappers/vk_resource_funcs.cpp index 0bc3b3da1..499fb730f 100644 --- a/renderdoc/driver/vulkan/wrappers/vk_resource_funcs.cpp +++ b/renderdoc/driver/vulkan/wrappers/vk_resource_funcs.cpp @@ -150,6 +150,8 @@ bool WrappedVulkan::Serialise_vkAllocateMemory(SerialiserType &ser, VkDevice dev SERIALISE_ELEMENT_LOCAL(AllocateInfo, *pAllocateInfo); SERIALISE_ELEMENT_LOCAL(Memory, GetResID(*pMemory)); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { VkDeviceMemory mem = VK_NULL_HANDLE; @@ -599,7 +601,7 @@ bool WrappedVulkan::Serialise_vkUnmapMemory(SerialiserType &ser, VkDevice device SERIALISE_ELEMENT(MapOffset); SERIALISE_ELEMENT(MapSize); - if(IsReplayingAndReading()) + if(IsReplayingAndReading() && memory) { VkResult vkr = ObjDisp(device)->MapMemory(Unwrap(device), Unwrap(memory), MapOffset, MapSize, 0, (void **)&MapData); @@ -611,9 +613,11 @@ bool WrappedVulkan::Serialise_vkUnmapMemory(SerialiserType &ser, VkDevice device // directly into upload memory ser.Serialise("MapData", MapData, MapSize, SerialiserFlags::NoFlags); - if(IsReplayingAndReading() && MapData) + if(IsReplayingAndReading() && MapData && memory) ObjDisp(device)->UnmapMemory(Unwrap(device), Unwrap(memory)); + SERIALISE_CHECK_READ_ERRORS(); + return true; } @@ -720,7 +724,7 @@ bool WrappedVulkan::Serialise_vkFlushMappedMemoryRanges(SerialiserType &ser, VkD MappedData = state->mappedPtr + (size_t)MemRange.offset; } - if(IsReplayingAndReading()) + if(IsReplayingAndReading() && MemRange.memory) { VkResult ret = ObjDisp(device)->MapMemory(Unwrap(device), Unwrap(MemRange.memory), MemRange.offset, @@ -733,9 +737,11 @@ bool WrappedVulkan::Serialise_vkFlushMappedMemoryRanges(SerialiserType &ser, VkD // directly into upload memory ser.Serialise("MappedData", MappedData, memRangeSize, SerialiserFlags::NoFlags); - if(IsReplayingAndReading() && MappedData) + if(IsReplayingAndReading() && MappedData && MemRange.memory) ObjDisp(device)->UnmapMemory(Unwrap(device), Unwrap(MemRange.memory)); + SERIALISE_CHECK_READ_ERRORS(); + // if we need to save off this serialised buffer as reference for future comparison, // do so now. See the call to vkFlushMappedMemoryRanges in WrappedVulkan::vkQueueSubmit() if(ser.IsWriting() && state->needRefData) @@ -847,6 +853,8 @@ bool WrappedVulkan::Serialise_vkBindBufferMemory(SerialiserType &ser, VkDevice d SERIALISE_ELEMENT(memory); SERIALISE_ELEMENT(memoryOffset); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { ObjDisp(device)->BindBufferMemory(Unwrap(device), Unwrap(buffer), Unwrap(memory), memoryOffset); @@ -904,6 +912,8 @@ bool WrappedVulkan::Serialise_vkBindImageMemory(SerialiserType &ser, VkDevice de SERIALISE_ELEMENT(memory); SERIALISE_ELEMENT(memoryOffset); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { ObjDisp(device)->BindImageMemory(Unwrap(device), Unwrap(image), Unwrap(memory), memoryOffset); @@ -965,6 +975,8 @@ bool WrappedVulkan::Serialise_vkCreateBuffer(SerialiserType &ser, VkDevice devic SERIALISE_ELEMENT_LOCAL(CreateInfo, *pCreateInfo); SERIALISE_ELEMENT_LOCAL(Buffer, GetResID(*pBuffer)); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { VkBuffer buf = VK_NULL_HANDLE; @@ -1073,6 +1085,8 @@ bool WrappedVulkan::Serialise_vkCreateBufferView(SerialiserType &ser, VkDevice d SERIALISE_ELEMENT_LOCAL(CreateInfo, *pCreateInfo); SERIALISE_ELEMENT_LOCAL(View, GetResID(*pView)); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { VkBufferView view = VK_NULL_HANDLE; @@ -1172,6 +1186,8 @@ bool WrappedVulkan::Serialise_vkCreateImage(SerialiserType &ser, VkDevice device SERIALISE_ELEMENT_LOCAL(CreateInfo, *pCreateInfo); SERIALISE_ELEMENT_LOCAL(Image, GetResID(*pImage)); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { VkImage img = VK_NULL_HANDLE; @@ -1482,6 +1498,8 @@ bool WrappedVulkan::Serialise_vkCreateImageView(SerialiserType &ser, VkDevice de SERIALISE_ELEMENT_LOCAL(CreateInfo, *pCreateInfo); SERIALISE_ELEMENT_LOCAL(View, GetResID(*pView)); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { VkImageView view = VK_NULL_HANDLE; diff --git a/renderdoc/driver/vulkan/wrappers/vk_shader_funcs.cpp b/renderdoc/driver/vulkan/wrappers/vk_shader_funcs.cpp index e119862d5..8b1ad6551 100644 --- a/renderdoc/driver/vulkan/wrappers/vk_shader_funcs.cpp +++ b/renderdoc/driver/vulkan/wrappers/vk_shader_funcs.cpp @@ -101,6 +101,8 @@ bool WrappedVulkan::Serialise_vkCreatePipelineLayout(SerialiserType &ser, VkDevi SERIALISE_ELEMENT_LOCAL(CreateInfo, *pCreateInfo); SERIALISE_ELEMENT_LOCAL(PipelineLayout, GetResID(*pPipelineLayout)); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { VkPipelineLayout layout = VK_NULL_HANDLE; @@ -202,6 +204,8 @@ bool WrappedVulkan::Serialise_vkCreateShaderModule(SerialiserType &ser, VkDevice SERIALISE_ELEMENT_LOCAL(CreateInfo, *pCreateInfo); SERIALISE_ELEMENT_LOCAL(ShaderModule, GetResID(*pShaderModule)); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { VkShaderModule sh = VK_NULL_HANDLE; @@ -295,6 +299,8 @@ bool WrappedVulkan::Serialise_vkCreatePipelineCache(SerialiserType &ser, VkDevic SERIALISE_ELEMENT_LOCAL(CreateInfo, *pCreateInfo); SERIALISE_ELEMENT_LOCAL(PipelineCache, GetResID(*pPipelineCache)); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { VkPipelineCache cache = VK_NULL_HANDLE; @@ -379,6 +385,8 @@ bool WrappedVulkan::Serialise_vkCreateGraphicsPipelines( SERIALISE_ELEMENT_LOCAL(CreateInfo, *pCreateInfos); SERIALISE_ELEMENT_LOCAL(Pipeline, GetResID(*pPipelines)); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { VkPipeline pipe = VK_NULL_HANDLE; @@ -554,6 +562,8 @@ bool WrappedVulkan::Serialise_vkCreateComputePipelines(SerialiserType &ser, VkDe SERIALISE_ELEMENT_LOCAL(CreateInfo, *pCreateInfos); SERIALISE_ELEMENT_LOCAL(Pipeline, GetResID(*pPipelines)); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { VkPipeline pipe = VK_NULL_HANDLE; diff --git a/renderdoc/driver/vulkan/wrappers/vk_sync_funcs.cpp b/renderdoc/driver/vulkan/wrappers/vk_sync_funcs.cpp index 35c29f5cf..930ffd669 100644 --- a/renderdoc/driver/vulkan/wrappers/vk_sync_funcs.cpp +++ b/renderdoc/driver/vulkan/wrappers/vk_sync_funcs.cpp @@ -80,6 +80,8 @@ bool WrappedVulkan::Serialise_vkCreateFence(SerialiserType &ser, VkDevice device SERIALISE_ELEMENT_LOCAL(CreateInfo, *pCreateInfo); SERIALISE_ELEMENT_LOCAL(Fence, GetResID(*pFence)); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { VkFence fence = VK_NULL_HANDLE; @@ -145,6 +147,8 @@ bool WrappedVulkan::Serialise_vkGetFenceStatus(SerialiserType &ser, VkDevice dev Serialise_DebugMessages(ser); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { ObjDisp(device)->DeviceWaitIdle(Unwrap(device)); @@ -181,6 +185,8 @@ bool WrappedVulkan::Serialise_vkResetFences(SerialiserType &ser, VkDevice device Serialise_DebugMessages(ser); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { // we don't care about fence states ourselves as we cannot record them perfectly and just @@ -226,6 +232,8 @@ bool WrappedVulkan::Serialise_vkWaitForFences(SerialiserType &ser, VkDevice devi Serialise_DebugMessages(ser); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { ObjDisp(device)->DeviceWaitIdle(Unwrap(device)); @@ -264,6 +272,8 @@ bool WrappedVulkan::Serialise_vkCreateEvent(SerialiserType &ser, VkDevice device SERIALISE_ELEMENT_LOCAL(CreateInfo, *pCreateInfo); SERIALISE_ELEMENT_LOCAL(Event, GetResID(*pEvent)); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { VkEvent ev = VK_NULL_HANDLE; @@ -332,6 +342,8 @@ bool WrappedVulkan::Serialise_vkSetEvent(SerialiserType &ser, VkDevice device, V Serialise_DebugMessages(ser); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { // see top of this file for current event/fence handling @@ -367,6 +379,8 @@ bool WrappedVulkan::Serialise_vkResetEvent(SerialiserType &ser, VkDevice device, Serialise_DebugMessages(ser); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { // see top of this file for current event/fence handling @@ -402,6 +416,8 @@ bool WrappedVulkan::Serialise_vkGetEventStatus(SerialiserType &ser, VkDevice dev Serialise_DebugMessages(ser); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { ObjDisp(device)->DeviceWaitIdle(Unwrap(device)); @@ -439,6 +455,8 @@ bool WrappedVulkan::Serialise_vkCreateSemaphore(SerialiserType &ser, VkDevice de SERIALISE_ELEMENT_LOCAL(CreateInfo, *pCreateInfo); SERIALISE_ELEMENT_LOCAL(Semaphore, GetResID(*pSemaphore)); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { VkSemaphore sem = VK_NULL_HANDLE; @@ -528,6 +546,8 @@ bool WrappedVulkan::Serialise_vkCmdSetEvent(SerialiserType &ser, VkCommandBuffer Serialise_DebugMessages(ser); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_LastCmdBufferID = GetResourceManager()->GetOriginalID(GetResID(commandBuffer)); @@ -580,6 +600,8 @@ bool WrappedVulkan::Serialise_vkCmdResetEvent(SerialiserType &ser, VkCommandBuff Serialise_DebugMessages(ser); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { m_LastCmdBufferID = GetResourceManager()->GetOriginalID(GetResID(commandBuffer)); @@ -643,6 +665,8 @@ bool WrappedVulkan::Serialise_vkCmdWaitEvents( SERIALISE_ELEMENT_ARRAY(pBufferMemoryBarriers, bufferMemoryBarrierCount); SERIALISE_ELEMENT_ARRAY(pImageMemoryBarriers, imageMemoryBarrierCount); + SERIALISE_CHECK_READ_ERRORS(); + std::vector imgBarriers; std::vector bufBarriers; diff --git a/renderdoc/driver/vulkan/wrappers/vk_wsi_funcs.cpp b/renderdoc/driver/vulkan/wrappers/vk_wsi_funcs.cpp index 5ab02c6cd..24404673c 100644 --- a/renderdoc/driver/vulkan/wrappers/vk_wsi_funcs.cpp +++ b/renderdoc/driver/vulkan/wrappers/vk_wsi_funcs.cpp @@ -187,6 +187,8 @@ bool WrappedVulkan::Serialise_vkGetSwapchainImagesKHR(SerialiserType &ser, VkDev SERIALISE_ELEMENT_LOCAL(SwapchainImageIndex, *pCount); SERIALISE_ELEMENT_LOCAL(SwapchainImage, GetResID(*pSwapchainImages)); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { // use original ID because we don't create a live version of the swapchain @@ -302,6 +304,8 @@ bool WrappedVulkan::Serialise_vkCreateSwapchainKHR(SerialiserType &ser, VkDevice SERIALISE_ELEMENT(NumImages); + SERIALISE_CHECK_READ_ERRORS(); + if(IsReplayingAndReading()) { // use original ID because we don't create a live version of the swapchain