From cab76389c785ffdb460f2beeb67e71f543a6de76 Mon Sep 17 00:00:00 2001 From: baldurk Date: Wed, 18 Aug 2021 13:33:05 +0100 Subject: [PATCH] Add fatal (device lost/out of memory) error checking to backends * We check for errors to try to catch them as soon as possible, and early-out return even in the middle of functions. The idea being even if this leaves us in a weird state we won't get called again as the replay controller will detect the error and substitute out a dummy driver. --- renderdoc/driver/d3d11/d3d11_context.cpp | 3 + renderdoc/driver/d3d11/d3d11_context_wrap.cpp | 2 + renderdoc/driver/d3d11/d3d11_counters.cpp | 11 +- renderdoc/driver/d3d11/d3d11_debug.cpp | 28 +++- renderdoc/driver/d3d11/d3d11_device.cpp | 34 +++- renderdoc/driver/d3d11/d3d11_device.h | 3 + renderdoc/driver/d3d11/d3d11_device_wrap.cpp | 97 +++++++++++ renderdoc/driver/d3d11/d3d11_initstate.cpp | 3 + renderdoc/driver/d3d11/d3d11_outputwindow.cpp | 22 ++- renderdoc/driver/d3d11/d3d11_replay.cpp | 6 + .../driver/d3d12/d3d12_command_list_wrap.cpp | 5 +- .../driver/d3d12/d3d12_command_queue_wrap.cpp | 2 + renderdoc/driver/d3d12/d3d12_commands.cpp | 6 + renderdoc/driver/d3d12/d3d12_counters.cpp | 9 + renderdoc/driver/d3d12/d3d12_debug.cpp | 3 + renderdoc/driver/d3d12/d3d12_device.cpp | 113 +++++++++++-- renderdoc/driver/d3d12/d3d12_device.h | 4 + renderdoc/driver/d3d12/d3d12_device_wrap.cpp | 56 +++++++ renderdoc/driver/d3d12/d3d12_device_wrap2.cpp | 4 + renderdoc/driver/d3d12/d3d12_device_wrap3.cpp | 8 + renderdoc/driver/d3d12/d3d12_device_wrap4.cpp | 12 ++ renderdoc/driver/d3d12/d3d12_device_wrap8.cpp | 8 + renderdoc/driver/d3d12/d3d12_device_wrap9.cpp | 4 + renderdoc/driver/d3d12/d3d12_initstate.cpp | 17 ++ .../driver/d3d12/d3d12_msaa_array_conv.cpp | 3 + renderdoc/driver/d3d12/d3d12_outputwindow.cpp | 39 ++++- renderdoc/driver/d3d12/d3d12_overlay.cpp | 14 ++ renderdoc/driver/d3d12/d3d12_postvs.cpp | 14 ++ renderdoc/driver/d3d12/d3d12_rendermesh.cpp | 2 + .../driver/d3d12/d3d12_rendertexture.cpp | 10 ++ renderdoc/driver/d3d12/d3d12_replay.cpp | 66 +++++++- .../driver/d3d12/d3d12_shader_feedback.cpp | 5 + renderdoc/driver/vulkan/vk_android.cpp | 2 +- renderdoc/driver/vulkan/vk_apple.cpp | 4 +- renderdoc/driver/vulkan/vk_common.cpp | 15 +- renderdoc/driver/vulkan/vk_core.cpp | 158 +++++++++++++----- renderdoc/driver/vulkan/vk_core.h | 13 +- renderdoc/driver/vulkan/vk_counters.cpp | 30 ++-- renderdoc/driver/vulkan/vk_debug.cpp | 140 ++++++++++------ renderdoc/driver/vulkan/vk_debug.h | 1 + renderdoc/driver/vulkan/vk_ggp.cpp | 2 +- renderdoc/driver/vulkan/vk_initstate.cpp | 88 ++++++---- renderdoc/driver/vulkan/vk_linux.cpp | 6 +- renderdoc/driver/vulkan/vk_memory.cpp | 9 +- .../driver/vulkan/vk_msaa_array_conv.cpp | 36 ++-- renderdoc/driver/vulkan/vk_outputwindow.cpp | 106 ++++++++---- renderdoc/driver/vulkan/vk_overlay.cpp | 156 +++++++++++------ renderdoc/driver/vulkan/vk_pixelhistory.cpp | 82 +++++---- renderdoc/driver/vulkan/vk_postvs.cpp | 101 ++++++----- renderdoc/driver/vulkan/vk_rendermesh.cpp | 40 +++-- renderdoc/driver/vulkan/vk_rendertexture.cpp | 9 +- renderdoc/driver/vulkan/vk_replay.cpp | 135 +++++++++++---- renderdoc/driver/vulkan/vk_replay.h | 1 + renderdoc/driver/vulkan/vk_shader_cache.cpp | 4 +- .../driver/vulkan/vk_shader_feedback.cpp | 17 +- renderdoc/driver/vulkan/vk_shaderdebug.cpp | 35 ++-- renderdoc/driver/vulkan/vk_win32.cpp | 2 +- .../vulkan/wrappers/vk_device_funcs.cpp | 42 ++--- .../driver/vulkan/wrappers/vk_draw_funcs.cpp | 2 +- .../driver/vulkan/wrappers/vk_misc_funcs.cpp | 8 +- .../driver/vulkan/wrappers/vk_queue_funcs.cpp | 9 + .../vulkan/wrappers/vk_resource_funcs.cpp | 25 ++- .../driver/vulkan/wrappers/vk_wsi_funcs.cpp | 41 ++--- renderdoc/replay/replay_output.cpp | 2 + 64 files changed, 1438 insertions(+), 496 deletions(-) diff --git a/renderdoc/driver/d3d11/d3d11_context.cpp b/renderdoc/driver/d3d11/d3d11_context.cpp index 87102ee01..17dc1e176 100644 --- a/renderdoc/driver/d3d11/d3d11_context.cpp +++ b/renderdoc/driver/d3d11/d3d11_context.cpp @@ -1284,6 +1284,9 @@ ReplayStatus WrappedID3D11DeviceContext::ReplayLog(CaptureState readType, uint32 if(ser.GetReader()->IsErrored()) return ReplayStatus::APIDataCorrupted; + if(m_pDevice->HasFatalError()) + return m_pDevice->FatalErrorCheck(); + // if there wasn't a serialisation error, but the chunk didn't succeed, then it's an API replay // failure. if(!success) diff --git a/renderdoc/driver/d3d11/d3d11_context_wrap.cpp b/renderdoc/driver/d3d11/d3d11_context_wrap.cpp index f26cfcf4d..006a67bb3 100644 --- a/renderdoc/driver/d3d11/d3d11_context_wrap.cpp +++ b/renderdoc/driver/d3d11/d3d11_context_wrap.cpp @@ -7669,6 +7669,8 @@ HRESULT WrappedID3D11DeviceContext::Map(ID3D11Resource *pResource, UINT Subresou } } + m_pDevice->CheckHRESULT(ret); + return ret; } diff --git a/renderdoc/driver/d3d11/d3d11_counters.cpp b/renderdoc/driver/d3d11/d3d11_counters.cpp index 46aa9cfec..6828e3153 100644 --- a/renderdoc/driver/d3d11/d3d11_counters.cpp +++ b/renderdoc/driver/d3d11/d3d11_counters.cpp @@ -261,12 +261,16 @@ void D3D11Replay::FillTimers(D3D11CounterContext &ctx, const ActionDescription & timer->before = timer->after = timer->stats = timer->occlusion = NULL; hr = m_pDevice->GetReal()->CreateQuery(&qtimedesc, &timer->before); + m_pDevice->CheckHRESULT(hr); RDCASSERTEQUAL(hr, S_OK); hr = m_pDevice->GetReal()->CreateQuery(&qtimedesc, &timer->after); + m_pDevice->CheckHRESULT(hr); RDCASSERTEQUAL(hr, S_OK); hr = m_pDevice->GetReal()->CreateQuery(&qstatsdesc, &timer->stats); + m_pDevice->CheckHRESULT(hr); RDCASSERTEQUAL(hr, S_OK); hr = m_pDevice->GetReal()->CreateQuery(&qoccldesc, &timer->occlusion); + m_pDevice->CheckHRESULT(hr); RDCASSERTEQUAL(hr, S_OK); } @@ -286,9 +290,8 @@ void D3D11Replay::FillTimers(D3D11CounterContext &ctx, const ActionDescription & if(timer->occlusion) m_pImmediateContext->GetReal()->End(timer->occlusion); if(timer->stats) - m_pImmediateContext->GetReal()->End(timer->stats); - ctx.eventStart = a.eventId + 1; + ctx.eventStart = a.eventId + 1; } } @@ -298,8 +301,10 @@ void D3D11Replay::SerializeImmediateContext() D3D11_QUERY_DESC desc = {D3D11_QUERY_EVENT}; HRESULT hr = m_pDevice->GetReal()->CreateQuery(&desc, &query); + m_pDevice->CheckHRESULT(hr); if(FAILED(hr)) { + RDCERR("Failed to create SerializeImmediateContext query HRESULT: %s", ToStr(hr).c_str()); return; } @@ -627,6 +632,7 @@ rdcarray D3D11Replay::FetchCounters(const rdcarray &c HRESULT hr = S_OK; hr = m_pDevice->CreateQuery(&disjointdesc, &disjoint); + m_pDevice->CheckHRESULT(hr); if(FAILED(hr)) { RDCERR("Failed to create disjoint query HRESULT: %s", ToStr(hr).c_str()); @@ -634,6 +640,7 @@ rdcarray D3D11Replay::FetchCounters(const rdcarray &c } hr = m_pDevice->CreateQuery(&qdesc, &start); + m_pDevice->CheckHRESULT(hr); if(FAILED(hr)) { RDCERR("Failed to create start query HRESULT: %s", ToStr(hr).c_str()); diff --git a/renderdoc/driver/d3d11/d3d11_debug.cpp b/renderdoc/driver/d3d11/d3d11_debug.cpp index 93ca37263..46467ab46 100644 --- a/renderdoc/driver/d3d11/d3d11_debug.cpp +++ b/renderdoc/driver/d3d11/d3d11_debug.cpp @@ -122,6 +122,7 @@ void D3D11DebugManager::FillCBuffer(ID3D11Buffer *buf, const void *data, size_t HRESULT hr = m_pImmediateContext->GetReal()->Map(UNWRAP(WrappedID3D11Buffer, buf), 0, D3D11_MAP_WRITE_DISCARD, 0, &mapped); + m_pDevice->CheckHRESULT(hr); if(FAILED(hr)) { @@ -404,17 +405,26 @@ void D3D11DebugManager::FillWithDiscardPattern(DiscardType type, ID3D11Resource if(desc.CPUAccessFlags & D3D11_CPU_ACCESS_WRITE) { D3D11_MAPPED_SUBRESOURCE mapped = {}; - m_pImmediateContext->Map(res, 0, D3D11_MAP_WRITE_DISCARD, 0, &mapped); + HRESULT hr = m_pImmediateContext->Map(res, 0, D3D11_MAP_WRITE_DISCARD, 0, &mapped); + m_pDevice->CheckHRESULT(hr); - byte *dst = (byte *)mapped.pData; - dst += pRect[r].left; - for(size_t i = 0; i < size; i++) + if(SUCCEEDED(hr)) { - memcpy(dst, &value, RDCMIN(sizeof(uint32_t), size - i)); - dst += sizeof(uint32_t); - } + byte *dst = (byte *)mapped.pData; + dst += pRect[r].left; + for(size_t i = 0; i < size; i++) + { + memcpy(dst, &value, RDCMIN(sizeof(uint32_t), size - i)); + dst += sizeof(uint32_t); + } - m_pImmediateContext->Unmap(res, 0); + m_pImmediateContext->Unmap(res, 0); + } + else + { + RDCERR("Couldn't fill discard pattern: %s", ToStr(hr).c_str()); + return; + } } } else if(desc.Usage == D3D11_USAGE_DEFAULT) @@ -857,6 +867,7 @@ uint32_t D3D11DebugManager::GetStructCount(ID3D11UnorderedAccessView *uav) D3D11_MAPPED_SUBRESOURCE mapped; HRESULT hr = m_pImmediateContext->Map(StageBuffer, 0, D3D11_MAP_READ, 0, &mapped); + m_pDevice->CheckHRESULT(hr); if(FAILED(hr)) { @@ -935,6 +946,7 @@ void D3D11DebugManager::GetBufferData(ID3D11Buffer *buffer, uint64_t offset, uin HRESULT hr = m_pImmediateContext->GetReal()->Map(UNWRAP(WrappedID3D11Buffer, StageBuffer), 0, D3D11_MAP_READ, 0, &mapped); + m_pDevice->CheckHRESULT(hr); if(FAILED(hr)) { diff --git a/renderdoc/driver/d3d11/d3d11_device.cpp b/renderdoc/driver/d3d11/d3d11_device.cpp index 9f393b8d7..56c8c8ad3 100644 --- a/renderdoc/driver/d3d11/d3d11_device.cpp +++ b/renderdoc/driver/d3d11/d3d11_device.cpp @@ -1370,7 +1370,7 @@ ReplayStatus WrappedID3D11Device::ReadLogInitialisation(RDCFile *rdc, bool store // 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; + return HasFatalError() ? m_FatalError : m_FailedReplayStatus; uint64_t offsetEnd = reader->GetOffset(); @@ -1474,6 +1474,12 @@ ReplayStatus WrappedID3D11Device::ReadLogInitialisation(RDCFile *rdc, bool store RDCDEBUG("Allocating %llu persistant bytes of memory for the log.", GetReplay()->WriteFrameRecord().frameInfo.persistentSize); + if(HasFatalError()) + return m_FatalError; + + if(m_pDevice && m_pDevice->GetDeviceRemovedReason() != S_OK) + return ReplayStatus::ReplayDeviceLost; + return ReplayStatus::Succeeded; } @@ -1521,6 +1527,9 @@ void WrappedID3D11Device::ReplayLog(uint32_t startEventID, uint32_t endEventID, D3D11MarkerRegion::End(); D3D11MarkerRegion::Set("!!!!RenderDoc Internal: Done replay"); + + if(m_pDevice->GetDeviceRemovedReason() != S_OK) + m_FatalError = ReplayStatus::ReplayDeviceLost; } void WrappedID3D11Device::NewSwapchainBuffer(IUnknown *backbuffer) @@ -2509,6 +2518,29 @@ void WrappedID3D11Device::FirstFrame(IDXGISwapper *swapper) } } +void WrappedID3D11Device::CheckHRESULT(HRESULT hr) +{ + if(SUCCEEDED(hr) || HasFatalError()) + return; + + if(hr == DXGI_ERROR_DEVICE_REMOVED || hr == DXGI_ERROR_DEVICE_RESET || + hr == DXGI_ERROR_DEVICE_HUNG || hr == DXGI_ERROR_DRIVER_INTERNAL_ERROR || + hr == DXGI_ERROR_DRIVER_INTERNAL_ERROR) + { + RDCLOG("Logging device lost fatal error for %s", ToStr(hr).c_str()); + m_FatalError = ReplayStatus::ReplayDeviceLost; + } + else if(hr == E_OUTOFMEMORY) + { + RDCLOG("Logging out of memory fatal error for %s", ToStr(hr).c_str()); + m_FatalError = ReplayStatus::ReplayOutOfMemory; + } + else + { + RDCLOG("Ignoring return code %s", ToStr(hr).c_str()); + } +} + HRESULT WrappedID3D11Device::Present(IDXGISwapper *swapper, UINT SyncInterval, UINT Flags) { if((Flags & DXGI_PRESENT_TEST) != 0) diff --git a/renderdoc/driver/d3d11/d3d11_device.h b/renderdoc/driver/d3d11/d3d11_device.h index 26afce5a9..36464a94f 100644 --- a/renderdoc/driver/d3d11/d3d11_device.h +++ b/renderdoc/driver/d3d11/d3d11_device.h @@ -666,7 +666,10 @@ public: double GetTimeFrequency() { return m_TimeFrequency; } void FirstFrame(IDXGISwapper *swapper); + void CheckHRESULT(HRESULT hr); + void ReportFatalError(ReplayStatus error) { m_FatalError = error; } ReplayStatus FatalErrorCheck() { return m_FatalError; } + bool HasFatalError() { return m_FatalError != ReplayStatus::Succeeded; } rdcarray GetDebugMessages(); void AddDebugMessage(DebugMessage msg); void AddDebugMessage(MessageCategory c, MessageSeverity sv, MessageSource src, rdcstr d); diff --git a/renderdoc/driver/d3d11/d3d11_device_wrap.cpp b/renderdoc/driver/d3d11/d3d11_device_wrap.cpp index 2e3bcd44d..daee0b70f 100644 --- a/renderdoc/driver/d3d11/d3d11_device_wrap.cpp +++ b/renderdoc/driver/d3d11/d3d11_device_wrap.cpp @@ -238,6 +238,10 @@ HRESULT WrappedID3D11Device::CreateBuffer(const D3D11_BUFFER_DESC *pDesc, *ppBuffer = wrapped; } + else + { + CheckHRESULT(ret); + } return ret; } @@ -492,6 +496,10 @@ HRESULT WrappedID3D11Device::CreateTexture1D(const D3D11_TEXTURE1D_DESC *pDesc, *ppTexture1D = wrapped; } + else + { + CheckHRESULT(ret); + } return ret; } @@ -628,6 +636,10 @@ HRESULT WrappedID3D11Device::CreateTexture2D(const D3D11_TEXTURE2D_DESC *pDesc, *ppTexture2D = wrapped; } + else + { + CheckHRESULT(ret); + } return ret; } @@ -763,6 +775,10 @@ HRESULT WrappedID3D11Device::CreateTexture3D(const D3D11_TEXTURE3D_DESC *pDesc, *ppTexture3D = wrapped; } + else + { + CheckHRESULT(ret); + } return ret; } @@ -894,6 +910,10 @@ HRESULT WrappedID3D11Device::CreateShaderResourceView(ID3D11Resource *pResource, *ppSRView = wrapped; } + else + { + CheckHRESULT(ret); + } return ret; } @@ -1039,6 +1059,11 @@ HRESULT WrappedID3D11Device::CreateUnorderedAccessView(ID3D11Resource *pResource *ppUAView = wrapped; } + else + { + CheckHRESULT(ret); + } + return ret; } @@ -1164,6 +1189,10 @@ HRESULT WrappedID3D11Device::CreateRenderTargetView(ID3D11Resource *pResource, *ppRTView = wrapped; } + else + { + CheckHRESULT(ret); + } return ret; } @@ -1259,6 +1288,10 @@ HRESULT WrappedID3D11Device::CreateDepthStencilView(ID3D11Resource *pResource, *ppDepthStencilView = wrapped; } + else + { + CheckHRESULT(ret); + } return ret; } @@ -1491,6 +1524,10 @@ HRESULT WrappedID3D11Device::CreateVertexShader(const void *pShaderBytecode, SIZ *ppVertexShader = wrapped; } + else + { + CheckHRESULT(ret); + } return ret; } @@ -1624,6 +1661,10 @@ HRESULT WrappedID3D11Device::CreateGeometryShader(const void *pShaderBytecode, S *ppGeometryShader = wrapped; } + else + { + CheckHRESULT(ret); + } return ret; } @@ -1767,6 +1808,10 @@ HRESULT WrappedID3D11Device::CreateGeometryShaderWithStreamOutput( *ppGeometryShader = wrapped; } + else + { + CheckHRESULT(ret); + } return ret; } @@ -1897,6 +1942,10 @@ HRESULT WrappedID3D11Device::CreatePixelShader(const void *pShaderBytecode, SIZE *ppPixelShader = wrapped; } + else + { + CheckHRESULT(ret); + } return ret; } @@ -2026,6 +2075,10 @@ HRESULT WrappedID3D11Device::CreateHullShader(const void *pShaderBytecode, SIZE_ *ppHullShader = wrapped; } + else + { + CheckHRESULT(ret); + } return ret; } @@ -2158,6 +2211,10 @@ HRESULT WrappedID3D11Device::CreateDomainShader(const void *pShaderBytecode, SIZ *ppDomainShader = wrapped; } + else + { + CheckHRESULT(ret); + } return ret; } @@ -2291,6 +2348,10 @@ HRESULT WrappedID3D11Device::CreateComputeShader(const void *pShaderBytecode, SI *ppComputeShader = wrapped; } + else + { + CheckHRESULT(ret); + } return ret; } @@ -2509,6 +2570,10 @@ HRESULT WrappedID3D11Device::CreateClassLinkage(ID3D11ClassLinkage **ppLinkage) *ppLinkage = wrapped; } + else + { + CheckHRESULT(ret); + } return ret; } @@ -2619,6 +2684,10 @@ HRESULT WrappedID3D11Device::CreateBlendState(const D3D11_BLEND_DESC *pBlendStat *ppBlendState = wrapped; } + else + { + CheckHRESULT(ret); + } return ret; } @@ -2727,6 +2796,10 @@ HRESULT WrappedID3D11Device::CreateDepthStencilState(const D3D11_DEPTH_STENCIL_D *ppDepthStencilState = wrapped; } + else + { + CheckHRESULT(ret); + } return ret; } @@ -2835,6 +2908,10 @@ HRESULT WrappedID3D11Device::CreateRasterizerState(const D3D11_RASTERIZER_DESC * *ppRasterizerState = wrapped; } + else + { + CheckHRESULT(ret); + } return ret; } @@ -2943,6 +3020,10 @@ HRESULT WrappedID3D11Device::CreateSamplerState(const D3D11_SAMPLER_DESC *pSampl *ppSamplerState = wrapped; } + else + { + CheckHRESULT(ret); + } return ret; } @@ -3018,6 +3099,10 @@ HRESULT WrappedID3D11Device::CreateQuery(const D3D11_QUERY_DESC *pQueryDesc, ID3 *ppQuery = wrapped; } + else + { + CheckHRESULT(ret); + } return ret; } @@ -3105,6 +3190,10 @@ HRESULT WrappedID3D11Device::CreatePredicate(const D3D11_QUERY_DESC *pPredicateD *ppPredicate = wrapped; } + else + { + CheckHRESULT(ret); + } return ret; } @@ -3187,6 +3276,10 @@ HRESULT WrappedID3D11Device::CreateCounter(const D3D11_COUNTER_DESC *pCounterDes *ppCounter = wrapped; } + else + { + CheckHRESULT(ret); + } return ret; } @@ -3268,6 +3361,10 @@ HRESULT WrappedID3D11Device::CreateDeferredContext(UINT ContextFlags, *ppDeferredContext = wrapped; } + else + { + CheckHRESULT(ret); + } return ret; } diff --git a/renderdoc/driver/d3d11/d3d11_initstate.cpp b/renderdoc/driver/d3d11/d3d11_initstate.cpp index 89a4c7682..d6d83727d 100644 --- a/renderdoc/driver/d3d11/d3d11_initstate.cpp +++ b/renderdoc/driver/d3d11/d3d11_initstate.cpp @@ -1286,6 +1286,9 @@ void WrappedID3D11Device::Create_InitialState(ResourceId id, ID3D11DeviceChild * void WrappedID3D11Device::Apply_InitialState(ID3D11DeviceChild *live, const D3D11InitialContents &initial) { + if(HasFatalError()) + return; + if(initial.resourceType == Resource_UnorderedAccessView) { ID3D11UnorderedAccessView *uav = (ID3D11UnorderedAccessView *)live; diff --git a/renderdoc/driver/d3d11/d3d11_outputwindow.cpp b/renderdoc/driver/d3d11/d3d11_outputwindow.cpp index 7bb3978b0..be2e71b74 100644 --- a/renderdoc/driver/d3d11/d3d11_outputwindow.cpp +++ b/renderdoc/driver/d3d11/d3d11_outputwindow.cpp @@ -37,6 +37,8 @@ void D3D11Replay::OutputWindow::MakeRTV() { hr = swap->GetBuffer(0, __uuidof(ID3D11Texture2D), (void **)&texture); + dev->CheckHRESULT(hr); + if(FAILED(hr)) { RDCERR("Failed to get swap chain buffer, HRESULT: %s", ToStr(hr).c_str()); @@ -65,6 +67,8 @@ void D3D11Replay::OutputWindow::MakeRTV() hr = dev->CreateRenderTargetView(texture, NULL, &rtv); + dev->CheckHRESULT(hr); + SAFE_RELEASE(texture); if(FAILED(hr)) @@ -103,6 +107,8 @@ void D3D11Replay::OutputWindow::MakeDSV() HRESULT hr = dev->CreateTexture2D(&texDesc, NULL, &texture); + dev->CheckHRESULT(hr); + if(FAILED(hr)) { RDCERR("Failed to create DSV texture for main output, HRESULT: %s", ToStr(hr).c_str()); @@ -113,6 +119,8 @@ void D3D11Replay::OutputWindow::MakeDSV() hr = dev->CreateDepthStencilView(texture, NULL, &dsv); + dev->CheckHRESULT(hr); + SAFE_RELEASE(texture); if(FAILED(hr)) @@ -157,6 +165,8 @@ uint64_t D3D11Replay::MakeOutputWindow(WindowingData window, bool depth) hr = m_pFactory->CreateSwapChain(m_pDevice, &swapDesc, &outw.swap); + m_pDevice->CheckHRESULT(hr); + if(FAILED(hr)) { RDCERR("Failed to create swap chain for HWND, HRESULT: %s", ToStr(hr).c_str()); @@ -233,6 +243,8 @@ bool D3D11Replay::CheckResizeOutputWindow(uint64_t id) HRESULT hr = outw.swap->ResizeBuffers(desc.BufferCount, outw.width, outw.height, desc.BufferDesc.Format, desc.Flags); + m_pDevice->CheckHRESULT(hr); + if(FAILED(hr)) { RDCERR("Failed to resize swap chain, HRESULT: %s", ToStr(hr).c_str()); @@ -316,6 +328,8 @@ void D3D11Replay::GetOutputWindowData(uint64_t id, bytebuf &retData) HRESULT hr = m_pDevice->CreateTexture2D(&texDesc, NULL, &readback); + m_pDevice->CheckHRESULT(hr); + if(FAILED(hr)) { RDCERR("Couldn't create staging texture for readback, HRESULT: %s", ToStr(hr).c_str()); @@ -332,6 +346,8 @@ void D3D11Replay::GetOutputWindowData(uint64_t id, bytebuf &retData) hr = m_pDevice->CreateTexture2D(&texDesc, NULL, &resolve); + m_pDevice->CheckHRESULT(hr); + if(FAILED(hr)) { RDCERR("Couldn't create staging texture for readback, HRESULT: %s", ToStr(hr).c_str()); @@ -436,7 +452,11 @@ void D3D11Replay::FlipOutputWindow(uint64_t id) return; if(m_OutputWindows[id].swap) - m_OutputWindows[id].swap->Present(0, 0); + { + HRESULT hr = m_OutputWindows[id].swap->Present(0, 0); + + m_pDevice->CheckHRESULT(hr); + } if(m_RealState.active) { diff --git a/renderdoc/driver/d3d11/d3d11_replay.cpp b/renderdoc/driver/d3d11/d3d11_replay.cpp index cfb84ed56..afb86bb32 100644 --- a/renderdoc/driver/d3d11/d3d11_replay.cpp +++ b/renderdoc/driver/d3d11/d3d11_replay.cpp @@ -1705,6 +1705,8 @@ void D3D11Replay::PickPixel(ResourceId texture, uint32_t x, uint32_t y, const Su mapped.pData = NULL; HRESULT hr = m_pImmediateContext->Map(m_PixelPick.StageTexture, 0, D3D11_MAP_READ, 0, &mapped); + m_pDevice->CheckHRESULT(hr); + if(FAILED(hr)) { RDCERR("Failed to map stage buff HRESULT: %s", ToStr(hr).c_str()); @@ -1816,6 +1818,8 @@ bool D3D11Replay::GetMinMax(ResourceId texid, const Subresource &sub, CompType t HRESULT hr = m_pImmediateContext->Map(m_Histogram.ResultStageBuff, 0, D3D11_MAP_READ, 0, &mapped); + m_pDevice->CheckHRESULT(hr); + if(FAILED(hr)) { RDCERR("Failed to map minmax results buffer HRESULT: %s", ToStr(hr).c_str()); @@ -1946,6 +1950,8 @@ bool D3D11Replay::GetHistogram(ResourceId texid, const Subresource &sub, CompTyp HRESULT hr = m_pImmediateContext->Map(m_Histogram.ResultStageBuff, 0, D3D11_MAP_READ, 0, &mapped); + m_pDevice->CheckHRESULT(hr); + histogram.clear(); histogram.resize(HGRAM_NUM_BUCKETS); diff --git a/renderdoc/driver/d3d12/d3d12_command_list_wrap.cpp b/renderdoc/driver/d3d12/d3d12_command_list_wrap.cpp index 85c9be6ab..1e0d7cbe4 100644 --- a/renderdoc/driver/d3d12/d3d12_command_list_wrap.cpp +++ b/renderdoc/driver/d3d12/d3d12_command_list_wrap.cpp @@ -173,6 +173,8 @@ HRESULT WrappedID3D12GraphicsCommandList::Close() m_ListRecord->Bake(); } + m_pDevice->CheckHRESULT(ret); + return ret; } @@ -455,6 +457,7 @@ HRESULT WrappedID3D12GraphicsCommandList::ResetInternal(ID3D12CommandAllocator * else { ret = m_pList->Reset(Unwrap(pAllocator), Unwrap(pInitialState)); + m_pDevice->CheckHRESULT(ret); } return ret; @@ -3538,7 +3541,7 @@ void WrappedID3D12GraphicsCommandList::PatchExecuteIndirect(BakedCmdListInfo &in D3D12_RANGE range = {0, D3D12CommandData::m_IndirectSize}; byte *mapPtr = NULL; - exec.argBuf->Map(0, &range, (void **)&mapPtr); + m_pDevice->CheckHRESULT(exec.argBuf->Map(0, &range, (void **)&mapPtr)); rdcarray &actions = info.action->children; diff --git a/renderdoc/driver/d3d12/d3d12_command_queue_wrap.cpp b/renderdoc/driver/d3d12/d3d12_command_queue_wrap.cpp index 0c0eff53b..c4d253a03 100644 --- a/renderdoc/driver/d3d12/d3d12_command_queue_wrap.cpp +++ b/renderdoc/driver/d3d12/d3d12_command_queue_wrap.cpp @@ -711,6 +711,8 @@ bool WrappedID3D12CommandQueue::Serialise_ExecuteCommandLists(SerialiserType &se void WrappedID3D12CommandQueue::ExecuteCommandLists(UINT NumCommandLists, ID3D12CommandList *const *ppCommandLists) { + if(m_pDevice->HasFatalError()) + return; ExecuteCommandListsInternal(NumCommandLists, ppCommandLists, false, false); } diff --git a/renderdoc/driver/d3d12/d3d12_commands.cpp b/renderdoc/driver/d3d12/d3d12_commands.cpp index 8aa36903a..d39e46575 100644 --- a/renderdoc/driver/d3d12/d3d12_commands.cpp +++ b/renderdoc/driver/d3d12/d3d12_commands.cpp @@ -959,6 +959,9 @@ ReplayStatus WrappedID3D12CommandQueue::ReplayLog(CaptureState readType, uint32_ m_pDevice->ExecuteLists(); m_pDevice->FlushLists(); + + if(m_pDevice->HasFatalError()) + return m_pDevice->FatalErrorCheck(); } if(IsActiveReplaying(m_State)) @@ -1028,6 +1031,9 @@ ReplayStatus WrappedID3D12CommandQueue::ReplayLog(CaptureState readType, uint32_ if(!success) return m_FailedReplayStatus; + if(m_pDevice->HasFatalError()) + return m_pDevice->FatalErrorCheck(); + RenderDoc::Inst().SetProgress( LoadProgress::FrameEventsRead, float(m_Cmd.m_CurChunkOffset - startOffset) / float(ser.GetReader()->GetSize())); diff --git a/renderdoc/driver/d3d12/d3d12_counters.cpp b/renderdoc/driver/d3d12/d3d12_counters.cpp index 2a8cbc08b..0ba782327 100644 --- a/renderdoc/driver/d3d12/d3d12_counters.cpp +++ b/renderdoc/driver/d3d12/d3d12_counters.cpp @@ -535,6 +535,7 @@ rdcarray D3D12Replay::FetchCounters(const rdcarray &c HRESULT hr = m_pDevice->CreateCommittedResource(&heapProps, D3D12_HEAP_FLAG_NONE, &bufDesc, D3D12_RESOURCE_STATE_COPY_DEST, NULL, __uuidof(ID3D12Resource), (void **)&readbackBuf); + m_pDevice->CheckHRESULT(hr); if(FAILED(hr)) { RDCERR("Failed to create query readback buffer HRESULT: %s", ToStr(hr).c_str()); @@ -548,6 +549,7 @@ rdcarray D3D12Replay::FetchCounters(const rdcarray &c ID3D12QueryHeap *timerQueryHeap = NULL; hr = m_pDevice->CreateQueryHeap(&timerQueryDesc, __uuidof(timerQueryHeap), (void **)&timerQueryHeap); + m_pDevice->CheckHRESULT(hr); if(FAILED(hr)) { RDCERR("Failed to create timer query heap HRESULT: %s", ToStr(hr).c_str()); @@ -561,6 +563,7 @@ rdcarray D3D12Replay::FetchCounters(const rdcarray &c ID3D12QueryHeap *pipestatsQueryHeap = NULL; hr = m_pDevice->CreateQueryHeap(&pipestatsQueryDesc, __uuidof(pipestatsQueryHeap), (void **)&pipestatsQueryHeap); + m_pDevice->CheckHRESULT(hr); if(FAILED(hr)) { RDCERR("Failed to create pipeline statistics query heap HRESULT: %s", ToStr(hr).c_str()); @@ -574,6 +577,7 @@ rdcarray D3D12Replay::FetchCounters(const rdcarray &c ID3D12QueryHeap *occlusionQueryHeap = NULL; hr = m_pDevice->CreateQueryHeap(&occlusionQueryDesc, __uuidof(occlusionQueryHeap), (void **)&occlusionQueryHeap); + m_pDevice->CheckHRESULT(hr); if(FAILED(hr)) { RDCERR("Failed to create occlusion query heap HRESULT: %s", ToStr(hr).c_str()); @@ -587,6 +591,7 @@ rdcarray D3D12Replay::FetchCounters(const rdcarray &c "D3D12 counters require Win10 developer mode enabled: Settings > Update & Security " "> For Developers > Developer Mode", "D3D12 Counters Error", MB_ICONWARNING | MB_OK); + m_pDevice->CheckHRESULT(hr); D3D12GPUTimerCallback cb(m_pDevice, this, timerQueryHeap, pipestatsQueryHeap, occlusionQueryHeap); @@ -603,6 +608,9 @@ rdcarray D3D12Replay::FetchCounters(const rdcarray &c ID3D12GraphicsCommandList *list = m_pDevice->GetNewList(); + if(!list) + return ret; + UINT64 bufferOffset = 0; list->ResolveQueryData(timerQueryHeap, D3D12_QUERY_TYPE_TIMESTAMP, 0, @@ -629,6 +637,7 @@ rdcarray D3D12Replay::FetchCounters(const rdcarray &c uint8_t *data; hr = readbackBuf->Map(0, &range, (void **)&data); + m_pDevice->CheckHRESULT(hr); if(FAILED(hr)) { RDCERR("Failed to read timer query heap data HRESULT: %s", ToStr(hr).c_str()); diff --git a/renderdoc/driver/d3d12/d3d12_debug.cpp b/renderdoc/driver/d3d12/d3d12_debug.cpp index 6901e1c25..95f14aa59 100644 --- a/renderdoc/driver/d3d12/d3d12_debug.cpp +++ b/renderdoc/driver/d3d12/d3d12_debug.cpp @@ -661,6 +661,7 @@ void D3D12DebugManager::FillBuffer(ID3D12Resource *buf, size_t offset, const voi D3D12_RANGE range = {offset, offset + size}; byte *ptr = NULL; HRESULT hr = buf->Map(0, &range, (void **)&ptr); + m_pDevice->CheckHRESULT(hr); if(FAILED(hr)) { @@ -1276,6 +1277,7 @@ void D3D12DebugManager::GetBufferData(ID3D12Resource *buffer, uint64_t offset, u byte *data = NULL; HRESULT hr = buffer->Map(0, &range, (void **)&data); + m_pDevice->CheckHRESULT(hr); if(FAILED(hr)) { @@ -1320,6 +1322,7 @@ void D3D12DebugManager::GetBufferData(ID3D12Resource *buffer, uint64_t offset, u void *data = NULL; HRESULT hr = m_ReadbackBuffer->Map(0, &range, &data); + m_pDevice->CheckHRESULT(hr); if(FAILED(hr)) { diff --git a/renderdoc/driver/d3d12/d3d12_device.cpp b/renderdoc/driver/d3d12/d3d12_device.cpp index 2830c2e20..13a19074a 100644 --- a/renderdoc/driver/d3d12/d3d12_device.cpp +++ b/renderdoc/driver/d3d12/d3d12_device.cpp @@ -1760,6 +1760,7 @@ bool WrappedID3D12Device::Serialise_MapDataWrite(SerialiserType &ser, ID3D12Reso D3D12_RANGE maprange = {0, 0}; void *dst = NULL; HRESULT hr = uploadBuf->Map(Subresource, &maprange, &dst); + CheckHRESULT(hr); if(SUCCEEDED(hr)) { @@ -1792,6 +1793,7 @@ bool WrappedID3D12Device::Serialise_MapDataWrite(SerialiserType &ser, ID3D12Reso D3D12_RANGE nopRange = {0, 0}; HRESULT hr = Resource->Map(Subresource, &nopRange, (void **)&dst); + CheckHRESULT(hr); if(SUCCEEDED(hr)) { @@ -1914,6 +1916,7 @@ bool WrappedID3D12Device::Serialise_WriteToSubresource(SerialiserType &ser, ID3D D3D12_RANGE range = {0, 0}; void *dst = NULL; HRESULT hr = uploadBuf->Map(Subresource, &range, &dst); + CheckHRESULT(hr); if(SUCCEEDED(hr)) { @@ -1945,6 +1948,7 @@ bool WrappedID3D12Device::Serialise_WriteToSubresource(SerialiserType &ser, ID3D else { HRESULT hr = Resource->Map(Subresource, NULL, NULL); + CheckHRESULT(hr); if(SUCCEEDED(hr)) { @@ -2183,6 +2187,8 @@ bool WrappedID3D12Device::Serialise_BeginCaptureFrame(SerialiserType &ser) { // apply initial resource states ID3D12GraphicsCommandList *list = GetNewList(); + if(!list) + return false; list->ResourceBarrier((UINT)barriers.size(), &barriers[0]); @@ -2977,6 +2983,29 @@ rdcarray WrappedID3D12Device::GetDebugMessages() return ret; } +void WrappedID3D12Device::CheckHRESULT(HRESULT hr) +{ + if(SUCCEEDED(hr) || HasFatalError()) + return; + + if(hr == DXGI_ERROR_DEVICE_REMOVED || hr == DXGI_ERROR_DEVICE_RESET || + hr == DXGI_ERROR_DEVICE_HUNG || hr == DXGI_ERROR_DRIVER_INTERNAL_ERROR || + hr == DXGI_ERROR_DRIVER_INTERNAL_ERROR) + { + RDCLOG("Logging device lost fatal error for %s", ToStr(hr).c_str()); + m_FatalError = ReplayStatus::ReplayDeviceLost; + } + else if(hr == E_OUTOFMEMORY) + { + RDCLOG("Logging out of memory fatal error for %s", ToStr(hr).c_str()); + m_FatalError = ReplayStatus::ReplayOutOfMemory; + } + else + { + RDCLOG("Ignoring return code %s", ToStr(hr).c_str()); + } +} + template bool WrappedID3D12Device::Serialise_SetShaderDebugPath(SerialiserType &ser, ID3D12DeviceChild *pResource, const char *Path) @@ -3442,6 +3471,9 @@ void WrappedID3D12Device::GPUSync(ID3D12CommandQueue *queue, ID3D12Fence *fence) { m_GPUSyncCounter++; + if(HasFatalError()) + return; + if(queue == NULL) queue = GetQueue(); @@ -3449,11 +3481,14 @@ void WrappedID3D12Device::GPUSync(ID3D12CommandQueue *queue, ID3D12Fence *fence) fence = m_GPUSyncFence; HRESULT hr = queue->Signal(fence, m_GPUSyncCounter); + CheckHRESULT(hr); + RDCASSERTEQUAL(hr, S_OK); + fence->SetEventOnCompletion(m_GPUSyncCounter, m_GPUSyncHandle); WaitForSingleObject(m_GPUSyncHandle, 10000); - RDCASSERTEQUAL(hr, S_OK); hr = m_pDevice->GetDeviceRemovedReason(); + CheckHRESULT(hr); RDCASSERTEQUAL(hr, S_OK); } @@ -3485,6 +3520,7 @@ ID3D12GraphicsCommandListX *WrappedID3D12Device::GetNewList() ret = (ID3D12GraphicsCommandListX *)list; RDCASSERTEQUAL(hr, S_OK); + CheckHRESULT(hr); if(ret == NULL) return NULL; @@ -3538,6 +3574,9 @@ void WrappedID3D12Device::CloseInitialStateList() void WrappedID3D12Device::ExecuteList(ID3D12GraphicsCommandListX *list, WrappedID3D12CommandQueue *queue, bool InFrameCaptureBoundary) { + if(HasFatalError()) + return; + if(queue == NULL) queue = GetQueue(); @@ -3555,6 +3594,9 @@ void WrappedID3D12Device::MarkListExecuted(ID3D12GraphicsCommandListX *list) void WrappedID3D12Device::ExecuteLists(WrappedID3D12CommandQueue *queue, bool InFrameCaptureBoundary) { + if(HasFatalError()) + return; + // nothing to do if(m_InternalCmds.pendingcmds.empty()) return; @@ -3579,6 +3621,9 @@ void WrappedID3D12Device::ExecuteLists(WrappedID3D12CommandQueue *queue, bool In void WrappedID3D12Device::FlushLists(bool forceSync, ID3D12CommandQueue *queue) { + if(HasFatalError()) + return; + if(!m_InternalCmds.submittedcmds.empty() || forceSync) { GPUSync(queue); @@ -3933,7 +3978,7 @@ ReplayStatus WrappedID3D12Device::ReadLogInitialisation(RDCFile *rdc, bool store // 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; + return HasFatalError() ? m_FatalError : m_FailedReplayStatus; uint64_t offsetEnd = reader->GetOffset(); @@ -4035,6 +4080,12 @@ ReplayStatus WrappedID3D12Device::ReadLogInitialisation(RDCFile *rdc, bool store RDCDEBUG("Allocating %llu persistant bytes of memory for the log.", GetReplay()->WriteFrameRecord().frameInfo.persistentSize); + if(m_FatalError != ReplayStatus::Succeeded) + return m_FatalError; + + if(m_pDevice && m_pDevice->GetDeviceRemovedReason() != S_OK) + return ReplayStatus::ReplayDeviceLost; + return ReplayStatus::Succeeded; } @@ -4054,16 +4105,19 @@ void WrappedID3D12Device::ReplayLog(uint32_t startEventID, uint32_t endEventID, // command lists due to the 'previous queue fence' not being ready yet, even if no fences are // signalled or waited. So instead we just signal a dummy fence each new 'frame' for(size_t i = 0; i < m_Queues.size(); i++) - m_Queues[i]->Signal(m_QueueFences[i], m_GPUSyncCounter); + CheckHRESULT(m_Queues[i]->Signal(m_QueueFences[i], m_GPUSyncCounter)); FlushLists(true); // take this opportunity to reset command allocators to ensure we don't steadily leak over time. if(m_DataUploadAlloc) - m_DataUploadAlloc->Reset(); + CheckHRESULT(m_DataUploadAlloc->Reset()); for(ID3D12CommandAllocator *alloc : m_CommandAllocators) - alloc->Reset(); + CheckHRESULT(alloc->Reset()); + + if(HasFatalError()) + return; } if(!partial) @@ -4075,6 +4129,9 @@ void WrappedID3D12Device::ReplayLog(uint32_t startEventID, uint32_t endEventID, ExecuteLists(); FlushLists(true); + + if(HasFatalError()) + return; } m_State = CaptureState::ActiveReplaying; @@ -4086,13 +4143,20 @@ void WrappedID3D12Device::ReplayLog(uint32_t startEventID, uint32_t endEventID, if(!partial) { ID3D12GraphicsCommandList *beginList = GetNewList(); + if(!beginList) + return; + { rdcwstr text = StringFormat::UTF82Wide(AMDRGPControl::GetBeginMarker()); UINT size = UINT(text.length() * sizeof(wchar_t)); beginList->SetMarker(0, text.c_str(), size); } - beginList->Close(); + + CheckHRESULT(beginList->Close()); ExecuteLists(); + + if(HasFatalError()) + return; } { @@ -4121,6 +4185,9 @@ void WrappedID3D12Device::ReplayLog(uint32_t startEventID, uint32_t endEventID, { ID3D12GraphicsCommandListX *list = cmd.m_OutsideCmdList = GetNewList(); + if(!list) + return; + cmd.m_RenderState.ApplyState(this, list); } @@ -4141,18 +4208,24 @@ void WrappedID3D12Device::ReplayLog(uint32_t startEventID, uint32_t endEventID, { ID3D12GraphicsCommandList *list = cmd.m_OutsideCmdList; - list->Close(); + CheckHRESULT(list->Close()); ExecuteLists(); cmd.m_OutsideCmdList = NULL; } + if(HasFatalError()) + return; + cmd.m_RenderState = cmd.m_BakedCmdListInfo[cmd.m_Partial[D3D12CommandData::Primary].partialParent].state; #if ENABLED(SINGLE_FLUSH_VALIDATE) FlushLists(true); + + if(HasFatalError()) + return; #endif } @@ -4160,17 +4233,21 @@ void WrappedID3D12Device::ReplayLog(uint32_t startEventID, uint32_t endEventID, // ensure all UAV writes have finished before subsequent work ID3D12GraphicsCommandList *list = GetNewList(); + + if(list) { - rdcwstr text = StringFormat::UTF82Wide(AMDRGPControl::GetEndMarker()); - UINT size = UINT(text.length() * sizeof(wchar_t)); - list->SetMarker(0, text.c_str(), size); + { + rdcwstr text = StringFormat::UTF82Wide(AMDRGPControl::GetEndMarker()); + UINT size = UINT(text.length() * sizeof(wchar_t)); + list->SetMarker(0, text.c_str(), size); + } + + D3D12_RESOURCE_BARRIER uavBarrier = {}; + uavBarrier.Type = D3D12_RESOURCE_BARRIER_TYPE_UAV; + list->ResourceBarrier(1, &uavBarrier); + + CheckHRESULT(list->Close()); + + ExecuteLists(); } - - D3D12_RESOURCE_BARRIER uavBarrier = {}; - uavBarrier.Type = D3D12_RESOURCE_BARRIER_TYPE_UAV; - list->ResourceBarrier(1, &uavBarrier); - - list->Close(); - - ExecuteLists(); } diff --git a/renderdoc/driver/d3d12/d3d12_device.h b/renderdoc/driver/d3d12/d3d12_device.h index 9209fca14..f09b971a7 100644 --- a/renderdoc/driver/d3d12/d3d12_device.h +++ b/renderdoc/driver/d3d12/d3d12_device.h @@ -800,7 +800,11 @@ public: void AddDebugMessage(MessageCategory c, MessageSeverity sv, MessageSource src, rdcstr d); void AddDebugMessage(const DebugMessage &msg); rdcarray GetDebugMessages(); + + void CheckHRESULT(HRESULT hr); + void ReportFatalError(ReplayStatus error) { m_FatalError = error; } ReplayStatus FatalErrorCheck() { return m_FatalError; } + bool HasFatalError() { return m_FatalError != ReplayStatus::Succeeded; } ResourceDescription &GetResourceDesc(ResourceId id); void AddResource(ResourceId id, ResourceType type, const char *defaultNamePrefix); void DerivedResource(ResourceId parent, ResourceId child); diff --git a/renderdoc/driver/d3d12/d3d12_device_wrap.cpp b/renderdoc/driver/d3d12/d3d12_device_wrap.cpp index 903887472..e77607d2b 100644 --- a/renderdoc/driver/d3d12/d3d12_device_wrap.cpp +++ b/renderdoc/driver/d3d12/d3d12_device_wrap.cpp @@ -160,6 +160,10 @@ HRESULT WrappedID3D12Device::CreateCommandQueue(const D3D12_COMMAND_QUEUE_DESC * *ppCommandQueue = (ID3D12CommandQueue *)wrapped; } + else + { + CheckHRESULT(ret); + } return ret; } @@ -245,6 +249,10 @@ HRESULT WrappedID3D12Device::CreateCommandAllocator(D3D12_COMMAND_LIST_TYPE type *ppCommandAllocator = (ID3D12CommandAllocator *)wrapped; } + else + { + CheckHRESULT(ret); + } return ret; } @@ -398,6 +406,10 @@ HRESULT WrappedID3D12Device::CreateCommandList(UINT nodeMask, D3D12_COMMAND_LIST else RDCERR("Unexpected riid! %s", ToStr(riid).c_str()); } + else + { + CheckHRESULT(ret); + } return ret; } @@ -674,6 +686,10 @@ HRESULT WrappedID3D12Device::CreateGraphicsPipelineState(const D3D12_GRAPHICS_PI ProcessCreatedGraphicsPSO(real, reg, space, pDesc, riid, ppPipelineState); } + else + { + CheckHRESULT(ret); + } return ret; } @@ -827,6 +843,10 @@ HRESULT WrappedID3D12Device::CreateComputePipelineState(const D3D12_COMPUTE_PIPE ProcessCreatedComputePSO(real, reg, space, pDesc, riid, ppPipelineState); } + else + { + CheckHRESULT(ret); + } return ret; } @@ -926,6 +946,10 @@ HRESULT WrappedID3D12Device::CreateDescriptorHeap(const D3D12_DESCRIPTOR_HEAP_DE *ppvHeap = (ID3D12DescriptorHeap *)wrapped; } + else + { + CheckHRESULT(ret); + } return ret; } @@ -1098,6 +1122,10 @@ HRESULT WrappedID3D12Device::CreateRootSignature(UINT nodeMask, const void *pBlo *ppvRootSignature = (ID3D12RootSignature *)wrapped; } + else + { + CheckHRESULT(ret); + } return ret; } @@ -1586,6 +1614,10 @@ HRESULT WrappedID3D12Device::CreateCommittedResource(const D3D12_HEAP_PROPERTIES } } } + else + { + CheckHRESULT(ret); + } return ret; } @@ -1681,6 +1713,10 @@ HRESULT WrappedID3D12Device::CreateHeap(const D3D12_HEAP_DESC *pDesc, REFIID rii *ppvHeap = (ID3D12Heap *)wrapped; } + else + { + CheckHRESULT(ret); + } return ret; } @@ -1886,6 +1922,10 @@ HRESULT WrappedID3D12Device::CreatePlacedResource(ID3D12Heap *pHeap, UINT64 Heap } } } + else + { + CheckHRESULT(ret); + } return ret; } @@ -2116,6 +2156,10 @@ HRESULT WrappedID3D12Device::CreateReservedResource(const D3D12_RESOURCE_DESC *p } } } + else + { + CheckHRESULT(ret); + } return ret; } @@ -2209,6 +2253,10 @@ HRESULT WrappedID3D12Device::CreateFence(UINT64 InitialValue, D3D12_FENCE_FLAGS else if(riid == __uuidof(ID3D12Fence1)) *ppFence = (ID3D12Fence1 *)wrapped; } + else + { + CheckHRESULT(ret); + } return ret; } @@ -2286,6 +2334,10 @@ HRESULT WrappedID3D12Device::CreateQueryHeap(const D3D12_QUERY_HEAP_DESC *pDesc, *ppvHeap = (ID3D12QueryHeap *)wrapped; } + else + { + CheckHRESULT(ret); + } return ret; } @@ -2413,6 +2465,10 @@ HRESULT WrappedID3D12Device::CreateCommandSignature(const D3D12_COMMAND_SIGNATUR *ppvCommandSignature = (ID3D12CommandSignature *)wrapped; } + else + { + CheckHRESULT(ret); + } return ret; } diff --git a/renderdoc/driver/d3d12/d3d12_device_wrap2.cpp b/renderdoc/driver/d3d12/d3d12_device_wrap2.cpp index 3742d3fd4..6e5147d78 100644 --- a/renderdoc/driver/d3d12/d3d12_device_wrap2.cpp +++ b/renderdoc/driver/d3d12/d3d12_device_wrap2.cpp @@ -353,6 +353,10 @@ HRESULT WrappedID3D12Device::CreatePipelineState(const D3D12_PIPELINE_STATE_STRE *ppPipelineState = (ID3D12PipelineState *)wrapped; } + else + { + CheckHRESULT(ret); + } return ret; } diff --git a/renderdoc/driver/d3d12/d3d12_device_wrap3.cpp b/renderdoc/driver/d3d12/d3d12_device_wrap3.cpp index 5b30d7cdd..fd04970c8 100644 --- a/renderdoc/driver/d3d12/d3d12_device_wrap3.cpp +++ b/renderdoc/driver/d3d12/d3d12_device_wrap3.cpp @@ -88,6 +88,10 @@ HRESULT WrappedID3D12Device::OpenExistingHeapFromAddress(const void *pAddress, R *ppvHeap = (ID3D12Heap *)wrapped; } + else + { + CheckHRESULT(ret); + } return ret; } @@ -153,6 +157,10 @@ HRESULT WrappedID3D12Device::OpenExistingHeapFromFileMapping(HANDLE hFileMapping *ppvHeap = (ID3D12Heap *)wrapped; } + else + { + CheckHRESULT(ret); + } return ret; } diff --git a/renderdoc/driver/d3d12/d3d12_device_wrap4.cpp b/renderdoc/driver/d3d12/d3d12_device_wrap4.cpp index 002151340..29b7da1b5 100644 --- a/renderdoc/driver/d3d12/d3d12_device_wrap4.cpp +++ b/renderdoc/driver/d3d12/d3d12_device_wrap4.cpp @@ -167,6 +167,10 @@ HRESULT WrappedID3D12Device::CreateCommandList1(UINT nodeMask, D3D12_COMMAND_LIS else RDCERR("Unexpected riid! %s", ToStr(riid).c_str()); } + else + { + CheckHRESULT(ret); + } return ret; } @@ -411,6 +415,10 @@ HRESULT WrappedID3D12Device::CreateCommittedResource1( } } } + else + { + CheckHRESULT(ret); + } return ret; } @@ -517,6 +525,10 @@ HRESULT WrappedID3D12Device::CreateHeap1(const D3D12_HEAP_DESC *pDesc, *ppvHeap = (ID3D12Heap *)wrapped; } + else + { + CheckHRESULT(ret); + } return ret; } diff --git a/renderdoc/driver/d3d12/d3d12_device_wrap8.cpp b/renderdoc/driver/d3d12/d3d12_device_wrap8.cpp index a7e1dc43d..6f406dbb0 100644 --- a/renderdoc/driver/d3d12/d3d12_device_wrap8.cpp +++ b/renderdoc/driver/d3d12/d3d12_device_wrap8.cpp @@ -252,6 +252,10 @@ HRESULT WrappedID3D12Device::CreateCommittedResource2( } } } + else + { + CheckHRESULT(ret); + } return ret; } @@ -469,6 +473,10 @@ HRESULT WrappedID3D12Device::CreatePlacedResource1(ID3D12Heap *pHeap, UINT64 Hea } } } + else + { + CheckHRESULT(ret); + } return ret; } diff --git a/renderdoc/driver/d3d12/d3d12_device_wrap9.cpp b/renderdoc/driver/d3d12/d3d12_device_wrap9.cpp index f9054d55e..9cf089d1d 100644 --- a/renderdoc/driver/d3d12/d3d12_device_wrap9.cpp +++ b/renderdoc/driver/d3d12/d3d12_device_wrap9.cpp @@ -187,6 +187,10 @@ HRESULT WrappedID3D12Device::CreateCommandQueue1(const D3D12_COMMAND_QUEUE_DESC *ppCommandQueue = (ID3D12CommandQueue *)wrapped; } + else + { + CheckHRESULT(ret); + } return ret; } diff --git a/renderdoc/driver/d3d12/d3d12_initstate.cpp b/renderdoc/driver/d3d12/d3d12_initstate.cpp index 9d5756d16..dfe56dcb9 100644 --- a/renderdoc/driver/d3d12/d3d12_initstate.cpp +++ b/renderdoc/driver/d3d12/d3d12_initstate.cpp @@ -793,6 +793,9 @@ bool D3D12ResourceManager::Serialise_InitialState(SerialiserType &ser, ResourceI ID3D12GraphicsCommandList *list = Unwrap(m_Device->GetInitialStateList()); + if(!list) + return false; + D3D12_RESOURCE_DESC arrayDesc = resDesc; arrayDesc.Alignment = 0; arrayDesc.DepthOrArraySize *= (UINT16)arrayDesc.SampleDesc.Count; @@ -895,6 +898,9 @@ bool D3D12ResourceManager::Serialise_InitialState(SerialiserType &ser, ResourceI { list = Unwrap(m_Device->GetInitialStateList()); + if(!list) + return false; + D3D12_RESOURCE_BARRIER b = {}; b.Transition.pResource = Unwrap(msaaTex); b.Transition.Subresource = D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES; @@ -1023,6 +1029,9 @@ void D3D12ResourceManager::Create_InitialState(ResourceId id, ID3D12DeviceChild void D3D12ResourceManager::Apply_InitialState(ID3D12DeviceChild *live, const D3D12InitialContents &data) { + if(m_Device->HasFatalError()) + return; + D3D12ResourceType type = (D3D12ResourceType)data.resourceType; if(type == Resource_DescriptorHeap) @@ -1055,6 +1064,9 @@ void D3D12ResourceManager::Apply_InitialState(ID3D12DeviceChild *live, { if(IsLoading(m_State) || m_Device->GetQueue()->IsSparseUpdatedResource(GetResID(live))) data.sparseBinds->Apply(m_Device, (ID3D12Resource *)live); + + if(m_Device->HasFatalError()) + return; } else { @@ -1079,6 +1091,7 @@ void D3D12ResourceManager::Apply_InitialState(ID3D12DeviceChild *live, if(copyDst->GetDesc().Dimension == D3D12_RESOURCE_DIMENSION_BUFFER) { hr = copyDst->Map(0, NULL, (void **)&dst); + m_Device->CheckHRESULT(hr); if(FAILED(hr)) { @@ -1111,6 +1124,7 @@ void D3D12ResourceManager::Apply_InitialState(ID3D12DeviceChild *live, for(UINT i = 0; i < numSubresources; i++) { hr = copyDst->Map(i, NULL, (void **)&dst); + m_Device->CheckHRESULT(hr); if(FAILED(hr)) { @@ -1156,6 +1170,9 @@ void D3D12ResourceManager::Apply_InitialState(ID3D12DeviceChild *live, ID3D12GraphicsCommandList *list = Unwrap(m_Device->GetInitialStateList()); + if(!list) + return; + rdcarray barriers; const rdcarray &states = diff --git a/renderdoc/driver/d3d12/d3d12_msaa_array_conv.cpp b/renderdoc/driver/d3d12/d3d12_msaa_array_conv.cpp index f01ca1362..b7731024d 100644 --- a/renderdoc/driver/d3d12/d3d12_msaa_array_conv.cpp +++ b/renderdoc/driver/d3d12/d3d12_msaa_array_conv.cpp @@ -321,6 +321,9 @@ void D3D12DebugManager::CopyTex2DMSToArray(ID3D12GraphicsCommandList *list, { list->Close(); + if(m_pDevice->HasFatalError()) + return; + ID3D12CommandList *l = list; m_pDevice->GetQueue()->GetReal()->ExecuteCommandLists(1, &l); m_pDevice->GPUSync(m_pDevice->GetQueue()->GetReal(), Unwrap(m_DebugFence)); diff --git a/renderdoc/driver/d3d12/d3d12_outputwindow.cpp b/renderdoc/driver/d3d12/d3d12_outputwindow.cpp index 15a192924..829b0eab4 100644 --- a/renderdoc/driver/d3d12/d3d12_outputwindow.cpp +++ b/renderdoc/driver/d3d12/d3d12_outputwindow.cpp @@ -207,8 +207,15 @@ uint64_t D3D12Replay::MakeOutputWindow(WindowingData window, bool depth) if(outw.swap) { - outw.swap->GetBuffer(0, __uuidof(ID3D12Resource), (void **)&outw.bb[0]); - outw.swap->GetBuffer(1, __uuidof(ID3D12Resource), (void **)&outw.bb[1]); + hr = outw.swap->GetBuffer(0, __uuidof(ID3D12Resource), (void **)&outw.bb[0]); + m_pDevice->CheckHRESULT(hr); + if(FAILED(hr)) + return 0; + hr = outw.swap->GetBuffer(1, __uuidof(ID3D12Resource), (void **)&outw.bb[1]); + m_pDevice->CheckHRESULT(hr); + if(FAILED(hr)) + return 0; + outw.bbDesc = outw.bb[0]->GetDesc(); } else @@ -315,6 +322,7 @@ bool D3D12Replay::CheckResizeOutputWindow(uint64_t id) HRESULT hr = outw.swap->ResizeBuffers(desc.BufferCount, outw.width, outw.height, desc.BufferDesc.Format, desc.Flags); + m_pDevice->CheckHRESULT(hr); if(FAILED(hr)) { @@ -322,8 +330,14 @@ bool D3D12Replay::CheckResizeOutputWindow(uint64_t id) return true; } - outw.swap->GetBuffer(0, __uuidof(ID3D12Resource), (void **)&outw.bb[0]); - outw.swap->GetBuffer(1, __uuidof(ID3D12Resource), (void **)&outw.bb[1]); + hr = outw.swap->GetBuffer(0, __uuidof(ID3D12Resource), (void **)&outw.bb[0]); + m_pDevice->CheckHRESULT(hr); + if(FAILED(hr)) + return true; + hr = outw.swap->GetBuffer(1, __uuidof(ID3D12Resource), (void **)&outw.bb[1]); + m_pDevice->CheckHRESULT(hr); + if(FAILED(hr)) + return true; } outw.bbIdx = 0; @@ -417,10 +431,13 @@ void D3D12Replay::GetOutputWindowData(uint64_t id, bytebuf &retData) HRESULT hr = m_pDevice->CreateCommittedResource(&heapProps, D3D12_HEAP_FLAG_NONE, &bufDesc, D3D12_RESOURCE_STATE_COPY_DEST, NULL, __uuidof(ID3D12Resource), (void **)&readback); + m_pDevice->CheckHRESULT(hr); if(SUCCEEDED(hr)) { ID3D12GraphicsCommandList *list = m_pDevice->GetNewList(); + if(!list) + return; D3D12_RESOURCE_BARRIER barrier = {}; @@ -480,6 +497,7 @@ void D3D12Replay::GetOutputWindowData(uint64_t id, bytebuf &retData) byte *data = NULL; hr = readback->Map(0, NULL, (void **)&data); + m_pDevice->CheckHRESULT(hr); if(SUCCEEDED(hr) && data) { @@ -521,6 +539,8 @@ void D3D12Replay::ClearOutputWindowColor(uint64_t id, FloatVector col) return; ID3D12GraphicsCommandList *list = m_pDevice->GetNewList(); + if(!list) + return; list->ClearRenderTargetView(m_OutputWindows[id].rtv, &col.x, 0, NULL); @@ -533,6 +553,8 @@ void D3D12Replay::ClearOutputWindowDepth(uint64_t id, float depth, uint8_t stenc return; ID3D12GraphicsCommandList *list = m_pDevice->GetNewList(); + if(!list) + return; list->ClearDepthStencilView(m_OutputWindows[id].dsv, D3D12_CLEAR_FLAG_DEPTH | D3D12_CLEAR_FLAG_STENCIL, depth, stencil, 0, @@ -603,6 +625,8 @@ void D3D12Replay::FlipOutputWindow(uint64_t id) } ID3D12GraphicsCommandList *list = m_pDevice->GetNewList(); + if(!list) + return; // resolve or copy from colour to backbuffer if(outw.colResolve) @@ -666,6 +690,8 @@ void D3D12Replay::FlipOutputWindow(uint64_t id) m_pDevice->MarkListExecuted((ID3D12GraphicsCommandListX *)list); list = m_pDevice->GetNewList(); + if(!list) + return; std::swap(toPresent.Transition.StateBefore, toPresent.Transition.StateAfter); @@ -678,7 +704,10 @@ void D3D12Replay::FlipOutputWindow(uint64_t id) m_pDevice->FlushLists(); if(outw.swap) - outw.swap->Present(0, 0); + { + HRESULT hr = outw.swap->Present(0, 0); + m_pDevice->CheckHRESULT(hr); + } outw.bbIdx++; outw.bbIdx %= 2; diff --git a/renderdoc/driver/d3d12/d3d12_overlay.cpp b/renderdoc/driver/d3d12/d3d12_overlay.cpp index 8f0e79991..ad683567d 100644 --- a/renderdoc/driver/d3d12/d3d12_overlay.cpp +++ b/renderdoc/driver/d3d12/d3d12_overlay.cpp @@ -439,6 +439,8 @@ ResourceId D3D12Replay::RenderOverlay(ResourceId texid, FloatVector clearCol, De renderDepth->SetName(L"Overlay renderDepth"); ID3D12GraphicsCommandList *list = m_pDevice->GetNewList(); + if(!list) + return ResourceId(); const rdcarray &states = m_pDevice->GetSubresourceStates(GetResID(realDepth)); @@ -492,6 +494,8 @@ ResourceId D3D12Replay::RenderOverlay(ResourceId texid, FloatVector clearCol, De rtDesc.Format = DXGI_FORMAT_R16G16B16A16_FLOAT; ID3D12GraphicsCommandListX *list = m_pDevice->GetNewList(); + if(!list) + return ResourceId(); // clear all mips and all slices first for(UINT mip = 0; mip < overlayTexDesc.MipLevels; mip++) @@ -841,6 +845,8 @@ ResourceId D3D12Replay::RenderOverlay(ResourceId texid, FloatVector clearCol, De m_pDevice->ReplayLog(0, events[0], eReplay_WithoutDraw); list = m_pDevice->GetNewList(); + if(!list) + return ResourceId(); for(size_t i = 0; i < rts.size(); i++) { @@ -984,6 +990,8 @@ ResourceId D3D12Replay::RenderOverlay(ResourceId texid, FloatVector clearCol, De rs = prev; list = m_pDevice->GetNewList(); + if(!list) + return ResourceId(); rs.ApplyState(m_pDevice, list); @@ -1185,6 +1193,8 @@ ResourceId D3D12Replay::RenderOverlay(ResourceId texid, FloatVector clearCol, De if(list == NULL) list = m_pDevice->GetNewList(); + if(!list) + return ResourceId(); rs.ApplyState(m_pDevice, list); @@ -1298,6 +1308,8 @@ ResourceId D3D12Replay::RenderOverlay(ResourceId texid, FloatVector clearCol, De list->Close(); m_pDevice->ReplayLog(0, events[0], eReplay_WithoutDraw); list = m_pDevice->GetNewList(); + if(!list) + return ResourceId(); } uint32_t width = uint32_t(RDCMAX(1ULL, overlayTexDesc.Width >> (sub.mip + 1))); @@ -1407,6 +1419,8 @@ ResourceId D3D12Replay::RenderOverlay(ResourceId texid, FloatVector clearCol, De // resolve pass { list = m_pDevice->GetNewList(); + if(!list) + return ResourceId(); D3D12_RESOURCE_BARRIER overdrawBarriers[2] = {}; diff --git a/renderdoc/driver/d3d12/d3d12_postvs.cpp b/renderdoc/driver/d3d12/d3d12_postvs.cpp index 019eea991..0890ef0bb 100644 --- a/renderdoc/driver/d3d12/d3d12_postvs.cpp +++ b/renderdoc/driver/d3d12/d3d12_postvs.cpp @@ -602,6 +602,7 @@ void D3D12Replay::InitPostVSBuffers(uint32_t eventId) byte *byteData = NULL; D3D12_RANGE range = {0, (SIZE_T)m_SOBufferSize}; hr = m_SOStagingBuffer->Map(0, &range, (void **)&byteData); + m_pDevice->CheckHRESULT(hr); if(FAILED(hr)) { RDCERR("Failed to map sobuffer HRESULT: %s", ToStr(hr).c_str()); @@ -898,6 +899,12 @@ void D3D12Replay::InitPostVSBuffers(uint32_t eventId) D3D12_QUERY_DATA_SO_STATISTICS *data; hr = m_SOStagingBuffer->Map(0, &range, (void **)&data); + m_pDevice->CheckHRESULT(hr); + if(FAILED(hr)) + { + RDCERR("Couldn't get SO statistics data"); + return; + } D3D12_QUERY_DATA_SO_STATISTICS result = *data; @@ -1061,6 +1068,12 @@ void D3D12Replay::InitPostVSBuffers(uint32_t eventId) D3D12_QUERY_DATA_SO_STATISTICS *data; hr = m_SOStagingBuffer->Map(0, &range, (void **)&data); + m_pDevice->CheckHRESULT(hr); + if(FAILED(hr)) + { + RDCERR("Couldn't get SO statistics data"); + return; + } uint64_t outputSize = data->PrimitivesStorageNeeded * 3 * stride; @@ -1125,6 +1138,7 @@ void D3D12Replay::InitPostVSBuffers(uint32_t eventId) byte *byteData = NULL; D3D12_RANGE range = {0, (SIZE_T)m_SOBufferSize}; hr = m_SOStagingBuffer->Map(0, &range, (void **)&byteData); + m_pDevice->CheckHRESULT(hr); if(FAILED(hr)) { RDCERR("Failed to map sobuffer HRESULT: %s", ToStr(hr).c_str()); diff --git a/renderdoc/driver/d3d12/d3d12_rendermesh.cpp b/renderdoc/driver/d3d12/d3d12_rendermesh.cpp index d7f0fb40e..944036e30 100644 --- a/renderdoc/driver/d3d12/d3d12_rendermesh.cpp +++ b/renderdoc/driver/d3d12/d3d12_rendermesh.cpp @@ -245,6 +245,8 @@ void D3D12Replay::RenderMesh(uint32_t eventId, const rdcarray &secon OutputWindow &outw = it->second; ID3D12GraphicsCommandList *list = m_pDevice->GetNewList(); + if(!list) + return; list->OMSetRenderTargets(1, &outw.rtv, TRUE, &outw.dsv); diff --git a/renderdoc/driver/d3d12/d3d12_rendertexture.cpp b/renderdoc/driver/d3d12/d3d12_rendertexture.cpp index d6f63c554..0d5a778f5 100644 --- a/renderdoc/driver/d3d12/d3d12_rendertexture.cpp +++ b/renderdoc/driver/d3d12/d3d12_rendertexture.cpp @@ -241,10 +241,18 @@ void D3D12DebugManager::PrepareTextureSampling(ID3D12Resource *resource, CompTyp NULL, __uuidof(ID3D12Resource), (void **)&m_TexResource); RDCASSERTEQUAL(hr, S_OK); + if(FAILED(hr)) + { + RDCERR("Couldn't create display texture"); + return; + } + m_TexResource->SetName(L"m_TexResource"); } ID3D12GraphicsCommandList *list = m_pDevice->GetNewList(); + if(!list) + return; // prepare real resource for copying if(!barriers.empty()) @@ -665,6 +673,8 @@ bool D3D12Replay::RenderTextureInternal(D3D12_CPU_DESCRIPTOR_HANDLE rtv, Texture { ID3D12GraphicsCommandList *list = m_pDevice->GetNewList(); + if(!list) + return false; if(!barriers.empty()) list->ResourceBarrier((UINT)barriers.size(), &barriers[0]); diff --git a/renderdoc/driver/d3d12/d3d12_replay.cpp b/renderdoc/driver/d3d12/d3d12_replay.cpp index 3f7752a2f..a66ee1cf6 100644 --- a/renderdoc/driver/d3d12/d3d12_replay.cpp +++ b/renderdoc/driver/d3d12/d3d12_replay.cpp @@ -1804,6 +1804,8 @@ void D3D12Replay::RenderHighlightBox(float w, float h, float scale) { ID3D12GraphicsCommandList *list = m_pDevice->GetNewList(); + if(!list) + return; float black[] = {0.0f, 0.0f, 0.0f, 1.0f}; float white[] = {1.0f, 1.0f, 1.0f, 1.0f}; @@ -1877,6 +1879,8 @@ void D3D12Replay::RenderCheckerboard(FloatVector dark, FloatVector light) { ID3D12GraphicsCommandList *list = m_pDevice->GetNewList(); + if(!list) + return; list->OMSetRenderTargets(1, &outw.rtv, TRUE, NULL); @@ -2268,6 +2272,8 @@ uint32_t D3D12Replay::PickVertex(uint32_t eventId, int32_t width, int32_t height } ID3D12GraphicsCommandList *list = m_pDevice->GetNewList(); + if(!list) + return ~0U; list->SetPipelineState(m_VertexPick.Pipe); @@ -2288,6 +2294,8 @@ uint32_t D3D12Replay::PickVertex(uint32_t eventId, int32_t width, int32_t height GetDebugManager()->GetBufferData(m_VertexPick.ResultBuf, 0, 0, results); list = m_pDevice->GetNewList(); + if(!list) + return ~0U; UINT zeroes[4] = {0, 0, 0, 0}; list->ClearUnorderedAccessViewUint(GetDebugManager()->GetGPUHandle(PICK_RESULT_CLEAR_UAV), @@ -2396,6 +2404,8 @@ void D3D12Replay::PickPixel(ResourceId texture, uint32_t x, uint32_t y, const Su } ID3D12GraphicsCommandList *list = m_pDevice->GetNewList(); + if(!list) + return; D3D12_RESOURCE_BARRIER barrier = {}; @@ -2435,6 +2445,7 @@ void D3D12Replay::PickPixel(ResourceId texture, uint32_t x, uint32_t y, const Su float *pix = NULL; HRESULT hr = m_General.ResultReadbackBuffer->Map(0, &range, (void **)&pix); + m_pDevice->CheckHRESULT(hr); if(FAILED(hr)) { @@ -2522,6 +2533,8 @@ bool D3D12Replay::GetMinMax(ResourceId texid, const Subresource &sub, CompType t { ID3D12GraphicsCommandList *list = m_pDevice->GetNewList(); + if(!list) + return false; if(!barriers.empty()) list->ResourceBarrier((UINT)barriers.size(), &barriers[0]); @@ -2609,6 +2622,7 @@ bool D3D12Replay::GetMinMax(ResourceId texid, const Subresource &sub, CompType t void *data = NULL; HRESULT hr = m_General.ResultReadbackBuffer->Map(0, &range, &data); + m_pDevice->CheckHRESULT(hr); if(FAILED(hr)) { @@ -2718,6 +2732,8 @@ bool D3D12Replay::GetHistogram(ResourceId texid, const Subresource &sub, CompTyp { ID3D12GraphicsCommandList *list = m_pDevice->GetNewList(); + if(!list) + return false; if(!barriers.empty()) list->ResourceBarrier((UINT)barriers.size(), &barriers[0]); @@ -2780,6 +2796,7 @@ bool D3D12Replay::GetHistogram(ResourceId texid, const Subresource &sub, CompTyp void *data = NULL; HRESULT hr = m_General.ResultReadbackBuffer->Map(0, &range, &data); + m_pDevice->CheckHRESULT(hr); histogram.clear(); histogram.resize(HGRAM_NUM_BUCKETS); @@ -3335,7 +3352,11 @@ void D3D12Replay::GetTextureData(ResourceId tex, const Subresource &sub, hr = m_pDevice->CreateCommittedResource(&defaultHeap, D3D12_HEAP_FLAG_NONE, ©Desc, D3D12_RESOURCE_STATE_RENDER_TARGET, NULL, __uuidof(ID3D12Resource), (void **)&remapTexture); - RDCASSERTEQUAL(hr, S_OK); + if(FAILED(hr)) + { + RDCERR("Couldn't create remap texture: %s", ToStr(hr).c_str()); + return; + } TexDisplayFlags flags = IsSRGBFormat(copyDesc.Format) ? eTexDisplay_None : eTexDisplay_LinearRender; @@ -3411,6 +3432,8 @@ void D3D12Replay::GetTextureData(ResourceId tex, const Subresource &sub, tmpTexture = srcTexture = remapTexture; list = m_pDevice->GetNewList(); + if(!list) + return; D3D12_RESOURCE_BARRIER b = {}; b.Transition.pResource = remapTexture; @@ -3441,11 +3464,17 @@ void D3D12Replay::GetTextureData(ResourceId tex, const Subresource &sub, hr = m_pDevice->CreateCommittedResource(&defaultHeap, D3D12_HEAP_FLAG_NONE, ©Desc, D3D12_RESOURCE_STATE_RESOLVE_DEST, NULL, __uuidof(ID3D12Resource), (void **)&resolveTexture); - RDCASSERTEQUAL(hr, S_OK); + if(FAILED(hr)) + { + RDCERR("Couldn't create resolve texture: %s", ToStr(hr).c_str()); + return; + } RDCASSERT(!isDepth && !isStencil); list = m_pDevice->GetNewList(); + if(!list) + return; // put source texture into resolve source state const rdcarray &states = m_pDevice->GetSubresourceStates(tex); @@ -3511,9 +3540,15 @@ void D3D12Replay::GetTextureData(ResourceId tex, const Subresource &sub, &defaultHeap, D3D12_HEAP_FLAG_NONE, ©Desc, isDepth ? D3D12_RESOURCE_STATE_DEPTH_WRITE : D3D12_RESOURCE_STATE_RENDER_TARGET, NULL, __uuidof(ID3D12Resource), (void **)&arrayTexture); - RDCASSERTEQUAL(hr, S_OK); + if(FAILED(hr)) + { + RDCERR("Couldn't create array texture: %s", ToStr(hr).c_str()); + return; + } list = m_pDevice->GetNewList(); + if(!list) + return; // put source texture into shader read state const rdcarray &states = m_pDevice->GetSubresourceStates(tex); @@ -3553,6 +3588,8 @@ void D3D12Replay::GetTextureData(ResourceId tex, const Subresource &sub, tmpTexture = srcTexture = arrayTexture; list = m_pDevice->GetNewList(); + if(!list) + return; // real resource back to normal for(size_t i = 0; i < barriers.size(); i++) @@ -3575,6 +3612,8 @@ void D3D12Replay::GetTextureData(ResourceId tex, const Subresource &sub, if(list == NULL) list = m_pDevice->GetNewList(); + if(!list) + return; rdcarray barriers; @@ -3661,7 +3700,11 @@ void D3D12Replay::GetTextureData(ResourceId tex, const Subresource &sub, hr = m_pDevice->CreateCommittedResource(&heapProps, D3D12_HEAP_FLAG_NONE, &readbackDesc, D3D12_RESOURCE_STATE_COPY_DEST, NULL, __uuidof(ID3D12Resource), (void **)&readbackBuf); - RDCASSERTEQUAL(hr, S_OK); + if(FAILED(hr)) + { + RDCERR("Couldn't create readback buffer: %s", ToStr(hr).c_str()); + return; + } for(UINT p = 0; p < planes; p++) { @@ -3697,6 +3740,13 @@ void D3D12Replay::GetTextureData(ResourceId tex, const Subresource &sub, // map the buffer and copy to return buffer byte *pData = NULL; hr = readbackBuf->Map(0, NULL, (void **)&pData); + m_pDevice->CheckHRESULT(hr); + if(FAILED(hr)) + { + RDCERR("Couldn't map readback buffer: %s", ToStr(hr).c_str()); + readbackBuf->Unmap(0, NULL); + return; + } RDCASSERTEQUAL(hr, S_OK); RDCASSERT(pData != NULL); @@ -3869,7 +3919,11 @@ ResourceId D3D12Replay::ApplyCustomShader(ResourceId shader, ResourceId texid, HRESULT hr = m_pDevice->CreateCommittedResource( &heapProps, D3D12_HEAP_FLAG_NONE, &resDesc, D3D12_RESOURCE_STATE_RENDER_TARGET, NULL, __uuidof(ID3D12Resource), (void **)&m_CustomShaderTex); - RDCASSERTEQUAL(hr, S_OK); + if(FAILED(hr)) + { + RDCERR("Couldn't create custom shader texture: %s", ToStr(hr).c_str()); + return ResourceId(); + } if(m_CustomShaderTex) { @@ -3894,6 +3948,8 @@ ResourceId D3D12Replay::ApplyCustomShader(ResourceId shader, ResourceId texid, GetDebugManager()->GetCPUHandle(CUSTOM_SHADER_RTV)); ID3D12GraphicsCommandList *list = m_pDevice->GetNewList(); + if(!list) + return ResourceId(); float clr[] = {0.0f, 0.0f, 0.0f, 0.0f}; list->ClearRenderTargetView(GetDebugManager()->GetCPUHandle(CUSTOM_SHADER_RTV), clr, 0, NULL); diff --git a/renderdoc/driver/d3d12/d3d12_shader_feedback.cpp b/renderdoc/driver/d3d12/d3d12_shader_feedback.cpp index 42fcfbcb9..5aba4d2d5 100644 --- a/renderdoc/driver/d3d12/d3d12_shader_feedback.cpp +++ b/renderdoc/driver/d3d12/d3d12_shader_feedback.cpp @@ -280,6 +280,9 @@ void D3D12Replay::FetchShaderFeedback(uint32_t eventId) if(!D3D12_BindlessFeedback()) return; + if(m_pDevice->HasFatalError()) + return; + // create it here so we won't re-run any code if the event is re-selected. We'll mark it as valid // if it actually has any data in it later. D3D12DynamicShaderFeedback &result = m_BindlessFeedback.Usage[eventId]; @@ -432,6 +435,8 @@ void D3D12Replay::FetchShaderFeedback(uint32_t eventId) GetDebugManager()->GetUAVClearHandle(FEEDBACK_CLEAR_UAV)); ID3D12GraphicsCommandList *list = m_pDevice->GetNewList(); + if(!list) + return; UINT zeroes[4] = {0, 0, 0, 0}; list->ClearUnorderedAccessViewUint(GetDebugManager()->GetGPUHandle(FEEDBACK_CLEAR_UAV), diff --git a/renderdoc/driver/vulkan/vk_android.cpp b/renderdoc/driver/vulkan/vk_android.cpp index 1e4ce81e6..927ca756a 100644 --- a/renderdoc/driver/vulkan/vk_android.cpp +++ b/renderdoc/driver/vulkan/vk_android.cpp @@ -86,7 +86,7 @@ void VulkanReplay::OutputWindow::CreateSurface(WrappedVulkan *driver, VkInstance createInfo.window = wnd; VkResult vkr = ObjDisp(inst)->CreateAndroidSurfaceKHR(Unwrap(inst), &createInfo, NULL, &surface); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + driver->CheckVkResult(vkr); } void VulkanReplay::GetOutputWindowDimensions(uint64_t id, int32_t &w, int32_t &h) diff --git a/renderdoc/driver/vulkan/vk_apple.cpp b/renderdoc/driver/vulkan/vk_apple.cpp index e4222721b..e0e65192b 100644 --- a/renderdoc/driver/vulkan/vk_apple.cpp +++ b/renderdoc/driver/vulkan/vk_apple.cpp @@ -107,7 +107,7 @@ void VulkanReplay::OutputWindow::CreateSurface(WrappedVulkan *driver, VkInstance RDCDEBUG("Creating macOS surface with EXT_metal_surface"); VkResult vkr = ObjDisp(inst)->CreateMetalSurfaceEXT(Unwrap(inst), &createInfo, NULL, &surface); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + driver->CheckVkResult(vkr); return; } #endif @@ -125,7 +125,7 @@ void VulkanReplay::OutputWindow::CreateSurface(WrappedVulkan *driver, VkInstance RDCDEBUG("Creating macOS surface with MVK_macos_surface"); VkResult vkr = ObjDisp(inst)->CreateMacOSSurfaceMVK(Unwrap(inst), &createInfo, NULL, &surface); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + driver->CheckVkResult(vkr); return; } #endif diff --git a/renderdoc/driver/vulkan/vk_common.cpp b/renderdoc/driver/vulkan/vk_common.cpp index b17be081f..32dd7cfb9 100644 --- a/renderdoc/driver/vulkan/vk_common.cpp +++ b/renderdoc/driver/vulkan/vk_common.cpp @@ -226,7 +226,7 @@ void GPUBuffer::Create(WrappedVulkan *driver, VkDevice dev, VkDeviceSize size, u bufInfo.usage |= VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT; VkResult vkr = driver->vkCreateBuffer(dev, &bufInfo, NULL, &buf); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + driver->CheckVkResult(vkr); VkMemoryRequirements mrq = {}; driver->vkGetBufferMemoryRequirements(dev, buf, &mrq); @@ -250,10 +250,13 @@ void GPUBuffer::Create(WrappedVulkan *driver, VkDevice dev, VkDeviceSize size, u } vkr = driver->vkAllocateMemory(dev, &allocInfo, NULL, &mem); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + driver->CheckVkResult(vkr); + + if(vkr != VK_SUCCESS) + return; vkr = driver->vkBindBufferMemory(dev, buf, mem, 0); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + driver->CheckVkResult(vkr); } void GPUBuffer::FillDescriptor(VkDescriptorBufferInfo &desc) @@ -298,7 +301,7 @@ void *GPUBuffer::Map(uint32_t *bindoffset, VkDeviceSize usedsize) void *ptr = NULL; VkResult vkr = m_pDriver->vkMapMemory(device, mem, offset, size, 0, (void **)&ptr); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + m_pDriver->CheckVkResult(vkr); if(createFlags & eGPUBufferReadback) { @@ -307,7 +310,7 @@ void *GPUBuffer::Map(uint32_t *bindoffset, VkDeviceSize usedsize) }; vkr = m_pDriver->vkInvalidateMappedMemoryRanges(device, 1, &range); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + m_pDriver->CheckVkResult(vkr); } return ptr; @@ -333,7 +336,7 @@ void GPUBuffer::Unmap() }; VkResult vkr = m_pDriver->vkFlushMappedMemoryRanges(device, 1, &range); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + m_pDriver->CheckVkResult(vkr); } m_pDriver->vkUnmapMemory(device, mem); diff --git a/renderdoc/driver/vulkan/vk_core.cpp b/renderdoc/driver/vulkan/vk_core.cpp index d77b3018c..6cb529a45 100644 --- a/renderdoc/driver/vulkan/vk_core.cpp +++ b/renderdoc/driver/vulkan/vk_core.cpp @@ -215,11 +215,14 @@ VkCommandBuffer WrappedVulkan::GetInitStateCmd() { initStateCurCmd = GetNextCmd(); + if(initStateCurCmd == VK_NULL_HANDLE) + return VK_NULL_HANDLE; + VkCommandBufferBeginInfo beginInfo = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, NULL, VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT}; VkResult vkr = ObjDisp(initStateCurCmd)->BeginCommandBuffer(Unwrap(initStateCurCmd), &beginInfo); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); if(IsReplayMode(m_State)) { @@ -241,7 +244,7 @@ void WrappedVulkan::CloseInitStateCmd() VkMarkerRegion::End(initStateCurCmd); VkResult vkr = ObjDisp(initStateCurCmd)->EndCommandBuffer(Unwrap(initStateCurCmd)); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); initStateCurCmd = VK_NULL_HANDLE; initStateCurBatch = 0; @@ -269,13 +272,21 @@ VkCommandBuffer WrappedVulkan::GetNextCmd() }; VkResult vkr = ObjDisp(m_Device)->AllocateCommandBuffers(Unwrap(m_Device), &cmdInfo, &ret); - RDCASSERTEQUAL(vkr, VK_SUCCESS); - if(m_SetDeviceLoaderData) - m_SetDeviceLoaderData(m_Device, ret); - else - SetDispatchTableOverMagicNumber(m_Device, ret); + CheckVkResult(vkr); + if(vkr == VK_SUCCESS) + { + if(m_SetDeviceLoaderData) + m_SetDeviceLoaderData(m_Device, ret); + else + SetDispatchTableOverMagicNumber(m_Device, ret); - GetResourceManager()->WrapResource(Unwrap(m_Device), ret); + GetResourceManager()->WrapResource(Unwrap(m_Device), ret); + } + else + { + ret = VK_NULL_HANDLE; + m_FailedReplayStatus = ReplayStatus::APIInitFailed; + } } m_InternalCmds.pendingcmds.push_back(ret); @@ -302,6 +313,9 @@ void WrappedVulkan::SubmitCmds(VkSemaphore *unwrappedWaitSemaphores, VkPipelineStageFlags *waitStageMask, uint32_t waitSemaphoreCount) { RENDERDOC_PROFILEFUNCTION(); + if(HasFatalError()) + return; + // nothing to do if(m_InternalCmds.pendingcmds.empty()) return; @@ -331,7 +345,7 @@ void WrappedVulkan::SubmitCmds(VkSemaphore *unwrappedWaitSemaphores, { VkResult vkr = ObjDisp(m_Queue)->QueueSubmit(Unwrap(m_Queue), 1, &submitInfo, VK_NULL_HANDLE); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); } #if ENABLED(SINGLE_FLUSH_VALIDATE) @@ -357,7 +371,7 @@ VkSemaphore WrappedVulkan::GetNextSemaphore() { VkSemaphoreCreateInfo semInfo = {VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO}; VkResult vkr = ObjDisp(m_Device)->CreateSemaphore(Unwrap(m_Device), &semInfo, NULL, &ret); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); GetResourceManager()->WrapResource(Unwrap(m_Device), ret); } @@ -382,6 +396,10 @@ void WrappedVulkan::SubmitSemaphores() void WrappedVulkan::FlushQ() { RENDERDOC_PROFILEFUNCTION(); + + if(HasFatalError()) + return; + // VKTODOLOW could do away with the need for this function by keeping // commands until N presents later, or something, or checking on fences. // If we do so, then check each use for FlushQ to see if it needs a @@ -392,7 +410,7 @@ void WrappedVulkan::FlushQ() if(m_Queue != VK_NULL_HANDLE) { VkResult vkr = ObjDisp(m_Queue)->QueueWaitIdle(Unwrap(m_Queue)); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); } #if ENABLED(SINGLE_FLUSH_VALIDATE) @@ -400,7 +418,7 @@ void WrappedVulkan::FlushQ() { ObjDisp(m_Device)->DeviceWaitIdle(Unwrap(m_Device)); VkResult vkr = ObjDisp(m_Device)->DeviceWaitIdle(Unwrap(m_Device)); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); } #endif @@ -432,8 +450,11 @@ VkCommandBuffer WrappedVulkan::GetExtQueueCmd(uint32_t queueFamilyIdx) const return buf; } -void WrappedVulkan::SubmitAndFlushExtQueue(uint32_t queueFamilyIdx) const +void WrappedVulkan::SubmitAndFlushExtQueue(uint32_t queueFamilyIdx) { + if(HasFatalError()) + return; + if(queueFamilyIdx >= m_ExternalQueues.size()) { RDCERR("Unsupported queue family %u", queueFamilyIdx); @@ -457,13 +478,16 @@ void WrappedVulkan::SubmitAndFlushExtQueue(uint32_t queueFamilyIdx) const VkQueue q = m_ExternalQueues[queueFamilyIdx].queue; VkResult vkr = ObjDisp(q)->QueueSubmit(Unwrap(q), 1, &submitInfo, VK_NULL_HANDLE); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); ObjDisp(q)->QueueWaitIdle(Unwrap(q)); } void WrappedVulkan::SubmitAndFlushImageStateBarriers(ImageBarrierSequence &barriers) { + if(HasFatalError()) + return; + if(barriers.empty()) return; @@ -504,26 +528,26 @@ void WrappedVulkan::SubmitAndFlushImageStateBarriers(ImageBarrierSequence &barri for(auto it = batch.begin(); it != batch.end(); ++it) { vkr = ObjDisp(cmd)->BeginCommandBuffer(Unwrap(cmd), &beginInfo); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); DoPipelineBarrier(cmd, 1, it); vkr = ObjDisp(cmd)->EndCommandBuffer(Unwrap(cmd)); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); vkr = ObjDisp(queue)->QueueSubmit(Unwrap(queue), 1, &submitInfo, VK_NULL_HANDLE); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); vkr = ObjDisp(queue)->QueueWaitIdle(Unwrap(queue)); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); } #else vkr = ObjDisp(cmd)->BeginCommandBuffer(Unwrap(cmd), &beginInfo); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); DoPipelineBarrier(cmd, (uint32_t)batch.size(), batch.data()); vkr = ObjDisp(cmd)->EndCommandBuffer(Unwrap(cmd)); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); VkFence &fence = queueFamilyFences[queueFamilyIndex]; if(fence == VK_NULL_HANDLE) @@ -534,11 +558,11 @@ void WrappedVulkan::SubmitAndFlushImageStateBarriers(ImageBarrierSequence &barri /* flags = */ 0, }; vkr = ObjDisp(m_Device)->CreateFence(Unwrap(m_Device), &fenceInfo, NULL, &fence); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); } vkr = ObjDisp(queue)->QueueSubmit(Unwrap(queue), 1, &submitInfo, fence); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); submittedFences.push_back(fence); #endif batch.clear(); @@ -547,10 +571,10 @@ void WrappedVulkan::SubmitAndFlushImageStateBarriers(ImageBarrierSequence &barri { vkr = ObjDisp(m_Device)->WaitForFences(Unwrap(m_Device), (uint32_t)submittedFences.size(), submittedFences.data(), VK_TRUE, 1000000000); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); vkr = ObjDisp(m_Device)->ResetFences(Unwrap(m_Device), (uint32_t)submittedFences.size(), submittedFences.data()); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); submittedFences.clear(); } } @@ -1735,12 +1759,12 @@ void WrappedVulkan::StartFrameCapture(void *dev, void *wnd) VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT}; vkr = ObjDisp(cmd)->BeginCommandBuffer(Unwrap(cmd), &beginInfo); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); DoPipelineBarrier(cmd, 1, &memBarrier); vkr = ObjDisp(cmd)->EndCommandBuffer(Unwrap(cmd)); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); } GetResourceManager()->PrepareInitialContents(); @@ -1916,7 +1940,7 @@ bool WrappedVulkan::EndFrameCapture(void *dev, void *wnd) VK_BUFFER_USAGE_TRANSFER_DST_BIT, }; vt->CreateBuffer(Unwrap(device), &bufInfo, NULL, &readbackBuf); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); GetResourceManager()->WrapResource(Unwrap(device), readbackBuf); @@ -1925,14 +1949,14 @@ bool WrappedVulkan::EndFrameCapture(void *dev, void *wnd) vkr = vt->BindBufferMemory(Unwrap(device), Unwrap(readbackBuf), Unwrap(readbackMem.mem), readbackMem.offs); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); VkCommandBufferBeginInfo beginInfo = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, NULL, VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT}; // do image copy vkr = vt->BeginCommandBuffer(Unwrap(cmd), &beginInfo); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); uint32_t rowPitch = GetByteSize(swapInfo.imageInfo.extent.width, 1, 1, swapInfo.imageInfo.format, 0); @@ -1974,7 +1998,7 @@ bool WrappedVulkan::EndFrameCapture(void *dev, void *wnd) VkCommandBuffer extQCmd = GetExtQueueCmd(swapQueueIndex); vkr = vt->BeginCommandBuffer(Unwrap(extQCmd), &beginInfo); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); DoPipelineBarrier(extQCmd, 1, &bbBarrier); @@ -2007,7 +2031,7 @@ bool WrappedVulkan::EndFrameCapture(void *dev, void *wnd) DoPipelineBarrier(cmd, 1, &bufBarrier); vkr = vt->EndCommandBuffer(Unwrap(cmd)); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); SubmitCmds(); FlushQ(); // need to wait so we can readback @@ -2017,7 +2041,7 @@ bool WrappedVulkan::EndFrameCapture(void *dev, void *wnd) VkCommandBuffer extQCmd = GetExtQueueCmd(swapQueueIndex); vkr = vt->BeginCommandBuffer(Unwrap(extQCmd), &beginInfo); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); DoPipelineBarrier(extQCmd, 1, &bbBarrier); @@ -2030,7 +2054,7 @@ bool WrappedVulkan::EndFrameCapture(void *dev, void *wnd) byte *pData = NULL; vkr = vt->MapMemory(Unwrap(device), Unwrap(readbackMem.mem), readbackMem.offs, readbackMem.size, 0, (void **)&pData); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); RDCASSERT(pData != NULL); fp.len = (uint32_t)readbackMem.size; @@ -2046,7 +2070,7 @@ bool WrappedVulkan::EndFrameCapture(void *dev, void *wnd) }; vkr = vt->InvalidateMappedMemoryRanges(Unwrap(device), 1, &range); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); vt->UnmapMemory(Unwrap(device), Unwrap(readbackMem.mem)); @@ -2809,7 +2833,7 @@ ReplayStatus WrappedVulkan::ContextReplayLog(CaptureState readType, uint32_t sta }; VkResult vkr = ObjDisp(m_Queue)->QueueSubmit(Unwrap(m_Queue), 1, &submitInfo, VK_NULL_HANDLE); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); } m_IndirectDraw = false; @@ -2825,6 +2849,9 @@ ReplayStatus WrappedVulkan::ContextReplayLog(CaptureState readType, uint32_t sta void WrappedVulkan::ApplyInitialContents() { RENDERDOC_PROFILEFUNCTION(); + if(HasFatalError()) + return; + VkMarkerRegion region("ApplyInitialContents"); initStateCurBatch = 0; @@ -2858,18 +2885,21 @@ void WrappedVulkan::ApplyInitialContents() VkCommandBuffer cmd = GetNextCmd(); + if(cmd == VK_NULL_HANDLE) + return; + VkResult vkr = VK_SUCCESS; VkCommandBufferBeginInfo beginInfo = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, NULL, VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT}; vkr = ObjDisp(cmd)->BeginCommandBuffer(Unwrap(cmd), &beginInfo); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); DoPipelineBarrier(cmd, 1, &memBarrier); vkr = ObjDisp(cmd)->EndCommandBuffer(Unwrap(cmd)); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); // sync all GPU work so we can also apply descriptor set initial contents SubmitCmds(); @@ -2904,12 +2934,12 @@ void WrappedVulkan::ApplyInitialContents() cmd = GetNextCmd(); vkr = ObjDisp(cmd)->BeginCommandBuffer(Unwrap(cmd), &beginInfo); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); DoPipelineBarrier(cmd, 1, &memBarrier); vkr = ObjDisp(cmd)->EndCommandBuffer(Unwrap(cmd)); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); SubmitAndFlushImageStateBarriers(m_setupImageBarriers); SubmitCmds(); @@ -2925,8 +2955,11 @@ void WrappedVulkan::ApplyInitialContents() cmd = GetNextCmd(); + if(cmd == VK_NULL_HANDLE) + return; + vkr = ObjDisp(cmd)->BeginCommandBuffer(Unwrap(cmd), &beginInfo); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); uint32_t i = 0; for(const ResetQuery &r : m_ResetQueries) @@ -2953,21 +2986,24 @@ void WrappedVulkan::ApplyInitialContents() if(i > 0 && (i % (128 * 1024)) == 0) { vkr = ObjDisp(cmd)->EndCommandBuffer(Unwrap(cmd)); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); SubmitCmds(); FlushQ(); cmd = GetNextCmd(); + if(cmd == VK_NULL_HANDLE) + return; + vkr = ObjDisp(cmd)->BeginCommandBuffer(Unwrap(cmd), &beginInfo); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); } } } vkr = ObjDisp(cmd)->EndCommandBuffer(Unwrap(cmd)); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); m_ResetQueries.clear(); @@ -3492,17 +3528,23 @@ bool WrappedVulkan::ProcessChunk(ReadSerialiser &ser, VulkanChunk chunk) void WrappedVulkan::AddFrameTerminator(uint64_t queueMarkerTag) { + if(HasFatalError()) + return; + VkCommandBuffer cmdBuffer = GetNextCmd(); VkResult vkr = VK_SUCCESS; + if(cmdBuffer == VK_NULL_HANDLE) + return; + VkCommandBufferBeginInfo beginInfo = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, NULL, VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT}; vkr = ObjDisp(cmdBuffer)->BeginCommandBuffer(Unwrap(cmdBuffer), &beginInfo); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); vkr = ObjDisp(cmdBuffer)->EndCommandBuffer(Unwrap(cmdBuffer)); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); VkDebugMarkerObjectTagInfoEXT tagInfo = {VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT, NULL}; tagInfo.objectType = VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT; @@ -3578,6 +3620,9 @@ void WrappedVulkan::ReplayLog(uint32_t startEventID, uint32_t endEventID, Replay { VkCommandBuffer cmd = m_OutsideCmdBuffer = GetNextCmd(); + if(cmd == VK_NULL_HANDLE) + return; + // we'll explicitly submit this when we're ready RemovePendingCommandBuffer(cmd); @@ -3585,7 +3630,7 @@ void WrappedVulkan::ReplayLog(uint32_t startEventID, uint32_t endEventID, Replay VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT}; vkr = ObjDisp(cmd)->BeginCommandBuffer(Unwrap(cmd), &beginInfo); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); rpWasActive = m_Partial[Primary].renderPassActive; @@ -3863,6 +3908,27 @@ void WrappedVulkan::AddDebugMessage(DebugMessage msg) m_DebugMessages.push_back(msg); } +void WrappedVulkan::CheckErrorVkResult(VkResult vkr) +{ + if(vkr == VK_SUCCESS || m_FatalError == ReplayStatus::Succeeded) + return; + + if(vkr == VK_ERROR_INITIALIZATION_FAILED || vkr == VK_ERROR_DEVICE_LOST || vkr == VK_ERROR_UNKNOWN) + { + RDCLOG("Logging device lost fatal error for %s", ToStr(vkr).c_str()); + m_FailedReplayStatus = m_FatalError = ReplayStatus::ReplayDeviceLost; + } + else if(vkr == VK_ERROR_OUT_OF_HOST_MEMORY || vkr == VK_ERROR_OUT_OF_DEVICE_MEMORY) + { + RDCLOG("Logging out of memory fatal error for %s", ToStr(vkr).c_str()); + m_FailedReplayStatus = m_FatalError = ReplayStatus::ReplayOutOfMemory; + } + else + { + RDCLOG("Ignoring return code %s", ToStr(vkr).c_str()); + } +} + VkBool32 WrappedVulkan::DebugCallback(MessageSeverity severity, MessageCategory category, int messageCode, const char *pMessageId, const char *pMessage) { diff --git a/renderdoc/driver/vulkan/vk_core.h b/renderdoc/driver/vulkan/vk_core.h index 5b498eccd..9e282f749 100644 --- a/renderdoc/driver/vulkan/vk_core.h +++ b/renderdoc/driver/vulkan/vk_core.h @@ -290,7 +290,6 @@ private: void AddDebugMessage(DebugMessage msg); ReplayStatus m_FatalError = ReplayStatus::Succeeded; - ReplayStatus FatalErrorCheck() { return m_FatalError; } CaptureState m_State; bool m_AppControlledCapture = false; @@ -478,7 +477,7 @@ private: rdcarray m_ExternalQueues; VkCommandBuffer GetExtQueueCmd(uint32_t queueFamilyIdx) const; - void SubmitAndFlushExtQueue(uint32_t queueFamilyIdx) const; + void SubmitAndFlushExtQueue(uint32_t queueFamilyIdx); void SubmitAndFlushImageStateBarriers(ImageBarrierSequence &barriers); void InlineSetupImageBarriers(VkCommandBuffer cmd, ImageBarrierSequence &batches); @@ -1103,6 +1102,16 @@ public: bool SelectGraphicsComputeQueue(const rdcarray &queueProps, VkDeviceCreateInfo &createInfo, uint32_t &queueFamilyIndex); + ReplayStatus FatalErrorCheck() { return m_FatalError; } + bool HasFatalError() { return m_FatalError != ReplayStatus::Succeeded; } + inline void CheckVkResult(VkResult vkr) + { + if(vkr == VK_SUCCESS) + return; + CheckErrorVkResult(vkr); + } + void CheckErrorVkResult(VkResult vkr); + bool SeparateDepthStencil() const { return m_SeparateDepthStencil; } bool NULLDescriptorsAllowed() const { return m_NULLDescriptorsAllowed; } bool ExtendedDynamicState() const { return m_ExtendedDynState; } diff --git a/renderdoc/driver/vulkan/vk_counters.cpp b/renderdoc/driver/vulkan/vk_counters.cpp index 06b2e05ff..7c60aaa73 100644 --- a/renderdoc/driver/vulkan/vk_counters.cpp +++ b/renderdoc/driver/vulkan/vk_counters.cpp @@ -616,21 +616,24 @@ rdcarray VulkanReplay::FetchCountersKHR(const rdcarrayCreateQueryPool(Unwrap(dev), &queryPoolCreateInfo, NULL, &queryPool); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); // Reset query pool VkCommandBuffer cmd = m_pDriver->GetNextCmd(); + if(cmd == VK_NULL_HANDLE) + return {}; + VkCommandBufferBeginInfo beginInfo = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, NULL, VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT}; vkr = ObjDisp(dev)->BeginCommandBuffer(Unwrap(cmd), &beginInfo); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); ObjDisp(dev)->CmdResetQueryPool(Unwrap(cmd), queryPool, 0, maxEID); vkr = ObjDisp(dev)->EndCommandBuffer(Unwrap(cmd)); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); m_pDriver->SubmitCmds(); @@ -656,7 +659,7 @@ rdcarray VulkanReplay::FetchCountersKHR(const rdcarrayDestroyQueryPool(Unwrap(dev), queryPool, NULL); @@ -859,7 +862,7 @@ rdcarray VulkanReplay::FetchCounters(const rdcarray & VkQueryPool timeStampPool; VkResult vkr = ObjDisp(dev)->CreateQueryPool(Unwrap(dev), &timeStampPoolCreateInfo, NULL, &timeStampPool); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); bool occlNeeded = false; bool statsNeeded = false; @@ -888,23 +891,26 @@ rdcarray VulkanReplay::FetchCounters(const rdcarray & if(availableFeatures.occlusionQueryPrecise && occlNeeded) { vkr = ObjDisp(dev)->CreateQueryPool(Unwrap(dev), &occlusionPoolCreateInfo, NULL, &occlusionPool); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); } VkQueryPool pipeStatsPool = VK_NULL_HANDLE; if(availableFeatures.pipelineStatisticsQuery && statsNeeded) { vkr = ObjDisp(dev)->CreateQueryPool(Unwrap(dev), &pipeStatsPoolCreateInfo, NULL, &pipeStatsPool); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); } VkCommandBuffer cmd = m_pDriver->GetNextCmd(); + if(cmd == VK_NULL_HANDLE) + return {}; + VkCommandBufferBeginInfo beginInfo = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, NULL, VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT}; vkr = ObjDisp(dev)->BeginCommandBuffer(Unwrap(cmd), &beginInfo); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); ObjDisp(dev)->CmdResetQueryPool(Unwrap(cmd), timeStampPool, 0, maxEID * 2); if(occlusionPool != VK_NULL_HANDLE) @@ -913,7 +919,7 @@ rdcarray VulkanReplay::FetchCounters(const rdcarray & ObjDisp(dev)->CmdResetQueryPool(Unwrap(cmd), pipeStatsPool, 0, maxEID); vkr = ObjDisp(dev)->EndCommandBuffer(Unwrap(cmd)); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); #if ENABLED(SINGLE_FLUSH_VALIDATE) m_pDriver->SubmitCmds(); @@ -931,7 +937,7 @@ rdcarray VulkanReplay::FetchCounters(const rdcarray & Unwrap(dev), timeStampPool, 0, (uint32_t)m_TimeStampData.size(), sizeof(uint64_t) * m_TimeStampData.size(), &m_TimeStampData[0], sizeof(uint64_t), VK_QUERY_RESULT_64_BIT | VK_QUERY_RESULT_WAIT_BIT); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); ObjDisp(dev)->DestroyQueryPool(Unwrap(dev), timeStampPool, NULL); @@ -943,7 +949,7 @@ rdcarray VulkanReplay::FetchCounters(const rdcarray & Unwrap(dev), occlusionPool, 0, (uint32_t)m_OcclusionData.size(), sizeof(uint64_t) * m_OcclusionData.size(), &m_OcclusionData[0], sizeof(uint64_t), VK_QUERY_RESULT_64_BIT | VK_QUERY_RESULT_WAIT_BIT); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); ObjDisp(dev)->DestroyQueryPool(Unwrap(dev), occlusionPool, NULL); } @@ -956,7 +962,7 @@ rdcarray VulkanReplay::FetchCounters(const rdcarray & Unwrap(dev), pipeStatsPool, 0, (uint32_t)cb.m_Results.size(), sizeof(uint64_t) * m_PipeStatsData.size(), &m_PipeStatsData[0], sizeof(uint64_t) * 11, VK_QUERY_RESULT_64_BIT | VK_QUERY_RESULT_WAIT_BIT); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); ObjDisp(dev)->DestroyQueryPool(Unwrap(dev), pipeStatsPool, NULL); } diff --git a/renderdoc/driver/vulkan/vk_debug.cpp b/renderdoc/driver/vulkan/vk_debug.cpp index c099e257a..ad98eaf33 100644 --- a/renderdoc/driver/vulkan/vk_debug.cpp +++ b/renderdoc/driver/vulkan/vk_debug.cpp @@ -391,7 +391,7 @@ VulkanDebugManager::VulkanDebugManager(WrappedVulkan *driver) rm->SetInternalResource(GetResID(m_ArrayMSSampler)); vkr = m_pDriver->vkCreateDescriptorPool(dev, &poolInfo, NULL, &m_ArrayMSDescriptorPool); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); rm->SetInternalResource(GetResID(m_ArrayMSDescriptorPool)); @@ -475,7 +475,7 @@ VulkanDebugManager::VulkanDebugManager(WrappedVulkan *driver) continue; vkr = driver->vkCreateImage(driver->GetDev(), &imInfo, NULL, &m_DummyStencilImage[0]); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); rm->SetInternalResource(GetResID(m_DummyStencilImage[0])); @@ -498,7 +498,7 @@ VulkanDebugManager::VulkanDebugManager(WrappedVulkan *driver) RDCASSERT(imgprops.sampleCounts & imInfo.samples, imgprops.sampleCounts, imInfo.samples); vkr = driver->vkCreateImage(driver->GetDev(), &imInfo, NULL, &m_DummyStencilImage[1]); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); rm->SetInternalResource(GetResID(m_DummyStencilImage[1])); @@ -519,17 +519,20 @@ VulkanDebugManager::VulkanDebugManager(WrappedVulkan *driver) }; vkr = driver->vkAllocateMemory(driver->GetDev(), &allocInfo, NULL, &m_DummyStencilMemory); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); + + if(vkr != VK_SUCCESS) + return; rm->SetInternalResource(GetResID(m_DummyStencilMemory)); vkr = driver->vkBindImageMemory(driver->GetDev(), m_DummyStencilImage[0], m_DummyStencilMemory, 0); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); vkr = driver->vkBindImageMemory(driver->GetDev(), m_DummyStencilImage[1], m_DummyStencilMemory, AlignUp(mrq[0].size, mrq[1].alignment)); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); VkImageViewCreateInfo viewInfo = { VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, @@ -546,24 +549,27 @@ VulkanDebugManager::VulkanDebugManager(WrappedVulkan *driver) }; vkr = driver->vkCreateImageView(driver->GetDev(), &viewInfo, NULL, &m_DummyStencilView[0]); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); rm->SetInternalResource(GetResID(m_DummyStencilView[0])); viewInfo.image = m_DummyStencilImage[1]; vkr = driver->vkCreateImageView(driver->GetDev(), &viewInfo, NULL, &m_DummyStencilView[1]); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); rm->SetInternalResource(GetResID(m_DummyStencilView[1])); VkCommandBuffer cmd = driver->GetNextCmd(); + if(cmd == VK_NULL_HANDLE) + return; + VkCommandBufferBeginInfo beginInfo = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, NULL, VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT}; vkr = ObjDisp(cmd)->BeginCommandBuffer(Unwrap(cmd), &beginInfo); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); // need to update image layout into valid state VkImageMemoryBarrier barrier = { @@ -711,7 +717,7 @@ VulkanDebugManager::VulkanDebugManager(WrappedVulkan *driver) // create descriptor pool vkr = driver->vkCreateDescriptorPool(driver->GetDev(), &descPoolInfo, NULL, &m_DiscardPool); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); CREATE_OBJECT(m_DiscardSetLayout, { @@ -845,7 +851,7 @@ void VulkanDebugManager::CreateCustomShaderTex(uint32_t width, uint32_t height, }; vkr = m_pDriver->vkCreateFramebuffer(m_Device, &fbinfo, NULL, &m_Custom.TexFB); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); return; } @@ -880,7 +886,7 @@ void VulkanDebugManager::CreateCustomShaderTex(uint32_t width, uint32_t height, }; vkr = m_pDriver->vkCreateImage(m_Device, &imInfo, NULL, &m_Custom.TexImg); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); VkMemoryRequirements mrq = {0}; m_pDriver->vkGetImageMemoryRequirements(m_Device, m_Custom.TexImg, &mrq); @@ -898,13 +904,16 @@ void VulkanDebugManager::CreateCustomShaderTex(uint32_t width, uint32_t height, }; vkr = m_pDriver->vkAllocateMemory(m_Device, &allocInfo, NULL, &m_Custom.TexMem); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); + + if(vkr != VK_SUCCESS) + return; m_Custom.TexMemSize = mrq.size; } vkr = m_pDriver->vkBindImageMemory(m_Device, m_Custom.TexImg, m_Custom.TexMem, 0); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); VkImageViewCreateInfo viewInfo = { VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, @@ -924,13 +933,16 @@ void VulkanDebugManager::CreateCustomShaderTex(uint32_t width, uint32_t height, { viewInfo.subresourceRange.baseMipLevel = i; vkr = m_pDriver->vkCreateImageView(m_Device, &viewInfo, NULL, &m_Custom.TexImgView[i]); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); } // need to update image layout into valid state VkCommandBuffer cmd = m_pDriver->GetNextCmd(); + if(cmd == VK_NULL_HANDLE) + return; + VkCommandBufferBeginInfo beginInfo = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, NULL, VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT}; @@ -942,7 +954,7 @@ void VulkanDebugManager::CreateCustomShaderTex(uint32_t width, uint32_t height, m_pDriver->GetImageTransitionInfo()); vkr = ObjDisp(dev)->EndCommandBuffer(Unwrap(cmd)); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); #if ENABLED(SINGLE_FLUSH_VALIDATE) m_pDriver->SubmitCmds(); @@ -964,7 +976,7 @@ void VulkanDebugManager::CreateCustomShaderTex(uint32_t width, uint32_t height, }; vkr = m_pDriver->vkCreateFramebuffer(m_Device, &fbinfo, NULL, &m_Custom.TexFB); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); } void VulkanDebugManager::CreateCustomShaderPipeline(ResourceId shader, VkPipelineLayout pipeLayout) @@ -1344,6 +1356,9 @@ uint32_t VulkanReplay::PickVertex(uint32_t eventId, int32_t w, int32_t h, const VkCommandBuffer cmd = m_pDriver->GetNextCmd(); + if(cmd == VK_NULL_HANDLE) + return ~0U; + VkCommandBufferBeginInfo beginInfo = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, NULL, VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT}; @@ -1433,7 +1448,7 @@ uint32_t VulkanReplay::PickVertex(uint32_t eventId, int32_t w, int32_t h, const DoPipelineBarrier(cmd, 1, &bufBarrier); VkResult vkr = vt->EndCommandBuffer(Unwrap(cmd)); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); #if ENABLED(SINGLE_FLUSH_VALIDATE) m_pDriver->SubmitCmds(); @@ -1653,11 +1668,14 @@ void VulkanDebugManager::GetBufferData(ResourceId buff, uint64_t offset, uint64_ VkCommandBuffer cmd = m_pDriver->GetNextCmd(); + if(cmd == VK_NULL_HANDLE) + return; + VkCommandBufferBeginInfo beginInfo = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, NULL, VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT}; VkResult vkr = vt->BeginCommandBuffer(Unwrap(cmd), &beginInfo); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); VkBufferMemoryBarrier bufBarrier = { VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, @@ -1677,7 +1695,7 @@ void VulkanDebugManager::GetBufferData(ResourceId buff, uint64_t offset, uint64_ DoPipelineBarrier(cmd, 1, &bufBarrier); vkr = vt->EndCommandBuffer(Unwrap(cmd)); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); #if ENABLED(SINGLE_FLUSH_VALIDATE) m_pDriver->SubmitCmds(); @@ -1689,8 +1707,11 @@ void VulkanDebugManager::GetBufferData(ResourceId buff, uint64_t offset, uint64_ cmd = m_pDriver->GetNextCmd(); + if(cmd == VK_NULL_HANDLE) + return; + vkr = vt->BeginCommandBuffer(Unwrap(cmd), &beginInfo); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); VkBufferCopy region = {srcoffset, 0, chunkSize}; vt->CmdCopyBuffer(Unwrap(cmd), Unwrap(srcBuf), Unwrap(m_ReadbackWindow.buf), 1, ®ion); @@ -1705,7 +1726,7 @@ void VulkanDebugManager::GetBufferData(ResourceId buff, uint64_t offset, uint64_ DoPipelineBarrier(cmd, 1, &bufBarrier); vkr = vt->EndCommandBuffer(Unwrap(cmd)); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); m_pDriver->SubmitCmds(); m_pDriver->FlushQ(); @@ -1713,14 +1734,16 @@ void VulkanDebugManager::GetBufferData(ResourceId buff, uint64_t offset, uint64_ byte *pData = NULL; vkr = vt->MapMemory(Unwrap(dev), Unwrap(m_ReadbackWindow.mem), 0, VK_WHOLE_SIZE, 0, (void **)&pData); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); + if(vkr != VK_SUCCESS) + return; VkMappedMemoryRange range = { VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE, NULL, Unwrap(m_ReadbackWindow.mem), 0, VK_WHOLE_SIZE, }; vkr = vt->InvalidateMappedMemoryRanges(Unwrap(dev), 1, &range); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); RDCASSERT(pData != NULL); memcpy(&ret[dstoffset], pData, (size_t)chunkSize); @@ -1873,7 +1896,7 @@ void VulkanDebugManager::FillWithDiscardPattern(VkCommandBuffer cmd, DiscardType VkImageView view; VkResult vkr = driver->vkCreateImageView(driver->GetDev(), &viewInfo, NULL, &view); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); imgdata.views.push_back(view); @@ -1892,7 +1915,7 @@ void VulkanDebugManager::FillWithDiscardPattern(VkCommandBuffer cmd, DiscardType VkFramebuffer fb; vkr = driver->vkCreateFramebuffer(driver->GetDev(), &fbinfo, NULL, &fb); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); imgdata.fbs.push_back(fb); } @@ -2047,13 +2070,16 @@ void VulkanDebugManager::FillWithDiscardPattern(VkCommandBuffer cmd, DiscardType }; vkr = m_pDriver->vkCreateBuffer(dev, &bufInfo, NULL, &buf); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); MemoryAllocation alloc = m_pDriver->AllocateMemoryForResource( buf, MemoryScope::ImmutableReplayDebug, MemoryType::GPULocal); + if(alloc.mem == VK_NULL_HANDLE) + return; + vkr = vt->BindBufferMemory(Unwrap(dev), Unwrap(buf), Unwrap(alloc.mem), alloc.offs); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); vt->CmdUpdateBuffer(Unwrap(cmd), Unwrap(buf), 0, pattern.size(), pattern.data()); @@ -2195,7 +2221,7 @@ void VulkanDebugManager::InitReadbackBuffer(VkDeviceSize sz) VkResult vkr = ObjDisp(dev)->MapMemory(Unwrap(dev), Unwrap(m_ReadbackWindow.mem), 0, VK_WHOLE_SIZE, 0, (void **)&m_ReadbackPtr); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); } } @@ -2577,7 +2603,7 @@ void VulkanReplay::PatchReservedDescriptors(const VulkanStatePipeline &pipe, { // create new offseted descriptor layout vkr = m_pDriver->vkCreateDescriptorSetLayout(dev, &descsetLayoutInfo, NULL, &setLayouts[i]); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); } if(hasImmutableSamplers) @@ -2606,7 +2632,7 @@ void VulkanReplay::PatchReservedDescriptors(const VulkanStatePipeline &pipe, // create descriptor pool with enough space for our descriptors vkr = m_pDriver->vkCreateDescriptorPool(dev, &poolCreateInfo, NULL, &descpool); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); // allocate all the descriptors VkDescriptorSetAllocateInfo descSetAllocInfo = { @@ -2912,7 +2938,7 @@ void VulkanReplay::GeneralMisc::Init(WrappedVulkan *driver, VkDescriptorPool des // create descriptor pool vkr = driver->vkCreateDescriptorPool(driver->GetDev(), &descPoolInfo, NULL, &DescriptorPool); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + driver->CheckVkResult(vkr); CREATE_OBJECT(PointSampler, VK_FILTER_NEAREST); } @@ -3071,11 +3097,14 @@ void VulkanReplay::TextureRendering::Init(WrappedVulkan *driver, VkDescriptorPoo { VkCommandBuffer cmd = driver->GetNextCmd(); + if(cmd == VK_NULL_HANDLE) + return; + VkCommandBufferBeginInfo beginInfo = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, NULL, VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT}; vkr = ObjDisp(cmd)->BeginCommandBuffer(Unwrap(cmd), &beginInfo); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + driver->CheckVkResult(vkr); int index = 0; @@ -3140,14 +3169,17 @@ void VulkanReplay::TextureRendering::Init(WrappedVulkan *driver, VkDescriptorPoo } vkr = driver->vkCreateImage(driver->GetDev(), &imInfo, NULL, &DummyImages[fmt][type]); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + driver->CheckVkResult(vkr); MemoryAllocation alloc = driver->AllocateMemoryForResource( DummyImages[fmt][type], MemoryScope::ImmutableReplayDebug, MemoryType::GPULocal); + if(alloc.mem == VK_NULL_HANDLE) + return; + vkr = driver->vkBindImageMemory(driver->GetDev(), DummyImages[fmt][type], alloc.mem, alloc.offs); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + driver->CheckVkResult(vkr); // fill out the descriptor set write to the write binding - set will be filled out // on demand when we're actually using these writes. @@ -3199,13 +3231,16 @@ void VulkanReplay::TextureRendering::Init(WrappedVulkan *driver, VkDescriptorPoo }; vkr = driver->vkCreateBuffer(driver->GetDev(), &bufInfo, NULL, &DummyBuffer); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + driver->CheckVkResult(vkr); MemoryAllocation alloc = driver->AllocateMemoryForResource( DummyBuffer, MemoryScope::ImmutableReplayDebug, MemoryType::GPULocal); + if(alloc.mem == VK_NULL_HANDLE) + return; + vkr = driver->vkBindBufferMemory(driver->GetDev(), DummyBuffer, alloc.mem, alloc.offs); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + driver->CheckVkResult(vkr); } // now that the image memory is bound, we can create the image views and fill the descriptor @@ -3245,7 +3280,7 @@ void VulkanReplay::TextureRendering::Init(WrappedVulkan *driver, VkDescriptorPoo vkr = driver->vkCreateImageView(driver->GetDev(), &viewInfo, NULL, &DummyImageViews[fmt][type]); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + driver->CheckVkResult(vkr); // the cubemap view we don't create an info for it, and the image is already transitioned if(cube) @@ -3291,7 +3326,7 @@ void VulkanReplay::TextureRendering::Init(WrappedVulkan *driver, VkDescriptorPoo }; vkr = driver->vkCreateBufferView(driver->GetDev(), &viewInfo, NULL, &DummyBufferView[i]); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + driver->CheckVkResult(vkr); } } @@ -3659,7 +3694,7 @@ void VulkanReplay::PixelPicking::Init(WrappedVulkan *driver, VkDescriptorPool de }; vkr = driver->vkCreateImage(driver->GetDev(), &imInfo, NULL, &Image); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + driver->CheckVkResult(vkr); VkMemoryRequirements mrq = {0}; driver->vkGetImageMemoryRequirements(driver->GetDev(), Image, &mrq); @@ -3671,10 +3706,10 @@ void VulkanReplay::PixelPicking::Init(WrappedVulkan *driver, VkDescriptorPool de }; vkr = driver->vkAllocateMemory(driver->GetDev(), &allocInfo, NULL, &ImageMem); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + driver->CheckVkResult(vkr); vkr = driver->vkBindImageMemory(driver->GetDev(), Image, ImageMem, 0); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + driver->CheckVkResult(vkr); VkImageViewCreateInfo viewInfo = { VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, @@ -3691,17 +3726,20 @@ void VulkanReplay::PixelPicking::Init(WrappedVulkan *driver, VkDescriptorPool de }; vkr = driver->vkCreateImageView(driver->GetDev(), &viewInfo, NULL, &ImageView); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + driver->CheckVkResult(vkr); // need to update image layout into valid state VkCommandBuffer cmd = driver->GetNextCmd(); + if(cmd == VK_NULL_HANDLE) + return; + VkCommandBufferBeginInfo beginInfo = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, NULL, VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT}; vkr = ObjDisp(cmd)->BeginCommandBuffer(Unwrap(cmd), &beginInfo); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + driver->CheckVkResult(vkr); VkImageMemoryBarrier barrier = { VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, @@ -3728,7 +3766,7 @@ void VulkanReplay::PixelPicking::Init(WrappedVulkan *driver, VkDescriptorPool de }; vkr = driver->vkCreateFramebuffer(driver->GetDev(), &fbinfo, NULL, &FB); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + driver->CheckVkResult(vkr); // since we always sync for readback, doesn't need to be ring'd ReadbackBuffer.Create(driver, driver->GetDev(), sizeof(float) * 4, 1, @@ -3773,7 +3811,7 @@ void VulkanReplay::PixelHistory::Init(WrappedVulkan *driver, VkDescriptorPool de // create descriptor pool vkr = driver->vkCreateDescriptorPool(driver->GetDev(), &descPoolInfo, NULL, &MSCopyDescPool); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + driver->CheckVkResult(vkr); CREATE_OBJECT(MSCopyPipeLayout, MSCopyDescSetLayout, 32); CREATE_OBJECT(MSCopyPipe, MSCopyPipeLayout, @@ -3973,7 +4011,7 @@ void ShaderDebugData::Init(WrappedVulkan *driver, VkDescriptorPool descriptorPoo }; vkr = driver->vkCreateImage(driver->GetDev(), &imInfo, NULL, &Image); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + driver->CheckVkResult(vkr); VkMemoryRequirements mrq = {0}; driver->vkGetImageMemoryRequirements(driver->GetDev(), Image, &mrq); @@ -3985,10 +4023,10 @@ void ShaderDebugData::Init(WrappedVulkan *driver, VkDescriptorPool descriptorPoo }; vkr = driver->vkAllocateMemory(driver->GetDev(), &allocInfo, NULL, &ImageMemory); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + driver->CheckVkResult(vkr); vkr = driver->vkBindImageMemory(driver->GetDev(), Image, ImageMemory, 0); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + driver->CheckVkResult(vkr); VkImageViewCreateInfo viewInfo = { VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, @@ -4005,7 +4043,7 @@ void ShaderDebugData::Init(WrappedVulkan *driver, VkDescriptorPool descriptorPoo }; vkr = driver->vkCreateImageView(driver->GetDev(), &viewInfo, NULL, &ImageView); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + driver->CheckVkResult(vkr); VkAttachmentDescription attDesc = { 0, @@ -4052,7 +4090,7 @@ void ShaderDebugData::Init(WrappedVulkan *driver, VkDescriptorPool descriptorPoo }; vkr = driver->vkCreateFramebuffer(driver->GetDev(), &fbinfo, NULL, &Framebuffer); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + driver->CheckVkResult(vkr); MathResult.Create(driver, driver->GetDev(), sizeof(Vec4f) * 4, 1, GPUBuffer::eGPUBufferGPULocal | GPUBuffer::eGPUBufferSSBO); diff --git a/renderdoc/driver/vulkan/vk_debug.h b/renderdoc/driver/vulkan/vk_debug.h index b2342719a..a535001d3 100644 --- a/renderdoc/driver/vulkan/vk_debug.h +++ b/renderdoc/driver/vulkan/vk_debug.h @@ -114,6 +114,7 @@ public: const WrappedVulkan::DescriptorSetInfo &GetDescSetInfo(ResourceId ds) const; private: + void CheckVkResult(VkResult vkr) { return m_pDriver->CheckVkResult(vkr); } // GetBufferData GPUBuffer m_ReadbackWindow; byte *m_ReadbackPtr = NULL; diff --git a/renderdoc/driver/vulkan/vk_ggp.cpp b/renderdoc/driver/vulkan/vk_ggp.cpp index 24de56e35..551e97f3d 100644 --- a/renderdoc/driver/vulkan/vk_ggp.cpp +++ b/renderdoc/driver/vulkan/vk_ggp.cpp @@ -63,7 +63,7 @@ void VulkanReplay::OutputWindow::CreateSurface(WrappedVulkan *driver, VkInstance VkResult vkr = ObjDisp(inst)->CreateStreamDescriptorSurfaceGGP(Unwrap(inst), &createInfo, NULL, &surface); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + driver->CheckVkResult(vkr); return; } diff --git a/renderdoc/driver/vulkan/vk_initstate.cpp b/renderdoc/driver/vulkan/vk_initstate.cpp index 0ea611943..1fc4603b0 100644 --- a/renderdoc/driver/vulkan/vk_initstate.cpp +++ b/renderdoc/driver/vulkan/vk_initstate.cpp @@ -153,16 +153,19 @@ bool WrappedVulkan::Prepare_InitialState(WrappedVkRes *res) arrayInfo.usage |= VK_IMAGE_USAGE_STORAGE_BIT; vkr = ObjDisp(d)->CreateImage(Unwrap(d), &arrayInfo, NULL, &arrayIm); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); GetResourceManager()->WrapResource(Unwrap(d), arrayIm); MemoryAllocation arrayMem = AllocateMemoryForResource(arrayIm, MemoryScope::InitialContents, MemoryType::GPULocal); + if(arrayMem.mem == VK_NULL_HANDLE) + return false; + vkr = ObjDisp(d)->BindImageMemory(Unwrap(d), Unwrap(arrayIm), Unwrap(arrayMem.mem), arrayMem.offs); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); // we don't use the memory after this, so we don't need to keep a reference. It's needed for // backing the array image only. @@ -244,22 +247,25 @@ bool WrappedVulkan::Prepare_InitialState(WrappedVkRes *res) VkBuffer dstBuf; vkr = ObjDisp(d)->CreateBuffer(Unwrap(d), &bufInfo, NULL, &dstBuf); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); GetResourceManager()->WrapResource(Unwrap(d), dstBuf); MemoryAllocation readbackmem = AllocateMemoryForResource(dstBuf, MemoryScope::InitialContents, MemoryType::Readback); + if(readbackmem.mem == VK_NULL_HANDLE) + return false; + vkr = ObjDisp(d)->BindBufferMemory(Unwrap(d), Unwrap(dstBuf), Unwrap(readbackmem.mem), readbackmem.offs); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); VkCommandBufferBeginInfo beginInfo = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, NULL, VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT}; vkr = ObjDisp(d)->BeginCommandBuffer(Unwrap(cmd), &beginInfo); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); VkImageAspectFlags aspectFlags = FormatImageAspects(imageInfo.format); @@ -292,7 +298,7 @@ bool WrappedVulkan::Prepare_InitialState(WrappedVkRes *res) DoPipelineBarrier(cmd, 1, &arrayimBarrier); vkr = ObjDisp(d)->EndCommandBuffer(Unwrap(cmd)); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); GetDebugManager()->CopyTex2DMSToArray(Unwrap(arrayIm), realim, imageInfo.extent, imageInfo.layerCount, imageInfo.sampleCount, @@ -301,7 +307,7 @@ bool WrappedVulkan::Prepare_InitialState(WrappedVkRes *res) cmd = GetNextCmd(); vkr = ObjDisp(d)->BeginCommandBuffer(Unwrap(cmd), &beginInfo); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); arrayimBarrier.srcAccessMask = VK_ACCESS_SHADER_WRITE_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT; @@ -406,7 +412,7 @@ bool WrappedVulkan::Prepare_InitialState(WrappedVkRes *res) m_cleanupImageBarriers.Merge(cleanupBarriers); vkr = ObjDisp(d)->EndCommandBuffer(Unwrap(cmd)); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); SubmitAndFlushImageStateBarriers(m_setupImageBarriers); SubmitCmds(); @@ -487,13 +493,16 @@ bool WrappedVulkan::Prepare_InitialState(WrappedVkRes *res) bufInfo.size = datasize; vkr = ObjDisp(d)->CreateBuffer(Unwrap(d), &bufInfo, NULL, &dstBuf); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); GetResourceManager()->WrapResource(Unwrap(d), dstBuf); MemoryAllocation readbackmem = AllocateMemoryForResource(dstBuf, MemoryScope::InitialContents, MemoryType::Readback); + if(readbackmem.mem == VK_NULL_HANDLE) + return false; + // dummy request to keep the validation layers happy - the buffers are identical so the // requirements must be identical { @@ -501,16 +510,16 @@ bool WrappedVulkan::Prepare_InitialState(WrappedVkRes *res) ObjDisp(d)->GetBufferMemoryRequirements(Unwrap(d), Unwrap(dstBuf), &mrq); } - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); vkr = ObjDisp(d)->BindBufferMemory(Unwrap(d), Unwrap(dstBuf), Unwrap(readbackmem.mem), readbackmem.offs); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); VkCommandBufferBeginInfo beginInfo = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, NULL, VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT}; vkr = ObjDisp(d)->BeginCommandBuffer(Unwrap(cmd), &beginInfo); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); VkBufferCopy region = {0, 0, datasize}; @@ -518,7 +527,7 @@ bool WrappedVulkan::Prepare_InitialState(WrappedVkRes *res) 1, ®ion); vkr = ObjDisp(d)->EndCommandBuffer(Unwrap(cmd)); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); // INITSTATEBATCH SubmitCmds(); @@ -1456,7 +1465,7 @@ bool WrappedVulkan::Serialise_InitialState(SerialiserType &ser, ResourceId id, V mappedMem = initial->mem; vkr = ObjDisp(d)->MapMemory(Unwrap(d), Unwrap(mappedMem.mem), initial->mem.offs, initial->mem.size, 0, (void **)&Contents); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); // invalidate the cpu cache for this memory range to avoid reading stale data VkMappedMemoryRange range = { @@ -1468,7 +1477,7 @@ bool WrappedVulkan::Serialise_InitialState(SerialiserType &ser, ResourceId id, V }; vkr = ObjDisp(d)->InvalidateMappedMemoryRanges(Unwrap(d), 1, &range); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); } } else if(IsReplayingAndReading() && !ser.IsErrored()) @@ -1483,18 +1492,26 @@ bool WrappedVulkan::Serialise_InitialState(SerialiserType &ser, ResourceId id, V }; vkr = vkCreateBuffer(d, &bufInfo, NULL, &uploadBuf); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); uploadMemory = AllocateMemoryForResource(uploadBuf, MemoryScope::InitialContents, MemoryType::Upload); + if(uploadMemory.mem == VK_NULL_HANDLE) + return false; + vkr = vkBindBufferMemory(d, uploadBuf, uploadMemory.mem, uploadMemory.offs); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); mappedMem = uploadMemory; - ObjDisp(d)->MapMemory(Unwrap(d), Unwrap(mappedMem.mem), mappedMem.offs, - AlignUp(mappedMem.size, nonCoherentAtomSize), 0, (void **)&Contents); + vkr = ObjDisp(d)->MapMemory(Unwrap(d), Unwrap(mappedMem.mem), mappedMem.offs, + AlignUp(mappedMem.size, nonCoherentAtomSize), 0, + (void **)&Contents); + CheckVkResult(vkr); + + if(vkr != VK_SUCCESS) + return false; } // not using SERIALISE_ELEMENT_ARRAY so we can deliberately avoid allocation - we serialise @@ -1516,7 +1533,7 @@ bool WrappedVulkan::Serialise_InitialState(SerialiserType &ser, ResourceId id, V }; vkr = ObjDisp(d)->FlushMappedMemoryRanges(Unwrap(d), 1, &range); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); } ObjDisp(d)->UnmapMemory(Unwrap(d), Unwrap(mappedMem.mem)); @@ -1591,21 +1608,27 @@ bool WrappedVulkan::Serialise_InitialState(SerialiserType &ser, ResourceId id, V VkImage arrayIm; vkr = vkCreateImage(d, &arrayInfo, NULL, &arrayIm); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); MemoryAllocation arrayMem = AllocateMemoryForResource(arrayIm, MemoryScope::InitialContents, MemoryType::GPULocal); + if(arrayMem.mem == VK_NULL_HANDLE) + return false; + vkr = vkBindImageMemory(d, arrayIm, arrayMem.mem, arrayMem.offs); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); VkCommandBuffer cmd = GetNextCmd(); + if(cmd == VK_NULL_HANDLE) + return false; + VkCommandBufferBeginInfo beginInfo = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, NULL, VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT}; vkr = ObjDisp(cmd)->BeginCommandBuffer(Unwrap(cmd), &beginInfo); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); VkExtent3D extent = c.extent; @@ -1708,7 +1731,7 @@ bool WrappedVulkan::Serialise_InitialState(SerialiserType &ser, ResourceId id, V DoPipelineBarrier(cmd, 1, &dstimBarrier); vkr = ObjDisp(cmd)->EndCommandBuffer(Unwrap(cmd)); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); // INITSTATEBATCH SubmitCmds(); @@ -1796,6 +1819,9 @@ void WrappedVulkan::Create_InitialState(ResourceId id, WrappedVkRes *live, bool) void WrappedVulkan::Apply_InitialState(WrappedVkRes *live, const VkInitialContents &initial) { + if(HasFatalError()) + return; + VkResourceType type = initial.type; ResourceId id = GetResourceManager()->GetID(live); @@ -2030,8 +2056,11 @@ void WrappedVulkan::Apply_InitialState(WrappedVkRes *live, const VkInitialConten VkCommandBuffer cmd = GetNextCmd(); + if(cmd == VK_NULL_HANDLE) + return; + vkr = ObjDisp(cmd)->BeginCommandBuffer(Unwrap(cmd), &beginInfo); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); VulkanCreationInfo::Image &c = m_CreationInfo.m_Image[id]; @@ -2048,7 +2077,7 @@ void WrappedVulkan::Apply_InitialState(WrappedVkRes *live, const VkInitialConten VkImage arrayIm = initial.img; vkr = ObjDisp(cmd)->EndCommandBuffer(Unwrap(cmd)); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); GetDebugManager()->CopyArrayToTex2DMS(ToUnwrappedHandle(live), Unwrap(arrayIm), c.extent, c.arrayLayers, (uint32_t)c.samples, fmt); @@ -2345,8 +2374,11 @@ void WrappedVulkan::Apply_InitialState(WrappedVkRes *live, const VkInitialConten VkCommandBuffer cmd = GetNextCmd(); + if(cmd == VK_NULL_HANDLE) + return; + vkr = ObjDisp(cmd)->BeginCommandBuffer(Unwrap(cmd), &beginInfo); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); VkMarkerRegion::Begin(StringFormat::Fmt("Initial state for %s", ToStr(orig).c_str()), cmd); @@ -2380,7 +2412,7 @@ void WrappedVulkan::Apply_InitialState(WrappedVkRes *live, const VkInitialConten VkMarkerRegion::End(cmd); vkr = ObjDisp(cmd)->EndCommandBuffer(Unwrap(cmd)); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); #if ENABLED(SINGLE_FLUSH_VALIDATE) SubmitCmds(); diff --git a/renderdoc/driver/vulkan/vk_linux.cpp b/renderdoc/driver/vulkan/vk_linux.cpp index 103ef82ca..f9a3ca374 100644 --- a/renderdoc/driver/vulkan/vk_linux.cpp +++ b/renderdoc/driver/vulkan/vk_linux.cpp @@ -215,7 +215,7 @@ void VulkanReplay::OutputWindow::CreateSurface(WrappedVulkan *driver, VkInstance createInfo.window = xlib.window; VkResult vkr = ObjDisp(inst)->CreateXlibSurfaceKHR(Unwrap(inst), &createInfo, NULL, &surface); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + driver->CheckVkResult(vkr); return; } @@ -233,7 +233,7 @@ void VulkanReplay::OutputWindow::CreateSurface(WrappedVulkan *driver, VkInstance createInfo.window = xcb.window; VkResult vkr = ObjDisp(inst)->CreateXcbSurfaceKHR(Unwrap(inst), &createInfo, NULL, &surface); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + driver->CheckVkResult(vkr); return; } @@ -251,7 +251,7 @@ void VulkanReplay::OutputWindow::CreateSurface(WrappedVulkan *driver, VkInstance createInfo.surface = wayland.window; VkResult vkr = ObjDisp(inst)->CreateWaylandSurfaceKHR(Unwrap(inst), &createInfo, NULL, &surface); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + driver->CheckVkResult(vkr); return; } diff --git a/renderdoc/driver/vulkan/vk_memory.cpp b/renderdoc/driver/vulkan/vk_memory.cpp index ce2743a42..12690f205 100644 --- a/renderdoc/driver/vulkan/vk_memory.cpp +++ b/renderdoc/driver/vulkan/vk_memory.cpp @@ -352,7 +352,13 @@ MemoryAllocation WrappedVulkan::AllocateMemoryForResource(bool buffer, VkMemoryR // do the actual allocation VkResult vkr = ObjDisp(d)->AllocateMemory(Unwrap(d), &info, NULL, &chunk.mem); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); + + ret.offs = 0; + ret.mem = VK_NULL_HANDLE; + + if(vkr != VK_SUCCESS) + return ret; GetResourceManager()->WrapResource(Unwrap(d), chunk.mem); @@ -360,7 +366,6 @@ MemoryAllocation WrappedVulkan::AllocateMemoryForResource(bool buffer, VkMemoryR blockList.push_back(chunk); // return the first bytes in the new chunk - ret.offs = 0; ret.mem = chunk.mem; } diff --git a/renderdoc/driver/vulkan/vk_msaa_array_conv.cpp b/renderdoc/driver/vulkan/vk_msaa_array_conv.cpp index 763949dce..759bec8bd 100644 --- a/renderdoc/driver/vulkan/vk_msaa_array_conv.cpp +++ b/renderdoc/driver/vulkan/vk_msaa_array_conv.cpp @@ -91,7 +91,7 @@ void VulkanDebugManager::CopyTex2DMSToArray(VkImage destArray, VkImage srcMS, Vk viewInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT; vkr = ObjDisp(dev)->CreateImageView(Unwrap(dev), &viewInfo, NULL, &srcView); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); viewInfo.image = destArray; viewInfo.viewType = VK_IMAGE_VIEW_TYPE_2D_ARRAY; @@ -112,6 +112,9 @@ void VulkanDebugManager::CopyTex2DMSToArray(VkImage destArray, VkImage srcMS, Vk { cmd = m_pDriver->GetNextCmd(); + if(cmd == VK_NULL_HANDLE) + return; + ObjDisp(cmd)->BeginCommandBuffer(Unwrap(cmd), &beginInfo); ObjDisp(cmd)->CmdBindPipeline(Unwrap(cmd), VK_PIPELINE_BIND_POINT_COMPUTE, @@ -124,7 +127,7 @@ void VulkanDebugManager::CopyTex2DMSToArray(VkImage destArray, VkImage srcMS, Vk viewInfo.subresourceRange.layerCount = 1; vkr = ObjDisp(dev)->CreateImageView(Unwrap(dev), &viewInfo, NULL, &destView); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); views.push_back(destView); @@ -233,13 +236,13 @@ void VulkanDebugManager::CopyDepthTex2DMSToArray(VkImage destArray, VkImage srcM }; vkr = ObjDisp(dev)->CreateImageView(Unwrap(dev), &viewInfo, NULL, &srcDepthView); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); if(aspectFlags & VK_IMAGE_ASPECT_STENCIL_BIT) { viewInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_STENCIL_BIT; vkr = ObjDisp(dev)->CreateImageView(Unwrap(dev), &viewInfo, NULL, &srcStencilView); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); } viewInfo.subresourceRange.aspectMask = aspectFlags; @@ -256,7 +259,7 @@ void VulkanDebugManager::CopyDepthTex2DMSToArray(VkImage destArray, VkImage srcM viewInfo.subresourceRange.layerCount = 1; vkr = ObjDisp(dev)->CreateImageView(Unwrap(dev), &viewInfo, NULL, &destView[i]); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); } VkDescriptorImageInfo srcdesc[2]; @@ -343,11 +346,14 @@ void VulkanDebugManager::CopyDepthTex2DMSToArray(VkImage destArray, VkImage srcM fbinfo.pAttachments = destView + i; vkr = ObjDisp(dev)->CreateFramebuffer(Unwrap(dev), &fbinfo, NULL, &fb[i]); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); } VkCommandBuffer cmd = m_pDriver->GetNextCmd(); + if(cmd == VK_NULL_HANDLE) + return; + VkCommandBufferBeginInfo beginInfo = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, NULL, VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT}; @@ -481,13 +487,13 @@ void VulkanDebugManager::CopyArrayToTex2DMS(VkImage destMS, VkImage srcArray, Vk viewInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT; vkr = ObjDisp(dev)->CreateImageView(Unwrap(dev), &viewInfo, NULL, &srcView); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); viewInfo.image = destMS; viewInfo.viewType = VK_IMAGE_VIEW_TYPE_2D_ARRAY; vkr = ObjDisp(dev)->CreateImageView(Unwrap(dev), &viewInfo, NULL, &destView); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); VkDescriptorImageInfo srcdesc = {0}; srcdesc.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; @@ -509,6 +515,9 @@ void VulkanDebugManager::CopyArrayToTex2DMS(VkImage destMS, VkImage srcArray, Vk VkCommandBuffer cmd = m_pDriver->GetNextCmd(); + if(cmd == VK_NULL_HANDLE) + return; + VkCommandBufferBeginInfo beginInfo = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, NULL, VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT}; @@ -600,13 +609,13 @@ void VulkanDebugManager::CopyDepthArrayToTex2DMS(VkImage destMS, VkImage srcArra }; vkr = ObjDisp(dev)->CreateImageView(Unwrap(dev), &viewInfo, NULL, &srcDepthView); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); if(aspectFlags & VK_IMAGE_ASPECT_STENCIL_BIT) { viewInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_STENCIL_BIT; vkr = ObjDisp(dev)->CreateImageView(Unwrap(dev), &viewInfo, NULL, &srcStencilView); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); } viewInfo.subresourceRange.aspectMask = aspectFlags; @@ -623,7 +632,7 @@ void VulkanDebugManager::CopyDepthArrayToTex2DMS(VkImage destMS, VkImage srcArra viewInfo.subresourceRange.layerCount = 1; vkr = ObjDisp(dev)->CreateImageView(Unwrap(dev), &viewInfo, NULL, &destView[i]); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); } VkDescriptorImageInfo srcdesc[2]; @@ -710,11 +719,14 @@ void VulkanDebugManager::CopyDepthArrayToTex2DMS(VkImage destMS, VkImage srcArra fbinfo.pAttachments = destView + i; vkr = ObjDisp(dev)->CreateFramebuffer(Unwrap(dev), &fbinfo, NULL, &fb[i]); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); } VkCommandBuffer cmd = m_pDriver->GetNextCmd(); + if(cmd == VK_NULL_HANDLE) + return; + VkCommandBufferBeginInfo beginInfo = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, NULL, VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT}; diff --git a/renderdoc/driver/vulkan/vk_outputwindow.cpp b/renderdoc/driver/vulkan/vk_outputwindow.cpp index 41851e52a..950383f9b 100644 --- a/renderdoc/driver/vulkan/vk_outputwindow.cpp +++ b/renderdoc/driver/vulkan/vk_outputwindow.cpp @@ -224,7 +224,7 @@ void VulkanReplay::OutputWindow::Create(WrappedVulkan *driver, VkDevice device, vkr = ObjDisp(inst)->GetPhysicalDeviceSurfaceFormatsKHR(Unwrap(phys), Unwrap(surface), &numFormats, NULL); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + driver->CheckVkResult(vkr); if(numFormats > 0) { @@ -232,7 +232,7 @@ void VulkanReplay::OutputWindow::Create(WrappedVulkan *driver, VkDevice device, vkr = ObjDisp(inst)->GetPhysicalDeviceSurfaceFormatsKHR(Unwrap(phys), Unwrap(surface), &numFormats, formats); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + driver->CheckVkResult(vkr); if(numFormats == 1 && formats[0].format == VK_FORMAT_UNDEFINED) { @@ -271,7 +271,7 @@ void VulkanReplay::OutputWindow::Create(WrappedVulkan *driver, VkDevice device, vkr = ObjDisp(inst)->GetPhysicalDeviceSurfacePresentModesKHR(Unwrap(phys), Unwrap(surface), &numModes, NULL); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + driver->CheckVkResult(vkr); if(numModes > 0) { @@ -279,7 +279,7 @@ void VulkanReplay::OutputWindow::Create(WrappedVulkan *driver, VkDevice device, vkr = ObjDisp(inst)->GetPhysicalDeviceSurfacePresentModesKHR(Unwrap(phys), Unwrap(surface), &numModes, modes); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + driver->CheckVkResult(vkr); // If mailbox mode is available, use it, as is the lowest-latency non- // tearing mode. If not, try IMMEDIATE which will usually be available, @@ -330,7 +330,7 @@ void VulkanReplay::OutputWindow::Create(WrappedVulkan *driver, VkDevice device, }; vkr = vt->CreateSwapchainKHR(Unwrap(device), &swapInfo, NULL, &swap); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + driver->CheckVkResult(vkr); if(old != VK_NULL_HANDLE) { @@ -365,13 +365,13 @@ void VulkanReplay::OutputWindow::Create(WrappedVulkan *driver, VkDevice device, GetResourceManager()->WrapResource(Unwrap(device), swap); vkr = vt->GetSwapchainImagesKHR(Unwrap(device), Unwrap(swap), &numImgs, NULL); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + driver->CheckVkResult(vkr); RDCASSERT(numImgs <= 8, numImgs); VkImage *imgs = new VkImage[numImgs]; vkr = vt->GetSwapchainImagesKHR(Unwrap(device), Unwrap(swap), &numImgs, imgs); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + driver->CheckVkResult(vkr); for(size_t i = 0; i < numImgs; i++) { @@ -410,7 +410,7 @@ void VulkanReplay::OutputWindow::Create(WrappedVulkan *driver, VkDevice device, }; vkr = vt->CreateImage(Unwrap(device), &imInfo, NULL, &dsimg); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + driver->CheckVkResult(vkr); GetResourceManager()->WrapResource(Unwrap(device), dsimg); @@ -424,12 +424,15 @@ void VulkanReplay::OutputWindow::Create(WrappedVulkan *driver, VkDevice device, }; vkr = vt->AllocateMemory(Unwrap(device), &allocInfo, NULL, &dsmem); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + driver->CheckVkResult(vkr); + + if(vkr != VK_SUCCESS) + return; GetResourceManager()->WrapResource(Unwrap(device), dsmem); vkr = vt->BindImageMemory(Unwrap(device), Unwrap(dsimg), Unwrap(dsmem), 0); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + driver->CheckVkResult(vkr); depthBarrier.image = Unwrap(dsimg); depthBarrier.oldLayout = depthBarrier.newLayout = VK_IMAGE_LAYOUT_UNDEFINED; @@ -447,7 +450,7 @@ void VulkanReplay::OutputWindow::Create(WrappedVulkan *driver, VkDevice device, }; vkr = vt->CreateImageView(Unwrap(device), &info, NULL, &dsview); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + driver->CheckVkResult(vkr); GetResourceManager()->WrapResource(Unwrap(device), dsview); @@ -458,7 +461,7 @@ void VulkanReplay::OutputWindow::Create(WrappedVulkan *driver, VkDevice device, imInfo.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT; vkr = vt->CreateImage(Unwrap(device), &imInfo, NULL, &resolveimg); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + driver->CheckVkResult(vkr); GetResourceManager()->WrapResource(Unwrap(device), resolveimg); @@ -468,12 +471,15 @@ void VulkanReplay::OutputWindow::Create(WrappedVulkan *driver, VkDevice device, allocInfo.memoryTypeIndex = driver->GetGPULocalMemoryIndex(mrq.memoryTypeBits); vkr = vt->AllocateMemory(Unwrap(device), &allocInfo, NULL, &resolvemem); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + driver->CheckVkResult(vkr); + + if(vkr != VK_SUCCESS) + return; GetResourceManager()->WrapResource(Unwrap(device), resolvemem); vkr = vt->BindImageMemory(Unwrap(device), Unwrap(resolveimg), Unwrap(resolvemem), 0); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + driver->CheckVkResult(vkr); } { @@ -513,7 +519,7 @@ void VulkanReplay::OutputWindow::Create(WrappedVulkan *driver, VkDevice device, }; vkr = vt->CreateRenderPass(Unwrap(device), &rpinfo, NULL, &rp); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + driver->CheckVkResult(vkr); GetResourceManager()->WrapResource(Unwrap(device), rp); @@ -524,7 +530,7 @@ void VulkanReplay::OutputWindow::Create(WrappedVulkan *driver, VkDevice device, rpinfo.attachmentCount = 2; vkr = vt->CreateRenderPass(Unwrap(device), &rpinfo, NULL, &rpdepth); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + driver->CheckVkResult(vkr); GetResourceManager()->WrapResource(Unwrap(device), rpdepth); } @@ -551,7 +557,7 @@ void VulkanReplay::OutputWindow::Create(WrappedVulkan *driver, VkDevice device, }; vkr = vt->CreateImage(Unwrap(device), &imInfo, NULL, &bb); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + driver->CheckVkResult(vkr); GetResourceManager()->WrapResource(Unwrap(device), bb); @@ -565,12 +571,15 @@ void VulkanReplay::OutputWindow::Create(WrappedVulkan *driver, VkDevice device, }; vkr = vt->AllocateMemory(Unwrap(device), &allocInfo, NULL, &bbmem); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + driver->CheckVkResult(vkr); + + if(vkr != VK_SUCCESS) + return; GetResourceManager()->WrapResource(Unwrap(device), bbmem); vkr = vt->BindImageMemory(Unwrap(device), Unwrap(bb), Unwrap(bbmem), 0); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + driver->CheckVkResult(vkr); bbBarrier.image = Unwrap(bb); bbBarrier.oldLayout = bbBarrier.newLayout = VK_IMAGE_LAYOUT_UNDEFINED; @@ -590,7 +599,7 @@ void VulkanReplay::OutputWindow::Create(WrappedVulkan *driver, VkDevice device, }; vkr = vt->CreateImageView(Unwrap(device), &info, NULL, &bbview); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + driver->CheckVkResult(vkr); GetResourceManager()->WrapResource(Unwrap(device), bbview); @@ -608,7 +617,7 @@ void VulkanReplay::OutputWindow::Create(WrappedVulkan *driver, VkDevice device, }; vkr = vt->CreateFramebuffer(Unwrap(device), &fbinfo, NULL, &fb); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + driver->CheckVkResult(vkr); GetResourceManager()->WrapResource(Unwrap(device), fb); } @@ -629,7 +638,7 @@ void VulkanReplay::OutputWindow::Create(WrappedVulkan *driver, VkDevice device, }; vkr = vt->CreateFramebuffer(Unwrap(device), &fbinfo, NULL, &fbdepth); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + driver->CheckVkResult(vkr); GetResourceManager()->WrapResource(Unwrap(device), fbdepth); } @@ -646,6 +655,9 @@ void VulkanReplay::GetOutputWindowData(uint64_t id, bytebuf &retData) VkDevice device = m_pDriver->GetDev(); VkCommandBuffer cmd = m_pDriver->GetNextCmd(); + if(cmd == VK_NULL_HANDLE) + return; + const VkDevDispatchTable *vt = ObjDisp(device); vt->DeviceWaitIdle(Unwrap(device)); @@ -663,7 +675,7 @@ void VulkanReplay::GetOutputWindowData(uint64_t id, bytebuf &retData) VK_BUFFER_USAGE_TRANSFER_DST_BIT, }; vt->CreateBuffer(Unwrap(device), &bufInfo, NULL, &readbackBuf); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + m_pDriver->CheckVkResult(vkr); VkMemoryRequirements mrq = {0}; @@ -676,17 +688,20 @@ void VulkanReplay::GetOutputWindowData(uint64_t id, bytebuf &retData) VkDeviceMemory readbackMem = VK_NULL_HANDLE; vkr = vt->AllocateMemory(Unwrap(device), &allocInfo, NULL, &readbackMem); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + m_pDriver->CheckVkResult(vkr); + + if(vkr != VK_SUCCESS) + return; vkr = vt->BindBufferMemory(Unwrap(device), readbackBuf, readbackMem, 0); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + m_pDriver->CheckVkResult(vkr); VkCommandBufferBeginInfo beginInfo = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, NULL, VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT}; // do image copy vkr = vt->BeginCommandBuffer(Unwrap(cmd), &beginInfo); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + m_pDriver->CheckVkResult(vkr); VkBufferImageCopy cpy = { 0, @@ -749,7 +764,7 @@ void VulkanReplay::GetOutputWindowData(uint64_t id, bytebuf &retData) outw.bbBarrier.srcAccessMask = outw.bbBarrier.dstAccessMask; vkr = vt->EndCommandBuffer(Unwrap(cmd)); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + m_pDriver->CheckVkResult(vkr); m_pDriver->SubmitCmds(); m_pDriver->FlushQ(); // need to wait so we can readback @@ -757,15 +772,16 @@ void VulkanReplay::GetOutputWindowData(uint64_t id, bytebuf &retData) // map memory and readback byte *pData = NULL; vkr = vt->MapMemory(Unwrap(device), readbackMem, 0, bufInfo.size, 0, (void **)&pData); - RDCASSERTEQUAL(vkr, VK_SUCCESS); - RDCASSERT(pData != NULL); + m_pDriver->CheckVkResult(vkr); + if(vkr != VK_SUCCESS) + return; VkMappedMemoryRange range = { VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE, NULL, readbackMem, 0, VK_WHOLE_SIZE, }; vkr = vt->InvalidateMappedMemoryRanges(Unwrap(device), 1, &range); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + m_pDriver->CheckVkResult(vkr); { retData.resize(outw.width * outw.height * 3); @@ -879,6 +895,9 @@ void VulkanReplay::BindOutputWindow(uint64_t id, bool depth) const VkDevDispatchTable *vt = ObjDisp(dev); VkResult vkr = VK_SUCCESS; + if(cmd == VK_NULL_HANDLE) + return; + // if we have a swapchain, acquire the next image. if(outw.swap != VK_NULL_HANDLE) { @@ -889,7 +908,7 @@ void VulkanReplay::BindOutputWindow(uint64_t id, bool depth) VkSemaphoreCreateInfo semInfo = {VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO, NULL, 0}; vkr = vt->CreateSemaphore(Unwrap(dev), &semInfo, NULL, &sem); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + m_pDriver->CheckVkResult(vkr); vkr = vt->AcquireNextImageKHR(Unwrap(dev), Unwrap(outw.swap), UINT64_MAX, sem, VK_NULL_HANDLE, &outw.curidx); @@ -910,7 +929,7 @@ void VulkanReplay::BindOutputWindow(uint64_t id, bool depth) if(vkr == VK_SUBOPTIMAL_KHR) vkr = VK_SUCCESS; - RDCASSERTEQUAL(vkr, VK_SUCCESS); + m_pDriver->CheckVkResult(vkr); VkSubmitInfo submitInfo = { VK_STRUCTURE_TYPE_SUBMIT_INFO, @@ -925,7 +944,7 @@ void VulkanReplay::BindOutputWindow(uint64_t id, bool depth) }; vkr = vt->QueueSubmit(Unwrap(m_pDriver->GetQ()), 1, &submitInfo, VK_NULL_HANDLE); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + m_pDriver->CheckVkResult(vkr); vt->QueueWaitIdle(Unwrap(m_pDriver->GetQ())); @@ -936,7 +955,7 @@ void VulkanReplay::BindOutputWindow(uint64_t id, bool depth) VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT}; vkr = vt->BeginCommandBuffer(Unwrap(cmd), &beginInfo); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + m_pDriver->CheckVkResult(vkr); outw.depthBarrier.newLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL; @@ -999,11 +1018,14 @@ void VulkanReplay::ClearOutputWindowColor(uint64_t id, FloatVector col) VkCommandBuffer cmd = m_pDriver->GetNextCmd(); const VkDevDispatchTable *vt = ObjDisp(dev); + if(cmd == VK_NULL_HANDLE) + return; + VkCommandBufferBeginInfo beginInfo = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, NULL, VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT}; VkResult vkr = vt->BeginCommandBuffer(Unwrap(cmd), &beginInfo); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + m_pDriver->CheckVkResult(vkr); VkMarkerRegion::Begin("ClearOutputWindowColor", cmd); @@ -1053,11 +1075,14 @@ void VulkanReplay::ClearOutputWindowDepth(uint64_t id, float depth, uint8_t sten VkCommandBuffer cmd = m_pDriver->GetNextCmd(); const VkDevDispatchTable *vt = ObjDisp(dev); + if(cmd == VK_NULL_HANDLE) + return; + VkCommandBufferBeginInfo beginInfo = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, NULL, VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT}; VkResult vkr = vt->BeginCommandBuffer(Unwrap(cmd), &beginInfo); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + m_pDriver->CheckVkResult(vkr); VkClearDepthStencilValue ds = {depth, stencil}; @@ -1106,11 +1131,14 @@ void VulkanReplay::FlipOutputWindow(uint64_t id) VkCommandBuffer cmd = m_pDriver->GetNextCmd(); const VkDevDispatchTable *vt = ObjDisp(dev); + if(cmd == VK_NULL_HANDLE) + return; + VkCommandBufferBeginInfo beginInfo = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, NULL, VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT}; VkResult vkr = vt->BeginCommandBuffer(Unwrap(cmd), &beginInfo); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + m_pDriver->CheckVkResult(vkr); VkMarkerRegion::Begin("FlipOutputWindow", cmd); @@ -1213,6 +1241,10 @@ void VulkanReplay::FlipOutputWindow(uint64_t id) VkResult retvkr = vt->QueuePresentKHR(Unwrap(m_pDriver->GetQ()), &presentInfo); + if(retvkr != VK_ERROR_OUT_OF_DATE_KHR && retvkr != VK_SUBOPTIMAL_KHR && + retvkr != VK_ERROR_SURFACE_LOST_KHR) + m_pDriver->CheckVkResult(retvkr); + m_pDriver->FlushQ(); if(retvkr == VK_ERROR_OUT_OF_DATE_KHR) diff --git a/renderdoc/driver/vulkan/vk_overlay.cpp b/renderdoc/driver/vulkan/vk_overlay.cpp index 633d635d6..b7bd3713a 100644 --- a/renderdoc/driver/vulkan/vk_overlay.cpp +++ b/renderdoc/driver/vulkan/vk_overlay.cpp @@ -113,7 +113,7 @@ struct VulkanQuadOverdrawCallback : public VulkanActionCallback // create pipeline layout with same descriptor set layouts, plus our mesh output set vkr = m_pDriver->vkCreatePipelineLayout(m_pDriver->GetDev(), &pipeLayoutInfo, NULL, &pipe.pipeLayout); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + m_pDriver->CheckVkResult(vkr); SAFE_DELETE_ARRAY(descSetLayouts); @@ -180,7 +180,7 @@ struct VulkanQuadOverdrawCallback : public VulkanActionCallback VkDevice dev = m_pDriver->GetDev(); vkr = m_pDriver->vkCreateShaderModule(dev, &modinfo, NULL, &module); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + m_pDriver->CheckVkResult(vkr); bool found = false; for(uint32_t i = 0; i < pipeCreateInfo.stageCount; i++) @@ -213,7 +213,7 @@ struct VulkanQuadOverdrawCallback : public VulkanActionCallback vkr = m_pDriver->vkCreateGraphicsPipelines(dev, VK_NULL_HANDLE, 1, &pipeCreateInfo, NULL, &pipe.pipe); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + m_pDriver->CheckVkResult(vkr); m_pDriver->vkDestroyShaderModule(dev, module, NULL); @@ -338,7 +338,7 @@ void VulkanDebugManager::PatchOutputLocation(VkShaderModule &mod, BuiltinShader }; VkResult vkr = m_pDriver->vkCreateShaderModule(m_Device, &modinfo, NULL, &mod); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); } void VulkanDebugManager::PatchFixedColShader(VkShaderModule &mod, float col[4]) @@ -393,7 +393,7 @@ void VulkanDebugManager::PatchFixedColShader(VkShaderModule &mod, float col[4]) }; VkResult vkr = m_pDriver->vkCreateShaderModule(m_Device, &modinfo, NULL, &mod); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); } void VulkanDebugManager::PatchLineStripIndexBuffer(const ActionDescription *action, @@ -452,11 +452,14 @@ void VulkanDebugManager::PatchLineStripIndexBuffer(const ActionDescription *acti VkCommandBuffer cmd = m_pDriver->GetNextCmd(); + if(cmd == VK_NULL_HANDLE) + return; + VkCommandBufferBeginInfo beginInfo = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, NULL, VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT}; VkResult vkr = ObjDisp(m_Device)->BeginCommandBuffer(Unwrap(cmd), &beginInfo); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); // ensure host writes finish before using as index buffer DoPipelineBarrier(cmd, 1, &uploadbarrier); @@ -505,11 +508,14 @@ ResourceId VulkanReplay::RenderOverlay(ResourceId texid, FloatVector clearCol, D VkCommandBuffer cmd = m_pDriver->GetNextCmd(); + if(cmd == VK_NULL_HANDLE) + return ResourceId(); + VkCommandBufferBeginInfo beginInfo = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, NULL, VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT}; VkResult vkr = vt->BeginCommandBuffer(Unwrap(cmd), &beginInfo); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); VkMarkerRegion::Begin(StringFormat::Fmt("RenderOverlay %d", overlay), cmd); @@ -587,7 +593,7 @@ ResourceId VulkanReplay::RenderOverlay(ResourceId texid, FloatVector clearCol, D }; vkr = m_pDriver->vkCreateImage(m_Device, &imInfo, NULL, &m_Overlay.Image); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); VkMemoryRequirements mrq = {0}; m_pDriver->vkGetImageMemoryRequirements(m_Device, m_Overlay.Image, &mrq); @@ -607,13 +613,16 @@ ResourceId VulkanReplay::RenderOverlay(ResourceId texid, FloatVector clearCol, D }; vkr = m_pDriver->vkAllocateMemory(m_Device, &allocInfo, NULL, &m_Overlay.ImageMem); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); + + if(vkr != VK_SUCCESS) + return ResourceId(); m_Overlay.ImageMemSize = mrq.size; } vkr = m_pDriver->vkBindImageMemory(m_Device, m_Overlay.Image, m_Overlay.ImageMem, 0); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); // need to update image layout into valid state @@ -661,7 +670,7 @@ ResourceId VulkanReplay::RenderOverlay(ResourceId texid, FloatVector clearCol, D rpinfo.pNext = &multiviewRP; vkr = m_pDriver->vkCreateRenderPass(m_Device, &rpinfo, NULL, &m_Overlay.NoDepthRP); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); } if(m_Overlay.ViewMip != sub.mip || m_Overlay.ViewSlice != sub.slice || @@ -687,7 +696,7 @@ ResourceId VulkanReplay::RenderOverlay(ResourceId texid, FloatVector clearCol, D }; vkr = m_pDriver->vkCreateImageView(m_Device, &viewInfo, NULL, &m_Overlay.ImageView); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); // Create framebuffer rendering just to overlay image, no depth VkFramebufferCreateInfo fbinfo = { @@ -703,7 +712,7 @@ ResourceId VulkanReplay::RenderOverlay(ResourceId texid, FloatVector clearCol, D }; vkr = m_pDriver->vkCreateFramebuffer(m_Device, &fbinfo, NULL, &m_Overlay.NoDepthFB); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); // can't create a framebuffer or renderpass for overlay image + depth as that // needs to match the depth texture type wherever our draw is. @@ -853,7 +862,7 @@ ResourceId VulkanReplay::RenderOverlay(ResourceId texid, FloatVector clearCol, D if(!pipeInfo.rasterizerDiscardEnable) { vkr = vt->EndCommandBuffer(Unwrap(cmd)); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); // backup state VulkanRenderState prevstate = m_pDriver->m_RenderState; @@ -1019,7 +1028,7 @@ ResourceId VulkanReplay::RenderOverlay(ResourceId texid, FloatVector clearCol, D vkr = m_pDriver->vkCreateGraphicsPipelines(m_Device, VK_NULL_HANDLE, 1, &pipeCreateInfo, NULL, &pipe); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); // modify state m_pDriver->m_RenderState.renderPass = GetResID(m_Overlay.NoDepthRP); @@ -1057,8 +1066,11 @@ ResourceId VulkanReplay::RenderOverlay(ResourceId texid, FloatVector clearCol, D // and no index offset. cmd = m_pDriver->GetNextCmd(); + if(cmd == VK_NULL_HANDLE) + return ResourceId(); + vkr = ObjDisp(cmd)->BeginCommandBuffer(Unwrap(cmd), &beginInfo); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); // do single draw m_pDriver->m_RenderState.BeginRenderPassAndApplyState(m_pDriver, cmd, @@ -1071,7 +1083,7 @@ ResourceId VulkanReplay::RenderOverlay(ResourceId texid, FloatVector clearCol, D m_pDriver->m_RenderState.EndRenderPass(cmd); vkr = ObjDisp(cmd)->EndCommandBuffer(Unwrap(cmd)); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); } // submit & flush so that we don't have to keep pipeline around for a while @@ -1080,8 +1092,11 @@ ResourceId VulkanReplay::RenderOverlay(ResourceId texid, FloatVector clearCol, D cmd = m_pDriver->GetNextCmd(); + if(cmd == VK_NULL_HANDLE) + return ResourceId(); + vkr = vt->BeginCommandBuffer(Unwrap(cmd), &beginInfo); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); // restore state m_pDriver->m_RenderState = prevstate; @@ -1125,7 +1140,7 @@ ResourceId VulkanReplay::RenderOverlay(ResourceId texid, FloatVector clearCol, D if(!pipeInfo.rasterizerDiscardEnable) { vkr = vt->EndCommandBuffer(Unwrap(cmd)); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); float highlightCol[] = {1.0f, 0.0f, 0.0f, 1.0f}; @@ -1225,13 +1240,13 @@ ResourceId VulkanReplay::RenderOverlay(ResourceId texid, FloatVector clearCol, D vkr = m_pDriver->vkCreateGraphicsPipelines(m_Device, VK_NULL_HANDLE, 1, &pipeCreateInfo, NULL, &pipe[0]); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); fragShader->module = mod[1]; vkr = m_pDriver->vkCreateGraphicsPipelines(m_Device, VK_NULL_HANDLE, 1, &pipeCreateInfo, NULL, &pipe[1]); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); // modify state m_pDriver->m_RenderState.renderPass = GetResID(m_Overlay.NoDepthRP); @@ -1261,8 +1276,11 @@ ResourceId VulkanReplay::RenderOverlay(ResourceId texid, FloatVector clearCol, D cmd = m_pDriver->GetNextCmd(); + if(cmd == VK_NULL_HANDLE) + return ResourceId(); + vkr = vt->BeginCommandBuffer(Unwrap(cmd), &beginInfo); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); { VkClearValue clearval = {}; @@ -1357,7 +1375,7 @@ ResourceId VulkanReplay::RenderOverlay(ResourceId texid, FloatVector clearCol, D } vkr = vt->EndCommandBuffer(Unwrap(cmd)); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); // submit & flush so that we don't have to keep pipeline around for a while m_pDriver->SubmitCmds(); @@ -1365,8 +1383,11 @@ ResourceId VulkanReplay::RenderOverlay(ResourceId texid, FloatVector clearCol, D cmd = m_pDriver->GetNextCmd(); + if(cmd == VK_NULL_HANDLE) + return ResourceId(); + vkr = vt->BeginCommandBuffer(Unwrap(cmd), &beginInfo); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); for(int i = 0; i < 2; i++) { @@ -1408,7 +1429,7 @@ ResourceId VulkanReplay::RenderOverlay(ResourceId texid, FloatVector clearCol, D if(!pipeInfo.rasterizerDiscardEnable) { vkr = vt->EndCommandBuffer(Unwrap(cmd)); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); // backup state VulkanRenderState prevstate = m_pDriver->m_RenderState; @@ -1507,14 +1528,14 @@ ResourceId VulkanReplay::RenderOverlay(ResourceId texid, FloatVector clearCol, D vkr = m_pDriver->vkCreateGraphicsPipelines(m_Device, VK_NULL_HANDLE, 1, &pipeCreateInfo, NULL, &pipe[0]); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); fragShader->module = mod[1]; rs->cullMode = origCullMode; vkr = m_pDriver->vkCreateGraphicsPipelines(m_Device, VK_NULL_HANDLE, 1, &pipeCreateInfo, NULL, &pipe[1]); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); // modify state m_pDriver->m_RenderState.renderPass = GetResID(m_Overlay.NoDepthRP); @@ -1536,8 +1557,11 @@ ResourceId VulkanReplay::RenderOverlay(ResourceId texid, FloatVector clearCol, D cmd = m_pDriver->GetNextCmd(); + if(cmd == VK_NULL_HANDLE) + return ResourceId(); + vkr = vt->BeginCommandBuffer(Unwrap(cmd), &beginInfo); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); // restore state m_pDriver->m_RenderState = prevstate; @@ -1578,7 +1602,7 @@ ResourceId VulkanReplay::RenderOverlay(ResourceId texid, FloatVector clearCol, D if(!pipeInfo.rasterizerDiscardEnable) { vkr = vt->EndCommandBuffer(Unwrap(cmd)); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); VkFramebuffer depthFB = VK_NULL_HANDLE; VkRenderPass depthRP = VK_NULL_HANDLE; @@ -1656,7 +1680,7 @@ ResourceId VulkanReplay::RenderOverlay(ResourceId texid, FloatVector clearCol, D rpinfo.pNext = &multiviewRP; vkr = m_pDriver->vkCreateRenderPass(m_Device, &rpinfo, NULL, &depthRP); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); VkImageView views[] = { m_Overlay.ImageView, @@ -1677,7 +1701,7 @@ ResourceId VulkanReplay::RenderOverlay(ResourceId texid, FloatVector clearCol, D }; vkr = m_pDriver->vkCreateFramebuffer(m_Device, &fbinfo, NULL, &depthFB); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); } // if depthRP is NULL, so is depthFB, and it means no depth buffer was @@ -1781,7 +1805,7 @@ ResourceId VulkanReplay::RenderOverlay(ResourceId texid, FloatVector clearCol, D vkr = m_pDriver->vkCreateGraphicsPipelines(m_Device, VK_NULL_HANDLE, 1, &pipeCreateInfo, NULL, &passpipe); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); fragShader->module = failmod; @@ -1799,7 +1823,7 @@ ResourceId VulkanReplay::RenderOverlay(ResourceId texid, FloatVector clearCol, D vkr = m_pDriver->vkCreateGraphicsPipelines(m_Device, VK_NULL_HANDLE, 1, &pipeCreateInfo, NULL, &failpipe); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); // modify state m_pDriver->m_RenderState.renderPass = GetResID(m_Overlay.NoDepthRP); @@ -1837,8 +1861,11 @@ ResourceId VulkanReplay::RenderOverlay(ResourceId texid, FloatVector clearCol, D cmd = m_pDriver->GetNextCmd(); + if(cmd == VK_NULL_HANDLE) + return ResourceId(); + vkr = vt->BeginCommandBuffer(Unwrap(cmd), &beginInfo); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); // restore state m_pDriver->m_RenderState = prevstate; @@ -1891,7 +1918,7 @@ ResourceId VulkanReplay::RenderOverlay(ResourceId texid, FloatVector clearCol, D { vkr = vt->EndCommandBuffer(Unwrap(cmd)); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); #if ENABLED(SINGLE_FLUSH_VALIDATE) m_pDriver->SubmitCmds(); @@ -1936,8 +1963,11 @@ ResourceId VulkanReplay::RenderOverlay(ResourceId texid, FloatVector clearCol, D cmd = m_pDriver->GetNextCmd(); + if(cmd == VK_NULL_HANDLE) + return ResourceId(); + vkr = vt->BeginCommandBuffer(Unwrap(cmd), &beginInfo); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); m_pDriver->m_RenderState.BeginRenderPassAndApplyState(m_pDriver, cmd, VulkanRenderState::BindGraphics); @@ -1994,7 +2024,7 @@ ResourceId VulkanReplay::RenderOverlay(ResourceId texid, FloatVector clearCol, D m_pDriver->m_RenderState.EndRenderPass(cmd); vkr = vt->EndCommandBuffer(Unwrap(cmd)); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); for(size_t i = startEvent; i < events.size(); i++) { @@ -2006,8 +2036,11 @@ ResourceId VulkanReplay::RenderOverlay(ResourceId texid, FloatVector clearCol, D cmd = m_pDriver->GetNextCmd(); + if(cmd == VK_NULL_HANDLE) + return ResourceId(); + vkr = vt->BeginCommandBuffer(Unwrap(cmd), &beginInfo); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); } } else if(overlay == DebugOverlay::QuadOverdrawPass || overlay == DebugOverlay::QuadOverdrawDraw) @@ -2083,7 +2116,7 @@ ResourceId VulkanReplay::RenderOverlay(ResourceId texid, FloatVector clearCol, D }; vkr = m_pDriver->vkCreateImage(m_Device, &imInfo, NULL, &quadImg); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); VkMemoryRequirements mrq = {0}; @@ -2095,10 +2128,13 @@ ResourceId VulkanReplay::RenderOverlay(ResourceId texid, FloatVector clearCol, D }; vkr = m_pDriver->vkAllocateMemory(m_Device, &allocInfo, NULL, &quadImgMem); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); + + if(vkr != VK_SUCCESS) + return ResourceId(); vkr = m_pDriver->vkBindImageMemory(m_Device, quadImg, quadImgMem, 0); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); VkImageViewCreateInfo viewinfo = { VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, @@ -2113,7 +2149,7 @@ ResourceId VulkanReplay::RenderOverlay(ResourceId texid, FloatVector clearCol, D }; vkr = m_pDriver->vkCreateImageView(m_Device, &viewinfo, NULL, &quadImgView); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); // update descriptor to point to our R32 result image VkDescriptorImageInfo imdesc = {0}; @@ -2167,7 +2203,7 @@ ResourceId VulkanReplay::RenderOverlay(ResourceId texid, FloatVector clearCol, D // end this cmd buffer so the image is in the right state for the next part vkr = vt->EndCommandBuffer(Unwrap(cmd)); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); #if ENABLED(SINGLE_FLUSH_VALIDATE) m_pDriver->SubmitCmds(); @@ -2186,8 +2222,11 @@ ResourceId VulkanReplay::RenderOverlay(ResourceId texid, FloatVector clearCol, D { cmd = m_pDriver->GetNextCmd(); + if(cmd == VK_NULL_HANDLE) + return ResourceId(); + vkr = vt->BeginCommandBuffer(Unwrap(cmd), &beginInfo); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); quadImBarrier.srcAccessMask = quadImBarrier.dstAccessMask; quadImBarrier.oldLayout = quadImBarrier.newLayout; @@ -2224,7 +2263,7 @@ ResourceId VulkanReplay::RenderOverlay(ResourceId texid, FloatVector clearCol, D vt->CmdEndRenderPass(Unwrap(cmd)); vkr = vt->EndCommandBuffer(Unwrap(cmd)); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); } m_pDriver->SubmitCmds(); @@ -2240,8 +2279,11 @@ ResourceId VulkanReplay::RenderOverlay(ResourceId texid, FloatVector clearCol, D cmd = m_pDriver->GetNextCmd(); + if(cmd == VK_NULL_HANDLE) + return ResourceId(); + vkr = vt->BeginCommandBuffer(Unwrap(cmd), &beginInfo); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); } } else if(overlay == DebugOverlay::TriangleSizePass || overlay == DebugOverlay::TriangleSizeDraw) @@ -2291,7 +2333,7 @@ ResourceId VulkanReplay::RenderOverlay(ResourceId texid, FloatVector clearCol, D // end this cmd buffer so the image is in the right state for the next part vkr = vt->EndCommandBuffer(Unwrap(cmd)); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); #if ENABLED(SINGLE_FLUSH_VALIDATE) m_pDriver->SubmitCmds(); @@ -2438,7 +2480,7 @@ ResourceId VulkanReplay::RenderOverlay(ResourceId texid, FloatVector clearCol, D rpinfo.pNext = &multiviewRP; vkr = m_pDriver->vkCreateRenderPass(m_Device, &rpinfo, NULL, &RP); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); VkImageView views[] = { m_Overlay.ImageView, @@ -2459,7 +2501,7 @@ ResourceId VulkanReplay::RenderOverlay(ResourceId texid, FloatVector clearCol, D }; vkr = m_pDriver->vkCreateFramebuffer(m_Device, &fbinfo, NULL, &FB); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); } VkGraphicsPipelineCreateInfo pipeCreateInfo; @@ -2562,8 +2604,11 @@ ResourceId VulkanReplay::RenderOverlay(ResourceId texid, FloatVector clearCol, D { cmd = m_pDriver->GetNextCmd(); + if(cmd == VK_NULL_HANDLE) + return ResourceId(); + vkr = vt->BeginCommandBuffer(Unwrap(cmd), &beginInfo); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); VkClearValue clearval = {}; VkRenderPassBeginInfo rpbegin = { @@ -2598,7 +2643,7 @@ ResourceId VulkanReplay::RenderOverlay(ResourceId texid, FloatVector clearCol, D { vkr = m_pDriver->vkCreateGraphicsPipelines(m_Device, VK_NULL_HANDLE, 1, &pipeCreateInfo, NULL, &pipe); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); } VkBuffer vb = @@ -2750,7 +2795,7 @@ ResourceId VulkanReplay::RenderOverlay(ResourceId texid, FloatVector clearCol, D vt->CmdEndRenderPass(Unwrap(cmd)); vkr = vt->EndCommandBuffer(Unwrap(cmd)); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); if(overlay == DebugOverlay::TriangleSizePass) { @@ -2782,15 +2827,18 @@ ResourceId VulkanReplay::RenderOverlay(ResourceId texid, FloatVector clearCol, D cmd = m_pDriver->GetNextCmd(); + if(cmd == VK_NULL_HANDLE) + return ResourceId(); + vkr = vt->BeginCommandBuffer(Unwrap(cmd), &beginInfo); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); } } VkMarkerRegion::End(cmd); vkr = vt->EndCommandBuffer(Unwrap(cmd)); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); #if ENABLED(SINGLE_FLUSH_VALIDATE) m_pDriver->SubmitCmds(); diff --git a/renderdoc/driver/vulkan/vk_pixelhistory.cpp b/renderdoc/driver/vulkan/vk_pixelhistory.cpp index 2dafc15cb..3f685b5e5 100644 --- a/renderdoc/driver/vulkan/vk_pixelhistory.cpp +++ b/renderdoc/driver/vulkan/vk_pixelhistory.cpp @@ -325,7 +325,7 @@ private: moduleCreateInfo.codeSize = modSpirv.byteSize(); VkResult vkr = m_pDriver->vkCreateShaderModule(m_pDriver->GetDev(), &moduleCreateInfo, NULL, &module); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + m_pDriver->CheckVkResult(vkr); } return module; } @@ -796,7 +796,7 @@ protected: VkRenderPass renderpass; VkResult vkr = m_pDriver->vkCreateRenderPass(m_pDriver->GetDev(), &rpCreateInfo, NULL, &renderpass); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + m_pDriver->CheckVkResult(vkr); m_RpsToDestroy.push_back(renderpass); return renderpass; } @@ -849,7 +849,7 @@ protected: VkFramebuffer framebuffer; VkResult vkr = m_pDriver->vkCreateFramebuffer(m_pDriver->GetDev(), &fbCI, NULL, &framebuffer); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + m_pDriver->CheckVkResult(vkr); m_FbsToDestroy.push_back(framebuffer); return framebuffer; } @@ -890,7 +890,7 @@ protected: VkImageView imageView; VkResult vkr = m_pDriver->vkCreateImageView(m_pDriver->GetDev(), &viewInfo, NULL, &imageView); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + m_pDriver->CheckVkResult(vkr); m_ImageViewsToDestroy.push_back(imageView); VkImageView imageView2 = VK_NULL_HANDLE; @@ -898,7 +898,7 @@ protected: { viewInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_STENCIL_BIT; vkr = m_pDriver->vkCreateImageView(m_pDriver->GetDev(), &viewInfo, NULL, &imageView2); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + m_pDriver->CheckVkResult(vkr); m_ImageViewsToDestroy.push_back(imageView2); } @@ -1157,7 +1157,7 @@ struct VulkanOcclusionCallback : public VulkanPixelHistoryCallback m_OcclusionResults.byteSize(), m_OcclusionResults.data(), sizeof(uint64_t), VK_QUERY_RESULT_64_BIT | VK_QUERY_RESULT_WAIT_BIT); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + m_pDriver->CheckVkResult(vkr); } uint64_t GetOcclusionResult(uint32_t eventId) @@ -1209,7 +1209,7 @@ private: VkPipeline pipe; VkResult vkr = m_pDriver->vkCreateGraphicsPipelines(m_pDriver->GetDev(), VK_NULL_HANDLE, 1, &pipeCreateInfo, NULL, &pipe); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + m_pDriver->CheckVkResult(vkr); m_PipeCache.insert(std::make_pair(pipeline, pipe)); return pipe; } @@ -1646,7 +1646,7 @@ private: VkResult vkr = m_pDriver->vkCreateGraphicsPipelines(m_pDriver->GetDev(), VK_NULL_HANDLE, 1, &pipeCreateInfo, NULL, &replacements.originalShaderStencil); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + m_pDriver->CheckVkResult(vkr); for(uint32_t i = 0; i < pipeCreateInfo.stageCount; i++) { @@ -1661,7 +1661,7 @@ private: vkr = m_pDriver->vkCreateGraphicsPipelines(m_pDriver->GetDev(), VK_NULL_HANDLE, 1, &pipeCreateInfo, NULL, &replacements.fixedShaderStencil); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + m_pDriver->CheckVkResult(vkr); m_PipeCache.insert(std::make_pair(pipeline, replacements)); @@ -1761,7 +1761,7 @@ struct TestsFailedCallback : public VulkanPixelHistoryCallback (uint32_t)m_OcclusionResults.size(), m_OcclusionResults.byteSize(), m_OcclusionResults.data(), sizeof(m_OcclusionResults[0]), VK_QUERY_RESULT_64_BIT | VK_QUERY_RESULT_WAIT_BIT); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + m_pDriver->CheckVkResult(vkr); } uint64_t GetOcclusionResult(uint32_t eventId, uint32_t test) const @@ -2137,7 +2137,7 @@ private: VkPipeline pipe; VkResult vkr = m_pDriver->vkCreateGraphicsPipelines(m_pDriver->GetDev(), VK_NULL_HANDLE, 1, &ci, NULL, &pipe); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + m_pDriver->CheckVkResult(vkr); m_PipeCache.insert(std::make_pair(pipeKey, pipe)); return pipe; } @@ -2556,7 +2556,7 @@ struct VulkanPixelHistoryPerFragmentCallback : VulkanPixelHistoryCallback Pipelines pipes = {}; VkResult vkr = m_pDriver->vkCreateGraphicsPipelines(m_pDriver->GetDev(), VK_NULL_HANDLE, 1, &pipeCreateInfo, NULL, &pipes.postModPipe); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + m_pDriver->CheckVkResult(vkr); m_PipesToDestroy.push_back(pipes.postModPipe); pipeCreateInfo.renderPass = rp; @@ -2608,7 +2608,7 @@ struct VulkanPixelHistoryPerFragmentCallback : VulkanPixelHistoryCallback vkr = m_pDriver->vkCreateGraphicsPipelines(m_pDriver->GetDev(), VK_NULL_HANDLE, 1, &pipeCreateInfo, NULL, &pipes.shaderOutPipe); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + m_pDriver->CheckVkResult(vkr); m_PipesToDestroy.push_back(pipes.shaderOutPipe); @@ -2649,7 +2649,7 @@ struct VulkanPixelHistoryPerFragmentCallback : VulkanPixelHistoryCallback { vkr = m_pDriver->vkCreateGraphicsPipelines(m_pDriver->GetDev(), VK_NULL_HANDLE, 1, &pipeCreateInfo, NULL, &pipes.primitiveIdPipe); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + m_pDriver->CheckVkResult(vkr); m_PipesToDestroy.push_back(pipes.primitiveIdPipe); } else @@ -2777,7 +2777,7 @@ struct VulkanPixelHistoryDiscardedFragmentsCallback : VulkanPixelHistoryCallback VkPipeline newPipe; VkResult vkr = m_pDriver->vkCreateGraphicsPipelines(m_pDriver->GetDev(), VK_NULL_HANDLE, 1, &pipeCreateInfo, NULL, &newPipe); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + m_pDriver->CheckVkResult(vkr); m_PipesToDestroy.push_back(newPipe); return newPipe; } @@ -2791,7 +2791,7 @@ struct VulkanPixelHistoryDiscardedFragmentsCallback : VulkanPixelHistoryCallback m_OcclusionResults.byteSize(), m_OcclusionResults.data(), sizeof(uint64_t), VK_QUERY_RESULT_64_BIT | VK_QUERY_RESULT_WAIT_BIT); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + m_pDriver->CheckVkResult(vkr); } bool PrimitiveDiscarded(uint32_t eid, uint32_t primId) @@ -2884,7 +2884,7 @@ bool VulkanDebugManager::PixelHistorySetupResources(PixelHistoryResources &resou imgInfo.usage |= VK_IMAGE_USAGE_SAMPLED_BIT; vkr = m_pDriver->vkCreateImage(dev, &imgInfo, NULL, &colorImage); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); ImageState colorImageState = ImageState(colorImage, ImageInfo(imgInfo), eFrameRef_None); @@ -2897,7 +2897,7 @@ bool VulkanDebugManager::PixelHistorySetupResources(PixelHistoryResources &resou VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT; vkr = m_pDriver->vkCreateImage(dev, &imgInfo, NULL, &dsImage); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); ImageState stencilImageState = ImageState(dsImage, ImageInfo(imgInfo), eFrameRef_None); @@ -2911,13 +2911,16 @@ bool VulkanDebugManager::PixelHistorySetupResources(PixelHistoryResources &resou m_pDriver->GetGPULocalMemoryIndex(colorImageMrq.memoryTypeBits), }; vkr = m_pDriver->vkAllocateMemory(m_Device, &allocInfo, NULL, &gpuMem); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); + + if(vkr != VK_SUCCESS) + return false; vkr = m_pDriver->vkBindImageMemory(m_Device, colorImage, gpuMem, 0); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); vkr = m_pDriver->vkBindImageMemory(m_Device, dsImage, gpuMem, offset); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); NameVulkanObject(colorImage, "Pixel History color image"); NameVulkanObject(dsImage, "Pixel History depth image"); @@ -2932,7 +2935,7 @@ bool VulkanDebugManager::PixelHistorySetupResources(PixelHistoryResources &resou viewInfo.viewType = VK_IMAGE_VIEW_TYPE_2D_ARRAY; vkr = m_pDriver->vkCreateImageView(m_Device, &viewInfo, NULL, &colorImageView); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); viewInfo.image = dsImage; viewInfo.format = dsFormat; @@ -2940,7 +2943,7 @@ bool VulkanDebugManager::PixelHistorySetupResources(PixelHistoryResources &resou imgInfo.arrayLayers}; vkr = m_pDriver->vkCreateImageView(m_Device, &viewInfo, NULL, &dsImageView); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); VkBufferCreateInfo bufferInfo = {VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO}; // TODO: the size for memory is calculated to fit pre and post modification values and @@ -2949,7 +2952,7 @@ bool VulkanDebugManager::PixelHistorySetupResources(PixelHistoryResources &resou bufferInfo.usage = VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT; vkr = m_pDriver->vkCreateBuffer(m_Device, &bufferInfo, NULL, &dstBuffer); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); // Allocate memory VkMemoryRequirements mrq = {}; @@ -2957,17 +2960,23 @@ bool VulkanDebugManager::PixelHistorySetupResources(PixelHistoryResources &resou allocInfo.allocationSize = mrq.size; allocInfo.memoryTypeIndex = m_pDriver->GetReadbackMemoryIndex(mrq.memoryTypeBits); vkr = m_pDriver->vkAllocateMemory(m_Device, &allocInfo, NULL, &bufferMemory); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); + + if(vkr != VK_SUCCESS) + return false; vkr = m_pDriver->vkBindBufferMemory(m_Device, dstBuffer, bufferMemory, 0); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); VkCommandBuffer cmd = m_pDriver->GetNextCmd(); VkCommandBufferBeginInfo beginInfo = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, NULL, VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT}; + if(cmd == VK_NULL_HANDLE) + return false; + vkr = ObjDisp(dev)->BeginCommandBuffer(Unwrap(cmd), &beginInfo); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); ObjDisp(cmd)->CmdFillBuffer(Unwrap(cmd), Unwrap(dstBuffer), 0, VK_WHOLE_SIZE, 0); colorImageState.InlineTransition( cmd, m_pDriver->m_QueueFamilyIdx, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, 0, @@ -2977,7 +2986,7 @@ bool VulkanDebugManager::PixelHistorySetupResources(PixelHistoryResources &resou VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT, m_pDriver->GetImageTransitionInfo()); vkr = ObjDisp(dev)->EndCommandBuffer(Unwrap(cmd)); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); m_pDriver->SubmitCmds(); m_pDriver->FlushQ(); @@ -3089,16 +3098,19 @@ void CreateOcclusionPool(WrappedVulkan *vk, uint32_t poolSize, VkQueryPool *pQue // TODO: check that occlusion feature is available VkResult vkr = ObjDisp(dev)->CreateQueryPool(Unwrap(dev), &occlusionPoolCreateInfo, NULL, pQueryPool); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + vk->CheckVkResult(vkr); VkCommandBuffer cmd = vk->GetNextCmd(); VkCommandBufferBeginInfo beginInfo = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, NULL, VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT}; + if(cmd == VK_NULL_HANDLE) + return; + vkr = ObjDisp(dev)->BeginCommandBuffer(Unwrap(cmd), &beginInfo); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + vk->CheckVkResult(vkr); ObjDisp(dev)->CmdResetQueryPool(Unwrap(cmd), *pQueryPool, 0, poolSize); vkr = ObjDisp(dev)->EndCommandBuffer(Unwrap(cmd)); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + vk->CheckVkResult(vkr); vk->SubmitCmds(); vk->FlushQ(); } @@ -3406,7 +3418,9 @@ rdcarray VulkanReplay::PixelHistory(rdcarray even EventInfo *eventsInfo; VkResult vkr = m_pDriver->vkMapMemory(dev, resources.bufferMemory, 0, VK_WHOLE_SIZE, 0, (void **)&eventsInfo); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); + if(vkr != VK_SUCCESS) + return history; std::map eventsWithFrags; std::map eventPremods; @@ -3489,7 +3503,9 @@ rdcarray VulkanReplay::PixelHistory(rdcarray even PerFragmentInfo *bp = NULL; vkr = m_pDriver->vkMapMemory(dev, resources.bufferMemory, 0, VK_WHOLE_SIZE, 0, (void **)&bp); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); + if(vkr != VK_SUCCESS) + return history; // Retrieve primitive ID values where fragment shader discarded some // fragments. For these primitives we are going to perform an occlusion diff --git a/renderdoc/driver/vulkan/vk_postvs.cpp b/renderdoc/driver/vulkan/vk_postvs.cpp index 9e0d7d59e..82b84da1b 100644 --- a/renderdoc/driver/vulkan/vk_postvs.cpp +++ b/renderdoc/driver/vulkan/vk_postvs.cpp @@ -1578,7 +1578,7 @@ void VulkanReplay::FetchVSOut(uint32_t eventId, VulkanRenderState &state) }; vkr = m_pDriver->vkCreatePipelineLayout(dev, &pipeLayoutInfo, NULL, &pipeLayout); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); } else { @@ -1607,7 +1607,7 @@ void VulkanReplay::FetchVSOut(uint32_t eventId, VulkanRenderState &state) }; vkr = m_pDriver->vkCreatePipelineLayout(dev, &pipeLayoutInfo, NULL, &pipeLayout); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); // clear the array because it's not needed after and we want to avoid releasing real resources setLayouts.clear(); @@ -1795,7 +1795,7 @@ void VulkanReplay::FetchVSOut(uint32_t eventId, VulkanRenderState &state) bufInfo.usage |= VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT; vkr = m_pDriver->vkCreateBuffer(dev, &bufInfo, NULL, &uniqIdxBuf); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); uniqIdxBufDescriptor.buffer = uniqIdxBuf; uniqIdxBufDescriptor.offset = 0; @@ -1820,14 +1820,16 @@ void VulkanReplay::FetchVSOut(uint32_t eventId, VulkanRenderState &state) return; } - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); vkr = m_pDriver->vkBindBufferMemory(dev, uniqIdxBuf, uniqIdxBufMem, 0); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); byte *idxData = NULL; vkr = m_pDriver->vkMapMemory(m_Device, uniqIdxBufMem, 0, VK_WHOLE_SIZE, 0, (void **)&idxData); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); + if(vkr != VK_SUCCESS) + return; memcpy(idxData, &indices[0], indices.size() * sizeof(uint32_t)); @@ -1836,7 +1838,7 @@ void VulkanReplay::FetchVSOut(uint32_t eventId, VulkanRenderState &state) }; vkr = m_pDriver->vkFlushMappedMemoryRanges(m_Device, 1, &range); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); m_pDriver->vkUnmapMemory(m_Device, uniqIdxBufMem); @@ -1876,7 +1878,7 @@ void VulkanReplay::FetchVSOut(uint32_t eventId, VulkanRenderState &state) bufInfo.usage = VK_BUFFER_USAGE_INDEX_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_SRC_BIT; vkr = m_pDriver->vkCreateBuffer(dev, &bufInfo, NULL, &rebasedIdxBuf); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); m_pDriver->vkGetBufferMemoryRequirements(dev, rebasedIdxBuf, &mrq); @@ -1891,13 +1893,15 @@ void VulkanReplay::FetchVSOut(uint32_t eventId, VulkanRenderState &state) return; } - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); vkr = m_pDriver->vkBindBufferMemory(dev, rebasedIdxBuf, rebasedIdxBufMem, 0); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); vkr = m_pDriver->vkMapMemory(m_Device, rebasedIdxBufMem, 0, VK_WHOLE_SIZE, 0, (void **)&idxData); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); + if(vkr != VK_SUCCESS) + return; memcpy(idxData, idxdata.data(), idxdata.size()); @@ -1906,7 +1910,7 @@ void VulkanReplay::FetchVSOut(uint32_t eventId, VulkanRenderState &state) }; vkr = m_pDriver->vkFlushMappedMemoryRanges(m_Device, 1, &rebasedRange); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); m_pDriver->vkUnmapMemory(m_Device, rebasedIdxBufMem); } @@ -2088,7 +2092,7 @@ void VulkanReplay::FetchVSOut(uint32_t eventId, VulkanRenderState &state) bufInfo.usage |= VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT; vkr = m_pDriver->vkCreateBuffer(dev, &bufInfo, NULL, &vbuffers[attr].buf); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); VkMemoryRequirements mrq = {0}; m_pDriver->vkGetBufferMemoryRequirements(dev, vbuffers[attr].buf, &mrq); @@ -2109,15 +2113,17 @@ void VulkanReplay::FetchVSOut(uint32_t eventId, VulkanRenderState &state) return; } - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); vkr = m_pDriver->vkBindBufferMemory(dev, vbuffers[attr].buf, vbuffers[attr].mem, 0); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); byte *dst = NULL; vkr = m_pDriver->vkMapMemory(m_Device, vbuffers[attr].mem, 0, VK_WHOLE_SIZE, 0, (void **)&dst); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); + if(vkr != VK_SUCCESS) + return; const byte *dstBase = dst; (void)dstBase; @@ -2273,7 +2279,7 @@ void VulkanReplay::FetchVSOut(uint32_t eventId, VulkanRenderState &state) }; vkr = m_pDriver->vkFlushMappedMemoryRanges(m_Device, 1, &range); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); m_pDriver->vkUnmapMemory(m_Device, vbuffers[attr].mem); } @@ -2347,12 +2353,12 @@ void VulkanReplay::FetchVSOut(uint32_t eventId, VulkanRenderState &state) bufInfo.usage |= VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT; vkr = m_pDriver->vkCreateBuffer(dev, &bufInfo, NULL, &meshBuffer); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); bufInfo.usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT; vkr = m_pDriver->vkCreateBuffer(dev, &bufInfo, NULL, &readbackBuffer); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); VkMemoryRequirements mrq = {0}; m_pDriver->vkGetBufferMemoryRequirements(dev, meshBuffer, &mrq); @@ -2373,10 +2379,10 @@ void VulkanReplay::FetchVSOut(uint32_t eventId, VulkanRenderState &state) return; } - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); vkr = m_pDriver->vkBindBufferMemory(dev, meshBuffer, meshMem, 0); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); m_pDriver->vkGetBufferMemoryRequirements(dev, readbackBuffer, &mrq); @@ -2391,10 +2397,10 @@ void VulkanReplay::FetchVSOut(uint32_t eventId, VulkanRenderState &state) return; } - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); vkr = m_pDriver->vkBindBufferMemory(dev, readbackBuffer, readbackMem, 0); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); } VkComputePipelineCreateInfo compPipeInfo = {VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO}; @@ -2410,7 +2416,7 @@ void VulkanReplay::FetchVSOut(uint32_t eventId, VulkanRenderState &state) VkShaderModule module; vkr = m_pDriver->vkCreateShaderModule(dev, &moduleCreateInfo, NULL, &module); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); compPipeInfo.stage.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; compPipeInfo.stage.module = module; @@ -2526,11 +2532,14 @@ void VulkanReplay::FetchVSOut(uint32_t eventId, VulkanRenderState &state) { VkCommandBuffer cmd = m_pDriver->GetNextCmd(); + if(cmd == VK_NULL_HANDLE) + return; + VkCommandBufferBeginInfo beginInfo = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, NULL, VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT}; vkr = ObjDisp(dev)->BeginCommandBuffer(Unwrap(cmd), &beginInfo); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); // fill destination buffer with 0s to ensure unwritten vertices have sane data ObjDisp(dev)->CmdFillBuffer(Unwrap(cmd), Unwrap(meshBuffer), 0, bufSize, 0); @@ -2602,7 +2611,7 @@ void VulkanReplay::FetchVSOut(uint32_t eventId, VulkanRenderState &state) DoPipelineBarrier(cmd, 1, &meshbufbarrier); vkr = ObjDisp(dev)->EndCommandBuffer(Unwrap(cmd)); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); // submit & flush so that we don't have to keep pipeline around for a while m_pDriver->SubmitCmds(); @@ -2618,14 +2627,16 @@ void VulkanReplay::FetchVSOut(uint32_t eventId, VulkanRenderState &state) // readback mesh data byte *byteData = NULL; vkr = m_pDriver->vkMapMemory(m_Device, readbackMem, 0, VK_WHOLE_SIZE, 0, (void **)&byteData); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); + if(vkr != VK_SUCCESS) + return; VkMappedMemoryRange range = { VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE, NULL, readbackMem, 0, VK_WHOLE_SIZE, }; vkr = m_pDriver->vkInvalidateMappedMemoryRanges(m_Device, 1, &range); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); // do near/far calculations @@ -2886,7 +2897,7 @@ void VulkanReplay::FetchTessGSOut(uint32_t eventId, VulkanRenderState &state) VkShaderModule module; vkr = m_pDriver->vkCreateShaderModule(dev, &moduleCreateInfo, NULL, &module); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); VkGraphicsPipelineCreateInfo pipeCreateInfo; @@ -2919,14 +2930,14 @@ void VulkanReplay::FetchTessGSOut(uint32_t eventId, VulkanRenderState &state) }; vkr = m_pDriver->vkCreateRenderPass(m_Device, &rpinfo, NULL, &rp); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); VkFramebufferCreateInfo fbinfo = { VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, NULL, 0, rp, 0, NULL, 16U, 16U, 1, }; vkr = m_pDriver->vkCreateFramebuffer(m_Device, &fbinfo, NULL, &fb); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); pipeCreateInfo.renderPass = rp; pipeCreateInfo.subpass = 0; @@ -2934,7 +2945,7 @@ void VulkanReplay::FetchTessGSOut(uint32_t eventId, VulkanRenderState &state) VkPipeline pipe = VK_NULL_HANDLE; vkr = m_pDriver->vkCreateGraphicsPipelines(m_Device, VK_NULL_HANDLE, 1, &pipeCreateInfo, NULL, &pipe); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); state.graphics.pipeline = GetResID(pipe); state.SetFramebuffer(m_pDriver, GetResID(fb)); @@ -2964,7 +2975,7 @@ void VulkanReplay::FetchTessGSOut(uint32_t eventId, VulkanRenderState &state) }; vkr = m_pDriver->vkCreateQueryPool(m_Device, &info, NULL, &m_PostVS.XFBQueryPool); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); m_PostVS.XFBQueryPoolSize = action->numInstances; } @@ -3002,7 +3013,7 @@ void VulkanReplay::FetchTessGSOut(uint32_t eventId, VulkanRenderState &state) bufInfo.usage |= VK_BUFFER_USAGE_VERTEX_BUFFER_BIT; vkr = m_pDriver->vkCreateBuffer(dev, &bufInfo, NULL, &meshBuffer); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); VkMemoryRequirements mrq = {0}; m_pDriver->vkGetBufferMemoryRequirements(dev, meshBuffer, &mrq); @@ -3033,18 +3044,21 @@ void VulkanReplay::FetchTessGSOut(uint32_t eventId, VulkanRenderState &state) return; } - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); vkr = m_pDriver->vkBindBufferMemory(dev, meshBuffer, meshMem, 0); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); VkCommandBuffer cmd = m_pDriver->GetNextCmd(); + if(cmd == VK_NULL_HANDLE) + return; + VkCommandBufferBeginInfo beginInfo = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, NULL, VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT}; vkr = ObjDisp(dev)->BeginCommandBuffer(Unwrap(cmd), &beginInfo); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); ObjDisp(dev)->CmdResetQueryPool(Unwrap(cmd), Unwrap(m_PostVS.XFBQueryPool), 0, 1); @@ -3084,7 +3098,7 @@ void VulkanReplay::FetchTessGSOut(uint32_t eventId, VulkanRenderState &state) state.EndRenderPass(cmd); vkr = ObjDisp(dev)->EndCommandBuffer(Unwrap(cmd)); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); m_pDriver->SubmitCmds(); m_pDriver->FlushQ(); @@ -3092,7 +3106,7 @@ void VulkanReplay::FetchTessGSOut(uint32_t eventId, VulkanRenderState &state) vkr = ObjDisp(dev)->GetQueryPoolResults( Unwrap(dev), Unwrap(m_PostVS.XFBQueryPool), 0, 1, sizeof(VkXfbQueryResult), &queryResult, sizeof(VkXfbQueryResult), VK_QUERY_RESULT_64_BIT | VK_QUERY_RESULT_WAIT_BIT); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); VkDeviceSize generatedSize = queryResult.numPrimitivesGenerated * 3 * xfbStride; @@ -3109,11 +3123,14 @@ void VulkanReplay::FetchTessGSOut(uint32_t eventId, VulkanRenderState &state) { VkCommandBuffer cmd = m_pDriver->GetNextCmd(); + if(cmd == VK_NULL_HANDLE) + return; + VkCommandBufferBeginInfo beginInfo = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, NULL, VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT}; vkr = ObjDisp(dev)->BeginCommandBuffer(Unwrap(cmd), &beginInfo); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); ObjDisp(dev)->CmdResetQueryPool(Unwrap(cmd), Unwrap(m_PostVS.XFBQueryPool), 0, action->numInstances); @@ -3147,7 +3164,7 @@ void VulkanReplay::FetchTessGSOut(uint32_t eventId, VulkanRenderState &state) state.EndRenderPass(cmd); vkr = ObjDisp(dev)->EndCommandBuffer(Unwrap(cmd)); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); m_pDriver->SubmitCmds(); m_pDriver->FlushQ(); @@ -3158,7 +3175,7 @@ void VulkanReplay::FetchTessGSOut(uint32_t eventId, VulkanRenderState &state) Unwrap(dev), Unwrap(m_PostVS.XFBQueryPool), 0, action->numInstances, sizeof(VkXfbQueryResult) * action->numInstances, queryResults.data(), sizeof(VkXfbQueryResult), VK_QUERY_RESULT_64_BIT | VK_QUERY_RESULT_WAIT_BIT); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); uint64_t prevVertCount = 0; diff --git a/renderdoc/driver/vulkan/vk_rendermesh.cpp b/renderdoc/driver/vulkan/vk_rendermesh.cpp index 1a8484b24..26f80365e 100644 --- a/renderdoc/driver/vulkan/vk_rendermesh.cpp +++ b/renderdoc/driver/vulkan/vk_rendermesh.cpp @@ -366,13 +366,13 @@ VKMeshDisplayPipelines VulkanDebugManager::CacheMeshDisplayPipelines(VkPipelineL vkr = vt->CreateGraphicsPipelines(Unwrap(m_Device), VK_NULL_HANDLE, 1, &pipeInfo, NULL, &cache.pipes[VKMeshDisplayPipelines::ePipe_Wire]); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); ds.depthTestEnable = true; vkr = vt->CreateGraphicsPipelines(Unwrap(m_Device), VK_NULL_HANDLE, 1, &pipeInfo, NULL, &cache.pipes[VKMeshDisplayPipelines::ePipe_WireDepth]); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); // solid shading pipeline rs.polygonMode = VK_POLYGON_MODE_FILL; @@ -380,13 +380,13 @@ VKMeshDisplayPipelines VulkanDebugManager::CacheMeshDisplayPipelines(VkPipelineL vkr = vt->CreateGraphicsPipelines(Unwrap(m_Device), VK_NULL_HANDLE, 1, &pipeInfo, NULL, &cache.pipes[VKMeshDisplayPipelines::ePipe_Solid]); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); ds.depthTestEnable = true; vkr = vt->CreateGraphicsPipelines(Unwrap(m_Device), VK_NULL_HANDLE, 1, &pipeInfo, NULL, &cache.pipes[VKMeshDisplayPipelines::ePipe_SolidDepth]); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); if(secondary.vertexResourceId != ResourceId()) { @@ -399,7 +399,7 @@ VKMeshDisplayPipelines VulkanDebugManager::CacheMeshDisplayPipelines(VkPipelineL vkr = vt->CreateGraphicsPipelines(Unwrap(m_Device), VK_NULL_HANDLE, 1, &pipeInfo, NULL, &cache.pipes[VKMeshDisplayPipelines::ePipe_Secondary]); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); } vertAttrs[1].binding = 0; @@ -414,7 +414,7 @@ VKMeshDisplayPipelines VulkanDebugManager::CacheMeshDisplayPipelines(VkPipelineL { vkr = vt->CreateGraphicsPipelines(Unwrap(m_Device), VK_NULL_HANDLE, 1, &pipeInfo, NULL, &cache.pipes[VKMeshDisplayPipelines::ePipe_Lit]); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); } for(uint32_t i = 0; i < VKMeshDisplayPipelines::ePipe_Count; i++) @@ -447,13 +447,16 @@ void VulkanReplay::RenderMesh(uint32_t eventId, const rdcarray &seco VkCommandBuffer cmd = m_pDriver->GetNextCmd(); const VkDevDispatchTable *vt = ObjDisp(dev); + if(cmd == VK_NULL_HANDLE) + return; + VkResult vkr = VK_SUCCESS; VkCommandBufferBeginInfo beginInfo = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, NULL, VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT}; vkr = vt->BeginCommandBuffer(Unwrap(cmd), &beginInfo); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); VkMarkerRegion::Begin( StringFormat::Fmt("RenderMesh with %zu secondary draws", secondaryDraws.size()), cmd); @@ -540,7 +543,7 @@ void VulkanReplay::RenderMesh(uint32_t eventId, const rdcarray &seco vt->CmdEndRenderPass(Unwrap(cmd)); vkr = vt->EndCommandBuffer(Unwrap(cmd)); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); m_pDriver->SubmitCmds(); m_pDriver->FlushQ(); @@ -549,8 +552,11 @@ void VulkanReplay::RenderMesh(uint32_t eventId, const rdcarray &seco cmd = m_pDriver->GetNextCmd(); + if(cmd == VK_NULL_HANDLE) + return; + vkr = vt->BeginCommandBuffer(Unwrap(cmd), &beginInfo); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); vt->CmdBeginRenderPass(Unwrap(cmd), &rpbegin, VK_SUBPASS_CONTENTS_INLINE); vt->CmdSetViewport(Unwrap(cmd), 0, 1, &viewport); @@ -601,15 +607,18 @@ void VulkanReplay::RenderMesh(uint32_t eventId, const rdcarray &seco vt->CmdEndRenderPass(Unwrap(cmd)); vkr = vt->EndCommandBuffer(Unwrap(cmd)); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); m_pDriver->SubmitCmds(); m_pDriver->FlushQ(); cmd = m_pDriver->GetNextCmd(); + if(cmd == VK_NULL_HANDLE) + return; + vkr = vt->BeginCommandBuffer(Unwrap(cmd), &beginInfo); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); vt->CmdBeginRenderPass(Unwrap(cmd), &rpbegin, VK_SUBPASS_CONTENTS_INLINE); vt->CmdSetViewport(Unwrap(cmd), 0, 1, &viewport); @@ -945,7 +954,7 @@ void VulkanReplay::RenderMesh(uint32_t eventId, const rdcarray &seco vt->CmdEndRenderPass(Unwrap(cmd)); vkr = vt->EndCommandBuffer(Unwrap(cmd)); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); #if ENABLED(SINGLE_FLUSH_VALIDATE) m_pDriver->SubmitCmds(); @@ -958,8 +967,11 @@ void VulkanReplay::RenderMesh(uint32_t eventId, const rdcarray &seco // get a new cmdbuffer and begin it cmd = m_pDriver->GetNextCmd(); + if(cmd == VK_NULL_HANDLE) + return; + vkr = vt->BeginCommandBuffer(Unwrap(cmd), &beginInfo); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); vt->CmdBeginRenderPass(Unwrap(cmd), &rpbegin, VK_SUBPASS_CONTENTS_INLINE); vt->CmdSetViewport(Unwrap(cmd), 0, 1, &viewport); @@ -1173,7 +1185,7 @@ void VulkanReplay::RenderMesh(uint32_t eventId, const rdcarray &seco VkMarkerRegion::End(cmd); vkr = vt->EndCommandBuffer(Unwrap(cmd)); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); #if ENABLED(SINGLE_FLUSH_VALIDATE) m_pDriver->SubmitCmds(); diff --git a/renderdoc/driver/vulkan/vk_rendertexture.cpp b/renderdoc/driver/vulkan/vk_rendertexture.cpp index 03a7e7841..cc967e365 100644 --- a/renderdoc/driver/vulkan/vk_rendertexture.cpp +++ b/renderdoc/driver/vulkan/vk_rendertexture.cpp @@ -96,14 +96,14 @@ void VulkanReplay::CreateTexImageView(VkImage liveIm, const VulkanCreationInfo:: // create as wrapped vkr = m_pDriver->vkCreateImageView(dev, &viewInfo, NULL, &views.views[i]); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); } } else { // create first view vkr = m_pDriver->vkCreateImageView(dev, &viewInfo, NULL, &views.views[0]); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); // for depth-stencil images, create a second view for stencil only if(IsDepthAndStencilFormat(fmt)) @@ -111,7 +111,7 @@ void VulkanReplay::CreateTexImageView(VkImage liveIm, const VulkanCreationInfo:: viewInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_STENCIL_BIT; vkr = m_pDriver->vkCreateImageView(dev, &viewInfo, NULL, &views.views[1]); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); } } } @@ -493,6 +493,9 @@ bool VulkanReplay::RenderTextureInternal(TextureDisplay cfg, const ImageState &i VkCommandBuffer cmd = m_pDriver->GetNextCmd(); + if(cmd == VK_NULL_HANDLE) + return false; + VkCommandBufferBeginInfo beginInfo = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, NULL, VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT}; diff --git a/renderdoc/driver/vulkan/vk_replay.cpp b/renderdoc/driver/vulkan/vk_replay.cpp index 957d9f5bb..00b1a5437 100644 --- a/renderdoc/driver/vulkan/vk_replay.cpp +++ b/renderdoc/driver/vulkan/vk_replay.cpp @@ -128,7 +128,7 @@ rdcarray VulkanReplay::GetAvailableGPUs() VkPhysicalDevice *devices = new VkPhysicalDevice[count]; vkr = ObjDisp(instance)->EnumeratePhysicalDevices(Unwrap(instance), &count, devices); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); for(uint32_t p = 0; p < count; p++) { @@ -758,11 +758,14 @@ void VulkanReplay::RenderCheckerboard(FloatVector dark, FloatVector light) VkCommandBuffer cmd = m_pDriver->GetNextCmd(); const VkDevDispatchTable *vt = ObjDisp(dev); + if(cmd == VK_NULL_HANDLE) + return; + VkCommandBufferBeginInfo beginInfo = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, NULL, VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT}; VkResult vkr = vt->BeginCommandBuffer(Unwrap(cmd), &beginInfo); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); uint32_t uboOffs = 0; @@ -856,7 +859,7 @@ void VulkanReplay::RenderCheckerboard(FloatVector dark, FloatVector light) vt->CmdEndRenderPass(Unwrap(cmd)); vkr = vt->EndCommandBuffer(Unwrap(cmd)); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); #if ENABLED(SINGLE_FLUSH_VALIDATE) m_pDriver->SubmitCmds(); @@ -880,11 +883,14 @@ void VulkanReplay::RenderHighlightBox(float w, float h, float scale) VkCommandBuffer cmd = m_pDriver->GetNextCmd(); const VkDevDispatchTable *vt = ObjDisp(dev); + if(cmd == VK_NULL_HANDLE) + return; + VkCommandBufferBeginInfo beginInfo = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, NULL, VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT}; VkResult vkr = vt->BeginCommandBuffer(Unwrap(cmd), &beginInfo); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); { VkRenderPassBeginInfo rpbegin = { @@ -956,7 +962,7 @@ void VulkanReplay::RenderHighlightBox(float w, float h, float scale) } vkr = vt->EndCommandBuffer(Unwrap(cmd)); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); #if ENABLED(SINGLE_FLUSH_VALIDATE) m_pDriver->SubmitCmds(); @@ -2179,6 +2185,9 @@ void VulkanReplay::PickPixel(ResourceId texture, uint32_t x, uint32_t y, const S VkCommandBuffer cmd = m_pDriver->GetNextCmd(); const VkDevDispatchTable *vt = ObjDisp(dev); + if(cmd == VK_NULL_HANDLE) + return; + VkResult vkr = VK_SUCCESS; { @@ -2201,7 +2210,7 @@ void VulkanReplay::PickPixel(ResourceId texture, uint32_t x, uint32_t y, const S VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT}; vkr = vt->BeginCommandBuffer(Unwrap(cmd), &beginInfo); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); DoPipelineBarrier(cmd, 1, &pickimBarrier); pickimBarrier.oldLayout = pickimBarrier.newLayout; @@ -2228,8 +2237,11 @@ void VulkanReplay::PickPixel(ResourceId texture, uint32_t x, uint32_t y, const S m_pDriver->FlushQ(); float *pData = NULL; - vt->MapMemory(Unwrap(dev), Unwrap(m_PixelPick.ReadbackBuffer.mem), 0, VK_WHOLE_SIZE, 0, - (void **)&pData); + vkr = vt->MapMemory(Unwrap(dev), Unwrap(m_PixelPick.ReadbackBuffer.mem), 0, VK_WHOLE_SIZE, 0, + (void **)&pData); + CheckVkResult(vkr); + if(vkr != VK_SUCCESS) + return; VkMappedMemoryRange range = { VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE, @@ -2240,7 +2252,7 @@ void VulkanReplay::PickPixel(ResourceId texture, uint32_t x, uint32_t y, const S }; vkr = vt->InvalidateMappedMemoryRanges(Unwrap(dev), 1, &range); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); RDCASSERT(pData != NULL); @@ -2513,6 +2525,9 @@ bool VulkanReplay::GetMinMax(ResourceId texid, const Subresource &sub, CompType VkCommandBuffer cmd = m_pDriver->GetNextCmd(); + if(cmd == VK_NULL_HANDLE) + return false; + vt->BeginCommandBuffer(Unwrap(cmd), &beginInfo); ImageBarrierSequence setupBarriers, cleanupBarriers; @@ -2542,6 +2557,9 @@ bool VulkanReplay::GetMinMax(ResourceId texid, const Subresource &sub, CompType m_pDriver->FlushQ(); m_pDriver->SubmitAndFlushImageStateBarriers(cleanupBarriers); cmd = m_pDriver->GetNextCmd(); + + if(cmd == VK_NULL_HANDLE) + return false; vt->BeginCommandBuffer(Unwrap(cmd), &beginInfo); } @@ -2614,6 +2632,11 @@ bool VulkanReplay::GetMinMax(ResourceId texid, const Subresource &sub, CompType return true; } +void VulkanReplay::CheckVkResult(VkResult vkr) +{ + return m_pDriver->CheckVkResult(vkr); +} + bool VulkanReplay::GetHistogram(ResourceId texid, const Subresource &sub, CompType typeCast, float minval, float maxval, const rdcfixedarray &channels, rdcarray &histogram) @@ -2828,6 +2851,9 @@ bool VulkanReplay::GetHistogram(ResourceId texid, const Subresource &sub, CompTy VkCommandBuffer cmd = m_pDriver->GetNextCmd(); + if(cmd == VK_NULL_HANDLE) + return false; + vt->BeginCommandBuffer(Unwrap(cmd), &beginInfo); ImageBarrierSequence setupBarriers, cleanupBarriers; @@ -2860,6 +2886,9 @@ bool VulkanReplay::GetHistogram(ResourceId texid, const Subresource &sub, CompTy m_pDriver->FlushQ(); m_pDriver->SubmitAndFlushImageStateBarriers(cleanupBarriers); cmd = m_pDriver->GetNextCmd(); + + if(cmd == VK_NULL_HANDLE) + return false; vt->BeginCommandBuffer(Unwrap(cmd), &beginInfo); } @@ -3013,11 +3042,14 @@ void VulkanReplay::GetTextureData(ResourceId tex, const Subresource &sub, VkCommandBuffer cmd = m_pDriver->GetNextCmd(); const VkDevDispatchTable *vt = ObjDisp(dev); + if(cmd == VK_NULL_HANDLE) + return; + VkCommandBufferBeginInfo beginInfo = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, NULL, VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT}; VkResult vkr = vt->BeginCommandBuffer(Unwrap(cmd), &beginInfo); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); if(imInfo.samples > 1) { @@ -3103,10 +3135,13 @@ void VulkanReplay::GetTextureData(ResourceId tex, const Subresource &sub, }; vkr = vt->AllocateMemory(Unwrap(dev), &allocInfo, NULL, &tmpMemory); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); + + if(vkr != VK_SUCCESS) + return; vkr = vt->BindImageMemory(Unwrap(dev), tmpImage, tmpMemory, 0); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); tmpImageState.InlineTransition( cmd, m_pDriver->m_QueueFamilyIdx, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, 0, @@ -3221,7 +3256,7 @@ void VulkanReplay::GetTextureData(ResourceId tex, const Subresource &sub, }; vkr = vt->CreateImageView(Unwrap(dev), &viewInfo, NULL, &tmpView[i]); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); VkFramebufferCreateInfo fbinfo = { VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, @@ -3236,7 +3271,7 @@ void VulkanReplay::GetTextureData(ResourceId tex, const Subresource &sub, }; vkr = vt->CreateFramebuffer(Unwrap(dev), &fbinfo, NULL, &tmpFB[i]); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); VkClearValue clearval = {}; VkRenderPassBeginInfo rpbegin = { @@ -3261,10 +3296,10 @@ void VulkanReplay::GetTextureData(ResourceId tex, const Subresource &sub, viewInfo.format = GetViewCastedFormat(viewInfo.format, CompType::UInt); vkr = vt->CreateImageView(Unwrap(dev), &viewInfo, NULL, &tmpView[i + numFBs]); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); fbinfo.pAttachments = &tmpView[i + numFBs]; vkr = vt->CreateFramebuffer(Unwrap(dev), &fbinfo, NULL, &tmpFB[i + numFBs]); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); rpbegin.framebuffer = tmpFB[i + numFBs]; texDisplay.red = texDisplay.blue = texDisplay.alpha = false; @@ -3284,8 +3319,11 @@ void VulkanReplay::GetTextureData(ResourceId tex, const Subresource &sub, // fetch a new command buffer for copy & readback cmd = m_pDriver->GetNextCmd(); + if(cmd == VK_NULL_HANDLE) + return; + vkr = vt->BeginCommandBuffer(Unwrap(cmd), &beginInfo); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); tmpImageState.InlineTransition(cmd, m_pDriver->m_QueueFamilyIdx, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, @@ -3325,10 +3363,13 @@ void VulkanReplay::GetTextureData(ResourceId tex, const Subresource &sub, }; vkr = vt->AllocateMemory(Unwrap(dev), &allocInfo, NULL, &tmpMemory); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); + + if(vkr != VK_SUCCESS) + return; vkr = vt->BindImageMemory(Unwrap(dev), tmpImage, tmpMemory, 0); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); RDCASSERT(!isDepth && !isStencil); @@ -3364,7 +3405,7 @@ void VulkanReplay::GetTextureData(ResourceId tex, const Subresource &sub, { // ensure this resolve happens before handing back the source image to the original queue vkr = vt->EndCommandBuffer(Unwrap(cmd)); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); m_pDriver->SubmitCmds(); m_pDriver->FlushQ(); @@ -3374,8 +3415,11 @@ void VulkanReplay::GetTextureData(ResourceId tex, const Subresource &sub, // fetch a new command buffer for remaining work cmd = m_pDriver->GetNextCmd(); + if(cmd == VK_NULL_HANDLE) + return; + vkr = vt->BeginCommandBuffer(Unwrap(cmd), &beginInfo); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); } srcImageState = &tmpImageState; @@ -3416,10 +3460,13 @@ void VulkanReplay::GetTextureData(ResourceId tex, const Subresource &sub, }; vkr = vt->AllocateMemory(Unwrap(dev), &allocInfo, NULL, &tmpMemory); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); + + if(vkr != VK_SUCCESS) + return; vkr = vt->BindImageMemory(Unwrap(dev), tmpImage, tmpMemory, 0); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); tmpImageState.InlineTransition(cmd, m_pDriver->m_QueueFamilyIdx, VK_IMAGE_LAYOUT_GENERAL, 0, VK_ACCESS_SHADER_WRITE_BIT, m_pDriver->GetImageTransitionInfo()); @@ -3432,7 +3479,7 @@ void VulkanReplay::GetTextureData(ResourceId tex, const Subresource &sub, m_pDriver->SubmitAndFlushImageStateBarriers(setupBarriers); vkr = vt->EndCommandBuffer(Unwrap(cmd)); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); // expand multisamples out to array GetDebugManager()->CopyTex2DMSToArray(tmpImage, srcImage, imCreateInfo.extent, @@ -3442,8 +3489,11 @@ void VulkanReplay::GetTextureData(ResourceId tex, const Subresource &sub, // fetch a new command buffer for copy & readback cmd = m_pDriver->GetNextCmd(); + if(cmd == VK_NULL_HANDLE) + return; + vkr = vt->BeginCommandBuffer(Unwrap(cmd), &beginInfo); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); tmpImageState.InlineTransition(cmd, m_pDriver->m_QueueFamilyIdx, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, VK_ACCESS_SHADER_WRITE_BIT, @@ -3455,7 +3505,7 @@ void VulkanReplay::GetTextureData(ResourceId tex, const Subresource &sub, { // ensure this resolve happens before handing back the source image to the original queue vkr = vt->EndCommandBuffer(Unwrap(cmd)); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); m_pDriver->SubmitCmds(); m_pDriver->FlushQ(); @@ -3465,8 +3515,11 @@ void VulkanReplay::GetTextureData(ResourceId tex, const Subresource &sub, // fetch a new command buffer for remaining work cmd = m_pDriver->GetNextCmd(); + if(cmd == VK_NULL_HANDLE) + return; + vkr = vt->BeginCommandBuffer(Unwrap(cmd), &beginInfo); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); } srcImage = tmpImage; @@ -3550,7 +3603,7 @@ void VulkanReplay::GetTextureData(ResourceId tex, const Subresource &sub, VkBuffer readbackBuf = VK_NULL_HANDLE; vkr = vt->CreateBuffer(Unwrap(dev), &bufInfo, NULL, &readbackBuf); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); VkMemoryRequirements mrq = {0}; @@ -3563,10 +3616,13 @@ void VulkanReplay::GetTextureData(ResourceId tex, const Subresource &sub, VkDeviceMemory readbackMem = VK_NULL_HANDLE; vkr = vt->AllocateMemory(Unwrap(dev), &allocInfo, NULL, &readbackMem); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); + + if(vkr != VK_SUCCESS) + return; vkr = vt->BindBufferMemory(Unwrap(dev), readbackBuf, readbackMem, 0); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); if(isDepth && isStencil) { @@ -3611,7 +3667,7 @@ void VulkanReplay::GetTextureData(ResourceId tex, const Subresource &sub, { // ensure this resolve happens before handing back the source image to the original queue vkr = vt->EndCommandBuffer(Unwrap(cmd)); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); m_pDriver->SubmitCmds(); m_pDriver->FlushQ(); @@ -3621,8 +3677,11 @@ void VulkanReplay::GetTextureData(ResourceId tex, const Subresource &sub, // fetch a new command buffer for remaining work cmd = m_pDriver->GetNextCmd(); + if(cmd == VK_NULL_HANDLE) + return; + vkr = vt->BeginCommandBuffer(Unwrap(cmd), &beginInfo); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); } } @@ -3649,14 +3708,16 @@ void VulkanReplay::GetTextureData(ResourceId tex, const Subresource &sub, // map the buffer and copy to return buffer byte *pData = NULL; vkr = vt->MapMemory(Unwrap(dev), readbackMem, 0, VK_WHOLE_SIZE, 0, (void **)&pData); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); + if(vkr != VK_SUCCESS) + return; VkMappedMemoryRange range = { VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE, NULL, readbackMem, 0, VK_WHOLE_SIZE, }; vkr = vt->InvalidateMappedMemoryRanges(Unwrap(dev), 1, &range); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); RDCASSERT(pData != NULL); @@ -3948,7 +4009,7 @@ void VulkanReplay::BuildTargetShader(ShaderEncoding sourceEncoding, const bytebu VkShaderModule module; VkResult vkr = m_pDriver->vkCreateShaderModule(m_pDriver->GetDev(), &modinfo, NULL, &module); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); id = GetResID(module); } @@ -4088,7 +4149,7 @@ void VulkanReplay::RefreshDerivedReplacements() // create the new graphics pipeline VkResult vkr = m_pDriver->vkCreateGraphicsPipelines(dev, VK_NULL_HANDLE, 1, &pipeCreateInfo, NULL, &pipe); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); } else { @@ -4110,7 +4171,7 @@ void VulkanReplay::RefreshDerivedReplacements() // create the new compute pipeline VkResult vkr = m_pDriver->vkCreateComputePipelines(dev, VK_NULL_HANDLE, 1, &pipeCreateInfo, NULL, &pipe); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); } // remove the replacements diff --git a/renderdoc/driver/vulkan/vk_replay.h b/renderdoc/driver/vulkan/vk_replay.h index 884f02877..396d1b826 100644 --- a/renderdoc/driver/vulkan/vk_replay.h +++ b/renderdoc/driver/vulkan/vk_replay.h @@ -465,6 +465,7 @@ private: bool GetMinMax(ResourceId texid, const Subresource &sub, CompType typeCast, bool stencil, float *minval, float *maxval); + void CheckVkResult(VkResult vkr); VulkanDebugManager *GetDebugManager(); VulkanResourceManager *GetResourceManager(); diff --git a/renderdoc/driver/vulkan/vk_shader_cache.cpp b/renderdoc/driver/vulkan/vk_shader_cache.cpp index 1f0e1cf29..34eddb513 100644 --- a/renderdoc/driver/vulkan/vk_shader_cache.cpp +++ b/renderdoc/driver/vulkan/vk_shader_cache.cpp @@ -328,7 +328,7 @@ VulkanShaderCache::VulkanShaderCache(WrappedVulkan *driver) VkResult vkr = driver->vkCreateShaderModule( m_Device, &modinfo, NULL, &m_BuiltinShaderModules[i][baseType][textureType]); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + driver->CheckVkResult(vkr); driver->GetResourceManager()->SetInternalResource( GetResID(m_BuiltinShaderModules[i][baseType][textureType])); @@ -393,7 +393,7 @@ VulkanShaderCache::VulkanShaderCache(WrappedVulkan *driver) VkResult vkr = ObjDisp(m_Device)->CreatePipelineCache(Unwrap(m_Device), &createInfo, NULL, &m_PipelineCache); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + driver->CheckVkResult(vkr); if(vkr == VK_SUCCESS) { diff --git a/renderdoc/driver/vulkan/vk_shader_feedback.cpp b/renderdoc/driver/vulkan/vk_shader_feedback.cpp index a485339ee..71365f4b1 100644 --- a/renderdoc/driver/vulkan/vk_shader_feedback.cpp +++ b/renderdoc/driver/vulkan/vk_shader_feedback.cpp @@ -1515,7 +1515,7 @@ void VulkanReplay::FetchShaderFeedback(uint32_t eventId) }; vkr = m_pDriver->vkCreatePipelineLayout(dev, &pipeLayoutInfo, NULL, &pipeLayout); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); // we'll only use one, set both structs to keep things simple computeInfo.layout = pipeLayout; @@ -1578,7 +1578,7 @@ void VulkanReplay::FetchShaderFeedback(uint32_t eventId) moduleCreateInfo.codeSize = modSpirv.size() * sizeof(uint32_t); vkr = m_pDriver->vkCreateShaderModule(dev, &moduleCreateInfo, NULL, &modules[0]); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); stage.module = modules[0]; } @@ -1638,7 +1638,7 @@ void VulkanReplay::FetchShaderFeedback(uint32_t eventId) moduleCreateInfo.codeSize = modSpirv.size() * sizeof(uint32_t); vkr = m_pDriver->vkCreateShaderModule(dev, &moduleCreateInfo, NULL, &modules[i]); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); stage.module = modules[i]; } @@ -1650,13 +1650,13 @@ void VulkanReplay::FetchShaderFeedback(uint32_t eventId) { vkr = m_pDriver->vkCreateComputePipelines(m_Device, VK_NULL_HANDLE, 1, &computeInfo, NULL, &feedbackPipe); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); } else { vkr = m_pDriver->vkCreateGraphicsPipelines(m_Device, VK_NULL_HANDLE, 1, &graphicsInfo, NULL, &feedbackPipe); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); } // make copy of state to draw from @@ -1684,11 +1684,14 @@ void VulkanReplay::FetchShaderFeedback(uint32_t eventId) { VkCommandBuffer cmd = m_pDriver->GetNextCmd(); + if(cmd == VK_NULL_HANDLE) + return; + VkCommandBufferBeginInfo beginInfo = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, NULL, VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT}; vkr = ObjDisp(dev)->BeginCommandBuffer(Unwrap(cmd), &beginInfo); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); // fill destination buffer with 0s to ensure a baseline to then feedback against ObjDisp(dev)->CmdFillBuffer(Unwrap(cmd), Unwrap(m_BindlessFeedback.FeedbackBuffer.buf), 0, @@ -1726,7 +1729,7 @@ void VulkanReplay::FetchShaderFeedback(uint32_t eventId) } vkr = ObjDisp(dev)->EndCommandBuffer(Unwrap(cmd)); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); m_pDriver->SubmitCmds(); m_pDriver->FlushQ(); diff --git a/renderdoc/driver/vulkan/vk_shaderdebug.cpp b/renderdoc/driver/vulkan/vk_shaderdebug.cpp index 1002c1134..edadff502 100644 --- a/renderdoc/driver/vulkan/vk_shaderdebug.cpp +++ b/renderdoc/driver/vulkan/vk_shaderdebug.cpp @@ -699,7 +699,7 @@ public: } VkResult vkr = m_pDriver->vkCreateImageView(dev, &viewInfo, NULL, &sampleView); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + m_pDriver->CheckVkResult(vkr); m_SampleViews[GetResID(view)] = sampleView; } @@ -783,7 +783,7 @@ public: sampInfo.mipLodBias += bias; VkResult vkr = m_pDriver->vkCreateSampler(dev, &sampInfo, NULL, &sampler); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + m_pDriver->CheckVkResult(vkr); insertIt.first->second = sampler; } @@ -1248,11 +1248,14 @@ public: { VkCommandBuffer cmd = m_pDriver->GetNextCmd(); + if(cmd == VK_NULL_HANDLE) + return false; + VkCommandBufferBeginInfo beginInfo = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, NULL, VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT}; VkResult vkr = ObjDisp(cmd)->BeginCommandBuffer(Unwrap(cmd), &beginInfo); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + m_pDriver->CheckVkResult(vkr); VkClearValue clear = {}; @@ -1307,7 +1310,7 @@ public: DoPipelineBarrier(cmd, 1, &bufBarrier); vkr = ObjDisp(cmd)->EndCommandBuffer(Unwrap(cmd)); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + m_pDriver->CheckVkResult(vkr); m_pDriver->SubmitCmds(); m_pDriver->FlushQ(); @@ -1381,11 +1384,14 @@ public: { VkCommandBuffer cmd = m_pDriver->GetNextCmd(); + if(cmd == VK_NULL_HANDLE) + return false; + VkCommandBufferBeginInfo beginInfo = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, NULL, VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT}; VkResult vkr = ObjDisp(cmd)->BeginCommandBuffer(Unwrap(cmd), &beginInfo); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + m_pDriver->CheckVkResult(vkr); ObjDisp(cmd)->CmdBindPipeline(Unwrap(cmd), VK_PIPELINE_BIND_POINT_COMPUTE, Unwrap(m_DebugData.MathPipe[floatSizeIdx])); @@ -1437,7 +1443,7 @@ public: DoPipelineBarrier(cmd, 1, &bufBarrier); vkr = ObjDisp(cmd)->EndCommandBuffer(Unwrap(cmd)); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + m_pDriver->CheckVkResult(vkr); m_pDriver->SubmitCmds(); m_pDriver->FlushQ(); @@ -1735,7 +1741,7 @@ private: VkResult vkr = m_pDriver->vkCreateShaderModule(m_pDriver->GetDev(), &moduleCreateInfo, NULL, &m_DebugData.Module[shaderIndex]); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + m_pDriver->CheckVkResult(vkr); const char *filename[] = { "/debug_psgather_float.spv", "/debug_psgather_uint.spv", "/debug_psgather_sint.spv", @@ -4206,7 +4212,7 @@ ShaderDebugTrace *VulkanReplay::DebugPixel(uint32_t eventId, uint32_t x, uint32_ }; vkr = m_pDriver->vkCreatePipelineLayout(dev, &pipeLayoutInfo, NULL, &pipeLayout); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); graphicsInfo.layout = pipeLayout; @@ -4283,7 +4289,7 @@ ShaderDebugTrace *VulkanReplay::DebugPixel(uint32_t eventId, uint32_t x, uint32_ moduleCreateInfo.codeSize = fragspv.size() * sizeof(uint32_t); vkr = m_pDriver->vkCreateShaderModule(dev, &moduleCreateInfo, NULL, &stage.module); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); stage.pSpecializationInfo = &specInfo; @@ -4321,7 +4327,7 @@ ShaderDebugTrace *VulkanReplay::DebugPixel(uint32_t eventId, uint32_t x, uint32_ moduleCreateInfo.codeSize = spirv.size() * sizeof(uint32_t); vkr = m_pDriver->vkCreateShaderModule(dev, &moduleCreateInfo, NULL, &stage.module); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); modules.push_back(stage.module); } @@ -4334,7 +4340,7 @@ ShaderDebugTrace *VulkanReplay::DebugPixel(uint32_t eventId, uint32_t x, uint32_ VkPipeline inputsPipe; vkr = m_pDriver->vkCreateGraphicsPipelines(dev, VK_NULL_HANDLE, 1, &graphicsInfo, NULL, &inputsPipe); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); // make copy of state to draw from VulkanRenderState modifiedstate = state; @@ -4359,11 +4365,14 @@ ShaderDebugTrace *VulkanReplay::DebugPixel(uint32_t eventId, uint32_t x, uint32_ { VkCommandBuffer cmd = m_pDriver->GetNextCmd(); + if(cmd == VK_NULL_HANDLE) + return new ShaderDebugTrace; + VkCommandBufferBeginInfo beginInfo = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, NULL, VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT}; vkr = ObjDisp(dev)->BeginCommandBuffer(Unwrap(cmd), &beginInfo); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); // fill destination buffer with 0s to ensure a baseline to then feedback against ObjDisp(dev)->CmdFillBuffer(Unwrap(cmd), Unwrap(m_BindlessFeedback.FeedbackBuffer.buf), 0, @@ -4391,7 +4400,7 @@ ShaderDebugTrace *VulkanReplay::DebugPixel(uint32_t eventId, uint32_t x, uint32_ modifiedstate.EndRenderPass(cmd); vkr = ObjDisp(dev)->EndCommandBuffer(Unwrap(cmd)); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); m_pDriver->SubmitCmds(); m_pDriver->FlushQ(); diff --git a/renderdoc/driver/vulkan/vk_win32.cpp b/renderdoc/driver/vulkan/vk_win32.cpp index d1646e4d4..d8de4c2fb 100644 --- a/renderdoc/driver/vulkan/vk_win32.cpp +++ b/renderdoc/driver/vulkan/vk_win32.cpp @@ -50,7 +50,7 @@ void VulkanReplay::OutputWindow::CreateSurface(WrappedVulkan *driver, VkInstance (const char *)&dllLocator, (HMODULE *)&createInfo.hinstance); VkResult vkr = ObjDisp(inst)->CreateWin32SurfaceKHR(Unwrap(inst), &createInfo, NULL, &surface); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + driver->CheckVkResult(vkr); } void VulkanReplay::GetOutputWindowDimensions(uint64_t id, int32_t &w, int32_t &h) diff --git a/renderdoc/driver/vulkan/wrappers/vk_device_funcs.cpp b/renderdoc/driver/vulkan/wrappers/vk_device_funcs.cpp index 7d24dbc3c..fe15cdac3 100644 --- a/renderdoc/driver/vulkan/wrappers/vk_device_funcs.cpp +++ b/renderdoc/driver/vulkan/wrappers/vk_device_funcs.cpp @@ -507,7 +507,7 @@ ReplayStatus WrappedVulkan::Initialise(VkInitParams ¶ms, uint64_t sectionVer uint32_t count = 0; VkResult vkr = ObjDisp(m_Instance)->EnumeratePhysicalDevices(Unwrap(m_Instance), &count, NULL); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); if(count == 0) return ReplayStatus::APIHardwareUnsupported; @@ -518,7 +518,7 @@ ReplayStatus WrappedVulkan::Initialise(VkInitParams ¶ms, uint64_t sectionVer vkr = ObjDisp(m_Instance) ->EnumeratePhysicalDevices(Unwrap(m_Instance), &count, &m_ReplayPhysicalDevices[0]); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); for(uint32_t i = 0; i < count; i++) GetResourceManager()->WrapResource(m_Instance, m_ReplayPhysicalDevices[i]); @@ -850,7 +850,7 @@ void WrappedVulkan::Shutdown() if(m_Device) { VkResult vkr = ObjDisp(m_Device)->DeviceWaitIdle(Unwrap(m_Device)); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); } // destroy any events we created for waiting on @@ -1416,7 +1416,7 @@ VkResult WrappedVulkan::vkEnumeratePhysicalDevices(VkInstance instance, SERIALISE_TIME_CALL( vkr = ObjDisp(instance)->EnumeratePhysicalDevices(Unwrap(instance), &count, devices)); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); m_PhysicalDevices.resize(count); @@ -2875,13 +2875,13 @@ bool WrappedVulkan::Serialise_vkCreateDevice(SerialiserType &ser, VkPhysicalDevi VkResult vkr = ObjDisp(physicalDevice) ->EnumerateDeviceExtensionProperties(Unwrap(physicalDevice), NULL, &numExts, NULL); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); VkExtensionProperties *exts = new VkExtensionProperties[numExts]; vkr = ObjDisp(physicalDevice) ->EnumerateDeviceExtensionProperties(Unwrap(physicalDevice), NULL, &numExts, exts); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); for(uint32_t i = 0; i < numExts; i++) RDCLOG("Dev Ext %u: %s (%u)", i, exts[i].extensionName, exts[i].specVersion); @@ -3287,7 +3287,7 @@ bool WrappedVulkan::Serialise_vkCreateDevice(SerialiserType &ser, VkPhysicalDevi qFamilyIdx}; vkr = ObjDisp(device)->CreateCommandPool(Unwrap(device), &poolInfo, NULL, &m_InternalCmds.cmdpool); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); GetResourceManager()->WrapResource(Unwrap(device), m_InternalCmds.cmdpool); } @@ -3306,7 +3306,7 @@ bool WrappedVulkan::Serialise_vkCreateDevice(SerialiserType &ser, VkPhysicalDevi }; vkr = ObjDisp(device)->CreateCommandPool(Unwrap(device), &poolInfo, NULL, &m_ExternalQueues[qidx].pool); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); GetResourceManager()->WrapResource(Unwrap(device), m_ExternalQueues[qidx].pool); @@ -3326,7 +3326,7 @@ bool WrappedVulkan::Serialise_vkCreateDevice(SerialiserType &ser, VkPhysicalDevi { vkr = ObjDisp(device)->AllocateCommandBuffers(Unwrap(device), &cmdInfo, &m_ExternalQueues[qidx].ring[x].acquire); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); if(m_SetDeviceLoaderData) m_SetDeviceLoaderData(device, m_ExternalQueues[qidx].ring[x].acquire); @@ -3337,7 +3337,7 @@ bool WrappedVulkan::Serialise_vkCreateDevice(SerialiserType &ser, VkPhysicalDevi vkr = ObjDisp(device)->AllocateCommandBuffers(Unwrap(device), &cmdInfo, &m_ExternalQueues[qidx].ring[x].release); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); if(m_SetDeviceLoaderData) m_SetDeviceLoaderData(device, m_ExternalQueues[qidx].ring[x].release); @@ -3348,19 +3348,19 @@ bool WrappedVulkan::Serialise_vkCreateDevice(SerialiserType &ser, VkPhysicalDevi vkr = ObjDisp(device)->CreateSemaphore(Unwrap(device), &semInfo, NULL, &m_ExternalQueues[qidx].ring[x].fromext); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); GetResourceManager()->WrapResource(Unwrap(device), m_ExternalQueues[qidx].ring[x].fromext); vkr = ObjDisp(device)->CreateSemaphore(Unwrap(device), &semInfo, NULL, &m_ExternalQueues[qidx].ring[x].toext); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); GetResourceManager()->WrapResource(Unwrap(device), m_ExternalQueues[qidx].ring[x].toext); vkr = ObjDisp(device)->CreateFence(Unwrap(device), &fenceInfo, NULL, &m_ExternalQueues[qidx].ring[x].fence); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); GetResourceManager()->WrapResource(Unwrap(device), m_ExternalQueues[qidx].ring[x].fence); } @@ -3732,7 +3732,7 @@ VkResult WrappedVulkan::vkCreateDevice(VkPhysicalDevice physicalDevice, qFamilyIdx}; vkr = ObjDisp(device)->CreateCommandPool(Unwrap(device), &poolInfo, NULL, &m_InternalCmds.cmdpool); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); GetResourceManager()->WrapResource(Unwrap(device), m_InternalCmds.cmdpool); } @@ -3750,7 +3750,7 @@ VkResult WrappedVulkan::vkCreateDevice(VkPhysicalDevice physicalDevice, }; vkr = ObjDisp(device)->CreateCommandPool(Unwrap(device), &poolInfo, NULL, &m_ExternalQueues[qidx].pool); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); GetResourceManager()->WrapResource(Unwrap(device), m_ExternalQueues[qidx].pool); @@ -3770,7 +3770,7 @@ VkResult WrappedVulkan::vkCreateDevice(VkPhysicalDevice physicalDevice, { vkr = ObjDisp(device)->AllocateCommandBuffers(Unwrap(device), &cmdInfo, &m_ExternalQueues[qidx].ring[x].acquire); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); if(m_SetDeviceLoaderData) m_SetDeviceLoaderData(device, m_ExternalQueues[qidx].ring[x].acquire); @@ -3781,7 +3781,7 @@ VkResult WrappedVulkan::vkCreateDevice(VkPhysicalDevice physicalDevice, vkr = ObjDisp(device)->AllocateCommandBuffers(Unwrap(device), &cmdInfo, &m_ExternalQueues[qidx].ring[x].release); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); if(m_SetDeviceLoaderData) m_SetDeviceLoaderData(device, m_ExternalQueues[qidx].ring[x].release); @@ -3792,19 +3792,19 @@ VkResult WrappedVulkan::vkCreateDevice(VkPhysicalDevice physicalDevice, vkr = ObjDisp(device)->CreateSemaphore(Unwrap(device), &semInfo, NULL, &m_ExternalQueues[qidx].ring[x].fromext); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); GetResourceManager()->WrapResource(Unwrap(device), m_ExternalQueues[qidx].ring[x].fromext); vkr = ObjDisp(device)->CreateSemaphore(Unwrap(device), &semInfo, NULL, &m_ExternalQueues[qidx].ring[x].toext); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); GetResourceManager()->WrapResource(Unwrap(device), m_ExternalQueues[qidx].ring[x].toext); vkr = ObjDisp(device)->CreateFence(Unwrap(device), &fenceInfo, NULL, &m_ExternalQueues[qidx].ring[x].fence); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); GetResourceManager()->WrapResource(Unwrap(device), m_ExternalQueues[qidx].ring[x].fence); } @@ -3852,7 +3852,7 @@ void WrappedVulkan::vkDestroyDevice(VkDevice device, const VkAllocationCallbacks // idle the device as well so that external queues are idle. VkResult vkr = ObjDisp(m_Device)->DeviceWaitIdle(Unwrap(m_Device)); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); // MULTIDEVICE this function will need to check if the device is the one we // used for debugmanager/cmd pool etc, and only remove child queues and diff --git a/renderdoc/driver/vulkan/wrappers/vk_draw_funcs.cpp b/renderdoc/driver/vulkan/wrappers/vk_draw_funcs.cpp index 54b9633f7..47507dc14 100644 --- a/renderdoc/driver/vulkan/wrappers/vk_draw_funcs.cpp +++ b/renderdoc/driver/vulkan/wrappers/vk_draw_funcs.cpp @@ -68,7 +68,7 @@ VkIndirectPatchData WrappedVulkan::FetchIndirectData(VkIndirectPatchType type, VkResult vkr = ObjDisp(m_Device)->BindBufferMemory(Unwrap(m_Device), Unwrap(paramsbuf), Unwrap(alloc.mem), alloc.offs); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); VkBufferMemoryBarrier buf = { VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, diff --git a/renderdoc/driver/vulkan/wrappers/vk_misc_funcs.cpp b/renderdoc/driver/vulkan/wrappers/vk_misc_funcs.cpp index c00fb6b4b..afaaaf950 100644 --- a/renderdoc/driver/vulkan/wrappers/vk_misc_funcs.cpp +++ b/renderdoc/driver/vulkan/wrappers/vk_misc_funcs.cpp @@ -1453,7 +1453,7 @@ bool WrappedVulkan::Serialise_vkCreateQueryPool(SerialiserType &ser, VkDevice de VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT}; vkr = ObjDisp(cmd)->BeginCommandBuffer(Unwrap(cmd), &beginInfo); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); ObjDisp(cmd)->CmdResetQueryPool(Unwrap(cmd), Unwrap(pool), 0, CreateInfo.queryCount); @@ -1475,7 +1475,7 @@ bool WrappedVulkan::Serialise_vkCreateQueryPool(SerialiserType &ser, VkDevice de if(i > 0 && (i % (128 * 1024)) == 0) { vkr = ObjDisp(cmd)->EndCommandBuffer(Unwrap(cmd)); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); SubmitCmds(); FlushQ(); @@ -1483,12 +1483,12 @@ bool WrappedVulkan::Serialise_vkCreateQueryPool(SerialiserType &ser, VkDevice de cmd = GetNextCmd(); vkr = ObjDisp(cmd)->BeginCommandBuffer(Unwrap(cmd), &beginInfo); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); } } vkr = ObjDisp(cmd)->EndCommandBuffer(Unwrap(cmd)); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); } AddResource(QueryPool, ResourceType::Query, "Query Pool"); diff --git a/renderdoc/driver/vulkan/wrappers/vk_queue_funcs.cpp b/renderdoc/driver/vulkan/wrappers/vk_queue_funcs.cpp index 5b93ff64e..469b4c7f6 100644 --- a/renderdoc/driver/vulkan/wrappers/vk_queue_funcs.cpp +++ b/renderdoc/driver/vulkan/wrappers/vk_queue_funcs.cpp @@ -1257,6 +1257,9 @@ VkResult WrappedVulkan::vkQueueSubmit(VkQueue queue, uint32_t submitCount, { SCOPED_DBG_SINK(); + if(HasFatalError()) + return VK_ERROR_DEVICE_LOST; + if(!m_MarkedActive) { m_MarkedActive = true; @@ -1424,6 +1427,9 @@ VkResult WrappedVulkan::vkQueueSubmit2KHR(VkQueue queue, uint32_t submitCount, { SCOPED_DBG_SINK(); + if(HasFatalError()) + return VK_ERROR_DEVICE_LOST; + if(!m_MarkedActive) { m_MarkedActive = true; @@ -1640,6 +1646,9 @@ bool WrappedVulkan::Serialise_vkQueueBindSparse(SerialiserType &ser, VkQueue que VkResult WrappedVulkan::vkQueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo *pBindInfo, VkFence fence) { + if(HasFatalError()) + return VK_ERROR_DEVICE_LOST; + // need to allocate space for each bind batch size_t tempmemSize = sizeof(VkBindSparseInfo) * bindInfoCount; diff --git a/renderdoc/driver/vulkan/wrappers/vk_resource_funcs.cpp b/renderdoc/driver/vulkan/wrappers/vk_resource_funcs.cpp index cc2f0b30b..801dbe42a 100644 --- a/renderdoc/driver/vulkan/wrappers/vk_resource_funcs.cpp +++ b/renderdoc/driver/vulkan/wrappers/vk_resource_funcs.cpp @@ -441,7 +441,7 @@ VkResult WrappedVulkan::vkAllocateMemory(VkDevice device, const VkMemoryAllocate VkBuffer buf; VkResult vkr = ObjDisp(device)->CreateBuffer(Unwrap(device), &bufInfo, NULL, &buf); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); if(vkr == VK_SUCCESS && buf != VK_NULL_HANDLE) { @@ -686,6 +686,10 @@ VkResult WrappedVulkan::vkAllocateMemory(VkDevice device, const VkMemoryAllocate m_CreationInfo.m_Memory[id].wholeMemBuf = wholeMemBuf; } } + else + { + CheckVkResult(ret); + } return ret; } @@ -851,7 +855,10 @@ bool WrappedVulkan::Serialise_vkUnmapMemory(SerialiserType &ser, VkDevice device VkResult vkr = ObjDisp(device)->MapMemory(Unwrap(device), Unwrap(memory), MapOffset, MapSize, 0, (void **)&MapData); if(vkr != VK_SUCCESS) + { RDCERR("Error mapping memory on replay: %s", ToStr(vkr).c_str()); + return false; + } const Intervals &bindings = m_CreationInfo.m_Memory[GetResID(memory)].bindings; @@ -1340,6 +1347,8 @@ VkResult WrappedVulkan::vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkD SERIALISE_TIME_CALL(ret = ObjDisp(device)->BindBufferMemory(Unwrap(device), Unwrap(buffer), Unwrap(memory), memoryOffset)); + CheckVkResult(ret); + if(IsCaptureMode(m_State)) { Chunk *chunk = NULL; @@ -1458,6 +1467,8 @@ VkResult WrappedVulkan::vkBindImageMemory(VkDevice device, VkImage image, VkDevi SERIALISE_TIME_CALL(ret = ObjDisp(device)->BindImageMemory(Unwrap(device), Unwrap(image), Unwrap(mem), memOffset)); + CheckVkResult(ret); + if(IsCaptureMode(m_State)) { Chunk *chunk = NULL; @@ -1789,6 +1800,10 @@ VkResult WrappedVulkan::vkCreateBuffer(VkDevice device, const VkBufferCreateInfo m_CreationInfo.m_Buffer[id].Init(GetResourceManager(), m_CreationInfo, pCreateInfo); } } + else + { + CheckVkResult(ret); + } return ret; } @@ -2454,6 +2469,10 @@ VkResult WrappedVulkan::vkCreateImage(VkDevice device, const VkImageCreateInfo * if(isSparse) state->isMemoryBound = true; } + else + { + CheckVkResult(ret); + } return ret; } @@ -2651,6 +2670,8 @@ VkResult WrappedVulkan::vkBindBufferMemory2(VkDevice device, uint32_t bindInfoCo SERIALISE_TIME_CALL( ret = ObjDisp(device)->BindBufferMemory2(Unwrap(device), bindInfoCount, unwrapped)); + CheckVkResult(ret); + if(IsCaptureMode(m_State)) { for(uint32_t i = 0; i < bindInfoCount; i++) @@ -2780,6 +2801,8 @@ VkResult WrappedVulkan::vkBindImageMemory2(VkDevice device, uint32_t bindInfoCou SERIALISE_TIME_CALL( ret = ObjDisp(device)->BindImageMemory2(Unwrap(device), bindInfoCount, unwrapped)); + CheckVkResult(ret); + if(IsCaptureMode(m_State)) { for(uint32_t i = 0; i < bindInfoCount; i++) diff --git a/renderdoc/driver/vulkan/wrappers/vk_wsi_funcs.cpp b/renderdoc/driver/vulkan/wrappers/vk_wsi_funcs.cpp index 4ca02cb3f..8a05aa1bd 100644 --- a/renderdoc/driver/vulkan/wrappers/vk_wsi_funcs.cpp +++ b/renderdoc/driver/vulkan/wrappers/vk_wsi_funcs.cpp @@ -341,7 +341,7 @@ bool WrappedVulkan::Serialise_vkCreateSwapchainKHR(SerialiserType &ser, VkDevice vkr = ObjDisp(device)->GetSwapchainImagesKHR(Unwrap(device), Unwrap(*pSwapChain), &NumImages, NULL); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); } SERIALISE_ELEMENT(NumImages); @@ -394,7 +394,7 @@ bool WrappedVulkan::Serialise_vkCreateSwapchainKHR(SerialiserType &ser, VkDevice VkImage im = VK_NULL_HANDLE; VkResult vkr = ObjDisp(device)->CreateImage(Unwrap(device), &imInfo, NULL, &im); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); ResourceId liveId = GetResourceManager()->WrapResource(Unwrap(device), im); @@ -408,14 +408,17 @@ bool WrappedVulkan::Serialise_vkCreateSwapchainKHR(SerialiserType &ser, VkDevice }; vkr = ObjDisp(device)->AllocateMemory(Unwrap(device), &allocInfo, NULL, &mem); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); + + if(vkr != VK_SUCCESS) + return false; ResourceId memid = GetResourceManager()->WrapResource(Unwrap(device), mem); // register as a live-only resource, so it is cleaned up properly GetResourceManager()->AddLiveResource(memid, mem); vkr = ObjDisp(device)->BindImageMemory(Unwrap(device), Unwrap(im), Unwrap(mem), 0); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); // image live ID will be assigned separately in Serialise_vkGetSwapChainInfoWSI // memory doesn't have a live ID @@ -533,7 +536,7 @@ void WrappedVulkan::WrapAndProcessCreatedSwapchain(VkDevice device, }; vkr = vt->CreateRenderPass(Unwrap(device), &rpinfo, NULL, &swapInfo.rp); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); GetResourceManager()->WrapResource(Unwrap(device), swapInfo.rp); GetResourceManager()->SetInternalResource(GetResID(swapInfo.rp)); @@ -543,7 +546,7 @@ void WrappedVulkan::WrapAndProcessCreatedSwapchain(VkDevice device, { uint32_t numSwapImages; vkr = vt->GetSwapchainImagesKHR(Unwrap(device), Unwrap(*pSwapChain), &numSwapImages, NULL); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); swapInfo.lastPresent.imageIndex = 0; swapInfo.lastPresent.presentQueue = VK_NULL_HANDLE; @@ -561,7 +564,7 @@ void WrappedVulkan::WrapAndProcessCreatedSwapchain(VkDevice device, // go through our own function so we assign these images IDs vkr = vkGetSwapchainImagesKHR(device, *pSwapChain, &numSwapImages, images); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); for(uint32_t i = 0; i < numSwapImages; i++) { @@ -594,7 +597,7 @@ void WrappedVulkan::WrapAndProcessCreatedSwapchain(VkDevice device, VK_FENCE_CREATE_SIGNALED_BIT}; vkr = ObjDisp(device)->CreateFence(Unwrap(device), &fenceInfo, NULL, &swapImInfo.fence); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); GetResourceManager()->WrapResource(Unwrap(device), swapImInfo.fence); GetResourceManager()->SetInternalResource(GetResID(swapImInfo.fence)); @@ -605,7 +608,7 @@ void WrappedVulkan::WrapAndProcessCreatedSwapchain(VkDevice device, vkr = ObjDisp(device)->CreateSemaphore(Unwrap(device), &semInfo, NULL, &swapImInfo.overlaydone); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); GetResourceManager()->WrapResource(Unwrap(device), swapImInfo.overlaydone); GetResourceManager()->SetInternalResource(GetResID(swapImInfo.overlaydone)); @@ -625,7 +628,7 @@ void WrappedVulkan::WrapAndProcessCreatedSwapchain(VkDevice device, }; vkr = vt->CreateImageView(Unwrap(device), &info, NULL, &swapImInfo.view); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); GetResourceManager()->WrapResource(Unwrap(device), swapImInfo.view); GetResourceManager()->SetInternalResource(GetResID(swapImInfo.view)); @@ -643,7 +646,7 @@ void WrappedVulkan::WrapAndProcessCreatedSwapchain(VkDevice device, }; vkr = vt->CreateFramebuffer(Unwrap(device), &fbinfo, NULL, &swapImInfo.fb); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); GetResourceManager()->WrapResource(Unwrap(device), swapImInfo.fb); GetResourceManager()->SetInternalResource(GetResID(swapImInfo.fb)); @@ -826,7 +829,7 @@ VkResult WrappedVulkan::vkQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR // If this ring has never been used the fence is signalled on creation. // this should generally be a no-op because we only get here when we've acquired the image VkResult vkr = vt->WaitForFences(Unwrap(m_Device), 1, UnwrapPtr(imfence), VK_TRUE, 50000000); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); vkr = vt->ResetFences(Unwrap(m_Device), 1, UnwrapPtr(imfence)); @@ -836,7 +839,7 @@ VkResult WrappedVulkan::vkQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT}; vkr = vt->BeginCommandBuffer(Unwrap(cmd), &beginInfo); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); VkImageMemoryBarrier bbBarrier = { VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, @@ -888,12 +891,12 @@ VkResult WrappedVulkan::vkQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR // wait for this queue ring to be free, but with a reasonably aggressive timeout (50ms). If // this ring has never been used the fence is signalled on creation vkr = vt->WaitForFences(Unwrap(m_Device), 1, UnwrapPtr(fence), VK_TRUE, 50000000); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); vkr = vt->ResetFences(Unwrap(m_Device), 1, UnwrapPtr(fence)); vkr = vt->BeginCommandBuffer(Unwrap(extQCmd), &beginInfo); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); DoPipelineBarrier(extQCmd, 1, &bbBarrier); @@ -913,7 +916,7 @@ VkResult WrappedVulkan::vkQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR UnwrapPtr(m_ExternalQueues[swapQueueIndex].ring[ringIdx].fromext); vkr = ObjDisp(q)->QueueSubmit(Unwrap(q), 1, &submitInfo, VK_NULL_HANDLE); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); // next submit needs to wait on fromext unwrappedSems.assign(submitInfo.pSignalSemaphores, 1); @@ -954,7 +957,7 @@ VkResult WrappedVulkan::vkQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR submitInfo.pCommandBuffers = UnwrapPtr(cmd); vkr = ObjDisp(m_Queue)->QueueSubmit(Unwrap(m_Queue), 1, &submitInfo, Unwrap(imfence)); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); } if(swapQueueIndex != m_QueueFamilyIdx && !swapInfo.concurrent) @@ -963,7 +966,7 @@ VkResult WrappedVulkan::vkQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR VkFence fence = m_ExternalQueues[swapQueueIndex].ring[ringIdx].fence; vkr = vt->BeginCommandBuffer(Unwrap(extQCmd), &beginInfo); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); DoPipelineBarrier(extQCmd, 1, &bbBarrier); @@ -990,7 +993,7 @@ VkResult WrappedVulkan::vkQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR // submit and signal the fence when we're done, so we know next time around that this is // safe to re-use vkr = ObjDisp(q)->QueueSubmit(Unwrap(q), 1, &submitInfo, Unwrap(fence)); - RDCASSERTEQUAL(vkr, VK_SUCCESS); + CheckVkResult(vkr); } // the present waits on our new semaphore diff --git a/renderdoc/replay/replay_output.cpp b/renderdoc/replay/replay_output.cpp index e10fa3eef..d8b4ed345 100644 --- a/renderdoc/replay/replay_output.cpp +++ b/renderdoc/replay/replay_output.cpp @@ -608,6 +608,8 @@ void ReplayOutput::Display() if(m_pDevice->CheckResizeOutputWindow(m_Thumbnails[i].outputID)) m_Thumbnails[i].dirty = true; + m_pController->FatalErrorCheck(); + if(m_MainOutput.dirty) { m_MainOutput.dirty = false;