From ef2804bfd30898816409f9a6541a1448969cafb5 Mon Sep 17 00:00:00 2001 From: Aliya Pazylbekova Date: Mon, 27 Jan 2020 18:45:54 -0500 Subject: [PATCH] Refactor: Rendering state per command buffer This is needed for Vulkan Pixel history, where we need to know render state at current point of time for a command buffer during callback replay. Modifications: - Removed m_pDriver and m_CreationInfo members from VulkanRenderState, instead these are accepted as arguments to member functions. - BakedCmdBufferInfo state is now full VulkanRenderState --- .../driver/vulkan/vk_bindless_feedback.cpp | 4 +- renderdoc/driver/vulkan/vk_core.cpp | 67 ++- renderdoc/driver/vulkan/vk_core.h | 32 +- renderdoc/driver/vulkan/vk_debug.cpp | 51 +- renderdoc/driver/vulkan/vk_debug.h | 9 +- renderdoc/driver/vulkan/vk_overlay.cpp | 48 +- renderdoc/driver/vulkan/vk_pixelhistory.cpp | 62 ++- renderdoc/driver/vulkan/vk_postvs.cpp | 30 +- renderdoc/driver/vulkan/vk_replay.h | 6 +- renderdoc/driver/vulkan/vk_state.cpp | 121 ++--- renderdoc/driver/vulkan/vk_state.h | 31 +- .../driver/vulkan/wrappers/vk_cmd_funcs.cpp | 446 +++++++++--------- .../driver/vulkan/wrappers/vk_draw_funcs.cpp | 21 +- .../vulkan/wrappers/vk_dynamic_funcs.cpp | 83 ++-- 14 files changed, 529 insertions(+), 482 deletions(-) diff --git a/renderdoc/driver/vulkan/vk_bindless_feedback.cpp b/renderdoc/driver/vulkan/vk_bindless_feedback.cpp index 9e8e1b127..485e56c10 100644 --- a/renderdoc/driver/vulkan/vk_bindless_feedback.cpp +++ b/renderdoc/driver/vulkan/vk_bindless_feedback.cpp @@ -820,14 +820,14 @@ void VulkanReplay::FetchShaderFeedback(uint32_t eventId) if(result.compute) { - modifiedstate.BindPipeline(cmd, VulkanRenderState::BindCompute, true); + modifiedstate.BindPipeline(m_pDriver, cmd, VulkanRenderState::BindCompute, true); ObjDisp(cmd)->CmdDispatch(Unwrap(cmd), drawcall->dispatchDimension[0], drawcall->dispatchDimension[1], drawcall->dispatchDimension[2]); } else { - modifiedstate.BeginRenderPassAndApplyState(cmd, VulkanRenderState::BindGraphics); + modifiedstate.BeginRenderPassAndApplyState(m_pDriver, cmd, VulkanRenderState::BindGraphics); if(drawcall->flags & DrawFlags::Indexed) { diff --git a/renderdoc/driver/vulkan/vk_core.cpp b/renderdoc/driver/vulkan/vk_core.cpp index ec04882e4..186dddba0 100644 --- a/renderdoc/driver/vulkan/vk_core.cpp +++ b/renderdoc/driver/vulkan/vk_core.cpp @@ -93,7 +93,7 @@ void VkInitParams::Set(const VkInstanceCreateInfo *pCreateInfo, ResourceId inst) InstanceID = inst; } -WrappedVulkan::WrappedVulkan() : m_RenderState(this, &m_CreationInfo) +WrappedVulkan::WrappedVulkan() { if(RenderDoc::Inst().GetCrashHandler()) RenderDoc::Inst().GetCrashHandler()->RegisterMemoryRegion(this, sizeof(WrappedVulkan)); @@ -2492,6 +2492,11 @@ ReplayStatus WrappedVulkan::ContextReplayLog(CaptureState readType, uint32_t sta if(!partial && !IsStructuredExporting(m_State)) AddFrameTerminator(AMDRGPControl::GetEndTag()); + if(m_Partial[Secondary].partialParent != ResourceId()) + m_RenderState = m_BakedCmdBufferInfo[m_Partial[Primary].partialParent].state; + else if(m_Partial[Primary].partialParent != ResourceId()) + m_RenderState = m_BakedCmdBufferInfo[m_Partial[Primary].partialParent].state; + // swap the structure back now that we've accumulated the frame as well. if(IsLoading(m_State) || IsStructuredExporting(m_State)) ser.GetStructuredFile().Swap(*prevFile); @@ -3139,7 +3144,16 @@ void WrappedVulkan::ReplayLog(uint32_t startEventID, uint32_t endEventID, Replay { m_Partial[Primary].Reset(); m_Partial[Secondary].Reset(); - m_RenderState = VulkanRenderState(this, &m_CreationInfo); + m_RenderState = VulkanRenderState(); + for(auto it = m_BakedCmdBufferInfo.begin(); it != m_BakedCmdBufferInfo.end(); it++) + it->second.state = VulkanRenderState(); + } + else + { + if(m_Partial[Secondary].partialParent != ResourceId()) + m_BakedCmdBufferInfo[m_Partial[Primary].partialParent].state = m_RenderState; + else if(m_Partial[Primary].partialParent != ResourceId()) + m_BakedCmdBufferInfo[m_Partial[Primary].partialParent].state = m_RenderState; } VkResult vkr = VK_SUCCESS; @@ -3187,13 +3201,13 @@ void WrappedVulkan::ReplayLog(uint32_t startEventID, uint32_t endEventID, Replay // if a render pass was active, begin it and set up the partial replay state m_RenderState.BeginRenderPassAndApplyState( - cmd, rpUnneeded ? VulkanRenderState::BindNone : VulkanRenderState::BindGraphics); + this, cmd, rpUnneeded ? VulkanRenderState::BindNone : VulkanRenderState::BindGraphics); } else { // even outside of render passes, we need to restore the state - m_RenderState.BindPipeline(cmd, VulkanRenderState::BindCompute, false); - m_RenderState.BindPipeline(cmd, VulkanRenderState::BindGraphics, false); + m_RenderState.BindPipeline(this, cmd, VulkanRenderState::BindCompute, false); + m_RenderState.BindPipeline(this, cmd, VulkanRenderState::BindGraphics, false); } } @@ -3216,7 +3230,7 @@ void WrappedVulkan::ReplayLog(uint32_t startEventID, uint32_t endEventID, Replay // end any active XFB if(!m_RenderState.xfbcounters.empty()) - m_RenderState.EndTransformFeedback(cmd); + m_RenderState.EndTransformFeedback(this, cmd); // end any active conditional rendering if(m_RenderState.IsConditionalRenderingEnabled()) @@ -3662,20 +3676,21 @@ void WrappedVulkan::AddDrawcall(const DrawcallDescription &d, bool hasEvents) if(m_LastCmdBufferID != ResourceId()) { - ResourceId pipe = m_BakedCmdBufferInfo[m_LastCmdBufferID].state.pipeline; + ResourceId pipe = m_BakedCmdBufferInfo[m_LastCmdBufferID].state.graphics.pipeline; if(pipe != ResourceId()) draw.topology = MakePrimitiveTopology(m_CreationInfo.m_Pipeline[pipe].topology, m_CreationInfo.m_Pipeline[pipe].patchControlPoints); - draw.indexByteWidth = m_BakedCmdBufferInfo[m_LastCmdBufferID].state.idxWidth; + draw.indexByteWidth = m_BakedCmdBufferInfo[m_LastCmdBufferID].state.ibuffer.bytewidth; - ResourceId fb = m_BakedCmdBufferInfo[m_LastCmdBufferID].state.framebuffer; + ResourceId fb = m_BakedCmdBufferInfo[m_LastCmdBufferID].state.GetFramebuffer(); ResourceId rp = m_BakedCmdBufferInfo[m_LastCmdBufferID].state.renderPass; uint32_t sp = m_BakedCmdBufferInfo[m_LastCmdBufferID].state.subpass; if(fb != ResourceId() && rp != ResourceId()) { - rdcarray &atts = m_BakedCmdBufferInfo[m_LastCmdBufferID].state.fbattachments; + const rdcarray &atts = + m_BakedCmdBufferInfo[m_LastCmdBufferID].state.GetFramebufferAttachments(); RDCASSERT(sp < m_CreationInfo.m_RenderPass[rp].subpasses.size()); @@ -3747,7 +3762,7 @@ void WrappedVulkan::AddUsage(VulkanDrawcallTreeNode &drawNode, rdcarrayGetOriginalID(state.pipeline); + ResourceId origPipe = GetResourceManager()->GetOriginalID(pipe); ResourceId origShad = GetResourceManager()->GetOriginalID(sh.module); // 5 is the compute shader's index (VS, TCS, TES, GS, FS, CS) - const rdcarray &descSets = - (shad == 5 ? state.computeDescSets : state.graphicsDescSets); + const rdcarray &descSets = + (compute ? state.compute.descSets : state.graphics.descSets); RDCASSERT(sh.mapping); @@ -3923,8 +3940,8 @@ void WrappedVulkan::AddUsage(VulkanDrawcallTreeNode &drawNode, rdcarray> resourceUsage; - struct CmdBufferState - { - ResourceId pipeline; - - struct DescriptorAndOffsets - { - ResourceId descSet; - rdcarray offsets; - }; - rdcarray graphicsDescSets, computeDescSets; - - uint32_t idxWidth = 0; - ResourceId ibuffer; - rdcarray vbuffers; - rdcarray xfbbuffers; - uint32_t xfbfirst = 0; - uint32_t xfbcount = 0; - - ResourceId renderPass; - ResourceId framebuffer; - rdcarray fbattachments; - uint32_t subpass = 0; - } state; + VulkanRenderState state; std::map imageStates; @@ -941,6 +919,14 @@ public: return record ? *record->instDevInfo : m_EnabledExtensions; } + VulkanRenderState &GetCmdRenderState() + { + RDCASSERT(m_LastCmdBufferID != ResourceId()); + auto it = m_BakedCmdBufferInfo.find(m_LastCmdBufferID); + RDCASSERT(it != m_BakedCmdBufferInfo.end()); + return it->second.state; + } + static rdcstr GetChunkName(uint32_t idx); VulkanResourceManager *GetResourceManager() { return m_ResourceManager; } VulkanDebugManager *GetDebugManager() { return m_DebugManager; } diff --git a/renderdoc/driver/vulkan/vk_debug.cpp b/renderdoc/driver/vulkan/vk_debug.cpp index 106b5ddd8..885e6c1a8 100644 --- a/renderdoc/driver/vulkan/vk_debug.cpp +++ b/renderdoc/driver/vulkan/vk_debug.cpp @@ -1473,13 +1473,62 @@ uint32_t VulkanReplay::PickVertex(uint32_t eventId, int32_t w, int32_t h, const return ret; } -const VulkanCreationInfo::Image &VulkanDebugManager::GetImageInfo(ResourceId img) +const VulkanCreationInfo::Image &VulkanDebugManager::GetImageInfo(ResourceId img) const { auto it = m_pDriver->m_CreationInfo.m_Image.find(img); RDCASSERT(it != m_pDriver->m_CreationInfo.m_Image.end()); return it->second; } +const VulkanCreationInfo::Pipeline &VulkanDebugManager::GetPipelineInfo(ResourceId pipe) const +{ + auto it = m_pDriver->m_CreationInfo.m_Pipeline.find(pipe); + RDCASSERT(it != m_pDriver->m_CreationInfo.m_Pipeline.end()); + return it->second; +} + +const VulkanCreationInfo::ShaderModule &VulkanDebugManager::GetShaderInfo(ResourceId shader) const +{ + auto it = m_pDriver->m_CreationInfo.m_ShaderModule.find(shader); + RDCASSERT(it != m_pDriver->m_CreationInfo.m_ShaderModule.end()); + return it->second; +} + +const VulkanCreationInfo::Framebuffer &VulkanDebugManager::GetFramebufferInfo(ResourceId fb) const +{ + auto it = m_pDriver->m_CreationInfo.m_Framebuffer.find(fb); + RDCASSERT(it != m_pDriver->m_CreationInfo.m_Framebuffer.end()); + return it->second; +} + +const VulkanCreationInfo::RenderPass &VulkanDebugManager::GetRenderPassInfo(ResourceId rp) const +{ + auto it = m_pDriver->m_CreationInfo.m_RenderPass.find(rp); + RDCASSERT(it != m_pDriver->m_CreationInfo.m_RenderPass.end()); + return it->second; +} + +const VulkanCreationInfo::PipelineLayout &VulkanDebugManager::GetPipelineLayoutInfo(ResourceId rp) const +{ + auto it = m_pDriver->m_CreationInfo.m_PipelineLayout.find(rp); + RDCASSERT(it != m_pDriver->m_CreationInfo.m_PipelineLayout.end()); + return it->second; +} + +const DescSetLayout &VulkanDebugManager::GetDescSetLayout(ResourceId dsl) const +{ + auto it = m_pDriver->m_CreationInfo.m_DescSetLayout.find(dsl); + RDCASSERT(it != m_pDriver->m_CreationInfo.m_DescSetLayout.end()); + return it->second; +} + +const WrappedVulkan::DescriptorSetInfo &VulkanDebugManager::GetDescSetInfo(ResourceId ds) const +{ + auto it = m_pDriver->m_DescriptorSetState.find(ds); + RDCASSERT(it != m_pDriver->m_DescriptorSetState.end()); + return it->second; +} + void VulkanDebugManager::GetBufferData(ResourceId buff, uint64_t offset, uint64_t len, bytebuf &ret) { VkDevice dev = m_pDriver->GetDev(); diff --git a/renderdoc/driver/vulkan/vk_debug.h b/renderdoc/driver/vulkan/vk_debug.h index b55ace5fb..1dc375063 100644 --- a/renderdoc/driver/vulkan/vk_debug.h +++ b/renderdoc/driver/vulkan/vk_debug.h @@ -89,7 +89,14 @@ public: VkImageLayout GetImageLayout(ResourceId image, VkImageAspectFlagBits aspect, uint32_t mip, uint32_t slice); - const VulkanCreationInfo::Image &GetImageInfo(ResourceId img); + const VulkanCreationInfo::Image &GetImageInfo(ResourceId img) const; + const VulkanCreationInfo::Pipeline &GetPipelineInfo(ResourceId pipe) const; + const VulkanCreationInfo::ShaderModule &GetShaderInfo(ResourceId shader) const; + const VulkanCreationInfo::Framebuffer &GetFramebufferInfo(ResourceId fb) const; + const VulkanCreationInfo::RenderPass &GetRenderPassInfo(ResourceId rp) const; + const VulkanCreationInfo::PipelineLayout &GetPipelineLayoutInfo(ResourceId pp) const; + const DescSetLayout &GetDescSetLayout(ResourceId dsl) const; + const WrappedVulkan::DescriptorSetInfo &GetDescSetInfo(ResourceId ds) const; private: // GetBufferData diff --git a/renderdoc/driver/vulkan/vk_overlay.cpp b/renderdoc/driver/vulkan/vk_overlay.cpp index c51993cba..bcf487336 100644 --- a/renderdoc/driver/vulkan/vk_overlay.cpp +++ b/renderdoc/driver/vulkan/vk_overlay.cpp @@ -43,11 +43,7 @@ struct VulkanQuadOverdrawCallback : public VulkanDrawcallCallback { VulkanQuadOverdrawCallback(WrappedVulkan *vk, VkDescriptorSetLayout descSetLayout, VkDescriptorSet descSet, const rdcarray &events) - : m_pDriver(vk), - m_DescSetLayout(descSetLayout), - m_DescSet(descSet), - m_Events(events), - m_PrevState(vk, NULL) + : m_pDriver(vk), m_DescSetLayout(descSetLayout), m_DescSet(descSet), m_Events(events) { m_pDriver->SetDrawcallCB(this); } @@ -63,8 +59,8 @@ struct VulkanQuadOverdrawCallback : public VulkanDrawcallCallback VkResult vkr = VK_SUCCESS; - m_PrevState = m_pDriver->GetRenderState(); - VulkanRenderState &pipestate = m_pDriver->GetRenderState(); + m_PrevState = m_pDriver->GetCmdRenderState(); + VulkanRenderState &pipestate = m_pDriver->GetCmdRenderState(); // check cache first CachedPipeline pipe = m_PipelineCache[pipestate.graphics.pipeline]; @@ -72,25 +68,26 @@ struct VulkanQuadOverdrawCallback : public VulkanDrawcallCallback // if we don't get a hit, create a modified pipeline if(pipe.pipe == VK_NULL_HANDLE) { - VulkanCreationInfo &c = *pipestate.m_CreationInfo; - - VulkanCreationInfo::Pipeline &p = c.m_Pipeline[pipestate.graphics.pipeline]; + const VulkanCreationInfo::Pipeline &p = + m_pDriver->GetDebugManager()->GetPipelineInfo(pipestate.graphics.pipeline); VkDescriptorSetLayout *descSetLayouts; // descSet will be the index of our new descriptor set - uint32_t descSet = (uint32_t)c.m_PipelineLayout[p.layout].descSetLayouts.size(); + uint32_t descSet = + (uint32_t)m_pDriver->GetDebugManager()->GetPipelineLayoutInfo(p.layout).descSetLayouts.size(); descSetLayouts = new VkDescriptorSetLayout[descSet + 1]; for(uint32_t i = 0; i < descSet; i++) descSetLayouts[i] = m_pDriver->GetResourceManager()->GetCurrentHandle( - c.m_PipelineLayout[p.layout].descSetLayouts[i]); + m_pDriver->GetDebugManager()->GetPipelineLayoutInfo(p.layout).descSetLayouts[i]); // this layout has storage image and descSetLayouts[descSet] = m_DescSetLayout; - const rdcarray &push = c.m_PipelineLayout[p.layout].pushRanges; + const rdcarray &push = + m_pDriver->GetDebugManager()->GetPipelineLayoutInfo(p.layout).pushRanges; VkPipelineLayoutCreateInfo pipeLayoutInfo = { VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, @@ -222,7 +219,7 @@ struct VulkanQuadOverdrawCallback : public VulkanDrawcallCallback pipestate.graphics.descSets[pipe.descSet].descSet = GetResID(m_DescSet); if(cmd) - pipestate.BindPipeline(cmd, VulkanRenderState::BindGraphics, false); + pipestate.BindPipeline(m_pDriver, cmd, VulkanRenderState::BindGraphics, false); } bool PostDraw(uint32_t eid, VkCommandBuffer cmd) @@ -231,10 +228,11 @@ struct VulkanQuadOverdrawCallback : public VulkanDrawcallCallback return false; // restore the render state and go ahead with the real draw - m_pDriver->GetRenderState() = m_PrevState; + m_pDriver->GetCmdRenderState() = m_PrevState; RDCASSERT(cmd); - m_pDriver->GetRenderState().BindPipeline(cmd, VulkanRenderState::BindGraphics, false); + m_pDriver->GetCmdRenderState().BindPipeline(m_pDriver, cmd, VulkanRenderState::BindGraphics, + false); return true; } @@ -838,7 +836,7 @@ ResourceId VulkanReplay::RenderOverlay(ResourceId texid, CompType typeCast, Floa // modify state m_pDriver->m_RenderState.renderPass = GetResID(m_Overlay.NoDepthRP); m_pDriver->m_RenderState.subpass = 0; - m_pDriver->m_RenderState.SetFramebuffer(GetResID(m_Overlay.NoDepthFB)); + m_pDriver->m_RenderState.SetFramebuffer(m_pDriver, GetResID(m_Overlay.NoDepthFB)); m_pDriver->m_RenderState.graphics.pipeline = GetResID(pipe); @@ -871,7 +869,8 @@ ResourceId VulkanReplay::RenderOverlay(ResourceId texid, CompType typeCast, Floa RDCASSERTEQUAL(vkr, VK_SUCCESS); // do single draw - m_pDriver->m_RenderState.BeginRenderPassAndApplyState(cmd, VulkanRenderState::BindGraphics); + m_pDriver->m_RenderState.BeginRenderPassAndApplyState(m_pDriver, cmd, + VulkanRenderState::BindGraphics); ObjDisp(cmd)->CmdDrawIndexed(Unwrap(cmd), patchedIndexCount, mainDraw->numInstances, 0, 0, mainDraw->instanceOffset); m_pDriver->m_RenderState.EndRenderPass(cmd); @@ -1179,7 +1178,7 @@ ResourceId VulkanReplay::RenderOverlay(ResourceId texid, CompType typeCast, Floa // modify state m_pDriver->m_RenderState.renderPass = GetResID(m_Overlay.NoDepthRP); m_pDriver->m_RenderState.subpass = 0; - m_pDriver->m_RenderState.SetFramebuffer(GetResID(m_Overlay.NoDepthFB)); + m_pDriver->m_RenderState.SetFramebuffer(m_pDriver, GetResID(m_Overlay.NoDepthFB)); m_pDriver->m_RenderState.graphics.pipeline = GetResID(pipe[0]); @@ -1472,7 +1471,7 @@ ResourceId VulkanReplay::RenderOverlay(ResourceId texid, CompType typeCast, Floa // modify state m_pDriver->m_RenderState.renderPass = GetResID(m_Overlay.NoDepthRP); m_pDriver->m_RenderState.subpass = 0; - m_pDriver->m_RenderState.SetFramebuffer(GetResID(m_Overlay.NoDepthFB)); + m_pDriver->m_RenderState.SetFramebuffer(m_pDriver, GetResID(m_Overlay.NoDepthFB)); m_pDriver->m_RenderState.graphics.pipeline = GetResID(failpipe); @@ -1494,7 +1493,7 @@ ResourceId VulkanReplay::RenderOverlay(ResourceId texid, CompType typeCast, Floa if(depthRP != VK_NULL_HANDLE) { m_pDriver->m_RenderState.renderPass = GetResID(depthRP); - m_pDriver->m_RenderState.SetFramebuffer(GetResID(depthFB)); + m_pDriver->m_RenderState.SetFramebuffer(m_pDriver, GetResID(depthFB)); } m_pDriver->ReplayLog(0, eventId, eReplay_OnlyDraw); @@ -1598,7 +1597,8 @@ ResourceId VulkanReplay::RenderOverlay(ResourceId texid, CompType typeCast, Floa vkr = vt->BeginCommandBuffer(Unwrap(cmd), &beginInfo); RDCASSERTEQUAL(vkr, VK_SUCCESS); - m_pDriver->m_RenderState.BeginRenderPassAndApplyState(cmd, VulkanRenderState::BindGraphics); + m_pDriver->m_RenderState.BeginRenderPassAndApplyState(m_pDriver, cmd, + VulkanRenderState::BindGraphics); VkClearAttachment clearatt = {VK_IMAGE_ASPECT_COLOR_BIT, 0, {}}; memcpy(clearatt.clearValue.color.float32, &clearCol, sizeof(clearatt.clearValue.color.float32)); @@ -1653,11 +1653,11 @@ ResourceId VulkanReplay::RenderOverlay(ResourceId texid, CompType typeCast, Floa vkr = vt->EndCommandBuffer(Unwrap(cmd)); RDCASSERTEQUAL(vkr, VK_SUCCESS); - for(size_t i = startEvent; i < events.size(); i++) + for (size_t i = startEvent; i < events.size(); i++) { m_pDriver->ReplayLog(events[i], events[i], eReplay_OnlyDraw); - if(overlay == DebugOverlay::ClearBeforePass && i + 1 < events.size()) + if (overlay == DebugOverlay::ClearBeforePass && i + 1 < events.size()) m_pDriver->ReplayLog(events[i] + 1, events[i + 1], eReplay_WithoutDraw); } diff --git a/renderdoc/driver/vulkan/vk_pixelhistory.cpp b/renderdoc/driver/vulkan/vk_pixelhistory.cpp index b8c47c157..ff8a9aae0 100644 --- a/renderdoc/driver/vulkan/vk_pixelhistory.cpp +++ b/renderdoc/driver/vulkan/vk_pixelhistory.cpp @@ -160,7 +160,7 @@ private: VkShaderModule CreateShaderReplacement(ResourceId shaderId, const rdcstr &entryName) { const VulkanCreationInfo::ShaderModule &moduleInfo = - m_pDriver->GetRenderState().m_CreationInfo->m_ShaderModule[shaderId]; + m_pDriver->GetDebugManager()->GetShaderInfo(shaderId); rdcarray modSpirv = moduleInfo.spirv.GetSPIRV(); rdcspv::Editor editor(modSpirv); editor.Prepare(); @@ -388,8 +388,7 @@ struct VulkanOcclusionAndStencilCallback : public VulkanPixelHistoryCallback m_DstBuffer(dstBuffer), m_ColorImageView(colorImageView), m_StencilImageView(stencilImageView), - m_StencilImage(stencilImage), - m_PrevState(vk, NULL) + m_StencilImage(stencilImage) { for(size_t i = 0; i < events.size(); i++) m_Events.insert(std::make_pair(events[i].eventId, events[i])); @@ -468,11 +467,12 @@ struct VulkanOcclusionAndStencilCallback : public VulkanPixelHistoryCallback if(it == m_Events.end()) return; EventUsage event = it->second; - m_PrevState = m_pDriver->GetRenderState(); + VulkanRenderState prevState = m_pDriver->GetCmdRenderState(); // TODO: handle secondary command buffers. // TODO: can't end renderpass if we are not on the last subpass. - m_pDriver->GetRenderState().EndRenderPass(cmd); + m_pDriver->GetCmdRenderState().EndRenderPass(cmd); + // Get pre-modification values size_t storeOffset = m_EventIndices.size() * sizeof(EventInfo); VkImage depthImage = VK_NULL_HANDLE; @@ -488,13 +488,12 @@ struct VulkanOcclusionAndStencilCallback : public VulkanPixelHistoryCallback CopyPixel(m_Image, m_Format, depthImage, depthFormat, cmd, storeOffset); - VulkanRenderState &pipestate = m_pDriver->GetRenderState(); - ResourceId prevState = pipestate.graphics.pipeline; + VulkanRenderState &pipestate = m_pDriver->GetCmdRenderState(); ResourceId prevRenderpass = pipestate.renderPass; ResourceId prevFramebuffer = pipestate.GetFramebuffer(); rdcarray prevFBattachments = pipestate.GetFramebufferAttachments(); const VulkanCreationInfo::Pipeline &p = - m_pDriver->GetRenderState().m_CreationInfo->m_Pipeline[pipestate.graphics.pipeline]; + m_pDriver->GetDebugManager()->GetPipelineInfo(pipestate.graphics.pipeline); uint32_t prevSubpass = pipestate.subpass; { @@ -509,7 +508,7 @@ struct VulkanOcclusionAndStencilCallback : public VulkanPixelHistoryCallback // the draw. We will get occlusion data to figure out if anything wrote to // the pixel, as well as number of fragments not accounting for potential // shader discard. - pipestate.SetFramebuffer(GetResID(m_OffscreenFB)); + pipestate.SetFramebuffer(m_pDriver, GetResID(m_OffscreenFB)); pipestate.renderPass = GetResID(m_RenderPass); pipestate.subpass = 0; pipestate.graphics.pipeline = GetResID(replacements.fixedShaderStencil); @@ -544,14 +543,15 @@ struct VulkanOcclusionAndStencilCallback : public VulkanPixelHistoryCallback } // Restore the state. - m_pDriver->GetRenderState() = m_PrevState; + m_pDriver->GetCmdRenderState() = prevState; pipestate.SetFramebuffer(prevFramebuffer, prevFBattachments); pipestate.renderPass = prevRenderpass; pipestate.subpass = prevSubpass; // TODO: Need to re-start on the correct subpass. - if(m_PrevState.graphics.pipeline != ResourceId()) - m_pDriver->GetRenderState().BeginRenderPassAndApplyState(cmd, VulkanRenderState::BindGraphics); + if(m_pDriver->GetCmdRenderState().graphics.pipeline != ResourceId()) + m_pDriver->GetCmdRenderState().BeginRenderPassAndApplyState(m_pDriver, cmd, + VulkanRenderState::BindGraphics); } bool PostDraw(uint32_t eid, VkCommandBuffer cmd) @@ -559,7 +559,7 @@ struct VulkanOcclusionAndStencilCallback : public VulkanPixelHistoryCallback if(m_Events.find(eid) == m_Events.end()) return false; - m_pDriver->GetRenderState().EndRenderPass(cmd); + m_pDriver->GetCmdRenderState().EndRenderPass(cmd); size_t storeOffset = m_EventIndices.size() * sizeof(EventInfo); VkImage depthImage = VK_NULL_HANDLE; @@ -576,7 +576,8 @@ struct VulkanOcclusionAndStencilCallback : public VulkanPixelHistoryCallback CopyPixel(m_Image, m_Format, depthImage, depthFormat, cmd, storeOffset + offsetof(struct EventInfo, postmod)); - m_pDriver->GetRenderState().BeginRenderPassAndApplyState(cmd, VulkanRenderState::BindGraphics); + m_pDriver->GetCmdRenderState().BeginRenderPassAndApplyState(m_pDriver, cmd, + VulkanRenderState::BindGraphics); // Get post-modification values m_EventIndices.insert(std::make_pair(eid, m_EventIndices.size())); @@ -685,9 +686,9 @@ private: void ReplayDraw(VkCommandBuffer cmd, size_t eventIndex, int eventId, bool doQuery, bool clear = false) { - VulkanRenderState &state = m_pDriver->GetRenderState(); const DrawcallDescription *drawcall = m_pDriver->GetDrawcall(eventId); - state.BeginRenderPassAndApplyState(cmd, VulkanRenderState::BindGraphics); + m_pDriver->GetCmdRenderState().BeginRenderPassAndApplyState(m_pDriver, cmd, + VulkanRenderState::BindGraphics); if(clear) { @@ -719,7 +720,7 @@ private: if(doQuery) ObjDisp(cmd)->CmdEndQuery(Unwrap(cmd), m_OcclusionPool, (uint32_t)eventIndex); - state.EndRenderPass(cmd); + m_pDriver->GetCmdRenderState().EndRenderPass(cmd); } // GetPipelineReplacements creates pipeline replacements that disable all tests, @@ -735,8 +736,7 @@ private: if(pipeIt != m_PipelineCache.end()) return pipeIt->second; - const VulkanCreationInfo::Pipeline &p = - m_pDriver->GetRenderState().m_CreationInfo->m_Pipeline[pipeline]; + const VulkanCreationInfo::Pipeline &p = m_pDriver->GetDebugManager()->GetPipelineInfo(pipeline); EventFlags eventFlags = m_pDriver->GetEventFlags(eid); VkShaderModule replacementShaders[5] = {}; @@ -855,8 +855,6 @@ private: // Key is event ID, and value is an index of where the occlusion result. std::map m_OcclusionQueries; rdcarray m_OcclusionResults; - - VulkanRenderState m_PrevState; }; // TestsFailedCallback replays draws to figure out which tests failed (for ex., depth, @@ -876,9 +874,9 @@ struct TestsFailedCallback : public VulkanPixelHistoryCallback if(!m_Events.contains(eid)) return; - VulkanRenderState &pipestate = m_pDriver->GetRenderState(); + VulkanRenderState &pipestate = m_pDriver->GetCmdRenderState(); const VulkanCreationInfo::Pipeline &p = - m_pDriver->GetRenderState().m_CreationInfo->m_Pipeline[pipestate.graphics.pipeline]; + m_pDriver->GetDebugManager()->GetPipelineInfo(pipestate.graphics.pipeline); uint32_t eventFlags = CalculateEventFlags(p, pipestate); m_EventFlags[eid] = eventFlags; @@ -888,12 +886,13 @@ struct TestsFailedCallback : public VulkanPixelHistoryCallback m_HasEarlyFragments[eid] = earlyFragmentTests; ResourceId curPipeline = pipestate.graphics.pipeline; - VulkanRenderState m_PrevState = m_pDriver->GetRenderState(); + VulkanRenderState m_PrevState = m_pDriver->GetCmdRenderState(); ReplayDrawWithTests(cmd, eid, eventFlags, curPipeline); - m_pDriver->GetRenderState() = m_PrevState; - m_pDriver->GetRenderState().BindPipeline(cmd, VulkanRenderState::BindGraphics, false); + m_pDriver->GetCmdRenderState() = m_PrevState; + m_pDriver->GetCmdRenderState().BindPipeline(m_pDriver, cmd, VulkanRenderState::BindGraphics, + false); } bool PostDraw(uint32_t eid, VkCommandBuffer cmd) { return false; } @@ -1085,7 +1084,7 @@ private: return; const VulkanCreationInfo::Pipeline &p = - m_pDriver->GetRenderState().m_CreationInfo->m_Pipeline[basePipeline]; + m_pDriver->GetDebugManager()->GetPipelineInfo(basePipeline); EventFlags eventShaderFlags = m_pDriver->GetEventFlags(eid); uint32_t numberOfStages = 5; rdcarray replacementShaders; @@ -1103,7 +1102,7 @@ private: } bool dynamicScissor = p.dynamicStates[VkDynamicScissor]; - VulkanRenderState &pipestate = m_pDriver->GetRenderState(); + VulkanRenderState &pipestate = m_pDriver->GetCmdRenderState(); rdcarray prevScissors = pipestate.scissors; if(dynamicScissor) for(uint32_t i = 0; i < pipestate.views.size(); i++) @@ -1275,8 +1274,9 @@ private: void ReplayDraw(VkCommandBuffer cmd, VkPipeline pipe, int eventId, uint32_t test) { - m_pDriver->GetRenderState().graphics.pipeline = GetResID(pipe); - m_pDriver->GetRenderState().BindPipeline(cmd, VulkanRenderState::BindGraphics, false); + m_pDriver->GetCmdRenderState().graphics.pipeline = GetResID(pipe); + m_pDriver->GetCmdRenderState().BindPipeline(m_pDriver, cmd, VulkanRenderState::BindGraphics, + false); uint32_t index = (uint32_t)m_OcclusionQueries.size(); if(m_OcclusionQueries.find(rdcpair(eventId, test)) != m_OcclusionQueries.end()) @@ -1346,7 +1346,6 @@ bool VulkanDebugManager::PixelHistorySetupResources(PixelHistoryResources &resou RDCASSERTEQUAL(vkr, VK_SUCCESS); VkImage wrappedColorImage = colorImage; - m_pDriver->GetResourceManager()->WrapResource(Unwrap(dev), wrappedColorImage); ImageState colorImageState = ImageState(wrappedColorImage, ImageInfo(imgInfo), eFrameRef_None); VkMemoryRequirements colorImageMrq = {0}; @@ -1360,7 +1359,6 @@ bool VulkanDebugManager::PixelHistorySetupResources(PixelHistoryResources &resou RDCASSERTEQUAL(vkr, VK_SUCCESS); VkImage wrappedStencilImage = stencilImage; - m_pDriver->GetResourceManager()->WrapResource(Unwrap(dev), wrappedStencilImage); ImageState stencilImageState = ImageState(wrappedStencilImage, ImageInfo(imgInfo), eFrameRef_None); VkMemoryRequirements stencilImageMrq = {0}; diff --git a/renderdoc/driver/vulkan/vk_postvs.cpp b/renderdoc/driver/vulkan/vk_postvs.cpp index 182f4a695..53921cf84 100644 --- a/renderdoc/driver/vulkan/vk_postvs.cpp +++ b/renderdoc/driver/vulkan/vk_postvs.cpp @@ -1557,9 +1557,8 @@ void VulkanReplay::PatchReservedDescriptors(const VulkanStatePipeline &pipe, } } -void VulkanReplay::FetchVSOut(uint32_t eventId) +void VulkanReplay::FetchVSOut(uint32_t eventId, VulkanRenderState &state) { - const VulkanRenderState &state = m_pDriver->m_RenderState; VulkanCreationInfo &creationInfo = m_pDriver->m_CreationInfo; const VulkanCreationInfo::Pipeline &pipeInfo = creationInfo.m_Pipeline[state.graphics.pipeline]; @@ -1637,7 +1636,7 @@ void VulkanReplay::FetchVSOut(uint32_t eventId) // create a duplicate set of descriptor sets, all visible to compute, with bindings shifted to // account for new ones we need. This also copies the existing bindings into the new sets - PatchReservedDescriptors(m_pDriver->m_RenderState.graphics, descpool, setLayouts, descSets, + PatchReservedDescriptors(state.graphics, descpool, setLayouts, descSets, VK_SHADER_STAGE_COMPUTE_BIT, newBindings, ARRAY_COUNT(newBindings)); // create pipeline layout with new descriptor set layouts @@ -2510,7 +2509,7 @@ void VulkanReplay::FetchVSOut(uint32_t eventId) m_pDriver->vkUpdateDescriptorSets(dev, 1, &write, 0, NULL); // do single draw - modifiedstate.BindPipeline(cmd, VulkanRenderState::BindCompute, true); + modifiedstate.BindPipeline(m_pDriver, cmd, VulkanRenderState::BindCompute, true); uint64_t totalVerts = numVerts * uint64_t(drawcall->numInstances) * uint64_t(numViews); // the validation layers will probably complain about this dispatch saying some arrays aren't @@ -2705,9 +2704,8 @@ void VulkanReplay::FetchVSOut(uint32_t eventId) m_pDriver->vkDestroyShaderModule(dev, module, NULL); } -void VulkanReplay::FetchTessGSOut(uint32_t eventId) +void VulkanReplay::FetchTessGSOut(uint32_t eventId, VulkanRenderState &state) { - VulkanRenderState state = m_pDriver->m_RenderState; VulkanCreationInfo &creationInfo = m_pDriver->m_CreationInfo; const VulkanCreationInfo::Pipeline &pipeInfo = creationInfo.m_Pipeline[state.graphics.pipeline]; @@ -2873,7 +2871,7 @@ void VulkanReplay::FetchTessGSOut(uint32_t eventId) RDCASSERTEQUAL(vkr, VK_SUCCESS); state.graphics.pipeline = GetResID(pipe); - state.SetFramebuffer(GetResID(fb)); + state.SetFramebuffer(m_pDriver, GetResID(fb)); state.renderPass = GetResID(rp); state.subpass = 0; state.renderArea.offset.x = 0; @@ -3002,7 +3000,7 @@ void VulkanReplay::FetchTessGSOut(uint32_t eventId) // wait for the above fill to finish. DoPipelineBarrier(cmd, 1, &meshbufbarrier); - state.BeginRenderPassAndApplyState(cmd, VulkanRenderState::BindGraphics); + state.BeginRenderPassAndApplyState(m_pDriver, cmd, VulkanRenderState::BindGraphics); ObjDisp(cmd)->CmdBeginQuery(Unwrap(cmd), Unwrap(m_PostVS.XFBQueryPool), 0, 0); @@ -3064,7 +3062,7 @@ void VulkanReplay::FetchTessGSOut(uint32_t eventId) ObjDisp(dev)->CmdResetQueryPool(Unwrap(cmd), Unwrap(m_PostVS.XFBQueryPool), 0, drawcall->numInstances); - state.BeginRenderPassAndApplyState(cmd, VulkanRenderState::BindGraphics); + state.BeginRenderPassAndApplyState(m_pDriver, cmd, VulkanRenderState::BindGraphics); // do incremental draws to get the output size. We have to do this O(N^2) style because // there's no way to replay only a single instance. We have to replay 1, 2, 3, ... N @@ -3250,7 +3248,7 @@ void VulkanReplay::FetchTessGSOut(uint32_t eventId) m_pDriver->vkDestroyShaderModule(dev, module, NULL); } -void VulkanReplay::InitPostVSBuffers(uint32_t eventId) +void VulkanReplay::InitPostVSBuffers(uint32_t eventId, VulkanRenderState &state) { // go through any aliasing if(m_PostVS.Alias.find(eventId) != m_PostVS.Alias.end()) @@ -3259,7 +3257,6 @@ void VulkanReplay::InitPostVSBuffers(uint32_t eventId) if(m_PostVS.Data.find(eventId) != m_PostVS.Data.end()) return; - const VulkanRenderState &state = m_pDriver->m_RenderState; VulkanCreationInfo &creationInfo = m_pDriver->m_CreationInfo; if(state.graphics.pipeline == ResourceId() || state.renderPass == ResourceId()) @@ -3277,7 +3274,7 @@ void VulkanReplay::InitPostVSBuffers(uint32_t eventId) VkMarkerRegion::Begin(StringFormat::Fmt("FetchVSOut for %u", eventId)); - FetchVSOut(eventId); + FetchVSOut(eventId, state); VkMarkerRegion::End(); @@ -3287,11 +3284,16 @@ void VulkanReplay::InitPostVSBuffers(uint32_t eventId) VkMarkerRegion::Begin(StringFormat::Fmt("FetchTessGSOut for %u", eventId)); - FetchTessGSOut(eventId); + FetchTessGSOut(eventId, state); VkMarkerRegion::End(); } +void VulkanReplay::InitPostVSBuffers(uint32_t eventId) +{ + InitPostVSBuffers(eventId, m_pDriver->GetRenderState()); +} + struct VulkanInitPostVSCallback : public VulkanDrawcallCallback { VulkanInitPostVSCallback(WrappedVulkan *vk, const rdcarray &events) @@ -3303,7 +3305,7 @@ struct VulkanInitPostVSCallback : public VulkanDrawcallCallback void PreDraw(uint32_t eid, VkCommandBuffer cmd) { if(m_Events.contains(eid)) - m_pDriver->GetReplay()->InitPostVSBuffers(eid); + m_pDriver->GetReplay()->InitPostVSBuffers(eid, m_pDriver->GetCmdRenderState()); } bool PostDraw(uint32_t eid, VkCommandBuffer cmd) { return false; } diff --git a/renderdoc/driver/vulkan/vk_replay.h b/renderdoc/driver/vulkan/vk_replay.h index 7277a6fea..7f24a1a25 100644 --- a/renderdoc/driver/vulkan/vk_replay.h +++ b/renderdoc/driver/vulkan/vk_replay.h @@ -29,6 +29,7 @@ #include "replay/replay_driver.h" #include "vk_common.h" #include "vk_info.h" +#include "vk_state.h" #if ENABLED(RDOC_WIN32) @@ -322,6 +323,7 @@ public: float maxval, bool channels[4], rdcarray &histogram); void InitPostVSBuffers(uint32_t eventId); + void InitPostVSBuffers(uint32_t eventId, VulkanRenderState &state); void InitPostVSBuffers(const rdcarray &passEvents); // indicates that EID alias is the same as eventId @@ -421,8 +423,8 @@ private: const VkDescriptorSetLayoutBinding *newBindings, size_t newBindingsCount); - void FetchVSOut(uint32_t eventId); - void FetchTessGSOut(uint32_t eventId); + void FetchVSOut(uint32_t eventId, VulkanRenderState &state); + void FetchTessGSOut(uint32_t eventId, VulkanRenderState &state); void ClearPostVSCache(); void RefreshDerivedReplacements(); diff --git a/renderdoc/driver/vulkan/vk_state.cpp b/renderdoc/driver/vulkan/vk_state.cpp index a9080ac37..71e7fda7b 100644 --- a/renderdoc/driver/vulkan/vk_state.cpp +++ b/renderdoc/driver/vulkan/vk_state.cpp @@ -23,17 +23,19 @@ ******************************************************************************/ #include "vk_state.h" +#include "vk_common.h" #include "vk_core.h" +#include "vk_debug.h" #include "vk_info.h" #include "vk_resources.h" -VulkanRenderState::VulkanRenderState(WrappedVulkan *driver, VulkanCreationInfo *createInfo) - : m_CreationInfo(createInfo), m_pDriver(driver) +VulkanRenderState::VulkanRenderState() { RDCEraseEl(ibuffer); } -void VulkanRenderState::BeginRenderPassAndApplyState(VkCommandBuffer cmd, PipelineBinding binding) +void VulkanRenderState::BeginRenderPassAndApplyState(WrappedVulkan *vk, VkCommandBuffer cmd, + PipelineBinding binding) { RDCASSERT(renderPass != ResourceId()); @@ -43,17 +45,18 @@ void VulkanRenderState::BeginRenderPassAndApplyState(VkCommandBuffer cmd, Pipeli VkClearValue empty[16] = {}; - RDCASSERT(ARRAY_COUNT(empty) >= m_CreationInfo->m_RenderPass[renderPass].attachments.size()); + RDCASSERT(ARRAY_COUNT(empty) >= + vk->GetDebugManager()->GetRenderPassInfo(renderPass).attachments.size()); - VulkanCreationInfo::Framebuffer fbinfo = m_CreationInfo->m_Framebuffer[framebuffer]; + VulkanCreationInfo::Framebuffer fbinfo = vk->GetDebugManager()->GetFramebufferInfo(framebuffer); VkRenderPassBeginInfo rpbegin = { VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO, NULL, - Unwrap(m_CreationInfo->m_RenderPass[renderPass].loadRPs[subpass]), + Unwrap(vk->GetDebugManager()->GetRenderPassInfo(renderPass).loadRPs[subpass]), Unwrap(fbinfo.loadFBs[subpass]), renderArea, - (uint32_t)m_CreationInfo->m_RenderPass[renderPass].attachments.size(), + (uint32_t)vk->GetDebugManager()->GetRenderPassInfo(renderPass).attachments.size(), empty, }; @@ -69,14 +72,14 @@ void VulkanRenderState::BeginRenderPassAndApplyState(VkCommandBuffer cmd, Pipeli for(size_t i = 0; i < fbattachments.size(); i++) imagelessViews.push_back( - Unwrap(GetResourceManager()->GetCurrentHandle(fbattachments[i]))); + Unwrap(vk->GetResourceManager()->GetCurrentHandle(fbattachments[i]))); imagelessAttachments.pAttachments = imagelessViews.data(); } ObjDisp(cmd)->CmdBeginRenderPass(Unwrap(cmd), &rpbegin, VK_SUBPASS_CONTENTS_INLINE); - BindPipeline(cmd, binding, true); + BindPipeline(vk, cmd, binding, true); if(IsConditionalRenderingEnabled()) { @@ -84,7 +87,7 @@ void VulkanRenderState::BeginRenderPassAndApplyState(VkCommandBuffer cmd, Pipeli beginInfo.sType = VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT; beginInfo.pNext = VK_NULL_HANDLE; beginInfo.buffer = - Unwrap(GetResourceManager()->GetCurrentHandle(conditionalRendering.buffer)); + Unwrap(vk->GetResourceManager()->GetCurrentHandle(conditionalRendering.buffer)); beginInfo.offset = conditionalRendering.offset; beginInfo.flags = conditionalRendering.flags; @@ -97,7 +100,7 @@ void VulkanRenderState::EndRenderPass(VkCommandBuffer cmd) ObjDisp(cmd)->CmdEndRenderPass(Unwrap(cmd)); } -void VulkanRenderState::EndTransformFeedback(VkCommandBuffer cmd) +void VulkanRenderState::EndTransformFeedback(WrappedVulkan *vk, VkCommandBuffer cmd) { if(!xfbcounters.empty()) { @@ -106,7 +109,8 @@ void VulkanRenderState::EndTransformFeedback(VkCommandBuffer cmd) for(size_t i = 0; i < xfbcounters.size(); i++) { - buffers.push_back(Unwrap(GetResourceManager()->GetCurrentHandle(xfbcounters[i].buf))); + buffers.push_back( + Unwrap(vk->GetResourceManager()->GetCurrentHandle(xfbcounters[i].buf))); offsets.push_back(xfbcounters[i].offs); } @@ -126,29 +130,31 @@ bool VulkanRenderState::IsConditionalRenderingEnabled() return conditionalRendering.buffer != ResourceId() && !conditionalRendering.forceDisable; } -void VulkanRenderState::BindPipeline(VkCommandBuffer cmd, PipelineBinding binding, bool subpass0) +void VulkanRenderState::BindPipeline(WrappedVulkan *vk, VkCommandBuffer cmd, + PipelineBinding binding, bool subpass0) { if(graphics.pipeline != ResourceId() && binding == BindGraphics) { - VkPipeline pipe = GetResourceManager()->GetCurrentHandle(graphics.pipeline); + VkPipeline pipe = vk->GetResourceManager()->GetCurrentHandle(graphics.pipeline); + const VulkanCreationInfo::Pipeline pipeinfo = + vk->GetDebugManager()->GetPipelineInfo(graphics.pipeline); - if(subpass0 && m_CreationInfo->m_Pipeline[graphics.pipeline].subpass0pipe != VK_NULL_HANDLE) - pipe = m_CreationInfo->m_Pipeline[graphics.pipeline].subpass0pipe; + if(subpass0 && pipeinfo.subpass0pipe != VK_NULL_HANDLE) + pipe = pipeinfo.subpass0pipe; ObjDisp(cmd)->CmdBindPipeline(Unwrap(cmd), VK_PIPELINE_BIND_POINT_GRAPHICS, Unwrap(pipe)); - ResourceId pipeLayoutId = m_CreationInfo->m_Pipeline[graphics.pipeline].layout; - VkPipelineLayout layout = GetResourceManager()->GetCurrentHandle(pipeLayoutId); + ResourceId pipeLayoutId = pipeinfo.layout; + VkPipelineLayout layout = + vk->GetResourceManager()->GetCurrentHandle(pipeLayoutId); const rdcarray &pushRanges = - m_CreationInfo->m_PipelineLayout[pipeLayoutId].pushRanges; + vk->GetDebugManager()->GetPipelineLayoutInfo(pipeLayoutId).pushRanges; bool dynamicStates[VkDynamicCount] = {0}; - memcpy(dynamicStates, m_CreationInfo->m_Pipeline[graphics.pipeline].dynamicStates, - sizeof(dynamicStates)); + memcpy(dynamicStates, pipeinfo.dynamicStates, sizeof(dynamicStates)); - RDCCOMPILE_ASSERT(sizeof(dynamicStates) == - sizeof(m_CreationInfo->m_Pipeline[graphics.pipeline].dynamicStates), + RDCCOMPILE_ASSERT(sizeof(dynamicStates) == sizeof(pipeinfo.dynamicStates), "Dynamic states array size is out of sync"); if(!views.empty() && dynamicStates[VkDynamicViewport]) @@ -209,7 +215,7 @@ void VulkanRenderState::BindPipeline(VkCommandBuffer cmd, PipelineBinding bindin pushRanges[i].offset, pushRanges[i].size, pushconsts + pushRanges[i].offset); - BindDescriptorSets(cmd, graphics, VK_PIPELINE_BIND_POINT_GRAPHICS); + BindDescriptorSets(vk, cmd, graphics, VK_PIPELINE_BIND_POINT_GRAPHICS); if(ibuffer.buf != ResourceId()) { @@ -220,7 +226,7 @@ void VulkanRenderState::BindPipeline(VkCommandBuffer cmd, PipelineBinding bindin type = VK_INDEX_TYPE_UINT8_EXT; ObjDisp(cmd)->CmdBindIndexBuffer( - Unwrap(cmd), Unwrap(GetResourceManager()->GetCurrentHandle(ibuffer.buf)), + Unwrap(cmd), Unwrap(vk->GetResourceManager()->GetCurrentHandle(ibuffer.buf)), ibuffer.offs, type); } @@ -231,7 +237,7 @@ void VulkanRenderState::BindPipeline(VkCommandBuffer cmd, PipelineBinding bindin ObjDisp(cmd)->CmdBindVertexBuffers( Unwrap(cmd), (uint32_t)i, 1, - UnwrapPtr(GetResourceManager()->GetCurrentHandle(vbuffers[i].buf)), + UnwrapPtr(vk->GetResourceManager()->GetCurrentHandle(vbuffers[i].buf)), &vbuffers[i].offs); } @@ -242,7 +248,7 @@ void VulkanRenderState::BindPipeline(VkCommandBuffer cmd, PipelineBinding bindin ObjDisp(cmd)->CmdBindTransformFeedbackBuffersEXT( Unwrap(cmd), (uint32_t)i, 1, - UnwrapPtr(GetResourceManager()->GetCurrentHandle(xfbbuffers[i].buf)), + UnwrapPtr(vk->GetResourceManager()->GetCurrentHandle(xfbbuffers[i].buf)), &xfbbuffers[i].offs, &xfbbuffers[i].size); } @@ -254,7 +260,7 @@ void VulkanRenderState::BindPipeline(VkCommandBuffer cmd, PipelineBinding bindin for(size_t i = 0; i < xfbcounters.size(); i++) { buffers.push_back( - Unwrap(GetResourceManager()->GetCurrentHandle(xfbcounters[i].buf))); + Unwrap(vk->GetResourceManager()->GetCurrentHandle(xfbcounters[i].buf))); offsets.push_back(xfbcounters[i].offs); } @@ -267,13 +273,14 @@ void VulkanRenderState::BindPipeline(VkCommandBuffer cmd, PipelineBinding bindin { ObjDisp(cmd)->CmdBindPipeline( Unwrap(cmd), VK_PIPELINE_BIND_POINT_COMPUTE, - Unwrap(GetResourceManager()->GetCurrentHandle(compute.pipeline))); + Unwrap(vk->GetResourceManager()->GetCurrentHandle(compute.pipeline))); - ResourceId pipeLayoutId = m_CreationInfo->m_Pipeline[compute.pipeline].layout; - VkPipelineLayout layout = GetResourceManager()->GetCurrentHandle(pipeLayoutId); + ResourceId pipeLayoutId = vk->GetDebugManager()->GetPipelineInfo(compute.pipeline).layout; + VkPipelineLayout layout = + vk->GetResourceManager()->GetCurrentHandle(pipeLayoutId); const rdcarray &pushRanges = - m_CreationInfo->m_PipelineLayout[pipeLayoutId].pushRanges; + vk->GetDebugManager()->GetPipelineLayoutInfo(pipeLayoutId).pushRanges; // only set push constant ranges that the layout uses for(size_t i = 0; i < pushRanges.size(); i++) @@ -281,20 +288,20 @@ void VulkanRenderState::BindPipeline(VkCommandBuffer cmd, PipelineBinding bindin pushRanges[i].offset, pushRanges[i].size, pushconsts + pushRanges[i].offset); - BindDescriptorSets(cmd, compute, VK_PIPELINE_BIND_POINT_COMPUTE); + BindDescriptorSets(vk, cmd, compute, VK_PIPELINE_BIND_POINT_COMPUTE); } } -void VulkanRenderState::BindDescriptorSets(VkCommandBuffer cmd, VulkanStatePipeline &pipe, - VkPipelineBindPoint bindPoint) +void VulkanRenderState::BindDescriptorSets(WrappedVulkan *vk, VkCommandBuffer cmd, + VulkanStatePipeline &pipe, VkPipelineBindPoint bindPoint) { - ResourceId pipeLayoutId = m_CreationInfo->m_Pipeline[pipe.pipeline].layout; + ResourceId pipeLayoutId = vk->GetDebugManager()->GetPipelineInfo(pipe.pipeline).layout; const rdcarray &descSetLayouts = - m_CreationInfo->m_PipelineLayout[pipeLayoutId].descSetLayouts; + vk->GetDebugManager()->GetPipelineLayoutInfo(pipeLayoutId).descSetLayouts; for(size_t i = 0; i < descSetLayouts.size(); i++) { - const DescSetLayout &descLayout = m_CreationInfo->m_DescSetLayout[descSetLayouts[i]]; + const DescSetLayout &descLayout = vk->GetDebugManager()->GetDescSetLayout(descSetLayouts[i]); if(i < pipe.descSets.size() && pipe.descSets[i].descSet != ResourceId()) { @@ -306,13 +313,12 @@ void VulkanRenderState::BindDescriptorSets(VkCommandBuffer cmd, VulkanStatePipel // by the next drawcall. The remaining sets are invalid, but also unused and this is // explicitly allowed by the spec. We just have to make sure we don't try to actively bind // an incompatible descriptor set. - ResourceId createdDescSetLayoutId = - m_pDriver->GetDescLayoutForDescSet(pipe.descSets[i].descSet); + ResourceId createdDescSetLayoutId = vk->GetDescLayoutForDescSet(pipe.descSets[i].descSet); if(descSetLayouts[i] != createdDescSetLayoutId) { const DescSetLayout &createdDescLayout = - m_CreationInfo->m_DescSetLayout[createdDescSetLayoutId]; + vk->GetDebugManager()->GetDescSetLayout(createdDescSetLayoutId); if(descLayout != createdDescLayout) { @@ -348,7 +354,7 @@ void VulkanRenderState::BindDescriptorSets(VkCommandBuffer cmd, VulkanStatePipel } } - BindDescriptorSet(descLayout, cmd, bindPoint, (uint32_t)i, dynamicOffsets); + BindDescriptorSet(vk, descLayout, cmd, bindPoint, (uint32_t)i, dynamicOffsets); if(pipe.descSets[i].offsets.size() < descLayout.dynamicCount) SAFE_DELETE_ARRAY(dynamicOffsets); @@ -356,9 +362,9 @@ void VulkanRenderState::BindDescriptorSets(VkCommandBuffer cmd, VulkanStatePipel } } -void VulkanRenderState::BindDescriptorSet(const DescSetLayout &descLayout, VkCommandBuffer cmd, - VkPipelineBindPoint bindPoint, uint32_t setIndex, - uint32_t *dynamicOffsets) +void VulkanRenderState::BindDescriptorSet(WrappedVulkan *vk, const DescSetLayout &descLayout, + VkCommandBuffer cmd, VkPipelineBindPoint bindPoint, + uint32_t setIndex, uint32_t *dynamicOffsets) { ResourceId descSet = (bindPoint == VK_PIPELINE_BIND_POINT_GRAPHICS) ? graphics.descSets[setIndex].descSet @@ -366,13 +372,13 @@ void VulkanRenderState::BindDescriptorSet(const DescSetLayout &descLayout, VkCom ResourceId pipeLayout = (bindPoint == VK_PIPELINE_BIND_POINT_GRAPHICS) ? graphics.descSets[setIndex].pipeLayout : compute.descSets[setIndex].pipeLayout; - VkPipelineLayout layout = GetResourceManager()->GetCurrentHandle(pipeLayout); + VkPipelineLayout layout = vk->GetResourceManager()->GetCurrentHandle(pipeLayout); if((descLayout.flags & VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR) == 0) { ObjDisp(cmd)->CmdBindDescriptorSets( Unwrap(cmd), bindPoint, Unwrap(layout), (uint32_t)setIndex, 1, - UnwrapPtr(GetResourceManager()->GetCurrentHandle(descSet)), + UnwrapPtr(vk->GetResourceManager()->GetCurrentHandle(descSet)), descLayout.dynamicCount, dynamicOffsets); } else @@ -386,7 +392,7 @@ void VulkanRenderState::BindDescriptorSet(const DescSetLayout &descLayout, VkCom rdcarray allocBufWrites; rdcarray allocBufViewWrites; - WrappedVulkan::DescriptorSetInfo &setInfo = m_pDriver->m_DescriptorSetState[descSet]; + const WrappedVulkan::DescriptorSetInfo &setInfo = vk->GetDebugManager()->GetDescSetInfo(descSet); VkWriteDescriptorSet push = {VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET}; @@ -412,8 +418,8 @@ void VulkanRenderState::BindDescriptorSet(const DescSetLayout &descLayout, VkCom VkBufferView *dst = new VkBufferView[push.descriptorCount]; for(uint32_t a = 0; a < push.descriptorCount; a++) - dst[a] = - Unwrap(GetResourceManager()->GetCurrentHandle(slots[a].texelBufferView)); + dst[a] = Unwrap( + vk->GetResourceManager()->GetCurrentHandle(slots[a].texelBufferView)); push.pTexelBufferView = dst; allocBufViewWrites.push_back(dst); @@ -431,9 +437,9 @@ void VulkanRenderState::BindDescriptorSet(const DescSetLayout &descLayout, VkCom const DescriptorSetSlotImageInfo &src = slots[a].imageInfo; dst[a].imageLayout = src.imageLayout; - dst[a].sampler = Unwrap(GetResourceManager()->GetCurrentHandle(src.sampler)); + dst[a].sampler = Unwrap(vk->GetResourceManager()->GetCurrentHandle(src.sampler)); dst[a].imageView = - Unwrap(GetResourceManager()->GetCurrentHandle(src.imageView)); + Unwrap(vk->GetResourceManager()->GetCurrentHandle(src.imageView)); } push.pImageInfo = dst; @@ -449,7 +455,7 @@ void VulkanRenderState::BindDescriptorSet(const DescSetLayout &descLayout, VkCom dst[a].offset = src.offset; dst[a].range = src.range; - dst[a].buffer = Unwrap(GetResourceManager()->GetCurrentHandle(src.buffer)); + dst[a].buffer = Unwrap(vk->GetResourceManager()->GetCurrentHandle(src.buffer)); } push.pBufferInfo = dst; @@ -511,12 +517,12 @@ void VulkanRenderState::BindDescriptorSet(const DescSetLayout &descLayout, VkCom } } -void VulkanRenderState::SetFramebuffer(ResourceId fb, +void VulkanRenderState::SetFramebuffer(WrappedVulkan *vk, ResourceId fb, const VkRenderPassAttachmentBeginInfo *attachmentsInfo) { framebuffer = fb; - VulkanCreationInfo::Framebuffer fbinfo = m_CreationInfo->m_Framebuffer[fb]; + VulkanCreationInfo::Framebuffer fbinfo = vk->GetDebugManager()->GetFramebufferInfo(fb); fbattachments.resize(fbinfo.attachments.size()); @@ -531,8 +537,3 @@ void VulkanRenderState::SetFramebuffer(ResourceId fb, fbattachments[i] = GetResID(attachmentsInfo->pAttachments[i]); } } - -VulkanResourceManager *VulkanRenderState::GetResourceManager() -{ - return m_pDriver->GetResourceManager(); -} diff --git a/renderdoc/driver/vulkan/vk_state.h b/renderdoc/driver/vulkan/vk_state.h index 34ea8acf5..7fb760fd8 100644 --- a/renderdoc/driver/vulkan/vk_state.h +++ b/renderdoc/driver/vulkan/vk_state.h @@ -53,23 +53,22 @@ struct VulkanRenderState BindCompute = 0x2, }; - VulkanRenderState(WrappedVulkan *driver, VulkanCreationInfo *createInfo); - void BeginRenderPassAndApplyState(VkCommandBuffer cmd, PipelineBinding binding); - void EndRenderPass(VkCommandBuffer cmd); + VulkanRenderState(); + bool IsConditionalRenderingEnabled(); + void BeginRenderPassAndApplyState(WrappedVulkan *vk, VkCommandBuffer cmd, PipelineBinding binding); + void BindPipeline(WrappedVulkan *vk, VkCommandBuffer cmd, PipelineBinding binding, bool subpass0); - void EndTransformFeedback(VkCommandBuffer cmd); - - void EndConditionalRendering(VkCommandBuffer cmd); - - void BindPipeline(VkCommandBuffer cmd, PipelineBinding binding, bool subpass0); - - void BindDescriptorSets(VkCommandBuffer cmd, VulkanStatePipeline &pipe, + void BindDescriptorSets(WrappedVulkan *vk, VkCommandBuffer cmd, VulkanStatePipeline &pipe, VkPipelineBindPoint bindPoint); - void BindDescriptorSet(const DescSetLayout &descLayout, VkCommandBuffer cmd, + void BindDescriptorSet(WrappedVulkan *vk, const DescSetLayout &descLayout, VkCommandBuffer cmd, VkPipelineBindPoint bindPoint, uint32_t setIndex, uint32_t *dynamicOffsets); - bool IsConditionalRenderingEnabled(); + void EndRenderPass(VkCommandBuffer cmd); + + void EndTransformFeedback(WrappedVulkan *vk, VkCommandBuffer cmd); + + void EndConditionalRendering(VkCommandBuffer cmd); // dynamic state rdcarray views; @@ -113,7 +112,9 @@ struct VulkanRenderState // framebuffer accessors - to allow for imageless framebuffers and prevent accidentally changing // only the framebuffer without updating the attachments - void SetFramebuffer(ResourceId fb, const VkRenderPassAttachmentBeginInfo *attachmentsInfo = NULL); + void SetFramebuffer(WrappedVulkan *vk, ResourceId fb, + const VkRenderPassAttachmentBeginInfo *attachmentsInfo = NULL); + void SetFramebuffer(ResourceId fb, const rdcarray &dynamicAttachments) { framebuffer = fb; @@ -166,10 +167,6 @@ struct VulkanRenderState bool forceDisable = false; } conditionalRendering; - VulkanResourceManager *GetResourceManager(); - VulkanCreationInfo *m_CreationInfo; - WrappedVulkan *m_pDriver; - private: ResourceId framebuffer; rdcarray fbattachments; diff --git a/renderdoc/driver/vulkan/wrappers/vk_cmd_funcs.cpp b/renderdoc/driver/vulkan/wrappers/vk_cmd_funcs.cpp index 794c0cf1f..3f388a40b 100644 --- a/renderdoc/driver/vulkan/wrappers/vk_cmd_funcs.cpp +++ b/renderdoc/driver/vulkan/wrappers/vk_cmd_funcs.cpp @@ -58,7 +58,7 @@ void WrappedVulkan::AddImplicitResolveResourceUsage(uint32_t subpass) subpass = m_BakedCmdBufferInfo[m_LastCmdBufferID].state.subpass; const rdcarray &fbattachments = - m_BakedCmdBufferInfo[m_LastCmdBufferID].state.fbattachments; + m_BakedCmdBufferInfo[m_LastCmdBufferID].state.GetFramebufferAttachments(); for(size_t i = 0; i < rpinfo.subpasses[subpass].resolveAttachments.size(); i++) { uint32_t attIdx = rpinfo.subpasses[subpass].resolveAttachments[i]; @@ -84,9 +84,10 @@ rdcarray WrappedVulkan::GetImplicitRenderPassBarriers(uint } else { - rp = m_BakedCmdBufferInfo[m_LastCmdBufferID].state.renderPass; - fb = m_BakedCmdBufferInfo[m_LastCmdBufferID].state.framebuffer; - fbattachments = m_BakedCmdBufferInfo[m_LastCmdBufferID].state.fbattachments; + const VulkanRenderState &renderstate = GetCmdRenderState(); + rp = renderstate.renderPass; + fb = renderstate.GetFramebuffer(); + fbattachments = renderstate.GetFramebufferAttachments(); } rdcarray ret; @@ -121,7 +122,7 @@ rdcarray WrappedVulkan::GetImplicitRenderPassBarriers(uint if(m_LastCmdBufferID == ResourceId()) subpass = m_RenderState.subpass; else - subpass = m_BakedCmdBufferInfo[m_LastCmdBufferID].state.subpass; + subpass = GetCmdRenderState().subpass; // transition the attachments in this subpass for(size_t i = 0; i < rpinfo.subpasses[subpass].colorAttachments.size(); i++) @@ -306,7 +307,7 @@ rdcstr WrappedVulkan::MakeRenderPassOpString(bool store) const VulkanCreationInfo::RenderPass &info = m_CreationInfo.m_RenderPass[m_BakedCmdBufferInfo[m_LastCmdBufferID].state.renderPass]; const VulkanCreationInfo::Framebuffer &fbinfo = - m_CreationInfo.m_Framebuffer[m_BakedCmdBufferInfo[m_LastCmdBufferID].state.framebuffer]; + m_CreationInfo.m_Framebuffer[m_BakedCmdBufferInfo[m_LastCmdBufferID].state.GetFramebuffer()]; const rdcarray &atts = info.attachments; @@ -788,8 +789,9 @@ bool WrappedVulkan::Serialise_vkBeginCommandBuffer(SerialiserType &ser, VkComman m_Partial[p].partialParent = BakedCommandBuffer; m_Partial[p].baseEvent = it->baseEvent; m_Partial[p].renderPassActive = false; - m_RenderState.xfbcounters.clear(); - m_RenderState.conditionalRendering.buffer = ResourceId(); + + GetCmdRenderState().xfbcounters.clear(); + GetCmdRenderState().conditionalRendering.buffer = ResourceId(); rerecord = true; partial = true; @@ -1042,16 +1044,16 @@ bool WrappedVulkan::Serialise_vkEndCommandBuffer(SerialiserType &ser, VkCommandB ToStr(GetResID(commandBuffer)).c_str()); #endif - if(m_Partial[Primary].partialParent == BakedCommandBuffer && - !m_RenderState.xfbcounters.empty()) + VulkanRenderState &renderstate = GetCmdRenderState(); + if(m_Partial[Primary].partialParent == BakedCommandBuffer && !renderstate.xfbcounters.empty()) { - m_RenderState.EndTransformFeedback(commandBuffer); + renderstate.EndTransformFeedback(this, commandBuffer); } if(m_Partial[Primary].partialParent == BakedCommandBuffer && - m_RenderState.IsConditionalRenderingEnabled()) + renderstate.IsConditionalRenderingEnabled()) { - m_RenderState.EndConditionalRendering(commandBuffer); + renderstate.EndConditionalRendering(commandBuffer); } // finish any render pass that was still active in the primary partial parent @@ -1059,18 +1061,16 @@ bool WrappedVulkan::Serialise_vkEndCommandBuffer(SerialiserType &ser, VkCommandB m_Partial[Primary].renderPassActive) { uint32_t numSubpasses = - (uint32_t)m_CreationInfo.m_RenderPass[m_RenderState.renderPass].subpasses.size(); + (uint32_t)m_CreationInfo.m_RenderPass[renderstate.renderPass].subpasses.size(); // for each subpass we skip, and for the finalLayout transition at the end of the // renderpass, record these barriers. These are executed implicitly but because we want to // pretend they never happened, we then reverse their effects so that our layout tracking // is accurate and the images end up in the layout they were in during the last active // subpass - uint32_t &sub = m_BakedCmdBufferInfo[m_LastCmdBufferID].state.subpass; - std::map renderPassEndStates; - for(sub = m_RenderState.subpass + 1; sub < numSubpasses; sub++) + for(uint32_t sub = renderstate.subpass + 1; sub < numSubpasses; sub++) { ObjDisp(commandBuffer)->CmdNextSubpass(Unwrap(commandBuffer), VK_SUBPASS_CONTENTS_INLINE); @@ -1127,8 +1127,10 @@ bool WrappedVulkan::Serialise_vkEndCommandBuffer(SerialiserType &ser, VkCommandB ObjDisp(commandBuffer)->EndCommandBuffer(Unwrap(commandBuffer)); - if(m_Partial[Primary].partialParent == BakedCommandBuffer) - m_Partial[Primary].partialParent = ResourceId(); + // TODO: preserve so that m_RenderState can be updated at the end + // of replay. + // if(m_Partial[Primary].partialParent == BakedCommandBuffer) + // m_Partial[Primary].partialParent = ResourceId(); } m_BakedCmdBufferInfo[CommandBuffer].curEventID = 0; @@ -1262,49 +1264,40 @@ bool WrappedVulkan::Serialise_vkCmdBeginRenderPass(SerialiserType &ser, VkComman { commandBuffer = RerecordCmdBuf(m_LastCmdBufferID); - // always track this, for WrappedVulkan::IsDrawInRenderPass() - m_BakedCmdBufferInfo[m_LastCmdBufferID].state.subpass = 0; - m_BakedCmdBufferInfo[m_LastCmdBufferID].state.renderPass = - GetResID(RenderPassBegin.renderPass); - - ResourceId fb = GetResID(RenderPassBegin.framebuffer); - m_BakedCmdBufferInfo[m_LastCmdBufferID].state.framebuffer = fb; - - const VkRenderPassAttachmentBeginInfo *attachmentsInfo = - (const VkRenderPassAttachmentBeginInfo *)FindNextStruct( - &RenderPassBegin, VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO); - - // set framebuffer attachments - by default from the ones used to create it, but if it is - // imageless then look for the attachments in our pNext chain - { - VulkanCreationInfo::Framebuffer fbinfo = m_CreationInfo.m_Framebuffer[fb]; - m_BakedCmdBufferInfo[m_LastCmdBufferID].state.fbattachments.resize( - fbinfo.attachments.size()); - - if(!fbinfo.imageless) - { - for(size_t i = 0; i < fbinfo.attachments.size(); i++) - m_BakedCmdBufferInfo[m_LastCmdBufferID].state.fbattachments[i] = - fbinfo.attachments[i].createdView; - } - else - { - for(size_t i = 0; i < fbinfo.attachments.size(); i++) - m_BakedCmdBufferInfo[m_LastCmdBufferID].state.fbattachments[i] = - GetResID(attachmentsInfo->pAttachments[i]); - } - } - // only if we're partially recording do we update this state if(ShouldUpdateRenderState(m_LastCmdBufferID, true)) { m_Partial[Primary].renderPassActive = true; + } - m_RenderState.subpass = 0; + ResourceId fb = GetResID(RenderPassBegin.framebuffer); + VulkanCreationInfo::Framebuffer fbinfo = m_CreationInfo.m_Framebuffer[fb]; - m_RenderState.renderPass = GetResID(RenderPassBegin.renderPass); - m_RenderState.SetFramebuffer(GetResID(RenderPassBegin.framebuffer), attachmentsInfo); - m_RenderState.renderArea = RenderPassBegin.renderArea; + { + VulkanRenderState &renderstate = GetCmdRenderState(); + renderstate.subpass = 0; + renderstate.renderPass = GetResID(RenderPassBegin.renderPass); + renderstate.renderArea = RenderPassBegin.renderArea; + + const VkRenderPassAttachmentBeginInfo *attachmentsInfo = + (const VkRenderPassAttachmentBeginInfo *)FindNextStruct( + &RenderPassBegin, VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO); + + rdcarray attachments(fbinfo.attachments.size()); + + // set framebuffer attachments - by default from the ones used to create it, but if it is + // imageless then look for the attachments in our pNext chain + if(!fbinfo.imageless) + { + for(size_t i = 0; i < fbinfo.attachments.size(); i++) + attachments[i] = fbinfo.attachments[i].createdView; + } + else + { + for(size_t i = 0; i < fbinfo.attachments.size(); i++) + attachments[i] = GetResID(attachmentsInfo->pAttachments[i]); + } + renderstate.SetFramebuffer(GetResID(RenderPassBegin.framebuffer), attachments); } rdcarray imgBarriers = GetImplicitRenderPassBarriers(); @@ -1316,9 +1309,8 @@ bool WrappedVulkan::Serialise_vkCmdBeginRenderPass(SerialiserType &ser, VkComman // be in subpass 0's layout if(m_FirstEventID == m_LastEventID) { - VulkanCreationInfo::Framebuffer fbinfo = m_CreationInfo.m_Framebuffer[fb]; VulkanCreationInfo::RenderPass rpinfo = - m_CreationInfo.m_RenderPass[m_RenderState.renderPass]; + m_CreationInfo.m_RenderPass[GetCmdRenderState().renderPass]; unwrappedInfo.renderPass = Unwrap(rpinfo.loadRPs[0]); unwrappedInfo.framebuffer = Unwrap(fbinfo.loadFBs[0]); @@ -1354,19 +1346,17 @@ bool WrappedVulkan::Serialise_vkCmdBeginRenderPass(SerialiserType &ser, VkComman m_BakedCmdBufferInfo[m_LastCmdBufferID].state.renderPass = GetResID(RenderPassBegin.renderPass); ResourceId fb = GetResID(RenderPassBegin.framebuffer); - m_BakedCmdBufferInfo[m_LastCmdBufferID].state.framebuffer = fb; // set framebuffer attachments - by default from the ones used to create it, but if it is // imageless then look for the attachments in our pNext chain { VulkanCreationInfo::Framebuffer fbinfo = m_CreationInfo.m_Framebuffer[fb]; - m_BakedCmdBufferInfo[m_LastCmdBufferID].state.fbattachments.resize(fbinfo.attachments.size()); + rdcarray attachments(fbinfo.attachments.size()); if(!fbinfo.imageless) { for(size_t i = 0; i < fbinfo.attachments.size(); i++) - m_BakedCmdBufferInfo[m_LastCmdBufferID].state.fbattachments[i] = - fbinfo.attachments[i].createdView; + attachments[i] = fbinfo.attachments[i].createdView; } else { @@ -1375,16 +1365,16 @@ bool WrappedVulkan::Serialise_vkCmdBeginRenderPass(SerialiserType &ser, VkComman &RenderPassBegin, VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO); for(size_t i = 0; i < fbinfo.attachments.size(); i++) - m_BakedCmdBufferInfo[m_LastCmdBufferID].state.fbattachments[i] = - GetResID(attachmentsInfo->pAttachments[i]); + attachments[i] = GetResID(attachmentsInfo->pAttachments[i]); } + m_BakedCmdBufferInfo[m_LastCmdBufferID].state.SetFramebuffer(fb, attachments); } // Record image usage for images cleared in the beginning of the render pass. const VulkanCreationInfo::RenderPass &rpinfo = m_CreationInfo.m_RenderPass[GetResID(RenderPassBegin.renderPass)]; const rdcarray &fbattachments = - m_BakedCmdBufferInfo[m_LastCmdBufferID].state.fbattachments; + m_BakedCmdBufferInfo[m_LastCmdBufferID].state.GetFramebufferAttachments(); for(size_t i = 0; i < rpinfo.attachments.size(); i++) { if(rpinfo.attachments[i].loadOp == VK_ATTACHMENT_LOAD_OP_CLEAR) @@ -1520,11 +1510,9 @@ bool WrappedVulkan::Serialise_vkCmdNextSubpass(SerialiserType &ser, VkCommandBuf { commandBuffer = RerecordCmdBuf(m_LastCmdBufferID); - // always track this, for WrappedVulkan::IsDrawInRenderPass() - m_BakedCmdBufferInfo[m_LastCmdBufferID].state.subpass++; - - if(ShouldUpdateRenderState(m_LastCmdBufferID, true)) - m_RenderState.subpass++; + { + GetCmdRenderState().subpass++; + } DrawFlags drawFlags = DrawFlags::PassBoundary | DrawFlags::BeginPass | DrawFlags::EndPass; uint32_t eventId = HandlePreCallback(commandBuffer, drawFlags); @@ -1614,16 +1602,17 @@ bool WrappedVulkan::Serialise_vkCmdEndRenderPass(SerialiserType &ser, VkCommandB rdcarray imgBarriers = GetImplicitRenderPassBarriers(~0U); - // always track this, for WrappedVulkan::IsDrawInRenderPass() - m_BakedCmdBufferInfo[m_LastCmdBufferID].state.renderPass = ResourceId(); - m_BakedCmdBufferInfo[m_LastCmdBufferID].state.framebuffer = ResourceId(); - m_BakedCmdBufferInfo[m_LastCmdBufferID].state.fbattachments.clear(); - if(ShouldUpdateRenderState(m_LastCmdBufferID, true)) { m_Partial[Primary].renderPassActive = false; } + { + VulkanRenderState &renderstate = GetCmdRenderState(); + renderstate.renderPass = ResourceId(); + renderstate.SetFramebuffer(ResourceId(), rdcarray()); + } + DrawFlags drawFlags = DrawFlags::PassBoundary | DrawFlags::EndPass; uint32_t eventId = HandlePreCallback(commandBuffer, drawFlags); @@ -1671,8 +1660,8 @@ bool WrappedVulkan::Serialise_vkCmdEndRenderPass(SerialiserType &ser, VkCommandB // track while reading, reset this to empty so AddDrawcall sets no outputs, // but only AFTER the above AddDrawcall (we want it grouped together) m_BakedCmdBufferInfo[m_LastCmdBufferID].state.renderPass = ResourceId(); - m_BakedCmdBufferInfo[m_LastCmdBufferID].state.framebuffer = ResourceId(); - m_BakedCmdBufferInfo[m_LastCmdBufferID].state.fbattachments.clear(); + m_BakedCmdBufferInfo[m_LastCmdBufferID].state.SetFramebuffer(ResourceId(), + rdcarray()); } } @@ -1740,49 +1729,39 @@ bool WrappedVulkan::Serialise_vkCmdBeginRenderPass2(SerialiserType &ser, { commandBuffer = RerecordCmdBuf(m_LastCmdBufferID); - // always track this, for WrappedVulkan::IsDrawInRenderPass() - m_BakedCmdBufferInfo[m_LastCmdBufferID].state.subpass = 0; - m_BakedCmdBufferInfo[m_LastCmdBufferID].state.renderPass = - GetResID(RenderPassBegin.renderPass); - - ResourceId fb = GetResID(RenderPassBegin.framebuffer); - m_BakedCmdBufferInfo[m_LastCmdBufferID].state.framebuffer = fb; - - const VkRenderPassAttachmentBeginInfo *attachmentsInfo = - (const VkRenderPassAttachmentBeginInfo *)FindNextStruct( - &RenderPassBegin, VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO); - - // set framebuffer attachments - by default from the ones used to create it, but if it is - // imageless then look for the attachments in our pNext chain - { - VulkanCreationInfo::Framebuffer fbinfo = m_CreationInfo.m_Framebuffer[fb]; - m_BakedCmdBufferInfo[m_LastCmdBufferID].state.fbattachments.resize( - fbinfo.attachments.size()); - - if(!fbinfo.imageless) - { - for(size_t i = 0; i < fbinfo.attachments.size(); i++) - m_BakedCmdBufferInfo[m_LastCmdBufferID].state.fbattachments[i] = - fbinfo.attachments[i].createdView; - } - else - { - for(size_t i = 0; i < fbinfo.attachments.size(); i++) - m_BakedCmdBufferInfo[m_LastCmdBufferID].state.fbattachments[i] = - GetResID(attachmentsInfo->pAttachments[i]); - } - } - // only if we're partially recording do we update this state if(ShouldUpdateRenderState(m_LastCmdBufferID, true)) { m_Partial[Primary].renderPassActive = true; + } - m_RenderState.subpass = 0; + ResourceId fb = GetResID(RenderPassBegin.framebuffer); + VulkanCreationInfo::Framebuffer fbinfo = m_CreationInfo.m_Framebuffer[fb]; + { + VulkanRenderState &renderstate = GetCmdRenderState(); + renderstate.subpass = 0; + renderstate.renderPass = GetResID(RenderPassBegin.renderPass); + renderstate.renderArea = RenderPassBegin.renderArea; - m_RenderState.renderPass = GetResID(RenderPassBegin.renderPass); - m_RenderState.SetFramebuffer(GetResID(RenderPassBegin.framebuffer), attachmentsInfo); - m_RenderState.renderArea = RenderPassBegin.renderArea; + const VkRenderPassAttachmentBeginInfo *attachmentsInfo = + (const VkRenderPassAttachmentBeginInfo *)FindNextStruct( + &RenderPassBegin, VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO); + + rdcarray attachments(fbinfo.attachments.size()); + + // set framebuffer attachments - by default from the ones used to create it, but if it is + // imageless then look for the attachments in our pNext chain + if(!fbinfo.imageless) + { + for(size_t i = 0; i < fbinfo.attachments.size(); i++) + attachments[i] = fbinfo.attachments[i].createdView; + } + else + { + for(size_t i = 0; i < fbinfo.attachments.size(); i++) + attachments[i] = GetResID(attachmentsInfo->pAttachments[i]); + } + renderstate.SetFramebuffer(GetResID(RenderPassBegin.framebuffer), attachments); } rdcarray imgBarriers = GetImplicitRenderPassBarriers(); @@ -1794,9 +1773,9 @@ bool WrappedVulkan::Serialise_vkCmdBeginRenderPass2(SerialiserType &ser, // be in subpass 0's layout if(m_FirstEventID == m_LastEventID) { - VulkanCreationInfo::Framebuffer fbinfo = m_CreationInfo.m_Framebuffer[fb]; + // VulkanCreationInfo::Framebuffer fbinfo = m_CreationInfo.m_Framebuffer[fb]; VulkanCreationInfo::RenderPass rpinfo = - m_CreationInfo.m_RenderPass[m_RenderState.renderPass]; + m_CreationInfo.m_RenderPass[GetCmdRenderState().renderPass]; unwrappedInfo.renderPass = Unwrap(rpinfo.loadRPs[0]); unwrappedInfo.framebuffer = Unwrap(fbinfo.loadFBs[0]); @@ -1834,19 +1813,17 @@ bool WrappedVulkan::Serialise_vkCmdBeginRenderPass2(SerialiserType &ser, m_BakedCmdBufferInfo[m_LastCmdBufferID].state.renderPass = GetResID(RenderPassBegin.renderPass); ResourceId fb = GetResID(RenderPassBegin.framebuffer); - m_BakedCmdBufferInfo[m_LastCmdBufferID].state.framebuffer = fb; // set framebuffer attachments - by default from the ones used to create it, but if it is // imageless then look for the attachments in our pNext chain { VulkanCreationInfo::Framebuffer fbinfo = m_CreationInfo.m_Framebuffer[fb]; - m_BakedCmdBufferInfo[m_LastCmdBufferID].state.fbattachments.resize(fbinfo.attachments.size()); + rdcarray attachments(fbinfo.attachments.size()); if(!fbinfo.imageless) { for(size_t i = 0; i < fbinfo.attachments.size(); i++) - m_BakedCmdBufferInfo[m_LastCmdBufferID].state.fbattachments[i] = - fbinfo.attachments[i].createdView; + attachments[i] = fbinfo.attachments[i].createdView; } else { @@ -1855,16 +1832,16 @@ bool WrappedVulkan::Serialise_vkCmdBeginRenderPass2(SerialiserType &ser, &RenderPassBegin, VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO); for(size_t i = 0; i < fbinfo.attachments.size(); i++) - m_BakedCmdBufferInfo[m_LastCmdBufferID].state.fbattachments[i] = - GetResID(attachmentsInfo->pAttachments[i]); + attachments[i] = GetResID(attachmentsInfo->pAttachments[i]); } + m_BakedCmdBufferInfo[m_LastCmdBufferID].state.SetFramebuffer(fb, attachments); } // Record image usage for images cleared in the beginning of the render pass. const VulkanCreationInfo::RenderPass &rpinfo = m_CreationInfo.m_RenderPass[GetResID(RenderPassBegin.renderPass)]; const rdcarray &fbattachments = - m_BakedCmdBufferInfo[m_LastCmdBufferID].state.fbattachments; + m_BakedCmdBufferInfo[m_LastCmdBufferID].state.GetFramebufferAttachments(); for(size_t i = 0; i < rpinfo.attachments.size(); i++) { if(rpinfo.attachments[i].loadOp == VK_ATTACHMENT_LOAD_OP_CLEAR) @@ -2016,11 +1993,9 @@ bool WrappedVulkan::Serialise_vkCmdNextSubpass2(SerialiserType &ser, VkCommandBu { commandBuffer = RerecordCmdBuf(m_LastCmdBufferID); - // always track this, for WrappedVulkan::IsDrawInRenderPass() - m_BakedCmdBufferInfo[m_LastCmdBufferID].state.subpass++; - - if(ShouldUpdateRenderState(m_LastCmdBufferID, true)) - m_RenderState.subpass++; + { + GetCmdRenderState().subpass++; + } DrawFlags drawFlags = DrawFlags::PassBoundary | DrawFlags::BeginPass | DrawFlags::EndPass; uint32_t eventId = HandlePreCallback(commandBuffer, drawFlags); @@ -2133,15 +2108,17 @@ bool WrappedVulkan::Serialise_vkCmdEndRenderPass2(SerialiserType &ser, VkCommand rdcarray imgBarriers = GetImplicitRenderPassBarriers(~0U); - // always track this, for WrappedVulkan::IsDrawInRenderPass() - m_BakedCmdBufferInfo[m_LastCmdBufferID].state.renderPass = ResourceId(); - m_BakedCmdBufferInfo[m_LastCmdBufferID].state.framebuffer = ResourceId(); - if(ShouldUpdateRenderState(m_LastCmdBufferID, true)) { m_Partial[Primary].renderPassActive = false; } + { + VulkanRenderState &renderstate = GetCmdRenderState(); + renderstate.renderPass = ResourceId(); + renderstate.SetFramebuffer(ResourceId(), rdcarray()); + } + DrawFlags drawFlags = DrawFlags::PassBoundary | DrawFlags::EndPass; uint32_t eventId = HandlePreCallback(commandBuffer, drawFlags); ObjDisp(commandBuffer)->CmdEndRenderPass2(Unwrap(commandBuffer), &unwrappedEndInfo); @@ -2179,7 +2156,8 @@ bool WrappedVulkan::Serialise_vkCmdEndRenderPass2(SerialiserType &ser, VkCommand // track while reading, reset this to empty so AddDrawcall sets no outputs, // but only AFTER the above AddDrawcall (we want it grouped together) m_BakedCmdBufferInfo[m_LastCmdBufferID].state.renderPass = ResourceId(); - m_BakedCmdBufferInfo[m_LastCmdBufferID].state.framebuffer = ResourceId(); + m_BakedCmdBufferInfo[m_LastCmdBufferID].state.SetFramebuffer(ResourceId(), + rdcarray()); } } @@ -2244,76 +2222,76 @@ bool WrappedVulkan::Serialise_vkCmdBindPipeline(SerialiserType &ser, VkCommandBu ResourceId liveid = GetResID(pipeline); - if(ShouldUpdateRenderState(m_LastCmdBufferID)) { + VulkanRenderState &renderstate = GetCmdRenderState(); if(pipelineBindPoint == VK_PIPELINE_BIND_POINT_COMPUTE) { - m_RenderState.compute.pipeline = liveid; + renderstate.compute.pipeline = liveid; } else { - m_RenderState.graphics.pipeline = liveid; + renderstate.graphics.pipeline = liveid; if(!m_CreationInfo.m_Pipeline[liveid].dynamicStates[VkDynamicViewport]) { - m_RenderState.views = m_CreationInfo.m_Pipeline[liveid].viewports; + renderstate.views = m_CreationInfo.m_Pipeline[liveid].viewports; } if(!m_CreationInfo.m_Pipeline[liveid].dynamicStates[VkDynamicScissor]) { - m_RenderState.scissors = m_CreationInfo.m_Pipeline[liveid].scissors; + renderstate.scissors = m_CreationInfo.m_Pipeline[liveid].scissors; } if(!m_CreationInfo.m_Pipeline[liveid].dynamicStates[VkDynamicLineWidth]) { - m_RenderState.lineWidth = m_CreationInfo.m_Pipeline[liveid].lineWidth; + renderstate.lineWidth = m_CreationInfo.m_Pipeline[liveid].lineWidth; } if(!m_CreationInfo.m_Pipeline[liveid].dynamicStates[VkDynamicDepthBias]) { - m_RenderState.bias.depth = m_CreationInfo.m_Pipeline[liveid].depthBiasConstantFactor; - m_RenderState.bias.biasclamp = m_CreationInfo.m_Pipeline[liveid].depthBiasClamp; - m_RenderState.bias.slope = m_CreationInfo.m_Pipeline[liveid].depthBiasSlopeFactor; + renderstate.bias.depth = m_CreationInfo.m_Pipeline[liveid].depthBiasConstantFactor; + renderstate.bias.biasclamp = m_CreationInfo.m_Pipeline[liveid].depthBiasClamp; + renderstate.bias.slope = m_CreationInfo.m_Pipeline[liveid].depthBiasSlopeFactor; } if(!m_CreationInfo.m_Pipeline[liveid].dynamicStates[VkDynamicBlendConstants]) { - memcpy(m_RenderState.blendConst, m_CreationInfo.m_Pipeline[liveid].blendConst, + memcpy(renderstate.blendConst, m_CreationInfo.m_Pipeline[liveid].blendConst, sizeof(float) * 4); } if(!m_CreationInfo.m_Pipeline[liveid].dynamicStates[VkDynamicDepthBounds]) { - m_RenderState.mindepth = m_CreationInfo.m_Pipeline[liveid].minDepthBounds; - m_RenderState.maxdepth = m_CreationInfo.m_Pipeline[liveid].maxDepthBounds; + renderstate.mindepth = m_CreationInfo.m_Pipeline[liveid].minDepthBounds; + renderstate.maxdepth = m_CreationInfo.m_Pipeline[liveid].maxDepthBounds; } if(!m_CreationInfo.m_Pipeline[liveid].dynamicStates[VkDynamicStencilCompareMask]) { - m_RenderState.front.compare = m_CreationInfo.m_Pipeline[liveid].front.compareMask; - m_RenderState.back.compare = m_CreationInfo.m_Pipeline[liveid].back.compareMask; + renderstate.front.compare = m_CreationInfo.m_Pipeline[liveid].front.compareMask; + renderstate.back.compare = m_CreationInfo.m_Pipeline[liveid].back.compareMask; } if(!m_CreationInfo.m_Pipeline[liveid].dynamicStates[VkDynamicStencilWriteMask]) { - m_RenderState.front.write = m_CreationInfo.m_Pipeline[liveid].front.writeMask; - m_RenderState.back.write = m_CreationInfo.m_Pipeline[liveid].back.writeMask; + renderstate.front.write = m_CreationInfo.m_Pipeline[liveid].front.writeMask; + renderstate.back.write = m_CreationInfo.m_Pipeline[liveid].back.writeMask; } if(!m_CreationInfo.m_Pipeline[liveid].dynamicStates[VkDynamicStencilReference]) { - m_RenderState.front.ref = m_CreationInfo.m_Pipeline[liveid].front.reference; - m_RenderState.back.ref = m_CreationInfo.m_Pipeline[liveid].back.reference; + renderstate.front.ref = m_CreationInfo.m_Pipeline[liveid].front.reference; + renderstate.back.ref = m_CreationInfo.m_Pipeline[liveid].back.reference; } if(!m_CreationInfo.m_Pipeline[liveid].dynamicStates[VkDynamicSampleLocationsEXT]) { - m_RenderState.sampleLocations.locations = + renderstate.sampleLocations.locations = m_CreationInfo.m_Pipeline[liveid].sampleLocations.locations; - m_RenderState.sampleLocations.gridSize = + renderstate.sampleLocations.gridSize = m_CreationInfo.m_Pipeline[liveid].sampleLocations.gridSize; - m_RenderState.sampleLocations.sampleCount = + renderstate.sampleLocations.sampleCount = m_CreationInfo.m_Pipeline[liveid].rasterizationSamples; } if(!m_CreationInfo.m_Pipeline[liveid].dynamicStates[VkDynamicDiscardRectangleEXT]) { - m_RenderState.discardRectangles = m_CreationInfo.m_Pipeline[liveid].discardRectangles; + renderstate.discardRectangles = m_CreationInfo.m_Pipeline[liveid].discardRectangles; } if(!m_CreationInfo.m_Pipeline[liveid].dynamicStates[VkDynamicLineStippleEXT]) { - m_RenderState.stippleFactor = m_CreationInfo.m_Pipeline[liveid].stippleFactor; - m_RenderState.stipplePattern = m_CreationInfo.m_Pipeline[liveid].stipplePattern; + renderstate.stippleFactor = m_CreationInfo.m_Pipeline[liveid].stippleFactor; + renderstate.stipplePattern = m_CreationInfo.m_Pipeline[liveid].stipplePattern; } } } @@ -2326,7 +2304,14 @@ bool WrappedVulkan::Serialise_vkCmdBindPipeline(SerialiserType &ser, VkCommandBu else { // track while reading, as we need to bind current topology & index byte width in AddDrawcall - m_BakedCmdBufferInfo[m_LastCmdBufferID].state.pipeline = GetResID(pipeline); + if(pipelineBindPoint == VK_PIPELINE_BIND_POINT_COMPUTE) + { + m_BakedCmdBufferInfo[m_LastCmdBufferID].state.compute.pipeline = GetResID(pipeline); + } + else + { + m_BakedCmdBufferInfo[m_LastCmdBufferID].state.graphics.pipeline = GetResID(pipeline); + } } if(commandBuffer != VK_NULL_HANDLE) @@ -2394,12 +2379,12 @@ bool WrappedVulkan::Serialise_vkCmdBindDescriptorSets( firstSet, setCount, UnwrapArray(pDescriptorSets, setCount), dynamicOffsetCount, pDynamicOffsets); - if(ShouldUpdateRenderState(m_LastCmdBufferID)) { + VulkanRenderState &renderstate = GetCmdRenderState(); + rdcarray &descsets = - (pipelineBindPoint == VK_PIPELINE_BIND_POINT_GRAPHICS) - ? m_RenderState.graphics.descSets - : m_RenderState.compute.descSets; + (pipelineBindPoint == VK_PIPELINE_BIND_POINT_GRAPHICS) ? renderstate.graphics.descSets + : renderstate.compute.descSets; // expand as necessary if(descsets.size() < firstSet + setCount) @@ -2466,10 +2451,10 @@ bool WrappedVulkan::Serialise_vkCmdBindDescriptorSets( else { // track while reading, as we need to track resource usage - rdcarray &descsets = + rdcarray &descsets = (pipelineBindPoint == VK_PIPELINE_BIND_POINT_GRAPHICS) - ? m_BakedCmdBufferInfo[m_LastCmdBufferID].state.graphicsDescSets - : m_BakedCmdBufferInfo[m_LastCmdBufferID].state.computeDescSets; + ? m_BakedCmdBufferInfo[m_LastCmdBufferID].state.graphics.descSets + : m_BakedCmdBufferInfo[m_LastCmdBufferID].state.compute.descSets; // expand as necessary if(descsets.size() < firstSet + setCount) @@ -2549,15 +2534,15 @@ bool WrappedVulkan::Serialise_vkCmdBindVertexBuffers(SerialiserType &ser, ->CmdBindVertexBuffers(Unwrap(commandBuffer), firstBinding, bindingCount, UnwrapArray(pBuffers, bindingCount), pOffsets); - if(ShouldUpdateRenderState(m_LastCmdBufferID)) { - if(m_RenderState.vbuffers.size() < firstBinding + bindingCount) - m_RenderState.vbuffers.resize(firstBinding + bindingCount); + VulkanRenderState &renderstate = GetCmdRenderState(); + if(renderstate.vbuffers.size() < firstBinding + bindingCount) + renderstate.vbuffers.resize(firstBinding + bindingCount); for(uint32_t i = 0; i < bindingCount; i++) { - m_RenderState.vbuffers[firstBinding + i].buf = GetResID(pBuffers[i]); - m_RenderState.vbuffers[firstBinding + i].offs = pOffsets[i]; + renderstate.vbuffers[firstBinding + i].buf = GetResID(pBuffers[i]); + renderstate.vbuffers[firstBinding + i].offs = pOffsets[i]; } } } @@ -2569,7 +2554,7 @@ bool WrappedVulkan::Serialise_vkCmdBindVertexBuffers(SerialiserType &ser, m_BakedCmdBufferInfo[m_LastCmdBufferID].state.vbuffers.resize(firstBinding + bindingCount); for(uint32_t i = 0; i < bindingCount; i++) - m_BakedCmdBufferInfo[m_LastCmdBufferID].state.vbuffers[firstBinding + i] = + m_BakedCmdBufferInfo[m_LastCmdBufferID].state.vbuffers[firstBinding + i].buf = GetResID(pBuffers[i]); ObjDisp(commandBuffer) @@ -2636,17 +2621,17 @@ bool WrappedVulkan::Serialise_vkCmdBindIndexBuffer(SerialiserType &ser, ObjDisp(commandBuffer) ->CmdBindIndexBuffer(Unwrap(commandBuffer), Unwrap(buffer), offset, indexType); - if(ShouldUpdateRenderState(m_LastCmdBufferID)) { - m_RenderState.ibuffer.buf = GetResID(buffer); - m_RenderState.ibuffer.offs = offset; + VulkanRenderState &renderstate = GetCmdRenderState(); + renderstate.ibuffer.buf = GetResID(buffer); + renderstate.ibuffer.offs = offset; if(indexType == VK_INDEX_TYPE_UINT32) - m_RenderState.ibuffer.bytewidth = 4; + renderstate.ibuffer.bytewidth = 4; else if(indexType == VK_INDEX_TYPE_UINT8_EXT) - m_RenderState.ibuffer.bytewidth = 1; + renderstate.ibuffer.bytewidth = 1; else - m_RenderState.ibuffer.bytewidth = 2; + renderstate.ibuffer.bytewidth = 2; } } } @@ -2654,14 +2639,14 @@ bool WrappedVulkan::Serialise_vkCmdBindIndexBuffer(SerialiserType &ser, { // track while reading, as we need to bind current topology & index byte width in AddDrawcall if(indexType == VK_INDEX_TYPE_UINT32) - m_BakedCmdBufferInfo[m_LastCmdBufferID].state.idxWidth = 4; + m_BakedCmdBufferInfo[m_LastCmdBufferID].state.ibuffer.bytewidth = 4; else if(indexType == VK_INDEX_TYPE_UINT8_EXT) - m_BakedCmdBufferInfo[m_LastCmdBufferID].state.idxWidth = 1; + m_BakedCmdBufferInfo[m_LastCmdBufferID].state.ibuffer.bytewidth = 1; else - m_BakedCmdBufferInfo[m_LastCmdBufferID].state.idxWidth = 2; + m_BakedCmdBufferInfo[m_LastCmdBufferID].state.ibuffer.bytewidth = 2; // track while reading, as we need to track resource usage - m_BakedCmdBufferInfo[m_LastCmdBufferID].state.ibuffer = GetResID(buffer); + m_BakedCmdBufferInfo[m_LastCmdBufferID].state.ibuffer.buf = GetResID(buffer); ObjDisp(commandBuffer)->CmdBindIndexBuffer(Unwrap(commandBuffer), Unwrap(buffer), offset, indexType); } @@ -2789,13 +2774,13 @@ bool WrappedVulkan::Serialise_vkCmdPushConstants(SerialiserType &ser, VkCommandB ->CmdPushConstants(Unwrap(commandBuffer), Unwrap(layout), stageFlags, start, length, values); - if(ShouldUpdateRenderState(m_LastCmdBufferID)) { - RDCASSERT(start + length < (uint32_t)ARRAY_COUNT(m_RenderState.pushconsts)); + VulkanRenderState &renderstate = GetCmdRenderState(); + RDCASSERT(start + length < (uint32_t)ARRAY_COUNT(renderstate.pushconsts)); - memcpy(m_RenderState.pushconsts + start, values, length); + memcpy(renderstate.pushconsts + start, values, length); - m_RenderState.pushConstSize = RDCMAX(m_RenderState.pushConstSize, start + length); + renderstate.pushConstSize = RDCMAX(renderstate.pushConstSize, start + length); } } } @@ -3375,7 +3360,7 @@ bool WrappedVulkan::Serialise_vkCmdExecuteCommands(SerialiserType &ser, VkComman // should we add framebuffer usage to the child draws. bool framebufferUsage = parentCmdBufInfo.state.renderPass != ResourceId() && - parentCmdBufInfo.state.framebuffer != ResourceId(); + parentCmdBufInfo.state.GetFramebuffer() != ResourceId(); for(uint32_t c = 0; c < commandBufferCount; c++) { @@ -3419,8 +3404,8 @@ bool WrappedVulkan::Serialise_vkCmdExecuteCommands(SerialiserType &ser, VkComman { AddFramebufferUsageAllChildren( parentCmdBufInfo.draw->children[total - numChildren + i], - parentCmdBufInfo.state.renderPass, parentCmdBufInfo.state.framebuffer, - parentCmdBufInfo.state.subpass, parentCmdBufInfo.state.fbattachments); + parentCmdBufInfo.state.renderPass, parentCmdBufInfo.state.GetFramebuffer(), + parentCmdBufInfo.state.subpass, parentCmdBufInfo.state.GetFramebufferAttachments()); } } @@ -3500,8 +3485,9 @@ bool WrappedVulkan::Serialise_vkCmdExecuteCommands(SerialiserType &ser, VkComman // propagate renderpass state m_BakedCmdBufferInfo[cmd].state.renderPass = parentCmdBufInfo.state.renderPass; m_BakedCmdBufferInfo[cmd].state.subpass = parentCmdBufInfo.state.subpass; - m_BakedCmdBufferInfo[cmd].state.framebuffer = parentCmdBufInfo.state.framebuffer; - m_BakedCmdBufferInfo[cmd].state.fbattachments = parentCmdBufInfo.state.fbattachments; + m_BakedCmdBufferInfo[cmd].state.SetFramebuffer( + parentCmdBufInfo.state.GetFramebuffer(), + parentCmdBufInfo.state.GetFramebufferAttachments()); // 2 extra for the virtual labels around the command buffer parentCmdBufInfo.curEventID += 2 + m_BakedCmdBufferInfo[cmd].eventCount; @@ -3988,12 +3974,11 @@ bool WrappedVulkan::Serialise_vkCmdPushDescriptorSetKHR(SerialiserType &ser, { commandBuffer = RerecordCmdBuf(m_LastCmdBufferID); - if(ShouldUpdateRenderState(m_LastCmdBufferID)) { + VulkanRenderState &renderstate = GetCmdRenderState(); rdcarray &descsets = - (pipelineBindPoint == VK_PIPELINE_BIND_POINT_GRAPHICS) - ? m_RenderState.graphics.descSets - : m_RenderState.compute.descSets; + (pipelineBindPoint == VK_PIPELINE_BIND_POINT_GRAPHICS) ? renderstate.graphics.descSets + : renderstate.compute.descSets; // expand as necessary if(descsets.size() < set + 1) @@ -4013,10 +3998,10 @@ bool WrappedVulkan::Serialise_vkCmdPushDescriptorSetKHR(SerialiserType &ser, else { // track while reading, as we need to track resource usage - rdcarray &descsets = + rdcarray &descsets = (pipelineBindPoint == VK_PIPELINE_BIND_POINT_GRAPHICS) - ? m_BakedCmdBufferInfo[m_LastCmdBufferID].state.graphicsDescSets - : m_BakedCmdBufferInfo[m_LastCmdBufferID].state.computeDescSets; + ? m_BakedCmdBufferInfo[m_LastCmdBufferID].state.graphics.descSets + : m_BakedCmdBufferInfo[m_LastCmdBufferID].state.compute.descSets; // expand as necessary if(descsets.size() < set + 1) @@ -4257,11 +4242,11 @@ bool WrappedVulkan::Serialise_vkCmdPushDescriptorSetWithTemplateKHR( { commandBuffer = RerecordCmdBuf(m_LastCmdBufferID); - if(ShouldUpdateRenderState(m_LastCmdBufferID)) { + VulkanRenderState &renderstate = GetCmdRenderState(); rdcarray &descsets = - (bindPoint == VK_PIPELINE_BIND_POINT_GRAPHICS) ? m_RenderState.graphics.descSets - : m_RenderState.compute.descSets; + (bindPoint == VK_PIPELINE_BIND_POINT_GRAPHICS) ? renderstate.graphics.descSets + : renderstate.compute.descSets; // expand as necessary if(descsets.size() < set + 1) @@ -4281,11 +4266,11 @@ bool WrappedVulkan::Serialise_vkCmdPushDescriptorSetWithTemplateKHR( else { // track while reading, as we need to track resource usage - rdcarray &descsets = + rdcarray &descsets = (m_CreationInfo.m_DescUpdateTemplate[GetResID(descriptorUpdateTemplate)].bindPoint == VK_PIPELINE_BIND_POINT_GRAPHICS) - ? m_BakedCmdBufferInfo[m_LastCmdBufferID].state.graphicsDescSets - : m_BakedCmdBufferInfo[m_LastCmdBufferID].state.computeDescSets; + ? m_BakedCmdBufferInfo[m_LastCmdBufferID].state.graphics.descSets + : m_BakedCmdBufferInfo[m_LastCmdBufferID].state.compute.descSets; // expand as necessary if(descsets.size() < set + 1) @@ -4823,16 +4808,16 @@ bool WrappedVulkan::Serialise_vkCmdBindTransformFeedbackBuffersEXT( UnwrapArray(pBuffers, bindingCount), pOffsets, pSizes); - if(ShouldUpdateRenderState(m_LastCmdBufferID)) { - if(m_RenderState.xfbbuffers.size() < firstBinding + bindingCount) - m_RenderState.xfbbuffers.resize(firstBinding + bindingCount); + VulkanRenderState &renderstate = GetCmdRenderState(); + if(renderstate.xfbbuffers.size() < firstBinding + bindingCount) + renderstate.xfbbuffers.resize(firstBinding + bindingCount); for(uint32_t i = 0; i < bindingCount; i++) { - m_RenderState.xfbbuffers[firstBinding + i].buf = GetResID(pBuffers[i]); - m_RenderState.xfbbuffers[firstBinding + i].offs = pOffsets[i]; - m_RenderState.xfbbuffers[firstBinding + i].size = pSizes ? pSizes[i] : VK_WHOLE_SIZE; + renderstate.xfbbuffers[firstBinding + i].buf = GetResID(pBuffers[i]); + renderstate.xfbbuffers[firstBinding + i].offs = pOffsets[i]; + renderstate.xfbbuffers[firstBinding + i].size = pSizes ? pSizes[i] : VK_WHOLE_SIZE; } } } @@ -4844,7 +4829,7 @@ bool WrappedVulkan::Serialise_vkCmdBindTransformFeedbackBuffersEXT( m_BakedCmdBufferInfo[m_LastCmdBufferID].state.xfbbuffers.resize(firstBinding + bindingCount); for(uint32_t i = 0; i < bindingCount; i++) - m_BakedCmdBufferInfo[m_LastCmdBufferID].state.xfbbuffers[firstBinding + i] = + m_BakedCmdBufferInfo[m_LastCmdBufferID].state.xfbbuffers[firstBinding + i].buf = GetResID(pBuffers[i]); ObjDisp(commandBuffer) @@ -4918,17 +4903,16 @@ bool WrappedVulkan::Serialise_vkCmdBeginTransformFeedbackEXT( { commandBuffer = RerecordCmdBuf(m_LastCmdBufferID); - // only if we're partially recording do we update this state - if(ShouldUpdateRenderState(m_LastCmdBufferID)) { - m_RenderState.firstxfbcounter = firstBuffer; - m_RenderState.xfbcounters.resize(bufferCount); + VulkanRenderState &renderstate = GetCmdRenderState(); + renderstate.firstxfbcounter = firstBuffer; + renderstate.xfbcounters.resize(bufferCount); for(uint32_t i = 0; i < bufferCount; i++) { - m_RenderState.xfbcounters[i].buf = + renderstate.xfbcounters[i].buf = pCounterBuffers ? GetResID(pCounterBuffers[i]) : ResourceId(); - m_RenderState.xfbcounters[i].offs = pCounterBufferOffsets ? pCounterBufferOffsets[i] : 0; + renderstate.xfbcounters[i].offs = pCounterBufferOffsets ? pCounterBufferOffsets[i] : 0; } } @@ -4946,8 +4930,9 @@ bool WrappedVulkan::Serialise_vkCmdBeginTransformFeedbackEXT( pCounterBufferOffsets); // track while reading, for fetching the right set of outputs in AddDrawcall - m_BakedCmdBufferInfo[m_LastCmdBufferID].state.xfbfirst = firstBuffer; - m_BakedCmdBufferInfo[m_LastCmdBufferID].state.xfbcount = bufferCount; + m_BakedCmdBufferInfo[m_LastCmdBufferID].state.firstxfbcounter = firstBuffer; + // TODO: should change the xfbcount, resize? + m_BakedCmdBufferInfo[m_LastCmdBufferID].state.xfbcounters.resize(bufferCount); } } @@ -5014,11 +4999,10 @@ bool WrappedVulkan::Serialise_vkCmdEndTransformFeedbackEXT( { commandBuffer = RerecordCmdBuf(m_LastCmdBufferID); - // only if we're partially recording do we update this state - if(ShouldUpdateRenderState(m_LastCmdBufferID)) { - m_RenderState.firstxfbcounter = 0; - m_RenderState.xfbcounters.clear(); + VulkanRenderState &renderstate = GetCmdRenderState(); + renderstate.firstxfbcounter = 0; + renderstate.xfbcounters.clear(); } ObjDisp(commandBuffer) @@ -5035,8 +5019,8 @@ bool WrappedVulkan::Serialise_vkCmdEndTransformFeedbackEXT( pCounterBufferOffsets); // track while reading, for fetching the right set of outputs in AddDrawcall - m_BakedCmdBufferInfo[m_LastCmdBufferID].state.xfbfirst = 0; - m_BakedCmdBufferInfo[m_LastCmdBufferID].state.xfbcount = 0; + m_BakedCmdBufferInfo[m_LastCmdBufferID].state.firstxfbcounter = 0; + m_BakedCmdBufferInfo[m_LastCmdBufferID].state.xfbcounters.clear(); } } @@ -5219,11 +5203,11 @@ bool WrappedVulkan::Serialise_vkCmdBeginConditionalRenderingEXT( { commandBuffer = RerecordCmdBuf(m_LastCmdBufferID); - if(ShouldUpdateRenderState(m_LastCmdBufferID)) { - m_RenderState.conditionalRendering.buffer = GetResID(BeginInfo.buffer); - m_RenderState.conditionalRendering.offset = BeginInfo.offset; - m_RenderState.conditionalRendering.flags = BeginInfo.flags; + VulkanRenderState &renderstate = GetCmdRenderState(); + renderstate.conditionalRendering.buffer = GetResID(BeginInfo.buffer); + renderstate.conditionalRendering.offset = BeginInfo.offset; + renderstate.conditionalRendering.flags = BeginInfo.flags; } BeginInfo.buffer = Unwrap(BeginInfo.buffer); @@ -5291,8 +5275,10 @@ bool WrappedVulkan::Serialise_vkCmdEndConditionalRenderingEXT(SerialiserType &se { commandBuffer = RerecordCmdBuf(m_LastCmdBufferID); - if(ShouldUpdateRenderState(m_LastCmdBufferID)) - m_RenderState.conditionalRendering.buffer = ResourceId(); + { + VulkanRenderState &renderstate = GetCmdRenderState(); + renderstate.conditionalRendering.buffer = ResourceId(); + } ObjDisp(commandBuffer)->CmdEndConditionalRenderingEXT(Unwrap(commandBuffer)); } diff --git a/renderdoc/driver/vulkan/wrappers/vk_draw_funcs.cpp b/renderdoc/driver/vulkan/wrappers/vk_draw_funcs.cpp index 8203decd4..5e600810a 100644 --- a/renderdoc/driver/vulkan/wrappers/vk_draw_funcs.cpp +++ b/renderdoc/driver/vulkan/wrappers/vk_draw_funcs.cpp @@ -2421,10 +2421,9 @@ bool WrappedVulkan::Serialise_vkCmdClearAttachments(SerialiserType &ser, AddDrawcall(draw, true); VulkanDrawcallTreeNode &drawNode = GetDrawcallStack().back()->children.back(); - const BakedCmdBufferInfo::CmdBufferState &state = - m_BakedCmdBufferInfo[m_LastCmdBufferID].state; + const VulkanRenderState &state = m_BakedCmdBufferInfo[m_LastCmdBufferID].state; - if(state.renderPass != ResourceId() && state.framebuffer != ResourceId()) + if(state.renderPass != ResourceId() && state.GetFramebuffer() != ResourceId()) { VulkanCreationInfo::RenderPass &rp = m_CreationInfo.m_RenderPass[state.renderPass]; @@ -2439,10 +2438,10 @@ bool WrappedVulkan::Serialise_vkCmdClearAttachments(SerialiserType &ser, if(att < (uint32_t)rp.subpasses[state.subpass].colorAttachments.size()) { att = rp.subpasses[state.subpass].colorAttachments[att]; - drawNode.resourceUsage.push_back( - make_rdcpair(m_CreationInfo.m_ImageView[state.fbattachments[att]].image, - EventUsage(drawNode.draw.eventId, ResourceUsage::Clear, - state.fbattachments[att]))); + drawNode.resourceUsage.push_back(make_rdcpair( + m_CreationInfo.m_ImageView[state.GetFramebufferAttachments()[att]].image, + EventUsage(drawNode.draw.eventId, ResourceUsage::Clear, + state.GetFramebufferAttachments()[att]))); } } else if(pAttachments[a].aspectMask & VK_IMAGE_ASPECT_DEPTH_BIT) @@ -2450,10 +2449,10 @@ bool WrappedVulkan::Serialise_vkCmdClearAttachments(SerialiserType &ser, if(rp.subpasses[state.subpass].depthstencilAttachment >= 0) { att = (uint32_t)rp.subpasses[state.subpass].depthstencilAttachment; - drawNode.resourceUsage.push_back( - make_rdcpair(m_CreationInfo.m_ImageView[state.fbattachments[att]].image, - EventUsage(drawNode.draw.eventId, ResourceUsage::Clear, - state.fbattachments[att]))); + drawNode.resourceUsage.push_back(make_rdcpair( + m_CreationInfo.m_ImageView[state.GetFramebufferAttachments()[att]].image, + EventUsage(drawNode.draw.eventId, ResourceUsage::Clear, + state.GetFramebufferAttachments()[att]))); } } } diff --git a/renderdoc/driver/vulkan/wrappers/vk_dynamic_funcs.cpp b/renderdoc/driver/vulkan/wrappers/vk_dynamic_funcs.cpp index d6b226680..472915cb1 100644 --- a/renderdoc/driver/vulkan/wrappers/vk_dynamic_funcs.cpp +++ b/renderdoc/driver/vulkan/wrappers/vk_dynamic_funcs.cpp @@ -48,13 +48,13 @@ bool WrappedVulkan::Serialise_vkCmdSetViewport(SerialiserType &ser, VkCommandBuf { commandBuffer = RerecordCmdBuf(m_LastCmdBufferID); - if(ShouldUpdateRenderState(m_LastCmdBufferID)) { - if(m_RenderState.views.size() < firstViewport + viewportCount) - m_RenderState.views.resize(firstViewport + viewportCount); + VulkanRenderState &renderstate = GetCmdRenderState(); + if(renderstate.views.size() < firstViewport + viewportCount) + renderstate.views.resize(firstViewport + viewportCount); for(uint32_t i = 0; i < viewportCount; i++) - m_RenderState.views[firstViewport + i] = pViewports[i]; + renderstate.views[firstViewport + i] = pViewports[i]; } } else @@ -117,13 +117,13 @@ bool WrappedVulkan::Serialise_vkCmdSetScissor(SerialiserType &ser, VkCommandBuff { commandBuffer = RerecordCmdBuf(m_LastCmdBufferID); - if(ShouldUpdateRenderState(m_LastCmdBufferID)) { - if(m_RenderState.scissors.size() < firstScissor + scissorCount) - m_RenderState.scissors.resize(firstScissor + scissorCount); + VulkanRenderState &renderstate = GetCmdRenderState(); + if(renderstate.scissors.size() < firstScissor + scissorCount) + renderstate.scissors.resize(firstScissor + scissorCount); for(uint32_t i = 0; i < scissorCount; i++) - m_RenderState.scissors[firstScissor + i] = pScissors[i]; + renderstate.scissors[firstScissor + i] = pScissors[i]; } } else @@ -182,8 +182,9 @@ bool WrappedVulkan::Serialise_vkCmdSetLineWidth(SerialiserType &ser, VkCommandBu { commandBuffer = RerecordCmdBuf(m_LastCmdBufferID); - if(ShouldUpdateRenderState(m_LastCmdBufferID)) - m_RenderState.lineWidth = lineWidth; + { + GetCmdRenderState().lineWidth = lineWidth; + } } else { @@ -241,11 +242,11 @@ bool WrappedVulkan::Serialise_vkCmdSetDepthBias(SerialiserType &ser, VkCommandBu { commandBuffer = RerecordCmdBuf(m_LastCmdBufferID); - if(ShouldUpdateRenderState(m_LastCmdBufferID)) { - m_RenderState.bias.depth = depthBias; - m_RenderState.bias.biasclamp = depthBiasClamp; - m_RenderState.bias.slope = slopeScaledDepthBias; + VulkanRenderState &renderstate = GetCmdRenderState(); + renderstate.bias.depth = depthBias; + renderstate.bias.biasclamp = depthBiasClamp; + renderstate.bias.slope = slopeScaledDepthBias; } } else @@ -306,8 +307,10 @@ bool WrappedVulkan::Serialise_vkCmdSetBlendConstants(SerialiserType &ser, { commandBuffer = RerecordCmdBuf(m_LastCmdBufferID); - if(ShouldUpdateRenderState(m_LastCmdBufferID)) - memcpy(m_RenderState.blendConst, blendConst, sizeof(m_RenderState.blendConst)); + { + VulkanRenderState &renderstate = GetCmdRenderState(); + memcpy(renderstate.blendConst, blendConst, sizeof(renderstate.blendConst)); + } } else { @@ -363,10 +366,10 @@ bool WrappedVulkan::Serialise_vkCmdSetDepthBounds(SerialiserType &ser, VkCommand { commandBuffer = RerecordCmdBuf(m_LastCmdBufferID); - if(ShouldUpdateRenderState(m_LastCmdBufferID)) { - m_RenderState.mindepth = minDepthBounds; - m_RenderState.maxdepth = maxDepthBounds; + VulkanRenderState &renderstate = GetCmdRenderState(); + renderstate.mindepth = minDepthBounds; + renderstate.maxdepth = maxDepthBounds; } } else @@ -427,12 +430,12 @@ bool WrappedVulkan::Serialise_vkCmdSetStencilCompareMask(SerialiserType &ser, { commandBuffer = RerecordCmdBuf(m_LastCmdBufferID); - if(ShouldUpdateRenderState(m_LastCmdBufferID)) { + VulkanRenderState &renderstate = GetCmdRenderState(); if(faceMask & VK_STENCIL_FACE_FRONT_BIT) - m_RenderState.front.compare = compareMask; + renderstate.front.compare = compareMask; if(faceMask & VK_STENCIL_FACE_BACK_BIT) - m_RenderState.back.compare = compareMask; + renderstate.back.compare = compareMask; } } else @@ -493,12 +496,12 @@ bool WrappedVulkan::Serialise_vkCmdSetStencilWriteMask(SerialiserType &ser, { commandBuffer = RerecordCmdBuf(m_LastCmdBufferID); - if(ShouldUpdateRenderState(m_LastCmdBufferID)) { + VulkanRenderState &renderstate = GetCmdRenderState(); if(faceMask & VK_STENCIL_FACE_FRONT_BIT) - m_RenderState.front.write = writeMask; + renderstate.front.write = writeMask; if(faceMask & VK_STENCIL_FACE_BACK_BIT) - m_RenderState.back.write = writeMask; + renderstate.back.write = writeMask; } } else @@ -559,12 +562,12 @@ bool WrappedVulkan::Serialise_vkCmdSetStencilReference(SerialiserType &ser, { commandBuffer = RerecordCmdBuf(m_LastCmdBufferID); - if(ShouldUpdateRenderState(m_LastCmdBufferID)) { + VulkanRenderState &renderstate = GetCmdRenderState(); if(faceMask & VK_STENCIL_FACE_FRONT_BIT) - m_RenderState.front.ref = reference; + renderstate.front.ref = reference; if(faceMask & VK_STENCIL_FACE_BACK_BIT) - m_RenderState.back.ref = reference; + renderstate.back.ref = reference; } } else @@ -623,12 +626,12 @@ bool WrappedVulkan::Serialise_vkCmdSetSampleLocationsEXT( { commandBuffer = RerecordCmdBuf(m_LastCmdBufferID); - if(ShouldUpdateRenderState(m_LastCmdBufferID)) { - m_RenderState.sampleLocations.locations.assign(sampleInfo.pSampleLocations, - sampleInfo.sampleLocationsCount); - m_RenderState.sampleLocations.gridSize = sampleInfo.sampleLocationGridSize; - m_RenderState.sampleLocations.sampleCount = sampleInfo.sampleLocationsPerPixel; + VulkanRenderState &renderstate = GetCmdRenderState(); + renderstate.sampleLocations.locations.assign(sampleInfo.pSampleLocations, + sampleInfo.sampleLocationsCount); + renderstate.sampleLocations.gridSize = sampleInfo.sampleLocationGridSize; + renderstate.sampleLocations.sampleCount = sampleInfo.sampleLocationsPerPixel; } } else @@ -691,13 +694,13 @@ bool WrappedVulkan::Serialise_vkCmdSetDiscardRectangleEXT(SerialiserType &ser, { commandBuffer = RerecordCmdBuf(m_LastCmdBufferID); - if(ShouldUpdateRenderState(m_LastCmdBufferID)) { - if(m_RenderState.discardRectangles.size() < firstDiscardRectangle + discardRectangleCount) - m_RenderState.discardRectangles.resize(firstDiscardRectangle + discardRectangleCount); + VulkanRenderState &renderstate = GetCmdRenderState(); + if(renderstate.discardRectangles.size() < firstDiscardRectangle + discardRectangleCount) + renderstate.discardRectangles.resize(firstDiscardRectangle + discardRectangleCount); for(uint32_t i = 0; i < discardRectangleCount; i++) - m_RenderState.discardRectangles[firstDiscardRectangle + i] = pDiscardRectangles[i]; + renderstate.discardRectangles[firstDiscardRectangle + i] = pDiscardRectangles[i]; } } else @@ -764,10 +767,10 @@ bool WrappedVulkan::Serialise_vkCmdSetLineStippleEXT(SerialiserType &ser, { commandBuffer = RerecordCmdBuf(m_LastCmdBufferID); - if(ShouldUpdateRenderState(m_LastCmdBufferID)) { - m_RenderState.stippleFactor = lineStippleFactor; - m_RenderState.stipplePattern = lineStipplePattern; + VulkanRenderState &renderstate = GetCmdRenderState(); + renderstate.stippleFactor = lineStippleFactor; + renderstate.stipplePattern = lineStipplePattern; } } else