From 076c203f9a5b239d2f71dfc7c217759677e8a95e Mon Sep 17 00:00:00 2001 From: baldurk Date: Mon, 2 Oct 2017 15:17:00 +0100 Subject: [PATCH] Update drawcall wrapping Vulkan functions --- .../driver/vulkan/wrappers/vk_draw_funcs.cpp | 2562 +++++++++-------- 1 file changed, 1283 insertions(+), 1279 deletions(-) diff --git a/renderdoc/driver/vulkan/wrappers/vk_draw_funcs.cpp b/renderdoc/driver/vulkan/wrappers/vk_draw_funcs.cpp index 8c988ed32..863fb2316 100644 --- a/renderdoc/driver/vulkan/wrappers/vk_draw_funcs.cpp +++ b/renderdoc/driver/vulkan/wrappers/vk_draw_funcs.cpp @@ -29,7 +29,7 @@ bool WrappedVulkan::IsDrawInRenderPass() { ResourceId rp; - if(m_State == READING) + if(IsLoading(m_State)) rp = m_BakedCmdBufferInfo[m_LastCmdBufferID].state.renderPass; else rp = m_RenderState.renderPass; @@ -38,7 +38,7 @@ bool WrappedVulkan::IsDrawInRenderPass() bool rpActive = true; - if(m_State == EXECUTING) + if(IsActiveReplaying(m_State)) { cmdid = GetResID(RerecordCmdBuf(cmdid)); @@ -65,69 +65,72 @@ bool WrappedVulkan::IsDrawInRenderPass() return true; } -bool WrappedVulkan::Serialise_vkCmdDraw(Serialiser *localSerialiser, VkCommandBuffer commandBuffer, +template +bool WrappedVulkan::Serialise_vkCmdDraw(SerialiserType &ser, VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) { - SERIALISE_ELEMENT(ResourceId, cmdid, GetResID(commandBuffer)); - SERIALISE_ELEMENT(uint32_t, vtxCount, vertexCount); - SERIALISE_ELEMENT(uint32_t, instCount, instanceCount); - SERIALISE_ELEMENT(uint32_t, firstVtx, firstVertex); - SERIALISE_ELEMENT(uint32_t, firstInst, firstInstance); + SERIALISE_ELEMENT(commandBuffer); + SERIALISE_ELEMENT(vertexCount); + SERIALISE_ELEMENT(instanceCount); + SERIALISE_ELEMENT(firstVertex); + SERIALISE_ELEMENT(firstInstance); - Serialise_DebugMessages(localSerialiser, true); + Serialise_DebugMessages(ser); - if(m_State < WRITING) - m_LastCmdBufferID = cmdid; - - if(m_State == EXECUTING) + if(IsReplayingAndReading()) { - if(ShouldRerecordCmd(cmdid) && InRerecordRange(cmdid) && IsDrawInRenderPass()) + m_LastCmdBufferID = GetResourceManager()->GetOriginalID(GetResID(commandBuffer)); + + if(IsActiveReplaying(m_State)) { - commandBuffer = RerecordCmdBuf(cmdid); - - uint32_t eventID = HandlePreCallback(commandBuffer); - - ObjDisp(commandBuffer)->CmdDraw(Unwrap(commandBuffer), vtxCount, instCount, firstVtx, firstInst); - - if(eventID && m_DrawcallCallback->PostDraw(eventID, commandBuffer)) + if(ShouldRerecordCmd(m_LastCmdBufferID) && InRerecordRange(m_LastCmdBufferID) && + IsDrawInRenderPass()) { - ObjDisp(commandBuffer)->CmdDraw(Unwrap(commandBuffer), vtxCount, instCount, firstVtx, firstInst); - m_DrawcallCallback->PostRedraw(eventID, commandBuffer); + commandBuffer = RerecordCmdBuf(m_LastCmdBufferID); + + uint32_t eventID = HandlePreCallback(commandBuffer); + + ObjDisp(commandBuffer) + ->CmdDraw(Unwrap(commandBuffer), vertexCount, instanceCount, firstVertex, firstInstance); + + if(eventID && m_DrawcallCallback->PostDraw(eventID, commandBuffer)) + { + ObjDisp(commandBuffer) + ->CmdDraw(Unwrap(commandBuffer), vertexCount, instanceCount, firstVertex, + firstInstance); + m_DrawcallCallback->PostRedraw(eventID, commandBuffer); + } } } - } - else if(m_State == READING) - { - commandBuffer = GetResourceManager()->GetLiveHandle(cmdid); - - ObjDisp(commandBuffer)->CmdDraw(Unwrap(commandBuffer), vtxCount, instCount, firstVtx, firstInst); - - const string desc = localSerialiser->GetDebugStr(); - - if(!IsDrawInRenderPass()) + else { - AddDebugMessage(MessageCategory::Execution, MessageSeverity::High, - MessageSource::IncorrectAPIUse, - "Drawcall in happening outside of render pass, or in secondary command " - "buffer without RENDER_PASS_CONTINUE_BIT"); - } + ObjDisp(commandBuffer) + ->CmdDraw(Unwrap(commandBuffer), vertexCount, instanceCount, firstVertex, firstInstance); - { - AddEvent(desc); - string name = "vkCmdDraw(" + ToStr(vtxCount) + "," + ToStr(instCount) + ")"; + if(!IsDrawInRenderPass()) + { + AddDebugMessage(MessageCategory::Execution, MessageSeverity::High, + MessageSource::IncorrectAPIUse, + "Drawcall in happening outside of render pass, or in secondary command " + "buffer without RENDER_PASS_CONTINUE_BIT"); + } - DrawcallDescription draw; - draw.name = name; - draw.numIndices = vtxCount; - draw.numInstances = instCount; - draw.indexOffset = 0; - draw.vertexOffset = firstVtx; - draw.instanceOffset = firstInst; + { + AddEvent(); - draw.flags |= DrawFlags::Drawcall | DrawFlags::Instanced; + DrawcallDescription draw; + draw.name = StringFormat::Fmt("vkCmdDraw(%u, %u)", vertexCount, instanceCount); + draw.numIndices = vertexCount; + draw.numInstances = instanceCount; + draw.indexOffset = 0; + draw.vertexOffset = firstVertex; + draw.instanceOffset = firstInstance; - AddDrawcall(draw, true); + draw.flags |= DrawFlags::Drawcall | DrawFlags::Instanced; + + AddDrawcall(draw, true); + } } } @@ -142,89 +145,90 @@ void WrappedVulkan::vkCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCoun ObjDisp(commandBuffer) ->CmdDraw(Unwrap(commandBuffer), vertexCount, instanceCount, firstVertex, firstInstance); - if(m_State >= WRITING) + if(IsCaptureMode(m_State)) { VkResourceRecord *record = GetRecord(commandBuffer); CACHE_THREAD_SERIALISER(); - SCOPED_SERIALISE_CONTEXT(DRAW); - Serialise_vkCmdDraw(localSerialiser, commandBuffer, vertexCount, instanceCount, firstVertex, - firstInstance); + ser.SetDrawChunk(); + SCOPED_SERIALISE_CHUNK(VulkanChunk::vkCmdDraw); + Serialise_vkCmdDraw(ser, commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance); record->AddChunk(scope.Get()); } } -bool WrappedVulkan::Serialise_vkCmdDrawIndexed(Serialiser *localSerialiser, - VkCommandBuffer commandBuffer, uint32_t indexCount, - uint32_t instanceCount, uint32_t firstIndex, - int32_t vertexOffset, uint32_t firstInstance) +template +bool WrappedVulkan::Serialise_vkCmdDrawIndexed(SerialiserType &ser, VkCommandBuffer commandBuffer, + uint32_t indexCount, uint32_t instanceCount, + uint32_t firstIndex, int32_t vertexOffset, + uint32_t firstInstance) { - SERIALISE_ELEMENT(ResourceId, cmdid, GetResID(commandBuffer)); - SERIALISE_ELEMENT(uint32_t, idxCount, indexCount); - SERIALISE_ELEMENT(uint32_t, instCount, instanceCount); - SERIALISE_ELEMENT(uint32_t, firstIdx, firstIndex); - SERIALISE_ELEMENT(int32_t, vtxOffs, vertexOffset); - SERIALISE_ELEMENT(uint32_t, firstInst, firstInstance); + SERIALISE_ELEMENT(commandBuffer); + SERIALISE_ELEMENT(indexCount); + SERIALISE_ELEMENT(instanceCount); + SERIALISE_ELEMENT(firstIndex); + SERIALISE_ELEMENT(vertexOffset); + SERIALISE_ELEMENT(firstInstance); - Serialise_DebugMessages(localSerialiser, true); + Serialise_DebugMessages(ser); - if(m_State < WRITING) - m_LastCmdBufferID = cmdid; - - if(m_State == EXECUTING) + if(IsReplayingAndReading()) { - if(ShouldRerecordCmd(cmdid) && InRerecordRange(cmdid) && IsDrawInRenderPass()) + m_LastCmdBufferID = GetResourceManager()->GetOriginalID(GetResID(commandBuffer)); + + if(IsActiveReplaying(m_State)) { - commandBuffer = RerecordCmdBuf(cmdid); - - uint32_t eventID = HandlePreCallback(commandBuffer); - - ObjDisp(commandBuffer) - ->CmdDrawIndexed(Unwrap(commandBuffer), idxCount, instCount, firstIdx, vtxOffs, firstInst); - - if(eventID && m_DrawcallCallback->PostDraw(eventID, commandBuffer)) + if(ShouldRerecordCmd(m_LastCmdBufferID) && InRerecordRange(m_LastCmdBufferID) && + IsDrawInRenderPass()) { + commandBuffer = RerecordCmdBuf(m_LastCmdBufferID); + + uint32_t eventID = HandlePreCallback(commandBuffer); + ObjDisp(commandBuffer) - ->CmdDrawIndexed(Unwrap(commandBuffer), idxCount, instCount, firstIdx, vtxOffs, - firstInst); - m_DrawcallCallback->PostRedraw(eventID, commandBuffer); + ->CmdDrawIndexed(Unwrap(commandBuffer), indexCount, instanceCount, firstIndex, + vertexOffset, firstInstance); + + if(eventID && m_DrawcallCallback->PostDraw(eventID, commandBuffer)) + { + ObjDisp(commandBuffer) + ->CmdDrawIndexed(Unwrap(commandBuffer), indexCount, instanceCount, firstIndex, + vertexOffset, firstInstance); + m_DrawcallCallback->PostRedraw(eventID, commandBuffer); + } } } - } - else if(m_State == READING) - { - commandBuffer = GetResourceManager()->GetLiveHandle(cmdid); - - ObjDisp(commandBuffer) - ->CmdDrawIndexed(Unwrap(commandBuffer), idxCount, instCount, firstIdx, vtxOffs, firstInst); - - const string desc = localSerialiser->GetDebugStr(); - - if(!IsDrawInRenderPass()) + else { - AddDebugMessage(MessageCategory::Execution, MessageSeverity::High, - MessageSource::IncorrectAPIUse, - "Drawcall in happening outside of render pass, or in secondary command " - "buffer without RENDER_PASS_CONTINUE_BIT"); - } + ObjDisp(commandBuffer) + ->CmdDrawIndexed(Unwrap(commandBuffer), indexCount, instanceCount, firstIndex, + vertexOffset, firstInstance); - { - AddEvent(desc); - string name = "vkCmdDrawIndexed(" + ToStr(idxCount) + "," + ToStr(instCount) + ")"; + if(!IsDrawInRenderPass()) + { + AddDebugMessage(MessageCategory::Execution, MessageSeverity::High, + MessageSource::IncorrectAPIUse, + "Drawcall in happening outside of render pass, or in secondary command " + "buffer without RENDER_PASS_CONTINUE_BIT"); + } - DrawcallDescription draw; - draw.name = name; - draw.numIndices = idxCount; - draw.numInstances = instCount; - draw.indexOffset = firstIdx; - draw.baseVertex = vtxOffs; - draw.instanceOffset = firstInst; + { + AddEvent(); - draw.flags |= DrawFlags::Drawcall | DrawFlags::UseIBuffer | DrawFlags::Instanced; + DrawcallDescription draw; + draw.name = StringFormat::Fmt("vkCmdDrawIndexed(%u, %u)", indexCount, instanceCount); + draw.numIndices = indexCount; + draw.numInstances = instanceCount; + draw.indexOffset = firstIndex; + draw.baseVertex = vertexOffset; + draw.instanceOffset = firstInstance; - AddDrawcall(draw, true); + draw.flags |= DrawFlags::Drawcall | DrawFlags::UseIBuffer | DrawFlags::Instanced; + + AddDrawcall(draw, true); + } } } @@ -241,202 +245,219 @@ void WrappedVulkan::vkCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t ind ->CmdDrawIndexed(Unwrap(commandBuffer), indexCount, instanceCount, firstIndex, vertexOffset, firstInstance); - if(m_State >= WRITING) + if(IsCaptureMode(m_State)) { VkResourceRecord *record = GetRecord(commandBuffer); CACHE_THREAD_SERIALISER(); - SCOPED_SERIALISE_CONTEXT(DRAW_INDEXED); - Serialise_vkCmdDrawIndexed(localSerialiser, commandBuffer, indexCount, instanceCount, - firstIndex, vertexOffset, firstInstance); + ser.SetDrawChunk(); + SCOPED_SERIALISE_CHUNK(VulkanChunk::vkCmdDrawIndexed); + Serialise_vkCmdDrawIndexed(ser, commandBuffer, indexCount, instanceCount, firstIndex, + vertexOffset, firstInstance); record->AddChunk(scope.Get()); } } -bool WrappedVulkan::Serialise_vkCmdDrawIndirect(Serialiser *localSerialiser, - VkCommandBuffer commandBuffer, VkBuffer buffer, - VkDeviceSize offset, uint32_t count, uint32_t stride) +template +bool WrappedVulkan::Serialise_vkCmdDrawIndirect(SerialiserType &ser, VkCommandBuffer commandBuffer, + VkBuffer buffer, VkDeviceSize offset, + uint32_t count, uint32_t stride) { - SERIALISE_ELEMENT(ResourceId, cmdid, GetResID(commandBuffer)); - SERIALISE_ELEMENT(ResourceId, bufid, GetResID(buffer)); - SERIALISE_ELEMENT(uint64_t, offs, offset); + SERIALISE_ELEMENT(commandBuffer); + SERIALISE_ELEMENT(buffer); + SERIALISE_ELEMENT(offset); + SERIALISE_ELEMENT(count); + SERIALISE_ELEMENT(stride); - SERIALISE_ELEMENT(uint32_t, cnt, count); - SERIALISE_ELEMENT(uint32_t, strd, stride); + Serialise_DebugMessages(ser); - bool multidraw = cnt > 1; + bool multidraw = count > 1; - if(m_State < WRITING) - m_LastCmdBufferID = cmdid; - - // do execution (possibly partial) - if(m_State == READING) + if(IsReplayingAndReading()) { - commandBuffer = GetResourceManager()->GetLiveHandle(cmdid); - buffer = GetResourceManager()->GetLiveHandle(bufid); + m_LastCmdBufferID = GetResourceManager()->GetOriginalID(GetResID(commandBuffer)); - ObjDisp(commandBuffer)->CmdDrawIndirect(Unwrap(commandBuffer), Unwrap(buffer), offs, cnt, strd); - } - else if(m_State == EXECUTING && cnt <= 1) - { - // for single draws, it's pretty simple - buffer = GetResourceManager()->GetLiveHandle(bufid); - - if(ShouldRerecordCmd(cmdid) && InRerecordRange(cmdid) && IsDrawInRenderPass()) + // do execution (possibly partial) + if(IsActiveReplaying(m_State)) { - commandBuffer = RerecordCmdBuf(cmdid); - - uint32_t eventID = HandlePreCallback(commandBuffer); - - ObjDisp(commandBuffer)->CmdDrawIndirect(Unwrap(commandBuffer), Unwrap(buffer), offs, cnt, strd); - - if(eventID && m_DrawcallCallback->PostDraw(eventID, commandBuffer)) + if(!multidraw) { - ObjDisp(commandBuffer)->CmdDrawIndirect(Unwrap(commandBuffer), Unwrap(buffer), offs, cnt, strd); - m_DrawcallCallback->PostRedraw(eventID, commandBuffer); - } - } - } - else if(m_State == EXECUTING) - { - buffer = GetResourceManager()->GetLiveHandle(bufid); + // for single draws, it's pretty simple - if(ShouldRerecordCmd(cmdid) && InRerecordRange(cmdid)) - { - commandBuffer = RerecordCmdBuf(cmdid); - - uint32_t curEID = m_RootEventID; - - if(m_FirstEventID <= 1) - { - curEID = m_BakedCmdBufferInfo[m_LastCmdBufferID].curEventID; - - if(m_Partial[Primary].partialParent == m_LastCmdBufferID) - curEID += m_Partial[Primary].baseEvent; - else if(m_Partial[Secondary].partialParent == m_LastCmdBufferID) - curEID += m_Partial[Secondary].baseEvent; - } - - DrawcallUse use(m_CurChunkOffset, 0); - auto it = std::lower_bound(m_DrawcallUses.begin(), m_DrawcallUses.end(), use); - - RDCASSERT(it != m_DrawcallUses.end()); - - uint32_t baseEventID = it->eventID; - - // when re-recording all, submit every drawcall individually to the callback - if(m_DrawcallCallback && m_DrawcallCallback->RecordAllCmds() && IsDrawInRenderPass()) - { - for(uint32_t i = 0; i < cnt; i++) + if(ShouldRerecordCmd(m_LastCmdBufferID) && InRerecordRange(m_LastCmdBufferID) && + IsDrawInRenderPass()) { - uint32_t eventID = HandlePreCallback(commandBuffer, DrawFlags::Drawcall, i + 1); + commandBuffer = RerecordCmdBuf(m_LastCmdBufferID); - ObjDisp(commandBuffer)->CmdDrawIndirect(Unwrap(commandBuffer), Unwrap(buffer), offs, 1, strd); + uint32_t eventID = HandlePreCallback(commandBuffer); - if(eventID && m_DrawcallCallback->PostDraw(eventID, commandBuffer)) - { - ObjDisp(commandBuffer)->CmdDrawIndirect(Unwrap(commandBuffer), Unwrap(buffer), offs, 1, strd); - m_DrawcallCallback->PostRedraw(eventID, commandBuffer); - } - - offs += strd; - } - } - // To add the multidraw, we made an event N that is the 'parent' marker, then - // N+1, N+2, N+3, ... for each of the sub-draws. If the first sub-draw is selected - // then we'll replay up to N but not N+1, so just do nothing - we DON'T want to draw - // the first sub-draw in that range. - else if(m_LastEventID > baseEventID) - { - uint32_t drawidx = 0; - - if(m_FirstEventID <= 1) - { - // if we're replaying part-way into a multidraw, we can replay the first part 'easily' - // by just reducing the Count parameter to however many we want to replay. This only - // works if we're replaying from the first multidraw to the nth (n less than Count) - cnt = RDCMIN(cnt, m_LastEventID - baseEventID); - } - else - { - // otherwise we do the 'hard' case, draw only one multidraw - // note we'll never be asked to do e.g. 3rd-7th of a multidraw. Only ever 0th-nth or - // a single draw. - drawidx = (curEID - baseEventID - 1); - - offs += strd * drawidx; - cnt = 1; - } - - if(IsDrawInRenderPass()) - { - uint32_t eventID = HandlePreCallback(commandBuffer, DrawFlags::Drawcall, drawidx + 1); - - ObjDisp(commandBuffer)->CmdDrawIndirect(Unwrap(commandBuffer), Unwrap(buffer), offs, cnt, strd); + ObjDisp(commandBuffer) + ->CmdDrawIndirect(Unwrap(commandBuffer), Unwrap(buffer), offset, count, stride); if(eventID && m_DrawcallCallback->PostDraw(eventID, commandBuffer)) { ObjDisp(commandBuffer) - ->CmdDrawIndirect(Unwrap(commandBuffer), Unwrap(buffer), offs, cnt, strd); + ->CmdDrawIndirect(Unwrap(commandBuffer), Unwrap(buffer), offset, count, stride); m_DrawcallCallback->PostRedraw(eventID, commandBuffer); } } } - } - } - - const string desc = m_pSerialiser->GetDebugStr(); - - Serialise_DebugMessages(localSerialiser, true); - - // while reading, create the drawcall set - if(m_State == READING) - { - vector argbuf; - GetDebugManager()->GetBufferData(GetResID(buffer), offs, - sizeof(VkDrawIndirectCommand) + (cnt - 1) * strd, argbuf); - - string name = "vkCmdDrawIndirect(" + ToStr(cnt) + ")"; - - if(!IsDrawInRenderPass()) - { - AddDebugMessage(MessageCategory::Execution, MessageSeverity::High, - MessageSource::IncorrectAPIUse, - "Drawcall in happening outside of render pass, or in secondary command " - "buffer without RENDER_PASS_CONTINUE_BIT"); - } - - // for 'single' draws, don't do complex multi-draw just inline it - if(cnt <= 1) - { - DrawcallDescription draw; - - if(cnt == 1) + else { - VkDrawIndirectCommand *args = (VkDrawIndirectCommand *)&argbuf[0]; - - if(argbuf.size() >= sizeof(VkDrawIndirectCommand)) + if(ShouldRerecordCmd(m_LastCmdBufferID) && InRerecordRange(m_LastCmdBufferID)) { - name += StringFormat::Fmt(" => <%u, %u>", args->vertexCount, args->instanceCount); + commandBuffer = RerecordCmdBuf(m_LastCmdBufferID); - draw.numIndices = args->vertexCount; - draw.numInstances = args->instanceCount; - draw.vertexOffset = args->firstVertex; - draw.instanceOffset = args->firstInstance; - } - else - { - name += " => "; + uint32_t curEID = m_RootEventID; + + if(m_FirstEventID <= 1) + { + curEID = m_BakedCmdBufferInfo[m_LastCmdBufferID].curEventID; + + if(m_Partial[Primary].partialParent == m_LastCmdBufferID) + curEID += m_Partial[Primary].baseEvent; + else if(m_Partial[Secondary].partialParent == m_LastCmdBufferID) + curEID += m_Partial[Secondary].baseEvent; + } + + DrawcallUse use(m_CurChunkOffset, 0); + auto it = std::lower_bound(m_DrawcallUses.begin(), m_DrawcallUses.end(), use); + + RDCASSERT(it != m_DrawcallUses.end()); + + uint32_t baseEventID = it->eventID; + + // when re-recording all, submit every drawcall individually to the callback + if(m_DrawcallCallback && m_DrawcallCallback->RecordAllCmds() && IsDrawInRenderPass()) + { + for(uint32_t i = 0; i < count; i++) + { + uint32_t eventID = HandlePreCallback(commandBuffer, DrawFlags::Drawcall, i + 1); + + ObjDisp(commandBuffer) + ->CmdDrawIndirect(Unwrap(commandBuffer), Unwrap(buffer), offset, 1, stride); + + if(eventID && m_DrawcallCallback->PostDraw(eventID, commandBuffer)) + { + ObjDisp(commandBuffer) + ->CmdDrawIndirect(Unwrap(commandBuffer), Unwrap(buffer), offset, 1, stride); + m_DrawcallCallback->PostRedraw(eventID, commandBuffer); + } + + offset += stride; + } + } + // To add the multidraw, we made an event N that is the 'parent' marker, then + // N+1, N+2, N+3, ... for each of the sub-draws. If the first sub-draw is selected + // then we'll replay up to N but not N+1, so just do nothing - we DON'T want to draw + // the first sub-draw in that range. + else if(m_LastEventID > baseEventID) + { + uint32_t drawidx = 0; + + if(m_FirstEventID <= 1) + { + // if we're replaying part-way into a multidraw, we can replay the first part 'easily' + // by just reducing the Count parameter to however many we want to replay. This only + // works if we're replaying from the first multidraw to the nth (n less than Count) + count = RDCMIN(count, m_LastEventID - baseEventID); + } + else + { + // otherwise we do the 'hard' case, draw only one multidraw + // note we'll never be asked to do e.g. 3rd-7th of a multidraw. Only ever 0th-nth or + // a single draw. + drawidx = (curEID - baseEventID - 1); + + offset += stride * drawidx; + count = 1; + } + + if(IsDrawInRenderPass()) + { + uint32_t eventID = HandlePreCallback(commandBuffer, DrawFlags::Drawcall, drawidx + 1); + + ObjDisp(commandBuffer) + ->CmdDrawIndirect(Unwrap(commandBuffer), Unwrap(buffer), offset, count, stride); + + if(eventID && m_DrawcallCallback->PostDraw(eventID, commandBuffer)) + { + ObjDisp(commandBuffer) + ->CmdDrawIndirect(Unwrap(commandBuffer), Unwrap(buffer), offset, count, stride); + m_DrawcallCallback->PostRedraw(eventID, commandBuffer); + } + } + } } + + // multidraws skip the event ID past the whole thing + m_BakedCmdBufferInfo[m_LastCmdBufferID].curEventID += count + 1; + } + } + else + { + ObjDisp(commandBuffer) + ->CmdDrawIndirect(Unwrap(commandBuffer), Unwrap(buffer), offset, count, stride); + + std::vector argbuf; + GetDebugManager()->GetBufferData( + GetResID(buffer), offset, sizeof(VkDrawIndirectCommand) + (count - 1) * stride, argbuf); + + string name = "vkCmdDrawIndirect(" + ToStr(count) + ")"; + + if(!IsDrawInRenderPass()) + { + AddDebugMessage(MessageCategory::Execution, MessageSeverity::High, + MessageSource::IncorrectAPIUse, + "Drawcall in happening outside of render pass, or in secondary command " + "buffer without RENDER_PASS_CONTINUE_BIT"); } - AddEvent(desc); + // for 'single' draws, don't do complex multi-draw just inline it + if(count <= 1) + { + DrawcallDescription draw; + if(count == 1) + { + VkDrawIndirectCommand *args = (VkDrawIndirectCommand *)&argbuf[0]; + + if(argbuf.size() >= sizeof(VkDrawIndirectCommand)) + { + name += StringFormat::Fmt(" => <%u, %u>", args->vertexCount, args->instanceCount); + + draw.numIndices = args->vertexCount; + draw.numInstances = args->instanceCount; + draw.vertexOffset = args->firstVertex; + draw.instanceOffset = args->firstInstance; + } + else + { + name += " => "; + } + } + + AddEvent(); + + draw.name = name; + draw.flags = DrawFlags::Drawcall | DrawFlags::Instanced; + + AddDrawcall(draw, true); + + VulkanDrawcallTreeNode &drawNode = GetDrawcallStack().back()->children.back(); + + drawNode.resourceUsage.push_back(std::make_pair( + GetResID(buffer), EventUsage(drawNode.draw.eventID, ResourceUsage::Indirect))); + + return true; + } + + DrawcallDescription draw; draw.name = name; - draw.flags = DrawFlags::Drawcall | DrawFlags::Instanced; - + draw.flags = DrawFlags::MultiDraw | DrawFlags::PushMarker; + AddEvent(); AddDrawcall(draw, true); VulkanDrawcallTreeNode &drawNode = GetDrawcallStack().back()->children.back(); @@ -444,63 +465,45 @@ bool WrappedVulkan::Serialise_vkCmdDrawIndirect(Serialiser *localSerialiser, drawNode.resourceUsage.push_back(std::make_pair( GetResID(buffer), EventUsage(drawNode.draw.eventID, ResourceUsage::Indirect))); - return true; - } + m_BakedCmdBufferInfo[m_LastCmdBufferID].curEventID++; - DrawcallDescription draw; - draw.name = name; - draw.flags = DrawFlags::MultiDraw | DrawFlags::PushMarker; - AddEvent(desc); - AddDrawcall(draw, true); + uint32_t cmdOffs = 0; - VulkanDrawcallTreeNode &drawNode = GetDrawcallStack().back()->children.back(); - - drawNode.resourceUsage.push_back(std::make_pair( - GetResID(buffer), EventUsage(drawNode.draw.eventID, ResourceUsage::Indirect))); - - m_BakedCmdBufferInfo[m_LastCmdBufferID].curEventID++; - - uint32_t cmdOffs = 0; - - for(uint32_t i = 0; i < cnt; i++) - { - VkDrawIndirectCommand params = {}; - bool valid = false; - - if(cmdOffs + sizeof(VkDrawIndirectCommand) <= argbuf.size()) + for(uint32_t i = 0; i < count; i++) { - params = *((VkDrawIndirectCommand *)&argbuf[cmdOffs]); - valid = true; - cmdOffs += sizeof(VkDrawIndirectCommand); + VkDrawIndirectCommand params = {}; + bool valid = false; + + if(cmdOffs + sizeof(VkDrawIndirectCommand) <= argbuf.size()) + { + params = *((VkDrawIndirectCommand *)&argbuf[cmdOffs]); + valid = true; + cmdOffs += sizeof(VkDrawIndirectCommand); + } + + offset += stride; + + DrawcallDescription multi; + multi.numIndices = params.vertexCount; + multi.numInstances = params.instanceCount; + multi.vertexOffset = params.firstVertex; + multi.instanceOffset = params.firstInstance; + + multi.name = "vkCmdDrawIndirect[" + ToStr(i) + "](<" + ToStr(multi.numIndices) + ", " + + ToStr(multi.numInstances) + ">)"; + + multi.flags |= DrawFlags::Drawcall | DrawFlags::Instanced | DrawFlags::Indirect; + + AddEvent(); + AddDrawcall(multi, true); + + m_BakedCmdBufferInfo[m_LastCmdBufferID].curEventID++; } - offs += strd; - - DrawcallDescription multi; - multi.numIndices = params.vertexCount; - multi.numInstances = params.instanceCount; - multi.vertexOffset = params.firstVertex; - multi.instanceOffset = params.firstInstance; - - multi.name = "vkCmdDrawIndirect[" + ToStr(i) + "](<" + ToStr(multi.numIndices) + ", " + - ToStr(multi.numInstances) + ">)"; - - multi.flags |= DrawFlags::Drawcall | DrawFlags::Instanced | DrawFlags::Indirect; - - AddEvent(multi.name); - AddDrawcall(multi, true); - - m_BakedCmdBufferInfo[m_LastCmdBufferID].curEventID++; + draw.name = name; + draw.flags = DrawFlags::PopMarker; + AddDrawcall(draw, false); } - - draw.name = name; - draw.flags = DrawFlags::PopMarker; - AddDrawcall(draw, false); - } - else if(multidraw) - { - // multidraws skip the event ID past the whole thing - m_BakedCmdBufferInfo[m_LastCmdBufferID].curEventID += cnt + 1; } return true; @@ -513,14 +516,15 @@ void WrappedVulkan::vkCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer bu ObjDisp(commandBuffer)->CmdDrawIndirect(Unwrap(commandBuffer), Unwrap(buffer), offset, count, stride); - if(m_State >= WRITING) + if(IsCaptureMode(m_State)) { VkResourceRecord *record = GetRecord(commandBuffer); CACHE_THREAD_SERIALISER(); - SCOPED_SERIALISE_CONTEXT(DRAW_INDIRECT); - Serialise_vkCmdDrawIndirect(localSerialiser, commandBuffer, buffer, offset, count, stride); + ser.SetDrawChunk(); + SCOPED_SERIALISE_CHUNK(VulkanChunk::vkCmdDrawIndirect); + Serialise_vkCmdDrawIndirect(ser, commandBuffer, buffer, offset, count, stride); record->AddChunk(scope.Get()); @@ -531,207 +535,209 @@ void WrappedVulkan::vkCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer bu } } -bool WrappedVulkan::Serialise_vkCmdDrawIndexedIndirect(Serialiser *localSerialiser, +template +bool WrappedVulkan::Serialise_vkCmdDrawIndexedIndirect(SerialiserType &ser, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride) { - SERIALISE_ELEMENT(ResourceId, cmdid, GetResID(commandBuffer)); - SERIALISE_ELEMENT(ResourceId, bufid, GetResID(buffer)); - SERIALISE_ELEMENT(uint64_t, offs, offset); + SERIALISE_ELEMENT(commandBuffer); + SERIALISE_ELEMENT(buffer); + SERIALISE_ELEMENT(offset); + SERIALISE_ELEMENT(count); + SERIALISE_ELEMENT(stride); - SERIALISE_ELEMENT(uint32_t, cnt, count); - SERIALISE_ELEMENT(uint32_t, strd, stride); + Serialise_DebugMessages(ser); - bool multidraw = cnt > 1; + bool multidraw = count > 1; - if(m_State < WRITING) - m_LastCmdBufferID = cmdid; - - // do execution (possibly partial) - if(m_State == READING) + if(IsReplayingAndReading()) { - commandBuffer = GetResourceManager()->GetLiveHandle(cmdid); - buffer = GetResourceManager()->GetLiveHandle(bufid); + m_LastCmdBufferID = GetResourceManager()->GetOriginalID(GetResID(commandBuffer)); - ObjDisp(commandBuffer)->CmdDrawIndexedIndirect(Unwrap(commandBuffer), Unwrap(buffer), offs, cnt, strd); - } - else if(m_State == EXECUTING && cnt <= 1) - { - // for single draws, it's pretty simple - buffer = GetResourceManager()->GetLiveHandle(bufid); - - if(ShouldRerecordCmd(cmdid) && InRerecordRange(cmdid) && IsDrawInRenderPass()) + // do execution (possibly partial) + if(IsActiveReplaying(m_State)) { - commandBuffer = RerecordCmdBuf(cmdid); - - uint32_t eventID = HandlePreCallback(commandBuffer); - - ObjDisp(commandBuffer) - ->CmdDrawIndexedIndirect(Unwrap(commandBuffer), Unwrap(buffer), offs, cnt, strd); - - if(eventID && m_DrawcallCallback->PostDraw(eventID, commandBuffer)) + if(!multidraw) { - ObjDisp(commandBuffer) - ->CmdDrawIndexedIndirect(Unwrap(commandBuffer), Unwrap(buffer), offs, cnt, strd); - m_DrawcallCallback->PostRedraw(eventID, commandBuffer); - } - } - } - else if(m_State == EXECUTING) - { - buffer = GetResourceManager()->GetLiveHandle(bufid); + // for single draws, it's pretty simple - if(ShouldRerecordCmd(cmdid) && InRerecordRange(cmdid)) - { - commandBuffer = RerecordCmdBuf(cmdid); - - uint32_t curEID = m_RootEventID; - - if(m_FirstEventID <= 1) - { - curEID = m_BakedCmdBufferInfo[m_LastCmdBufferID].curEventID; - - if(m_Partial[Primary].partialParent == m_LastCmdBufferID) - curEID += m_Partial[Primary].baseEvent; - else if(m_Partial[Secondary].partialParent == m_LastCmdBufferID) - curEID += m_Partial[Secondary].baseEvent; - } - - DrawcallUse use(m_CurChunkOffset, 0); - auto it = std::lower_bound(m_DrawcallUses.begin(), m_DrawcallUses.end(), use); - - RDCASSERT(it != m_DrawcallUses.end()); - - uint32_t baseEventID = it->eventID; - - // when re-recording all, submit every drawcall individually to the callback - if(m_DrawcallCallback && m_DrawcallCallback->RecordAllCmds() && IsDrawInRenderPass()) - { - for(uint32_t i = 0; i < cnt; i++) + if(ShouldRerecordCmd(m_LastCmdBufferID) && InRerecordRange(m_LastCmdBufferID) && + IsDrawInRenderPass()) { - uint32_t eventID = HandlePreCallback(commandBuffer, DrawFlags::Drawcall, i + 1); + commandBuffer = RerecordCmdBuf(m_LastCmdBufferID); + + uint32_t eventID = HandlePreCallback(commandBuffer); ObjDisp(commandBuffer) - ->CmdDrawIndexedIndirect(Unwrap(commandBuffer), Unwrap(buffer), offs, 1, strd); + ->CmdDrawIndexedIndirect(Unwrap(commandBuffer), Unwrap(buffer), offset, count, stride); if(eventID && m_DrawcallCallback->PostDraw(eventID, commandBuffer)) { ObjDisp(commandBuffer) - ->CmdDrawIndexedIndirect(Unwrap(commandBuffer), Unwrap(buffer), offs, 1, strd); + ->CmdDrawIndexedIndirect(Unwrap(commandBuffer), Unwrap(buffer), offset, count, + stride); m_DrawcallCallback->PostRedraw(eventID, commandBuffer); } - - offs += strd; } } - // To add the multidraw, we made an event N that is the 'parent' marker, then - // N+1, N+2, N+3, ... for each of the sub-draws. If the first sub-draw is selected - // then we'll replay up to N but not N+1, so just do nothing - we DON'T want to draw - // the first sub-draw in that range. - else if(m_LastEventID > baseEventID) + else { - uint32_t drawidx = 0; + if(ShouldRerecordCmd(m_LastCmdBufferID) && InRerecordRange(m_LastCmdBufferID)) + { + commandBuffer = RerecordCmdBuf(m_LastCmdBufferID); - if(m_FirstEventID <= 1) - { - // if we're replaying part-way into a multidraw, we can replay the first part 'easily' - // by just reducing the Count parameter to however many we want to replay. This only - // works if we're replaying from the first multidraw to the nth (n less than Count) - cnt = RDCMIN(cnt, m_LastEventID - baseEventID); - } - else - { - if(curEID > baseEventID) + uint32_t curEID = m_RootEventID; + + if(m_FirstEventID <= 1) { - // otherwise we do the 'hard' case, draw only one multidraw - // note we'll never be asked to do e.g. 3rd-7th of a multidraw. Only ever 0th-nth or - // a single draw. - drawidx = (curEID - baseEventID - 1); + curEID = m_BakedCmdBufferInfo[m_LastCmdBufferID].curEventID; - RDCASSERT(drawidx < cnt, drawidx, cnt); + if(m_Partial[Primary].partialParent == m_LastCmdBufferID) + curEID += m_Partial[Primary].baseEvent; + else if(m_Partial[Secondary].partialParent == m_LastCmdBufferID) + curEID += m_Partial[Secondary].baseEvent; + } - if(drawidx >= cnt) - drawidx = 0; + DrawcallUse use(m_CurChunkOffset, 0); + auto it = std::lower_bound(m_DrawcallUses.begin(), m_DrawcallUses.end(), use); - offs += strd * drawidx; - cnt = 1; + RDCASSERT(it != m_DrawcallUses.end()); + + uint32_t baseEventID = it->eventID; + + // when re-recording all, submit every drawcall individually to the callback + if(m_DrawcallCallback && m_DrawcallCallback->RecordAllCmds() && IsDrawInRenderPass()) + { + for(uint32_t i = 0; i < count; i++) + { + uint32_t eventID = HandlePreCallback(commandBuffer, DrawFlags::Drawcall, i + 1); + + ObjDisp(commandBuffer) + ->CmdDrawIndexedIndirect(Unwrap(commandBuffer), Unwrap(buffer), offset, 1, stride); + + if(eventID && m_DrawcallCallback->PostDraw(eventID, commandBuffer)) + { + ObjDisp(commandBuffer) + ->CmdDrawIndexedIndirect(Unwrap(commandBuffer), Unwrap(buffer), offset, 1, + stride); + m_DrawcallCallback->PostRedraw(eventID, commandBuffer); + } + + offset += stride; + } + } + // To add the multidraw, we made an event N that is the 'parent' marker, then + // N+1, N+2, N+3, ... for each of the sub-draws. If the first sub-draw is selected + // then we'll replay up to N but not N+1, so just do nothing - we DON'T want to draw + // the first sub-draw in that range. + else if(m_LastEventID > baseEventID) + { + uint32_t drawidx = 0; + + if(m_FirstEventID <= 1) + { + // if we're replaying part-way into a multidraw, we can replay the first part 'easily' + // by just reducing the Count parameter to however many we want to replay. This only + // works if we're replaying from the first multidraw to the nth (n less than Count) + count = RDCMIN(count, m_LastEventID - baseEventID); + } + else + { + // otherwise we do the 'hard' case, draw only one multidraw + // note we'll never be asked to do e.g. 3rd-7th of a multidraw. Only ever 0th-nth or + // a single draw. + drawidx = (curEID - baseEventID - 1); + + offset += stride * drawidx; + count = 1; + } + + if(IsDrawInRenderPass()) + { + uint32_t eventID = HandlePreCallback(commandBuffer, DrawFlags::Drawcall, drawidx + 1); + + ObjDisp(commandBuffer) + ->CmdDrawIndirect(Unwrap(commandBuffer), Unwrap(buffer), offset, count, stride); + + if(eventID && m_DrawcallCallback->PostDraw(eventID, commandBuffer)) + { + ObjDisp(commandBuffer) + ->CmdDrawIndirect(Unwrap(commandBuffer), Unwrap(buffer), offset, count, stride); + m_DrawcallCallback->PostRedraw(eventID, commandBuffer); + } + } + } + } + + // multidraws skip the event ID past the whole thing + m_BakedCmdBufferInfo[m_LastCmdBufferID].curEventID += count + 1; + } + } + else + { + ObjDisp(commandBuffer) + ->CmdDrawIndexedIndirect(Unwrap(commandBuffer), Unwrap(buffer), offset, count, stride); + + std::vector argbuf; + GetDebugManager()->GetBufferData(GetResID(buffer), offset, + sizeof(VkDrawIndexedIndirectCommand) + (count - 1) * stride, + argbuf); + + string name = "vkCmdDrawIndexedIndirect(" + ToStr(count) + ")"; + + if(!IsDrawInRenderPass()) + { + AddDebugMessage(MessageCategory::Execution, MessageSeverity::High, + MessageSource::IncorrectAPIUse, + "Drawcall in happening outside of render pass, or in secondary command " + "buffer without RENDER_PASS_CONTINUE_BIT"); + } + + // for 'single' draws, don't do complex multi-draw just inline it + if(count <= 1) + { + DrawcallDescription draw; + + if(count == 1) + { + VkDrawIndexedIndirectCommand *args = (VkDrawIndexedIndirectCommand *)&argbuf[0]; + + if(argbuf.size() >= sizeof(VkDrawIndexedIndirectCommand)) + { + name += StringFormat::Fmt(" => <%u, %u>", args->indexCount, args->instanceCount); + + draw.numIndices = args->indexCount; + draw.numInstances = args->instanceCount; + draw.vertexOffset = args->vertexOffset; + draw.indexOffset = args->firstIndex; + draw.instanceOffset = args->firstInstance; } else { - cnt = 0; + name += " => "; } } - if(IsDrawInRenderPass()) - { - uint32_t eventID = HandlePreCallback(commandBuffer, DrawFlags::Drawcall, drawidx + 1); + AddEvent(); - ObjDisp(commandBuffer) - ->CmdDrawIndexedIndirect(Unwrap(commandBuffer), Unwrap(buffer), offs, cnt, strd); + draw.name = name; + draw.flags = DrawFlags::Drawcall | DrawFlags::Instanced; - if(eventID && m_DrawcallCallback->PostDraw(eventID, commandBuffer)) - { - ObjDisp(commandBuffer) - ->CmdDrawIndexedIndirect(Unwrap(commandBuffer), Unwrap(buffer), offs, cnt, strd); - m_DrawcallCallback->PostRedraw(eventID, commandBuffer); - } - } + AddDrawcall(draw, true); + + VulkanDrawcallTreeNode &drawNode = GetDrawcallStack().back()->children.back(); + + drawNode.resourceUsage.push_back(std::make_pair( + GetResID(buffer), EventUsage(drawNode.draw.eventID, ResourceUsage::Indirect))); + + return true; } - } - } - const string desc = m_pSerialiser->GetDebugStr(); - - Serialise_DebugMessages(localSerialiser, true); - - // while reading, create the drawcall set - if(m_State == READING) - { - vector argbuf; - GetDebugManager()->GetBufferData( - GetResID(buffer), offs, sizeof(VkDrawIndexedIndirectCommand) + (cnt - 1) * strd, argbuf); - - string name = "vkCmdDrawIndexedIndirect(" + ToStr(cnt) + ")"; - - if(!IsDrawInRenderPass()) - { - AddDebugMessage(MessageCategory::Execution, MessageSeverity::High, - MessageSource::IncorrectAPIUse, - "Drawcall in happening outside of render pass, or in secondary command " - "buffer without RENDER_PASS_CONTINUE_BIT"); - } - - // for 'single' draws, don't do complex multi-draw just inline it - if(cnt <= 1) - { DrawcallDescription draw; - - if(cnt == 1) - { - VkDrawIndexedIndirectCommand *args = (VkDrawIndexedIndirectCommand *)&argbuf[0]; - - if(argbuf.size() >= sizeof(VkDrawIndexedIndirectCommand)) - { - name += StringFormat::Fmt(" => <%u, %u>", args->indexCount, args->instanceCount); - - draw.numIndices = args->indexCount; - draw.numInstances = args->instanceCount; - draw.vertexOffset = args->vertexOffset; - draw.indexOffset = args->firstIndex; - draw.instanceOffset = args->firstInstance; - } - else - { - name += " => "; - } - } - - AddEvent(desc); - draw.name = name; - draw.flags = DrawFlags::Drawcall | DrawFlags::UseIBuffer | DrawFlags::Instanced; - + draw.flags = DrawFlags::MultiDraw | DrawFlags::PushMarker; + AddEvent(); AddDrawcall(draw, true); VulkanDrawcallTreeNode &drawNode = GetDrawcallStack().back()->children.back(); @@ -739,65 +745,46 @@ bool WrappedVulkan::Serialise_vkCmdDrawIndexedIndirect(Serialiser *localSerialis drawNode.resourceUsage.push_back(std::make_pair( GetResID(buffer), EventUsage(drawNode.draw.eventID, ResourceUsage::Indirect))); - return true; - } + m_BakedCmdBufferInfo[m_LastCmdBufferID].curEventID++; - DrawcallDescription draw; - draw.name = name; - draw.flags = DrawFlags::MultiDraw | DrawFlags::PushMarker; - AddEvent(desc); - AddDrawcall(draw, true); + uint32_t cmdOffs = 0; - VulkanDrawcallTreeNode &drawNode = GetDrawcallStack().back()->children.back(); - - drawNode.resourceUsage.push_back(std::make_pair( - GetResID(buffer), EventUsage(drawNode.draw.eventID, ResourceUsage::Indirect))); - - m_BakedCmdBufferInfo[m_LastCmdBufferID].curEventID++; - - uint32_t cmdOffs = 0; - - for(uint32_t i = 0; i < cnt; i++) - { - VkDrawIndexedIndirectCommand params = {}; - bool valid = false; - - if(cmdOffs + sizeof(VkDrawIndexedIndirectCommand) <= argbuf.size()) + for(uint32_t i = 0; i < count; i++) { - params = *((VkDrawIndexedIndirectCommand *)&argbuf[cmdOffs]); - valid = true; - cmdOffs += sizeof(VkDrawIndexedIndirectCommand); + VkDrawIndexedIndirectCommand params = {}; + bool valid = false; + + if(cmdOffs + sizeof(VkDrawIndexedIndirectCommand) <= argbuf.size()) + { + params = *((VkDrawIndexedIndirectCommand *)&argbuf[cmdOffs]); + valid = true; + cmdOffs += sizeof(VkDrawIndexedIndirectCommand); + } + + offset += stride; + + DrawcallDescription multi; + multi.numIndices = params.indexCount; + multi.numInstances = params.instanceCount; + multi.vertexOffset = params.vertexOffset; + multi.indexOffset = params.firstIndex; + multi.instanceOffset = params.firstInstance; + + multi.name = "vkCmdDrawIndexedIndirect[" + ToStr(i) + "](<" + ToStr(multi.numIndices) + + ", " + ToStr(multi.numInstances) + ">)"; + + multi.flags |= DrawFlags::Drawcall | DrawFlags::Instanced | DrawFlags::Indirect; + + AddEvent(); + AddDrawcall(multi, true); + + m_BakedCmdBufferInfo[m_LastCmdBufferID].curEventID++; } - offs += strd; - - DrawcallDescription multi; - multi.numIndices = params.indexCount; - multi.numInstances = params.instanceCount; - multi.vertexOffset = params.vertexOffset; - multi.indexOffset = params.firstIndex; - multi.instanceOffset = params.firstInstance; - - multi.name = "vkCmdDrawIndexedIndirect[" + ToStr(i) + "](<" + ToStr(multi.numIndices) + ", " + - ToStr(multi.numInstances) + ">)"; - - multi.flags |= - DrawFlags::Drawcall | DrawFlags::UseIBuffer | DrawFlags::Instanced | DrawFlags::Indirect; - - AddEvent(multi.name); - AddDrawcall(multi, true); - - m_BakedCmdBufferInfo[m_LastCmdBufferID].curEventID++; + draw.name = name; + draw.flags = DrawFlags::PopMarker; + AddDrawcall(draw, false); } - - draw.name = name; - draw.flags = DrawFlags::PopMarker; - AddDrawcall(draw, false); - } - else if(multidraw) - { - // multidraws skip the event ID past the whole thing - m_BakedCmdBufferInfo[m_LastCmdBufferID].curEventID += cnt + 1; } return true; @@ -811,14 +798,15 @@ void WrappedVulkan::vkCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBu ObjDisp(commandBuffer) ->CmdDrawIndexedIndirect(Unwrap(commandBuffer), Unwrap(buffer), offset, count, stride); - if(m_State >= WRITING) + if(IsCaptureMode(m_State)) { VkResourceRecord *record = GetRecord(commandBuffer); CACHE_THREAD_SERIALISER(); - SCOPED_SERIALISE_CONTEXT(DRAW_INDEXED_INDIRECT); - Serialise_vkCmdDrawIndexedIndirect(localSerialiser, commandBuffer, buffer, offset, count, stride); + ser.SetDrawChunk(); + SCOPED_SERIALISE_CHUNK(VulkanChunk::vkCmdDrawIndexedIndirect); + Serialise_vkCmdDrawIndexedIndirect(ser, commandBuffer, buffer, offset, count, stride); record->AddChunk(scope.Get()); @@ -829,58 +817,55 @@ void WrappedVulkan::vkCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBu } } -bool WrappedVulkan::Serialise_vkCmdDispatch(Serialiser *localSerialiser, - VkCommandBuffer commandBuffer, uint32_t x, uint32_t y, - uint32_t z) +template +bool WrappedVulkan::Serialise_vkCmdDispatch(SerialiserType &ser, VkCommandBuffer commandBuffer, + uint32_t x, uint32_t y, uint32_t z) { - SERIALISE_ELEMENT(ResourceId, cmdid, GetResID(commandBuffer)); - SERIALISE_ELEMENT(uint32_t, X, x); - SERIALISE_ELEMENT(uint32_t, Y, y); - SERIALISE_ELEMENT(uint32_t, Z, z); + SERIALISE_ELEMENT(commandBuffer); + SERIALISE_ELEMENT(x); + SERIALISE_ELEMENT(y); + SERIALISE_ELEMENT(z); - Serialise_DebugMessages(localSerialiser, true); + Serialise_DebugMessages(ser); - if(m_State < WRITING) - m_LastCmdBufferID = cmdid; - - if(m_State == EXECUTING) + if(IsReplayingAndReading()) { - if(ShouldRerecordCmd(cmdid) && InRerecordRange(cmdid)) + m_LastCmdBufferID = GetResourceManager()->GetOriginalID(GetResID(commandBuffer)); + + if(IsActiveReplaying(m_State)) { - commandBuffer = RerecordCmdBuf(cmdid); - - uint32_t eventID = HandlePreCallback(commandBuffer, DrawFlags::Dispatch); - - ObjDisp(commandBuffer)->CmdDispatch(Unwrap(commandBuffer), X, Y, Z); - - if(eventID && m_DrawcallCallback->PostDispatch(eventID, commandBuffer)) + if(ShouldRerecordCmd(m_LastCmdBufferID) && InRerecordRange(m_LastCmdBufferID)) { - ObjDisp(commandBuffer)->CmdDispatch(Unwrap(commandBuffer), X, Y, Z); - m_DrawcallCallback->PostRedispatch(eventID, commandBuffer); + commandBuffer = RerecordCmdBuf(m_LastCmdBufferID); + + uint32_t eventID = HandlePreCallback(commandBuffer, DrawFlags::Dispatch); + + ObjDisp(commandBuffer)->CmdDispatch(Unwrap(commandBuffer), x, y, z); + + if(eventID && m_DrawcallCallback->PostDispatch(eventID, commandBuffer)) + { + ObjDisp(commandBuffer)->CmdDispatch(Unwrap(commandBuffer), x, y, z); + m_DrawcallCallback->PostRedispatch(eventID, commandBuffer); + } } } - } - else if(m_State == READING) - { - commandBuffer = GetResourceManager()->GetLiveHandle(cmdid); - - ObjDisp(commandBuffer)->CmdDispatch(Unwrap(commandBuffer), X, Y, Z); - - const string desc = localSerialiser->GetDebugStr(); - + else { - AddEvent(desc); - string name = "vkCmdDispatch(" + ToStr(X) + "," + ToStr(Y) + "," + ToStr(Z) + ")"; + ObjDisp(commandBuffer)->CmdDispatch(Unwrap(commandBuffer), x, y, z); - DrawcallDescription draw; - draw.name = name; - draw.dispatchDimension[0] = X; - draw.dispatchDimension[1] = Y; - draw.dispatchDimension[2] = Z; + { + AddEvent(); - draw.flags |= DrawFlags::Dispatch; + DrawcallDescription draw; + draw.name = StringFormat::Fmt("vkCmdDispatch(%u, %u, %u)", x, y, z); + draw.dispatchDimension[0] = x; + draw.dispatchDimension[1] = y; + draw.dispatchDimension[2] = z; - AddDrawcall(draw, true); + draw.flags |= DrawFlags::Dispatch; + + AddDrawcall(draw, true); + } } } @@ -893,91 +878,87 @@ void WrappedVulkan::vkCmdDispatch(VkCommandBuffer commandBuffer, uint32_t x, uin ObjDisp(commandBuffer)->CmdDispatch(Unwrap(commandBuffer), x, y, z); - if(m_State >= WRITING) + if(IsCaptureMode(m_State)) { VkResourceRecord *record = GetRecord(commandBuffer); CACHE_THREAD_SERIALISER(); - SCOPED_SERIALISE_CONTEXT(DISPATCH); - Serialise_vkCmdDispatch(localSerialiser, commandBuffer, x, y, z); + ser.SetDrawChunk(); + SCOPED_SERIALISE_CHUNK(VulkanChunk::vkCmdDispatch); + Serialise_vkCmdDispatch(ser, commandBuffer, x, y, z); record->AddChunk(scope.Get()); } } -bool WrappedVulkan::Serialise_vkCmdDispatchIndirect(Serialiser *localSerialiser, +template +bool WrappedVulkan::Serialise_vkCmdDispatchIndirect(SerialiserType &ser, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset) { - SERIALISE_ELEMENT(ResourceId, cmdid, GetResID(commandBuffer)); - SERIALISE_ELEMENT(ResourceId, bufid, GetResID(buffer)); - SERIALISE_ELEMENT(uint64_t, offs, offset); + SERIALISE_ELEMENT(commandBuffer); + SERIALISE_ELEMENT(buffer); + SERIALISE_ELEMENT(offset); - Serialise_DebugMessages(localSerialiser, true); + Serialise_DebugMessages(ser); - if(m_State < WRITING) - m_LastCmdBufferID = cmdid; - - if(m_State == EXECUTING) + if(IsReplayingAndReading()) { - buffer = GetResourceManager()->GetLiveHandle(bufid); + m_LastCmdBufferID = GetResourceManager()->GetOriginalID(GetResID(commandBuffer)); - if(ShouldRerecordCmd(cmdid) && InRerecordRange(cmdid)) + if(IsActiveReplaying(m_State)) { - commandBuffer = RerecordCmdBuf(cmdid); - - uint32_t eventID = HandlePreCallback(commandBuffer, DrawFlags::Dispatch); - - ObjDisp(commandBuffer)->CmdDispatchIndirect(Unwrap(commandBuffer), Unwrap(buffer), offs); - - if(eventID && m_DrawcallCallback->PostDispatch(eventID, commandBuffer)) + if(ShouldRerecordCmd(m_LastCmdBufferID) && InRerecordRange(m_LastCmdBufferID)) { - ObjDisp(commandBuffer)->CmdDispatchIndirect(Unwrap(commandBuffer), Unwrap(buffer), offs); - m_DrawcallCallback->PostRedispatch(eventID, commandBuffer); + commandBuffer = RerecordCmdBuf(m_LastCmdBufferID); + + uint32_t eventID = HandlePreCallback(commandBuffer, DrawFlags::Dispatch); + + ObjDisp(commandBuffer)->CmdDispatchIndirect(Unwrap(commandBuffer), Unwrap(buffer), offset); + + if(eventID && m_DrawcallCallback->PostDispatch(eventID, commandBuffer)) + { + ObjDisp(commandBuffer)->CmdDispatchIndirect(Unwrap(commandBuffer), Unwrap(buffer), offset); + m_DrawcallCallback->PostRedispatch(eventID, commandBuffer); + } } } - } - else if(m_State == READING) - { - commandBuffer = GetResourceManager()->GetLiveHandle(cmdid); - buffer = GetResourceManager()->GetLiveHandle(bufid); - - ObjDisp(commandBuffer)->CmdDispatchIndirect(Unwrap(commandBuffer), Unwrap(buffer), offs); - - const string desc = localSerialiser->GetDebugStr(); - + else { - VkDispatchIndirectCommand unknown = {0}; - vector argbuf; - GetDebugManager()->GetBufferData(GetResID(buffer), offs, sizeof(VkDispatchIndirectCommand), - argbuf); - VkDispatchIndirectCommand *args = (VkDispatchIndirectCommand *)&argbuf[0]; + ObjDisp(commandBuffer)->CmdDispatchIndirect(Unwrap(commandBuffer), Unwrap(buffer), offset); - if(argbuf.size() < sizeof(VkDispatchIndirectCommand)) { - RDCERR("Couldn't fetch arguments buffer for vkCmdDispatchIndirect"); - args = &unknown; + VkDispatchIndirectCommand unknown = {0}; + std::vector argbuf; + GetDebugManager()->GetBufferData(GetResID(buffer), offset, + sizeof(VkDispatchIndirectCommand), argbuf); + VkDispatchIndirectCommand *args = (VkDispatchIndirectCommand *)&argbuf[0]; + + if(argbuf.size() < sizeof(VkDispatchIndirectCommand)) + { + RDCERR("Couldn't fetch arguments buffer for vkCmdDispatchIndirect"); + args = &unknown; + } + + AddEvent(); + + DrawcallDescription draw; + draw.name = + StringFormat::Fmt("vkCmdDispatchIndirect(<%u, %u, %u>", args->x, args->y, args->z); + draw.dispatchDimension[0] = args->x; + draw.dispatchDimension[1] = args->y; + draw.dispatchDimension[2] = args->z; + + draw.flags |= DrawFlags::Dispatch | DrawFlags::Indirect; + + AddDrawcall(draw, true); + + VulkanDrawcallTreeNode &drawNode = GetDrawcallStack().back()->children.back(); + + drawNode.resourceUsage.push_back(std::make_pair( + GetResID(buffer), EventUsage(drawNode.draw.eventID, ResourceUsage::Indirect))); } - - AddEvent(desc); - string name = "vkCmdDispatchIndirect(<" + ToStr(args->x) + "," + ToStr(args->y) + "," + - ToStr(args->z) + ">)"; - - DrawcallDescription draw; - draw.name = name; - draw.dispatchDimension[0] = args->x; - draw.dispatchDimension[1] = args->y; - draw.dispatchDimension[2] = args->z; - - draw.flags |= DrawFlags::Dispatch | DrawFlags::Indirect; - - AddDrawcall(draw, true); - - VulkanDrawcallTreeNode &drawNode = GetDrawcallStack().back()->children.back(); - - drawNode.resourceUsage.push_back(std::make_pair( - GetResID(buffer), EventUsage(drawNode.draw.eventID, ResourceUsage::Indirect))); } } @@ -991,14 +972,15 @@ void WrappedVulkan::vkCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffe ObjDisp(commandBuffer)->CmdDispatchIndirect(Unwrap(commandBuffer), Unwrap(buffer), offset); - if(m_State >= WRITING) + if(IsCaptureMode(m_State)) { VkResourceRecord *record = GetRecord(commandBuffer); CACHE_THREAD_SERIALISER(); - SCOPED_SERIALISE_CONTEXT(DISPATCH_INDIRECT); - Serialise_vkCmdDispatchIndirect(localSerialiser, commandBuffer, buffer, offset); + ser.SetDrawChunk(); + SCOPED_SERIALISE_CHUNK(VulkanChunk::vkCmdDispatchIndirect); + Serialise_vkCmdDispatchIndirect(ser, commandBuffer, buffer, offset); record->AddChunk(scope.Get()); @@ -1009,97 +991,89 @@ void WrappedVulkan::vkCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffe } } -bool WrappedVulkan::Serialise_vkCmdBlitImage(Serialiser *localSerialiser, - VkCommandBuffer commandBuffer, VkImage srcImage, - VkImageLayout srcImageLayout, VkImage destImage, - VkImageLayout destImageLayout, uint32_t regionCount, - const VkImageBlit *pRegions, VkFilter filter) +template +bool WrappedVulkan::Serialise_vkCmdBlitImage(SerialiserType &ser, VkCommandBuffer commandBuffer, + VkImage srcImage, VkImageLayout srcImageLayout, + VkImage destImage, VkImageLayout destImageLayout, + uint32_t regionCount, const VkImageBlit *pRegions, + VkFilter filter) { - SERIALISE_ELEMENT(ResourceId, cmdid, GetResID(commandBuffer)); - SERIALISE_ELEMENT(ResourceId, srcid, GetResID(srcImage)); - SERIALISE_ELEMENT(VkImageLayout, srclayout, srcImageLayout); - SERIALISE_ELEMENT(ResourceId, dstid, GetResID(destImage)); - SERIALISE_ELEMENT(VkImageLayout, dstlayout, destImageLayout); + SERIALISE_ELEMENT(commandBuffer); + SERIALISE_ELEMENT(srcImage); + SERIALISE_ELEMENT(srcImageLayout); + SERIALISE_ELEMENT(destImage); + SERIALISE_ELEMENT(destImageLayout); + SERIALISE_ELEMENT_ARRAY(pRegions, regionCount); + SERIALISE_ELEMENT(filter); - SERIALISE_ELEMENT(VkFilter, f, filter); + Serialise_DebugMessages(ser); - SERIALISE_ELEMENT(uint32_t, count, regionCount); - SERIALISE_ELEMENT_ARR(VkImageBlit, regions, pRegions, count); - - Serialise_DebugMessages(localSerialiser, true); - - if(m_State < WRITING) - m_LastCmdBufferID = cmdid; - - if(m_State == EXECUTING) + if(IsReplayingAndReading()) { - srcImage = GetResourceManager()->GetLiveHandle(srcid); - destImage = GetResourceManager()->GetLiveHandle(dstid); + m_LastCmdBufferID = GetResourceManager()->GetOriginalID(GetResID(commandBuffer)); - if(ShouldRerecordCmd(cmdid) && InRerecordRange(cmdid)) + if(IsActiveReplaying(m_State)) { - commandBuffer = RerecordCmdBuf(cmdid); - - uint32_t eventID = HandlePreCallback(commandBuffer, DrawFlags::Resolve); - - ObjDisp(commandBuffer) - ->CmdBlitImage(Unwrap(commandBuffer), Unwrap(srcImage), srclayout, Unwrap(destImage), - dstlayout, count, regions, f); - - if(eventID && m_DrawcallCallback->PostMisc(eventID, DrawFlags::Resolve, commandBuffer)) + if(ShouldRerecordCmd(m_LastCmdBufferID) && InRerecordRange(m_LastCmdBufferID)) { + commandBuffer = RerecordCmdBuf(m_LastCmdBufferID); + + uint32_t eventID = HandlePreCallback(commandBuffer, DrawFlags::Resolve); + ObjDisp(commandBuffer) - ->CmdBlitImage(Unwrap(commandBuffer), Unwrap(srcImage), srclayout, Unwrap(destImage), - dstlayout, count, regions, f); + ->CmdBlitImage(Unwrap(commandBuffer), Unwrap(srcImage), srcImageLayout, + Unwrap(destImage), destImageLayout, regionCount, pRegions, filter); - m_DrawcallCallback->PostRemisc(eventID, DrawFlags::Resolve, commandBuffer); + if(eventID && m_DrawcallCallback->PostMisc(eventID, DrawFlags::Resolve, commandBuffer)) + { + ObjDisp(commandBuffer) + ->CmdBlitImage(Unwrap(commandBuffer), Unwrap(srcImage), srcImageLayout, + Unwrap(destImage), destImageLayout, regionCount, pRegions, filter); + + m_DrawcallCallback->PostRemisc(eventID, DrawFlags::Resolve, commandBuffer); + } } } - } - else if(m_State == READING) - { - commandBuffer = GetResourceManager()->GetLiveHandle(cmdid); - srcImage = GetResourceManager()->GetLiveHandle(srcid); - destImage = GetResourceManager()->GetLiveHandle(dstid); - - ObjDisp(commandBuffer) - ->CmdBlitImage(Unwrap(commandBuffer), Unwrap(srcImage), srclayout, Unwrap(destImage), - dstlayout, count, regions, f); - - const string desc = localSerialiser->GetDebugStr(); - + else { - AddEvent(desc); - string name = "vkCmdBlitImage(" + ToStr(srcid) + "," + ToStr(dstid) + ")"; + ObjDisp(commandBuffer) + ->CmdBlitImage(Unwrap(commandBuffer), Unwrap(srcImage), srcImageLayout, Unwrap(destImage), + destImageLayout, regionCount, pRegions, filter); - DrawcallDescription draw; - draw.name = name; - draw.flags |= DrawFlags::Resolve; - - draw.copySource = srcid; - draw.copyDestination = dstid; - - AddDrawcall(draw, true); - - VulkanDrawcallTreeNode &drawNode = GetDrawcallStack().back()->children.back(); - - if(srcImage == destImage) { - drawNode.resourceUsage.push_back(std::make_pair( - GetResID(srcImage), EventUsage(drawNode.draw.eventID, ResourceUsage::Resolve))); - } - else - { - drawNode.resourceUsage.push_back(std::make_pair( - GetResID(srcImage), EventUsage(drawNode.draw.eventID, ResourceUsage::ResolveSrc))); - drawNode.resourceUsage.push_back(std::make_pair( - GetResID(destImage), EventUsage(drawNode.draw.eventID, ResourceUsage::ResolveSrc))); + AddEvent(); + + ResourceId srcid = GetResourceManager()->GetOriginalID(GetResID(srcImage)); + ResourceId dstid = GetResourceManager()->GetOriginalID(GetResID(destImage)); + + DrawcallDescription draw; + draw.name = + StringFormat::Fmt("vkCmdBlitImage(%s, %s)", ToStr(srcid).c_str(), ToStr(dstid).c_str()); + draw.flags |= DrawFlags::Resolve; + + draw.copySource = srcid; + draw.copyDestination = dstid; + + AddDrawcall(draw, true); + + VulkanDrawcallTreeNode &drawNode = GetDrawcallStack().back()->children.back(); + + if(srcImage == destImage) + { + drawNode.resourceUsage.push_back(std::make_pair( + GetResID(srcImage), EventUsage(drawNode.draw.eventID, ResourceUsage::Resolve))); + } + else + { + drawNode.resourceUsage.push_back(std::make_pair( + GetResID(srcImage), EventUsage(drawNode.draw.eventID, ResourceUsage::ResolveSrc))); + drawNode.resourceUsage.push_back(std::make_pair( + GetResID(destImage), EventUsage(drawNode.draw.eventID, ResourceUsage::ResolveSrc))); + } } } } - SAFE_DELETE_ARRAY(regions); - return true; } @@ -1114,14 +1088,15 @@ void WrappedVulkan::vkCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcIma ->CmdBlitImage(Unwrap(commandBuffer), Unwrap(srcImage), srcImageLayout, Unwrap(destImage), destImageLayout, regionCount, pRegions, filter); - if(m_State >= WRITING) + if(IsCaptureMode(m_State)) { VkResourceRecord *record = GetRecord(commandBuffer); CACHE_THREAD_SERIALISER(); - SCOPED_SERIALISE_CONTEXT(BLIT_IMG); - Serialise_vkCmdBlitImage(localSerialiser, commandBuffer, srcImage, srcImageLayout, destImage, + ser.SetDrawChunk(); + SCOPED_SERIALISE_CHUNK(VulkanChunk::vkCmdBlitImage); + Serialise_vkCmdBlitImage(ser, commandBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions, filter); record->AddChunk(scope.Get()); @@ -1138,95 +1113,87 @@ void WrappedVulkan::vkCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcIma } } -bool WrappedVulkan::Serialise_vkCmdResolveImage(Serialiser *localSerialiser, - VkCommandBuffer commandBuffer, VkImage srcImage, - VkImageLayout srcImageLayout, VkImage destImage, - VkImageLayout destImageLayout, uint32_t regionCount, - const VkImageResolve *pRegions) +template +bool WrappedVulkan::Serialise_vkCmdResolveImage(SerialiserType &ser, VkCommandBuffer commandBuffer, + VkImage srcImage, VkImageLayout srcImageLayout, + VkImage destImage, VkImageLayout destImageLayout, + uint32_t regionCount, const VkImageResolve *pRegions) { - SERIALISE_ELEMENT(ResourceId, cmdid, GetResID(commandBuffer)); - SERIALISE_ELEMENT(ResourceId, srcid, GetResID(srcImage)); - SERIALISE_ELEMENT(VkImageLayout, srclayout, srcImageLayout); - SERIALISE_ELEMENT(ResourceId, dstid, GetResID(destImage)); - SERIALISE_ELEMENT(VkImageLayout, dstlayout, destImageLayout); + SERIALISE_ELEMENT(commandBuffer); + SERIALISE_ELEMENT(srcImage); + SERIALISE_ELEMENT(srcImageLayout); + SERIALISE_ELEMENT(destImage); + SERIALISE_ELEMENT(destImageLayout); + SERIALISE_ELEMENT_ARRAY(pRegions, regionCount); - SERIALISE_ELEMENT(uint32_t, count, regionCount); - SERIALISE_ELEMENT_ARR(VkImageResolve, regions, pRegions, count); + Serialise_DebugMessages(ser); - Serialise_DebugMessages(localSerialiser, true); - - if(m_State < WRITING) - m_LastCmdBufferID = cmdid; - - if(m_State == EXECUTING) + if(IsReplayingAndReading()) { - srcImage = GetResourceManager()->GetLiveHandle(srcid); - destImage = GetResourceManager()->GetLiveHandle(dstid); + m_LastCmdBufferID = GetResourceManager()->GetOriginalID(GetResID(commandBuffer)); - if(ShouldRerecordCmd(cmdid) && InRerecordRange(cmdid)) + if(IsActiveReplaying(m_State)) { - commandBuffer = RerecordCmdBuf(cmdid); - - uint32_t eventID = HandlePreCallback(commandBuffer, DrawFlags::Resolve); - - ObjDisp(commandBuffer) - ->CmdResolveImage(Unwrap(commandBuffer), Unwrap(srcImage), srclayout, Unwrap(destImage), - dstlayout, count, regions); - - if(eventID && m_DrawcallCallback->PostMisc(eventID, DrawFlags::Resolve, commandBuffer)) + if(ShouldRerecordCmd(m_LastCmdBufferID) && InRerecordRange(m_LastCmdBufferID)) { + commandBuffer = RerecordCmdBuf(m_LastCmdBufferID); + + uint32_t eventID = HandlePreCallback(commandBuffer, DrawFlags::Resolve); + ObjDisp(commandBuffer) - ->CmdResolveImage(Unwrap(commandBuffer), Unwrap(srcImage), srclayout, Unwrap(destImage), - dstlayout, count, regions); + ->CmdResolveImage(Unwrap(commandBuffer), Unwrap(srcImage), srcImageLayout, + Unwrap(destImage), destImageLayout, regionCount, pRegions); - m_DrawcallCallback->PostRemisc(eventID, DrawFlags::Resolve, commandBuffer); + if(eventID && m_DrawcallCallback->PostMisc(eventID, DrawFlags::Resolve, commandBuffer)) + { + ObjDisp(commandBuffer) + ->CmdResolveImage(Unwrap(commandBuffer), Unwrap(srcImage), srcImageLayout, + Unwrap(destImage), destImageLayout, regionCount, pRegions); + + m_DrawcallCallback->PostRemisc(eventID, DrawFlags::Resolve, commandBuffer); + } } } - } - else if(m_State == READING) - { - commandBuffer = GetResourceManager()->GetLiveHandle(cmdid); - srcImage = GetResourceManager()->GetLiveHandle(srcid); - destImage = GetResourceManager()->GetLiveHandle(dstid); - - ObjDisp(commandBuffer) - ->CmdResolveImage(Unwrap(commandBuffer), Unwrap(srcImage), srclayout, Unwrap(destImage), - dstlayout, count, regions); - - const string desc = localSerialiser->GetDebugStr(); - + else { - AddEvent(desc); - string name = "vkCmdResolveImage(" + ToStr(srcid) + "," + ToStr(dstid) + ")"; + ObjDisp(commandBuffer) + ->CmdResolveImage(Unwrap(commandBuffer), Unwrap(srcImage), srcImageLayout, + Unwrap(destImage), destImageLayout, regionCount, pRegions); - DrawcallDescription draw; - draw.name = name; - draw.flags |= DrawFlags::Resolve; - - draw.copySource = srcid; - draw.copyDestination = dstid; - - AddDrawcall(draw, true); - - VulkanDrawcallTreeNode &drawNode = GetDrawcallStack().back()->children.back(); - - if(srcImage == destImage) { - drawNode.resourceUsage.push_back(std::make_pair( - GetResID(srcImage), EventUsage(drawNode.draw.eventID, ResourceUsage::Resolve))); - } - else - { - drawNode.resourceUsage.push_back(std::make_pair( - GetResID(srcImage), EventUsage(drawNode.draw.eventID, ResourceUsage::ResolveSrc))); - drawNode.resourceUsage.push_back(std::make_pair( - GetResID(destImage), EventUsage(drawNode.draw.eventID, ResourceUsage::ResolveDst))); + AddEvent(); + + ResourceId srcid = GetResourceManager()->GetOriginalID(GetResID(srcImage)); + ResourceId dstid = GetResourceManager()->GetOriginalID(GetResID(destImage)); + + DrawcallDescription draw; + draw.name = StringFormat::Fmt("vkCmdResolveImage(%s, %s)", ToStr(srcid).c_str(), + ToStr(dstid).c_str()); + draw.flags |= DrawFlags::Resolve; + + draw.copySource = srcid; + draw.copyDestination = dstid; + + AddDrawcall(draw, true); + + VulkanDrawcallTreeNode &drawNode = GetDrawcallStack().back()->children.back(); + + if(srcImage == destImage) + { + drawNode.resourceUsage.push_back(std::make_pair( + GetResID(srcImage), EventUsage(drawNode.draw.eventID, ResourceUsage::Resolve))); + } + else + { + drawNode.resourceUsage.push_back(std::make_pair( + GetResID(srcImage), EventUsage(drawNode.draw.eventID, ResourceUsage::ResolveSrc))); + drawNode.resourceUsage.push_back(std::make_pair( + GetResID(destImage), EventUsage(drawNode.draw.eventID, ResourceUsage::ResolveDst))); + } } } } - SAFE_DELETE_ARRAY(regions); - return true; } @@ -1241,14 +1208,15 @@ void WrappedVulkan::vkCmdResolveImage(VkCommandBuffer commandBuffer, VkImage src ->CmdResolveImage(Unwrap(commandBuffer), Unwrap(srcImage), srcImageLayout, Unwrap(destImage), destImageLayout, regionCount, pRegions); - if(m_State >= WRITING) + if(IsCaptureMode(m_State)) { VkResourceRecord *record = GetRecord(commandBuffer); CACHE_THREAD_SERIALISER(); - SCOPED_SERIALISE_CONTEXT(RESOLVE_IMG); - Serialise_vkCmdResolveImage(localSerialiser, commandBuffer, srcImage, srcImageLayout, destImage, + ser.SetDrawChunk(); + SCOPED_SERIALISE_CHUNK(VulkanChunk::vkCmdResolveImage); + Serialise_vkCmdResolveImage(ser, commandBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions); record->AddChunk(scope.Get()); @@ -1265,95 +1233,87 @@ void WrappedVulkan::vkCmdResolveImage(VkCommandBuffer commandBuffer, VkImage src } } -bool WrappedVulkan::Serialise_vkCmdCopyImage(Serialiser *localSerialiser, - VkCommandBuffer commandBuffer, VkImage srcImage, - VkImageLayout srcImageLayout, VkImage destImage, - VkImageLayout destImageLayout, uint32_t regionCount, - const VkImageCopy *pRegions) +template +bool WrappedVulkan::Serialise_vkCmdCopyImage(SerialiserType &ser, VkCommandBuffer commandBuffer, + VkImage srcImage, VkImageLayout srcImageLayout, + VkImage destImage, VkImageLayout destImageLayout, + uint32_t regionCount, const VkImageCopy *pRegions) { - SERIALISE_ELEMENT(ResourceId, cmdid, GetResID(commandBuffer)); - SERIALISE_ELEMENT(ResourceId, srcid, GetResID(srcImage)); - SERIALISE_ELEMENT(VkImageLayout, srclayout, srcImageLayout); - SERIALISE_ELEMENT(ResourceId, dstid, GetResID(destImage)); - SERIALISE_ELEMENT(VkImageLayout, dstlayout, destImageLayout); + SERIALISE_ELEMENT(commandBuffer); + SERIALISE_ELEMENT(srcImage); + SERIALISE_ELEMENT(srcImageLayout); + SERIALISE_ELEMENT(destImage); + SERIALISE_ELEMENT(destImageLayout); + SERIALISE_ELEMENT_ARRAY(pRegions, regionCount); - SERIALISE_ELEMENT(uint32_t, count, regionCount); - SERIALISE_ELEMENT_ARR(VkImageCopy, regions, pRegions, count); + Serialise_DebugMessages(ser); - Serialise_DebugMessages(localSerialiser, true); - - if(m_State < WRITING) - m_LastCmdBufferID = cmdid; - - if(m_State == EXECUTING) + if(IsReplayingAndReading()) { - srcImage = GetResourceManager()->GetLiveHandle(srcid); - destImage = GetResourceManager()->GetLiveHandle(dstid); + m_LastCmdBufferID = GetResourceManager()->GetOriginalID(GetResID(commandBuffer)); - if(ShouldRerecordCmd(cmdid) && InRerecordRange(cmdid)) + if(IsActiveReplaying(m_State)) { - commandBuffer = RerecordCmdBuf(cmdid); - - uint32_t eventID = HandlePreCallback(commandBuffer, DrawFlags::Copy); - - ObjDisp(commandBuffer) - ->CmdCopyImage(Unwrap(commandBuffer), Unwrap(srcImage), srclayout, Unwrap(destImage), - dstlayout, count, regions); - - if(eventID && m_DrawcallCallback->PostMisc(eventID, DrawFlags::Copy, commandBuffer)) + if(ShouldRerecordCmd(m_LastCmdBufferID) && InRerecordRange(m_LastCmdBufferID)) { + commandBuffer = RerecordCmdBuf(m_LastCmdBufferID); + + uint32_t eventID = HandlePreCallback(commandBuffer, DrawFlags::Copy); + ObjDisp(commandBuffer) - ->CmdCopyImage(Unwrap(commandBuffer), Unwrap(srcImage), srclayout, Unwrap(destImage), - dstlayout, count, regions); + ->CmdCopyImage(Unwrap(commandBuffer), Unwrap(srcImage), srcImageLayout, + Unwrap(destImage), destImageLayout, regionCount, pRegions); - m_DrawcallCallback->PostRemisc(eventID, DrawFlags::Copy, commandBuffer); + if(eventID && m_DrawcallCallback->PostMisc(eventID, DrawFlags::Copy, commandBuffer)) + { + ObjDisp(commandBuffer) + ->CmdCopyImage(Unwrap(commandBuffer), Unwrap(srcImage), srcImageLayout, + Unwrap(destImage), destImageLayout, regionCount, pRegions); + + m_DrawcallCallback->PostRemisc(eventID, DrawFlags::Copy, commandBuffer); + } } } - } - else if(m_State == READING) - { - commandBuffer = GetResourceManager()->GetLiveHandle(cmdid); - srcImage = GetResourceManager()->GetLiveHandle(srcid); - destImage = GetResourceManager()->GetLiveHandle(dstid); - - ObjDisp(commandBuffer) - ->CmdCopyImage(Unwrap(commandBuffer), Unwrap(srcImage), srclayout, Unwrap(destImage), - dstlayout, count, regions); - - const string desc = localSerialiser->GetDebugStr(); - + else { - AddEvent(desc); - string name = "vkCmdCopyImage(" + ToStr(srcid) + "," + ToStr(dstid) + ")"; + ObjDisp(commandBuffer) + ->CmdCopyImage(Unwrap(commandBuffer), Unwrap(srcImage), srcImageLayout, Unwrap(destImage), + destImageLayout, regionCount, pRegions); - DrawcallDescription draw; - draw.name = name; - draw.flags |= DrawFlags::Copy; - - draw.copySource = srcid; - draw.copyDestination = dstid; - - AddDrawcall(draw, true); - - VulkanDrawcallTreeNode &drawNode = GetDrawcallStack().back()->children.back(); - - if(srcImage == destImage) { - drawNode.resourceUsage.push_back(std::make_pair( - GetResID(srcImage), EventUsage(drawNode.draw.eventID, ResourceUsage::Copy))); - } - else - { - drawNode.resourceUsage.push_back(std::make_pair( - GetResID(srcImage), EventUsage(drawNode.draw.eventID, ResourceUsage::CopySrc))); - drawNode.resourceUsage.push_back(std::make_pair( - GetResID(destImage), EventUsage(drawNode.draw.eventID, ResourceUsage::CopyDst))); + AddEvent(); + + ResourceId srcid = GetResourceManager()->GetOriginalID(GetResID(srcImage)); + ResourceId dstid = GetResourceManager()->GetOriginalID(GetResID(destImage)); + + DrawcallDescription draw; + draw.name = + StringFormat::Fmt("vkCmdCopyImage(%s, %s)", ToStr(srcid).c_str(), ToStr(dstid).c_str()); + draw.flags |= DrawFlags::Copy; + + draw.copySource = srcid; + draw.copyDestination = dstid; + + AddDrawcall(draw, true); + + VulkanDrawcallTreeNode &drawNode = GetDrawcallStack().back()->children.back(); + + if(srcImage == destImage) + { + drawNode.resourceUsage.push_back(std::make_pair( + GetResID(srcImage), EventUsage(drawNode.draw.eventID, ResourceUsage::Copy))); + } + else + { + drawNode.resourceUsage.push_back(std::make_pair( + GetResID(srcImage), EventUsage(drawNode.draw.eventID, ResourceUsage::CopySrc))); + drawNode.resourceUsage.push_back(std::make_pair( + GetResID(destImage), EventUsage(drawNode.draw.eventID, ResourceUsage::CopyDst))); + } } } } - SAFE_DELETE_ARRAY(regions); - return true; } @@ -1368,14 +1328,15 @@ void WrappedVulkan::vkCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcIma ->CmdCopyImage(Unwrap(commandBuffer), Unwrap(srcImage), srcImageLayout, Unwrap(destImage), destImageLayout, regionCount, pRegions); - if(m_State >= WRITING) + if(IsCaptureMode(m_State)) { VkResourceRecord *record = GetRecord(commandBuffer); CACHE_THREAD_SERIALISER(); - SCOPED_SERIALISE_CONTEXT(COPY_IMG); - Serialise_vkCmdCopyImage(localSerialiser, commandBuffer, srcImage, srcImageLayout, destImage, + ser.SetDrawChunk(); + SCOPED_SERIALISE_CHUNK(VulkanChunk::vkCmdCopyImage); + Serialise_vkCmdCopyImage(ser, commandBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions); record->AddChunk(scope.Get()); @@ -1391,87 +1352,76 @@ void WrappedVulkan::vkCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcIma } } -bool WrappedVulkan::Serialise_vkCmdCopyBufferToImage(Serialiser *localSerialiser, - VkCommandBuffer commandBuffer, - VkBuffer srcBuffer, VkImage destImage, - VkImageLayout destImageLayout, - uint32_t regionCount, - const VkBufferImageCopy *pRegions) +template +bool WrappedVulkan::Serialise_vkCmdCopyBufferToImage( + SerialiserType &ser, VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage destImage, + VkImageLayout destImageLayout, uint32_t regionCount, const VkBufferImageCopy *pRegions) { - SERIALISE_ELEMENT(ResourceId, cmdid, GetResID(commandBuffer)); - SERIALISE_ELEMENT(ResourceId, bufid, GetResID(srcBuffer)); - SERIALISE_ELEMENT(ResourceId, imgid, GetResID(destImage)); + SERIALISE_ELEMENT(commandBuffer); + SERIALISE_ELEMENT(srcBuffer); + SERIALISE_ELEMENT(destImage); + SERIALISE_ELEMENT(destImageLayout); + SERIALISE_ELEMENT_ARRAY(pRegions, regionCount); - SERIALISE_ELEMENT(VkImageLayout, layout, destImageLayout); + Serialise_DebugMessages(ser); - SERIALISE_ELEMENT(uint32_t, count, regionCount); - SERIALISE_ELEMENT_ARR(VkBufferImageCopy, regions, pRegions, count); - - Serialise_DebugMessages(localSerialiser, true); - - if(m_State < WRITING) - m_LastCmdBufferID = cmdid; - - if(m_State == EXECUTING) + if(IsReplayingAndReading()) { - srcBuffer = GetResourceManager()->GetLiveHandle(bufid); - destImage = GetResourceManager()->GetLiveHandle(imgid); + m_LastCmdBufferID = GetResourceManager()->GetOriginalID(GetResID(commandBuffer)); - if(ShouldRerecordCmd(cmdid) && InRerecordRange(cmdid)) + if(IsActiveReplaying(m_State)) { - commandBuffer = RerecordCmdBuf(cmdid); - - uint32_t eventID = HandlePreCallback(commandBuffer, DrawFlags::Copy); - - ObjDisp(commandBuffer) - ->CmdCopyBufferToImage(Unwrap(commandBuffer), Unwrap(srcBuffer), Unwrap(destImage), - layout, count, regions); - - if(eventID && m_DrawcallCallback->PostMisc(eventID, DrawFlags::Copy, commandBuffer)) + if(ShouldRerecordCmd(m_LastCmdBufferID) && InRerecordRange(m_LastCmdBufferID)) { + commandBuffer = RerecordCmdBuf(m_LastCmdBufferID); + + uint32_t eventID = HandlePreCallback(commandBuffer, DrawFlags::Copy); + ObjDisp(commandBuffer) ->CmdCopyBufferToImage(Unwrap(commandBuffer), Unwrap(srcBuffer), Unwrap(destImage), - layout, count, regions); + destImageLayout, regionCount, pRegions); - m_DrawcallCallback->PostRemisc(eventID, DrawFlags::Copy, commandBuffer); + if(eventID && m_DrawcallCallback->PostMisc(eventID, DrawFlags::Copy, commandBuffer)) + { + ObjDisp(commandBuffer) + ->CmdCopyBufferToImage(Unwrap(commandBuffer), Unwrap(srcBuffer), Unwrap(destImage), + destImageLayout, regionCount, pRegions); + + m_DrawcallCallback->PostRemisc(eventID, DrawFlags::Copy, commandBuffer); + } + } + } + else + { + ObjDisp(commandBuffer) + ->CmdCopyBufferToImage(Unwrap(commandBuffer), Unwrap(srcBuffer), Unwrap(destImage), + destImageLayout, regionCount, pRegions); + + { + AddEvent(); + + ResourceId bufid = GetResourceManager()->GetOriginalID(GetResID(srcBuffer)); + ResourceId imgid = GetResourceManager()->GetOriginalID(GetResID(destImage)); + + DrawcallDescription draw; + draw.name = StringFormat::Fmt("vkCmdCopyBufferToImage(%s, %s)", ToStr(bufid).c_str(), + ToStr(imgid).c_str()); + draw.flags |= DrawFlags::Copy; + + draw.copySource = bufid; + draw.copyDestination = imgid; + + AddDrawcall(draw, true); + + VulkanDrawcallTreeNode &drawNode = GetDrawcallStack().back()->children.back(); + + drawNode.resourceUsage.push_back(std::make_pair( + GetResID(srcBuffer), EventUsage(drawNode.draw.eventID, ResourceUsage::CopySrc))); + drawNode.resourceUsage.push_back(std::make_pair( + GetResID(destImage), EventUsage(drawNode.draw.eventID, ResourceUsage::CopyDst))); } } } - else if(m_State == READING) - { - commandBuffer = GetResourceManager()->GetLiveHandle(cmdid); - srcBuffer = GetResourceManager()->GetLiveHandle(bufid); - destImage = GetResourceManager()->GetLiveHandle(imgid); - - ObjDisp(commandBuffer) - ->CmdCopyBufferToImage(Unwrap(commandBuffer), Unwrap(srcBuffer), Unwrap(destImage), layout, - count, regions); - - const string desc = localSerialiser->GetDebugStr(); - - { - AddEvent(desc); - string name = "vkCmdCopyBufferToImage(" + ToStr(bufid) + "," + ToStr(imgid) + ")"; - - DrawcallDescription draw; - draw.name = name; - draw.flags |= DrawFlags::Copy; - - draw.copySource = bufid; - draw.copyDestination = imgid; - - AddDrawcall(draw, true); - - VulkanDrawcallTreeNode &drawNode = GetDrawcallStack().back()->children.back(); - - drawNode.resourceUsage.push_back(std::make_pair( - GetResID(srcBuffer), EventUsage(drawNode.draw.eventID, ResourceUsage::CopySrc))); - drawNode.resourceUsage.push_back(std::make_pair( - GetResID(destImage), EventUsage(drawNode.draw.eventID, ResourceUsage::CopyDst))); - } - } - - SAFE_DELETE_ARRAY(regions); return true; } @@ -1486,15 +1436,16 @@ void WrappedVulkan::vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuff ->CmdCopyBufferToImage(Unwrap(commandBuffer), Unwrap(srcBuffer), Unwrap(destImage), destImageLayout, regionCount, pRegions); - if(m_State >= WRITING) + if(IsCaptureMode(m_State)) { VkResourceRecord *record = GetRecord(commandBuffer); CACHE_THREAD_SERIALISER(); - SCOPED_SERIALISE_CONTEXT(COPY_BUF2IMG); - Serialise_vkCmdCopyBufferToImage(localSerialiser, commandBuffer, srcBuffer, destImage, - destImageLayout, regionCount, pRegions); + ser.SetDrawChunk(); + SCOPED_SERIALISE_CHUNK(VulkanChunk::vkCmdCopyBufferToImage); + Serialise_vkCmdCopyBufferToImage(ser, commandBuffer, srcBuffer, destImage, destImageLayout, + regionCount, pRegions); record->AddChunk(scope.Get()); @@ -1510,86 +1461,78 @@ void WrappedVulkan::vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuff } } -bool WrappedVulkan::Serialise_vkCmdCopyImageToBuffer(Serialiser *localSerialiser, +template +bool WrappedVulkan::Serialise_vkCmdCopyImageToBuffer(SerialiserType &ser, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer destBuffer, uint32_t regionCount, const VkBufferImageCopy *pRegions) { - SERIALISE_ELEMENT(ResourceId, cmdid, GetResID(commandBuffer)); - SERIALISE_ELEMENT(ResourceId, bufid, GetResID(destBuffer)); - SERIALISE_ELEMENT(ResourceId, imgid, GetResID(srcImage)); + SERIALISE_ELEMENT(commandBuffer); + SERIALISE_ELEMENT(destBuffer); + SERIALISE_ELEMENT(srcImage); + SERIALISE_ELEMENT(srcImageLayout); + SERIALISE_ELEMENT_ARRAY(pRegions, regionCount); - SERIALISE_ELEMENT(VkImageLayout, layout, srcImageLayout); + Serialise_DebugMessages(ser); - SERIALISE_ELEMENT(uint32_t, count, regionCount); - SERIALISE_ELEMENT_ARR(VkBufferImageCopy, regions, pRegions, count); - - Serialise_DebugMessages(localSerialiser, true); - - if(m_State < WRITING) - m_LastCmdBufferID = cmdid; - - if(m_State == EXECUTING) + if(IsReplayingAndReading()) { - srcImage = GetResourceManager()->GetLiveHandle(imgid); - destBuffer = GetResourceManager()->GetLiveHandle(bufid); + m_LastCmdBufferID = GetResourceManager()->GetOriginalID(GetResID(commandBuffer)); - if(ShouldRerecordCmd(cmdid) && InRerecordRange(cmdid)) + if(IsActiveReplaying(m_State)) { - commandBuffer = RerecordCmdBuf(cmdid); - - uint32_t eventID = HandlePreCallback(commandBuffer, DrawFlags::Copy); - - ObjDisp(commandBuffer) - ->CmdCopyImageToBuffer(Unwrap(commandBuffer), Unwrap(srcImage), layout, - Unwrap(destBuffer), count, regions); - - if(eventID && m_DrawcallCallback->PostMisc(eventID, DrawFlags::Copy, commandBuffer)) + if(ShouldRerecordCmd(m_LastCmdBufferID) && InRerecordRange(m_LastCmdBufferID)) { - ObjDisp(commandBuffer) - ->CmdCopyImageToBuffer(Unwrap(commandBuffer), Unwrap(srcImage), layout, - Unwrap(destBuffer), count, regions); + commandBuffer = RerecordCmdBuf(m_LastCmdBufferID); - m_DrawcallCallback->PostRemisc(eventID, DrawFlags::Copy, commandBuffer); + uint32_t eventID = HandlePreCallback(commandBuffer, DrawFlags::Copy); + + ObjDisp(commandBuffer) + ->CmdCopyImageToBuffer(Unwrap(commandBuffer), Unwrap(srcImage), srcImageLayout, + Unwrap(destBuffer), regionCount, pRegions); + + if(eventID && m_DrawcallCallback->PostMisc(eventID, DrawFlags::Copy, commandBuffer)) + { + ObjDisp(commandBuffer) + ->CmdCopyImageToBuffer(Unwrap(commandBuffer), Unwrap(srcImage), srcImageLayout, + Unwrap(destBuffer), regionCount, pRegions); + + m_DrawcallCallback->PostRemisc(eventID, DrawFlags::Copy, commandBuffer); + } + } + } + else + { + ObjDisp(commandBuffer) + ->CmdCopyImageToBuffer(Unwrap(commandBuffer), Unwrap(srcImage), srcImageLayout, + Unwrap(destBuffer), regionCount, pRegions); + + { + AddEvent(); + + ResourceId imgid = GetResourceManager()->GetOriginalID(GetResID(srcImage)); + ResourceId bufid = GetResourceManager()->GetOriginalID(GetResID(destBuffer)); + + DrawcallDescription draw; + draw.name = StringFormat::Fmt("vkCmdCopyImageToBuffer(%s, %s)", ToStr(imgid).c_str(), + ToStr(bufid).c_str()); + draw.flags |= DrawFlags::Copy; + + draw.copySource = imgid; + draw.copyDestination = bufid; + + AddDrawcall(draw, true); + + VulkanDrawcallTreeNode &drawNode = GetDrawcallStack().back()->children.back(); + + drawNode.resourceUsage.push_back(std::make_pair( + GetResID(srcImage), EventUsage(drawNode.draw.eventID, ResourceUsage::CopySrc))); + drawNode.resourceUsage.push_back(std::make_pair( + GetResID(destBuffer), EventUsage(drawNode.draw.eventID, ResourceUsage::CopyDst))); } } } - else if(m_State == READING) - { - commandBuffer = GetResourceManager()->GetLiveHandle(cmdid); - srcImage = GetResourceManager()->GetLiveHandle(imgid); - destBuffer = GetResourceManager()->GetLiveHandle(bufid); - - ObjDisp(commandBuffer) - ->CmdCopyImageToBuffer(Unwrap(commandBuffer), Unwrap(srcImage), layout, Unwrap(destBuffer), - count, regions); - - const string desc = localSerialiser->GetDebugStr(); - - { - AddEvent(desc); - string name = "vkCmdCopyImageToBuffer(" + ToStr(imgid) + "," + ToStr(bufid) + ")"; - - DrawcallDescription draw; - draw.name = name; - draw.flags |= DrawFlags::Copy; - - draw.copySource = imgid; - draw.copyDestination = bufid; - - AddDrawcall(draw, true); - - VulkanDrawcallTreeNode &drawNode = GetDrawcallStack().back()->children.back(); - - drawNode.resourceUsage.push_back(std::make_pair( - GetResID(srcImage), EventUsage(drawNode.draw.eventID, ResourceUsage::CopySrc))); - drawNode.resourceUsage.push_back(std::make_pair( - GetResID(destBuffer), EventUsage(drawNode.draw.eventID, ResourceUsage::CopyDst))); - } - } - - SAFE_DELETE_ARRAY(regions); return true; } @@ -1604,15 +1547,16 @@ void WrappedVulkan::vkCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImag ->CmdCopyImageToBuffer(Unwrap(commandBuffer), Unwrap(srcImage), srcImageLayout, Unwrap(destBuffer), regionCount, pRegions); - if(m_State >= WRITING) + if(IsCaptureMode(m_State)) { VkResourceRecord *record = GetRecord(commandBuffer); CACHE_THREAD_SERIALISER(); - SCOPED_SERIALISE_CONTEXT(COPY_IMG2BUF); - Serialise_vkCmdCopyImageToBuffer(localSerialiser, commandBuffer, srcImage, srcImageLayout, - destBuffer, regionCount, pRegions); + ser.SetDrawChunk(); + SCOPED_SERIALISE_CHUNK(VulkanChunk::vkCmdCopyImageToBuffer); + Serialise_vkCmdCopyImageToBuffer(ser, commandBuffer, srcImage, srcImageLayout, destBuffer, + regionCount, pRegions); record->AddChunk(scope.Get()); record->MarkResourceFrameReferenced(GetResID(srcImage), eFrameRef_Read); @@ -1632,91 +1576,84 @@ void WrappedVulkan::vkCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImag } } -bool WrappedVulkan::Serialise_vkCmdCopyBuffer(Serialiser *localSerialiser, - VkCommandBuffer commandBuffer, VkBuffer srcBuffer, - VkBuffer destBuffer, uint32_t regionCount, - const VkBufferCopy *pRegions) +template +bool WrappedVulkan::Serialise_vkCmdCopyBuffer(SerialiserType &ser, VkCommandBuffer commandBuffer, + VkBuffer srcBuffer, VkBuffer destBuffer, + uint32_t regionCount, const VkBufferCopy *pRegions) { - SERIALISE_ELEMENT(ResourceId, cmdid, GetResID(commandBuffer)); - SERIALISE_ELEMENT(ResourceId, srcid, GetResID(srcBuffer)); - SERIALISE_ELEMENT(ResourceId, dstid, GetResID(destBuffer)); + SERIALISE_ELEMENT(commandBuffer); + SERIALISE_ELEMENT(srcBuffer); + SERIALISE_ELEMENT(destBuffer); + SERIALISE_ELEMENT_ARRAY(pRegions, regionCount); - SERIALISE_ELEMENT(uint32_t, count, regionCount); - SERIALISE_ELEMENT_ARR(VkBufferCopy, regions, pRegions, count); + Serialise_DebugMessages(ser); - Serialise_DebugMessages(localSerialiser, true); - - if(m_State < WRITING) - m_LastCmdBufferID = cmdid; - - if(m_State == EXECUTING) + if(IsReplayingAndReading()) { - srcBuffer = GetResourceManager()->GetLiveHandle(srcid); - destBuffer = GetResourceManager()->GetLiveHandle(dstid); + m_LastCmdBufferID = GetResourceManager()->GetOriginalID(GetResID(commandBuffer)); - if(ShouldRerecordCmd(cmdid) && InRerecordRange(cmdid)) + if(IsActiveReplaying(m_State)) { - commandBuffer = RerecordCmdBuf(cmdid); - - uint32_t eventID = HandlePreCallback(commandBuffer, DrawFlags::Copy); - - ObjDisp(commandBuffer) - ->CmdCopyBuffer(Unwrap(commandBuffer), Unwrap(srcBuffer), Unwrap(destBuffer), count, - regions); - - if(eventID && m_DrawcallCallback->PostMisc(eventID, DrawFlags::Copy, commandBuffer)) + if(ShouldRerecordCmd(m_LastCmdBufferID) && InRerecordRange(m_LastCmdBufferID)) { + commandBuffer = RerecordCmdBuf(m_LastCmdBufferID); + + uint32_t eventID = HandlePreCallback(commandBuffer, DrawFlags::Copy); + ObjDisp(commandBuffer) - ->CmdCopyBuffer(Unwrap(commandBuffer), Unwrap(srcBuffer), Unwrap(destBuffer), count, - regions); + ->CmdCopyBuffer(Unwrap(commandBuffer), Unwrap(srcBuffer), Unwrap(destBuffer), + regionCount, pRegions); - m_DrawcallCallback->PostRemisc(eventID, DrawFlags::Copy, commandBuffer); + if(eventID && m_DrawcallCallback->PostMisc(eventID, DrawFlags::Copy, commandBuffer)) + { + ObjDisp(commandBuffer) + ->CmdCopyBuffer(Unwrap(commandBuffer), Unwrap(srcBuffer), Unwrap(destBuffer), + regionCount, pRegions); + + m_DrawcallCallback->PostRemisc(eventID, DrawFlags::Copy, commandBuffer); + } } } - } - else if(m_State == READING) - { - commandBuffer = GetResourceManager()->GetLiveHandle(cmdid); - srcBuffer = GetResourceManager()->GetLiveHandle(srcid); - destBuffer = GetResourceManager()->GetLiveHandle(dstid); - - ObjDisp(commandBuffer) - ->CmdCopyBuffer(Unwrap(commandBuffer), Unwrap(srcBuffer), Unwrap(destBuffer), count, regions); - - const string desc = localSerialiser->GetDebugStr(); - + else { - AddEvent(desc); - string name = "vkCmdCopyBuffer(" + ToStr(srcid) + "," + ToStr(dstid) + ")"; + ObjDisp(commandBuffer) + ->CmdCopyBuffer(Unwrap(commandBuffer), Unwrap(srcBuffer), Unwrap(destBuffer), regionCount, + pRegions); - DrawcallDescription draw; - draw.name = name; - draw.flags |= DrawFlags::Copy; - - draw.copySource = srcid; - draw.copyDestination = dstid; - - AddDrawcall(draw, true); - - VulkanDrawcallTreeNode &drawNode = GetDrawcallStack().back()->children.back(); - - if(srcBuffer == destBuffer) { - drawNode.resourceUsage.push_back(std::make_pair( - GetResID(srcBuffer), EventUsage(drawNode.draw.eventID, ResourceUsage::Copy))); - } - else - { - drawNode.resourceUsage.push_back(std::make_pair( - GetResID(srcBuffer), EventUsage(drawNode.draw.eventID, ResourceUsage::CopySrc))); - drawNode.resourceUsage.push_back(std::make_pair( - GetResID(destBuffer), EventUsage(drawNode.draw.eventID, ResourceUsage::CopyDst))); + AddEvent(); + + ResourceId srcid = GetResourceManager()->GetOriginalID(GetResID(srcBuffer)); + ResourceId dstid = GetResourceManager()->GetOriginalID(GetResID(destBuffer)); + + DrawcallDescription draw; + draw.name = + StringFormat::Fmt("vkCmdCopyBuffer(%s, %s)", ToStr(srcid).c_str(), ToStr(dstid).c_str()); + draw.flags |= DrawFlags::Copy; + + draw.copySource = srcid; + draw.copyDestination = dstid; + + AddDrawcall(draw, true); + + VulkanDrawcallTreeNode &drawNode = GetDrawcallStack().back()->children.back(); + + if(srcBuffer == destBuffer) + { + drawNode.resourceUsage.push_back(std::make_pair( + GetResID(srcBuffer), EventUsage(drawNode.draw.eventID, ResourceUsage::Copy))); + } + else + { + drawNode.resourceUsage.push_back(std::make_pair( + GetResID(srcBuffer), EventUsage(drawNode.draw.eventID, ResourceUsage::CopySrc))); + drawNode.resourceUsage.push_back(std::make_pair( + GetResID(destBuffer), EventUsage(drawNode.draw.eventID, ResourceUsage::CopyDst))); + } } } } - SAFE_DELETE_ARRAY(regions); - return true; } @@ -1730,15 +1667,15 @@ void WrappedVulkan::vkCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcB ->CmdCopyBuffer(Unwrap(commandBuffer), Unwrap(srcBuffer), Unwrap(destBuffer), regionCount, pRegions); - if(m_State >= WRITING) + if(IsCaptureMode(m_State)) { VkResourceRecord *record = GetRecord(commandBuffer); CACHE_THREAD_SERIALISER(); - SCOPED_SERIALISE_CONTEXT(COPY_BUF); - Serialise_vkCmdCopyBuffer(localSerialiser, commandBuffer, srcBuffer, destBuffer, regionCount, - pRegions); + ser.SetDrawChunk(); + SCOPED_SERIALISE_CHUNK(VulkanChunk::vkCmdCopyBuffer); + Serialise_vkCmdCopyBuffer(ser, commandBuffer, srcBuffer, destBuffer, regionCount, pRegions); record->AddChunk(scope.Get()); record->MarkResourceFrameReferenced(GetResID(srcBuffer), eFrameRef_Read); @@ -1758,81 +1695,75 @@ void WrappedVulkan::vkCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcB } } -bool WrappedVulkan::Serialise_vkCmdClearColorImage(Serialiser *localSerialiser, - VkCommandBuffer commandBuffer, VkImage image, - VkImageLayout imageLayout, +template +bool WrappedVulkan::Serialise_vkCmdClearColorImage(SerialiserType &ser, VkCommandBuffer commandBuffer, + VkImage image, VkImageLayout imageLayout, const VkClearColorValue *pColor, uint32_t rangeCount, const VkImageSubresourceRange *pRanges) { - SERIALISE_ELEMENT(ResourceId, cmdid, GetResID(commandBuffer)); - SERIALISE_ELEMENT(ResourceId, imgid, GetResID(image)); - SERIALISE_ELEMENT(VkImageLayout, layout, imageLayout); - SERIALISE_ELEMENT(VkClearColorValue, col, *pColor); + SERIALISE_ELEMENT(commandBuffer); + SERIALISE_ELEMENT(image); + SERIALISE_ELEMENT(imageLayout); + SERIALISE_ELEMENT_LOCAL(Color, *pColor); + SERIALISE_ELEMENT_ARRAY(pRanges, rangeCount); - SERIALISE_ELEMENT(uint32_t, count, rangeCount); - SERIALISE_ELEMENT_ARR(VkImageSubresourceRange, ranges, pRanges, count); + Serialise_DebugMessages(ser); - Serialise_DebugMessages(localSerialiser, true); - - if(m_State < WRITING) - m_LastCmdBufferID = cmdid; - - if(m_State == EXECUTING) + if(IsReplayingAndReading()) { - image = GetResourceManager()->GetLiveHandle(imgid); + m_LastCmdBufferID = GetResourceManager()->GetOriginalID(GetResID(commandBuffer)); - if(ShouldRerecordCmd(cmdid) && InRerecordRange(cmdid)) + if(IsActiveReplaying(m_State)) { - commandBuffer = RerecordCmdBuf(cmdid); - - uint32_t eventID = - HandlePreCallback(commandBuffer, DrawFlags(DrawFlags::Clear | DrawFlags::ClearColor)); - - ObjDisp(commandBuffer) - ->CmdClearColorImage(Unwrap(commandBuffer), Unwrap(image), layout, &col, count, ranges); - - if(eventID && - m_DrawcallCallback->PostMisc(eventID, DrawFlags(DrawFlags::Clear | DrawFlags::ClearColor), - commandBuffer)) + if(ShouldRerecordCmd(m_LastCmdBufferID) && InRerecordRange(m_LastCmdBufferID)) { - ObjDisp(commandBuffer) - ->CmdClearColorImage(Unwrap(commandBuffer), Unwrap(image), layout, &col, count, ranges); + commandBuffer = RerecordCmdBuf(m_LastCmdBufferID); - m_DrawcallCallback->PostRemisc(eventID, DrawFlags(DrawFlags::Clear | DrawFlags::ClearColor), - commandBuffer); + uint32_t eventID = + HandlePreCallback(commandBuffer, DrawFlags(DrawFlags::Clear | DrawFlags::ClearColor)); + + ObjDisp(commandBuffer) + ->CmdClearColorImage(Unwrap(commandBuffer), Unwrap(image), imageLayout, &Color, + rangeCount, pRanges); + + if(eventID && + m_DrawcallCallback->PostMisc( + eventID, DrawFlags(DrawFlags::Clear | DrawFlags::ClearColor), commandBuffer)) + { + ObjDisp(commandBuffer) + ->CmdClearColorImage(Unwrap(commandBuffer), Unwrap(image), imageLayout, &Color, + rangeCount, pRanges); + + m_DrawcallCallback->PostRemisc( + eventID, DrawFlags(DrawFlags::Clear | DrawFlags::ClearColor), commandBuffer); + } + } + } + else + { + ObjDisp(commandBuffer) + ->CmdClearColorImage(Unwrap(commandBuffer), Unwrap(image), imageLayout, &Color, + rangeCount, pRanges); + + { + AddEvent(); + + DrawcallDescription draw; + draw.name = StringFormat::Fmt("vkCmdClearColorImage(%f, %f, %f, %f)", Color.float32[0], + Color.float32[0], Color.float32[0], Color.float32[0]); + draw.flags |= DrawFlags::Clear | DrawFlags::ClearColor; + draw.copyDestination = GetResourceManager()->GetOriginalID(GetResID(image)); + + AddDrawcall(draw, true); + + VulkanDrawcallTreeNode &drawNode = GetDrawcallStack().back()->children.back(); + + drawNode.resourceUsage.push_back(std::make_pair( + GetResID(image), EventUsage(drawNode.draw.eventID, ResourceUsage::Clear))); } } } - else if(m_State == READING) - { - commandBuffer = GetResourceManager()->GetLiveHandle(cmdid); - image = GetResourceManager()->GetLiveHandle(imgid); - - ObjDisp(commandBuffer) - ->CmdClearColorImage(Unwrap(commandBuffer), Unwrap(image), layout, &col, count, ranges); - - const string desc = localSerialiser->GetDebugStr(); - - { - AddEvent(desc); - string name = "vkCmdClearColorImage(" + ToStr(col) + ")"; - - DrawcallDescription draw; - draw.name = name; - draw.flags |= DrawFlags::Clear | DrawFlags::ClearColor; - draw.copyDestination = imgid; - - AddDrawcall(draw, true); - - VulkanDrawcallTreeNode &drawNode = GetDrawcallStack().back()->children.back(); - - drawNode.resourceUsage.push_back( - std::make_pair(GetResID(image), EventUsage(drawNode.draw.eventID, ResourceUsage::Clear))); - } - } - - SAFE_DELETE_ARRAY(ranges); return true; } @@ -1847,15 +1778,16 @@ void WrappedVulkan::vkCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage ->CmdClearColorImage(Unwrap(commandBuffer), Unwrap(image), imageLayout, pColor, rangeCount, pRanges); - if(m_State >= WRITING) + if(IsCaptureMode(m_State)) { VkResourceRecord *record = GetRecord(commandBuffer); CACHE_THREAD_SERIALISER(); - SCOPED_SERIALISE_CONTEXT(CLEAR_COLOR); - Serialise_vkCmdClearColorImage(localSerialiser, commandBuffer, image, imageLayout, pColor, - rangeCount, pRanges); + ser.SetDrawChunk(); + SCOPED_SERIALISE_CHUNK(VulkanChunk::vkCmdClearColorImage); + Serialise_vkCmdClearColorImage(ser, commandBuffer, image, imageLayout, pColor, rangeCount, + pRanges); record->AddChunk(scope.Get()); record->MarkResourceFrameReferenced(GetResID(image), eFrameRef_Write); @@ -1865,78 +1797,74 @@ void WrappedVulkan::vkCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage } } +template bool WrappedVulkan::Serialise_vkCmdClearDepthStencilImage( - Serialiser *localSerialiser, VkCommandBuffer commandBuffer, VkImage image, - VkImageLayout imageLayout, const VkClearDepthStencilValue *pDepthStencil, uint32_t rangeCount, + SerialiserType &ser, VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, + const VkClearDepthStencilValue *pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange *pRanges) { - SERIALISE_ELEMENT(ResourceId, cmdid, GetResID(commandBuffer)); - SERIALISE_ELEMENT(ResourceId, imgid, GetResID(image)); - SERIALISE_ELEMENT(VkImageLayout, l, imageLayout); - SERIALISE_ELEMENT(VkClearDepthStencilValue, ds, *pDepthStencil); - SERIALISE_ELEMENT(uint32_t, count, rangeCount); - SERIALISE_ELEMENT_ARR(VkImageSubresourceRange, ranges, pRanges, count); + SERIALISE_ELEMENT(commandBuffer); + SERIALISE_ELEMENT(image); + SERIALISE_ELEMENT(imageLayout); + SERIALISE_ELEMENT_LOCAL(DepthStencil, *pDepthStencil); + SERIALISE_ELEMENT_ARRAY(pRanges, rangeCount); - Serialise_DebugMessages(localSerialiser, true); + Serialise_DebugMessages(ser); - if(m_State < WRITING) - m_LastCmdBufferID = cmdid; - - if(m_State == EXECUTING) + if(IsReplayingAndReading()) { - image = GetResourceManager()->GetLiveHandle(imgid); + m_LastCmdBufferID = GetResourceManager()->GetOriginalID(GetResID(commandBuffer)); - if(ShouldRerecordCmd(cmdid) && InRerecordRange(cmdid)) + if(IsActiveReplaying(m_State)) { - commandBuffer = RerecordCmdBuf(cmdid); - - uint32_t eventID = HandlePreCallback( - commandBuffer, DrawFlags(DrawFlags::Clear | DrawFlags::ClearDepthStencil)); - - ObjDisp(commandBuffer) - ->CmdClearDepthStencilImage(Unwrap(commandBuffer), Unwrap(image), l, &ds, count, ranges); - - if(eventID && - m_DrawcallCallback->PostMisc( - eventID, DrawFlags(DrawFlags::Clear | DrawFlags::ClearDepthStencil), commandBuffer)) + if(ShouldRerecordCmd(m_LastCmdBufferID) && InRerecordRange(m_LastCmdBufferID)) { - ObjDisp(commandBuffer) - ->CmdClearDepthStencilImage(Unwrap(commandBuffer), Unwrap(image), l, &ds, count, ranges); + commandBuffer = RerecordCmdBuf(m_LastCmdBufferID); - m_DrawcallCallback->PostRemisc( - eventID, DrawFlags(DrawFlags::Clear | DrawFlags::ClearDepthStencil), commandBuffer); + uint32_t eventID = HandlePreCallback( + commandBuffer, DrawFlags(DrawFlags::Clear | DrawFlags::ClearDepthStencil)); + + ObjDisp(commandBuffer) + ->CmdClearDepthStencilImage(Unwrap(commandBuffer), Unwrap(image), imageLayout, + &DepthStencil, rangeCount, pRanges); + + if(eventID && + m_DrawcallCallback->PostMisc( + eventID, DrawFlags(DrawFlags::Clear | DrawFlags::ClearDepthStencil), commandBuffer)) + { + ObjDisp(commandBuffer) + ->CmdClearDepthStencilImage(Unwrap(commandBuffer), Unwrap(image), imageLayout, + &DepthStencil, rangeCount, pRanges); + + m_DrawcallCallback->PostRemisc( + eventID, DrawFlags(DrawFlags::Clear | DrawFlags::ClearDepthStencil), commandBuffer); + } + } + } + else + { + ObjDisp(commandBuffer) + ->CmdClearDepthStencilImage(Unwrap(commandBuffer), Unwrap(image), imageLayout, + &DepthStencil, rangeCount, pRanges); + + { + AddEvent(); + + DrawcallDescription draw; + draw.name = StringFormat::Fmt("vkCmdClearColorImage(%f, %u)", DepthStencil.depth, + DepthStencil.stencil); + draw.flags |= DrawFlags::Clear | DrawFlags::ClearDepthStencil; + draw.copyDestination = GetResourceManager()->GetOriginalID(GetResID(image)); + + AddDrawcall(draw, true); + + VulkanDrawcallTreeNode &drawNode = GetDrawcallStack().back()->children.back(); + + drawNode.resourceUsage.push_back(std::make_pair( + GetResID(image), EventUsage(drawNode.draw.eventID, ResourceUsage::Clear))); } } } - else if(m_State == READING) - { - commandBuffer = GetResourceManager()->GetLiveHandle(cmdid); - image = GetResourceManager()->GetLiveHandle(imgid); - - ObjDisp(commandBuffer) - ->CmdClearDepthStencilImage(Unwrap(commandBuffer), Unwrap(image), l, &ds, count, ranges); - - const string desc = localSerialiser->GetDebugStr(); - - { - AddEvent(desc); - string name = "vkCmdClearDepthStencilImage(" + ToStr(ds.depth) + "," + ToStr(ds.stencil) + ")"; - - DrawcallDescription draw; - draw.name = name; - draw.flags |= DrawFlags::Clear | DrawFlags::ClearDepthStencil; - draw.copyDestination = imgid; - - AddDrawcall(draw, true); - - VulkanDrawcallTreeNode &drawNode = GetDrawcallStack().back()->children.back(); - - drawNode.resourceUsage.push_back( - std::make_pair(GetResID(image), EventUsage(drawNode.draw.eventID, ResourceUsage::Clear))); - } - } - - SAFE_DELETE_ARRAY(ranges); return true; } @@ -1953,15 +1881,16 @@ void WrappedVulkan::vkCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, V ->CmdClearDepthStencilImage(Unwrap(commandBuffer), Unwrap(image), imageLayout, pDepthStencil, rangeCount, pRanges); - if(m_State >= WRITING) + if(IsCaptureMode(m_State)) { VkResourceRecord *record = GetRecord(commandBuffer); CACHE_THREAD_SERIALISER(); - SCOPED_SERIALISE_CONTEXT(CLEAR_DEPTHSTENCIL); - Serialise_vkCmdClearDepthStencilImage(localSerialiser, commandBuffer, image, imageLayout, - pDepthStencil, rangeCount, pRanges); + ser.SetDrawChunk(); + SCOPED_SERIALISE_CHUNK(VulkanChunk::vkCmdClearDepthStencilImage); + Serialise_vkCmdClearDepthStencilImage(ser, commandBuffer, image, imageLayout, pDepthStencil, + rangeCount, pRanges); record->AddChunk(scope.Get()); record->MarkResourceFrameReferenced(GetResID(image), eFrameRef_Write); @@ -1971,104 +1900,116 @@ void WrappedVulkan::vkCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, V } } -bool WrappedVulkan::Serialise_vkCmdClearAttachments(Serialiser *localSerialiser, +template +bool WrappedVulkan::Serialise_vkCmdClearAttachments(SerialiserType &ser, VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment *pAttachments, uint32_t rectCount, const VkClearRect *pRects) { - SERIALISE_ELEMENT(ResourceId, cmdid, GetResID(commandBuffer)); + SERIALISE_ELEMENT(commandBuffer); + SERIALISE_ELEMENT_ARRAY(pAttachments, attachmentCount); + SERIALISE_ELEMENT_ARRAY(pRects, rectCount); - SERIALISE_ELEMENT(uint32_t, acount, attachmentCount); - SERIALISE_ELEMENT_ARR(VkClearAttachment, atts, pAttachments, acount); + Serialise_DebugMessages(ser); - SERIALISE_ELEMENT(uint32_t, rcount, rectCount); - SERIALISE_ELEMENT_ARR(VkClearRect, rects, pRects, rcount); - - Serialise_DebugMessages(localSerialiser, true); - - if(m_State < WRITING) - m_LastCmdBufferID = cmdid; - - if(m_State == EXECUTING) + if(IsReplayingAndReading()) { - if(ShouldRerecordCmd(cmdid) && InRerecordRange(cmdid)) + m_LastCmdBufferID = GetResourceManager()->GetOriginalID(GetResID(commandBuffer)); + + if(IsActiveReplaying(m_State)) { - commandBuffer = RerecordCmdBuf(cmdid); - - uint32_t eventID = HandlePreCallback(commandBuffer, DrawFlags(DrawFlags::Clear)); - - ObjDisp(commandBuffer)->CmdClearAttachments(Unwrap(commandBuffer), acount, atts, rcount, rects); - - if(eventID && m_DrawcallCallback->PostMisc(eventID, DrawFlags(DrawFlags::Clear), commandBuffer)) + if(ShouldRerecordCmd(m_LastCmdBufferID) && InRerecordRange(m_LastCmdBufferID)) { - ObjDisp(commandBuffer)->CmdClearAttachments(Unwrap(commandBuffer), acount, atts, rcount, rects); + commandBuffer = RerecordCmdBuf(m_LastCmdBufferID); - m_DrawcallCallback->PostRemisc(eventID, DrawFlags(DrawFlags::Clear), commandBuffer); + uint32_t eventID = HandlePreCallback(commandBuffer, DrawFlags(DrawFlags::Clear)); + + ObjDisp(commandBuffer) + ->CmdClearAttachments(Unwrap(commandBuffer), attachmentCount, pAttachments, rectCount, + pRects); + + if(eventID && + m_DrawcallCallback->PostMisc(eventID, DrawFlags(DrawFlags::Clear), commandBuffer)) + { + ObjDisp(commandBuffer) + ->CmdClearAttachments(Unwrap(commandBuffer), attachmentCount, pAttachments, rectCount, + pRects); + + m_DrawcallCallback->PostRemisc(eventID, DrawFlags(DrawFlags::Clear), commandBuffer); + } } } - } - else if(m_State == READING) - { - commandBuffer = GetResourceManager()->GetLiveHandle(cmdid); - - ObjDisp(commandBuffer)->CmdClearAttachments(Unwrap(commandBuffer), acount, atts, rcount, rects); - - const string desc = localSerialiser->GetDebugStr(); - + else { - AddEvent(desc); - string name = "vkCmdClearAttachments("; - for(uint32_t a = 0; a < acount; a++) - name += ToStr(atts[a]); - name += ")"; + ObjDisp(commandBuffer) + ->CmdClearAttachments(Unwrap(commandBuffer), attachmentCount, pAttachments, rectCount, + pRects); - DrawcallDescription draw; - draw.name = name; - draw.flags |= DrawFlags::Clear; - for(uint32_t a = 0; a < acount; a++) { - if(atts[a].aspectMask & VK_IMAGE_ASPECT_COLOR_BIT) - draw.flags |= DrawFlags::ClearColor; - if(atts[a].aspectMask & VK_IMAGE_ASPECT_DEPTH_BIT) - draw.flags |= DrawFlags::ClearDepthStencil; - } + AddEvent(); - AddDrawcall(draw, true); + string name = "vkCmdClearAttachments("; + for(uint32_t a = 0; a < attachmentCount; a++) + name += ToStr(pAttachments[a].colorAttachment); + name += ")"; - VulkanDrawcallTreeNode &drawNode = GetDrawcallStack().back()->children.back(); - const BakedCmdBufferInfo::CmdBufferState &state = m_BakedCmdBufferInfo[m_LastCmdBufferID].state; - - if(state.renderPass != ResourceId() && state.framebuffer != ResourceId()) - { - VulkanCreationInfo::RenderPass &rp = m_CreationInfo.m_RenderPass[state.renderPass]; - VulkanCreationInfo::Framebuffer &fb = m_CreationInfo.m_Framebuffer[state.framebuffer]; - - RDCASSERT(state.subpass < rp.subpasses.size()); - - for(size_t i = 0; i < rp.subpasses[state.subpass].colorAttachments.size(); i++) + DrawcallDescription draw; + draw.name = name; + draw.flags |= DrawFlags::Clear; + for(uint32_t a = 0; a < attachmentCount; a++) { - uint32_t att = rp.subpasses[state.subpass].colorAttachments[i]; - drawNode.resourceUsage.push_back(std::make_pair( - m_CreationInfo.m_ImageView[fb.attachments[att].view].image, - EventUsage(drawNode.draw.eventID, ResourceUsage::Clear, fb.attachments[att].view))); + if(pAttachments[a].aspectMask & VK_IMAGE_ASPECT_COLOR_BIT) + draw.flags |= DrawFlags::ClearColor; + if(pAttachments[a].aspectMask & VK_IMAGE_ASPECT_DEPTH_BIT) + draw.flags |= DrawFlags::ClearDepthStencil; } - if(draw.flags & DrawFlags::ClearDepthStencil && - rp.subpasses[state.subpass].depthstencilAttachment >= 0) + AddDrawcall(draw, true); + + VulkanDrawcallTreeNode &drawNode = GetDrawcallStack().back()->children.back(); + const BakedCmdBufferInfo::CmdBufferState &state = + m_BakedCmdBufferInfo[m_LastCmdBufferID].state; + + if(state.renderPass != ResourceId() && state.framebuffer != ResourceId()) { - int32_t att = rp.subpasses[state.subpass].depthstencilAttachment; - drawNode.resourceUsage.push_back(std::make_pair( - m_CreationInfo.m_ImageView[fb.attachments[att].view].image, - EventUsage(drawNode.draw.eventID, ResourceUsage::Clear, fb.attachments[att].view))); + VulkanCreationInfo::RenderPass &rp = m_CreationInfo.m_RenderPass[state.renderPass]; + VulkanCreationInfo::Framebuffer &fb = m_CreationInfo.m_Framebuffer[state.framebuffer]; + + RDCASSERT(state.subpass < rp.subpasses.size()); + + for(uint32_t a = 0; a < attachmentCount; a++) + { + uint32_t att = pAttachments[a].colorAttachment; + + if(pAttachments[a].aspectMask & VK_IMAGE_ASPECT_COLOR_BIT) + { + if(att < (uint32_t)rp.subpasses[state.subpass].colorAttachments.size()) + { + att = rp.subpasses[state.subpass].colorAttachments[att]; + drawNode.resourceUsage.push_back( + std::make_pair(m_CreationInfo.m_ImageView[fb.attachments[att].view].image, + EventUsage(drawNode.draw.eventID, ResourceUsage::Clear, + fb.attachments[att].view))); + } + } + else if(pAttachments[a].aspectMask & VK_IMAGE_ASPECT_DEPTH_BIT) + { + if(rp.subpasses[state.subpass].depthstencilAttachment >= 0) + { + att = (uint32_t)rp.subpasses[state.subpass].depthstencilAttachment; + drawNode.resourceUsage.push_back( + std::make_pair(m_CreationInfo.m_ImageView[fb.attachments[att].view].image, + EventUsage(drawNode.draw.eventID, ResourceUsage::Clear, + fb.attachments[att].view))); + } + } + } } } } } - SAFE_DELETE_ARRAY(atts); - SAFE_DELETE_ARRAY(rects); - return true; } @@ -2081,15 +2022,16 @@ void WrappedVulkan::vkCmdClearAttachments(VkCommandBuffer commandBuffer, uint32_ ObjDisp(commandBuffer) ->CmdClearAttachments(Unwrap(commandBuffer), attachmentCount, pAttachments, rectCount, pRects); - if(m_State >= WRITING) + if(IsCaptureMode(m_State)) { VkResourceRecord *record = GetRecord(commandBuffer); CACHE_THREAD_SERIALISER(); - SCOPED_SERIALISE_CONTEXT(CLEAR_ATTACH); - Serialise_vkCmdClearAttachments(localSerialiser, commandBuffer, attachmentCount, pAttachments, - rectCount, pRects); + ser.SetDrawChunk(); + SCOPED_SERIALISE_CHUNK(VulkanChunk::vkCmdClearAttachments); + Serialise_vkCmdClearAttachments(ser, commandBuffer, attachmentCount, pAttachments, rectCount, + pRects); record->AddChunk(scope.Get()); @@ -2097,3 +2039,65 @@ void WrappedVulkan::vkCmdClearAttachments(VkCommandBuffer commandBuffer, uint32_ // bound. } } + +INSTANTIATE_FUNCTION_SERIALISED(void, vkCmdDraw, VkCommandBuffer commandBuffer, uint32_t vertexCount, + uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance); + +INSTANTIATE_FUNCTION_SERIALISED(void, vkCmdDrawIndexed, VkCommandBuffer commandBuffer, + uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, + int32_t vertexOffset, uint32_t firstInstance); + +INSTANTIATE_FUNCTION_SERIALISED(void, vkCmdDrawIndirect, VkCommandBuffer commandBuffer, + VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, + uint32_t stride); + +INSTANTIATE_FUNCTION_SERIALISED(void, vkCmdDrawIndexedIndirect, VkCommandBuffer commandBuffer, + VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, + uint32_t stride); + +INSTANTIATE_FUNCTION_SERIALISED(void, vkCmdDispatch, VkCommandBuffer commandBuffer, uint32_t x, + uint32_t y, uint32_t z); + +INSTANTIATE_FUNCTION_SERIALISED(void, vkCmdDispatchIndirect, VkCommandBuffer commandBuffer, + VkBuffer buffer, VkDeviceSize offset); + +INSTANTIATE_FUNCTION_SERIALISED(void, vkCmdCopyBuffer, VkCommandBuffer commandBuffer, + VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, + const VkBufferCopy *pRegions); + +INSTANTIATE_FUNCTION_SERIALISED(void, vkCmdCopyImage, VkCommandBuffer commandBuffer, + VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, + VkImageLayout dstImageLayout, uint32_t regionCount, + const VkImageCopy *pRegions); + +INSTANTIATE_FUNCTION_SERIALISED(void, vkCmdBlitImage, VkCommandBuffer commandBuffer, + VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, + VkImageLayout dstImageLayout, uint32_t regionCount, + const VkImageBlit *pRegions, VkFilter filter); + +INSTANTIATE_FUNCTION_SERIALISED(void, vkCmdCopyBufferToImage, VkCommandBuffer commandBuffer, + VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, + uint32_t regionCount, const VkBufferImageCopy *pRegions); + +INSTANTIATE_FUNCTION_SERIALISED(void, vkCmdCopyImageToBuffer, VkCommandBuffer commandBuffer, + VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, + uint32_t regionCount, const VkBufferImageCopy *pRegions); + +INSTANTIATE_FUNCTION_SERIALISED(void, vkCmdClearColorImage, VkCommandBuffer commandBuffer, + VkImage image, VkImageLayout imageLayout, + const VkClearColorValue *pColor, uint32_t rangeCount, + const VkImageSubresourceRange *pRanges); + +INSTANTIATE_FUNCTION_SERIALISED(void, vkCmdClearDepthStencilImage, VkCommandBuffer commandBuffer, + VkImage image, VkImageLayout imageLayout, + const VkClearDepthStencilValue *pDepthStencil, uint32_t rangeCount, + const VkImageSubresourceRange *pRanges); + +INSTANTIATE_FUNCTION_SERIALISED(void, vkCmdClearAttachments, VkCommandBuffer commandBuffer, + uint32_t attachmentCount, const VkClearAttachment *pAttachments, + uint32_t rectCount, const VkClearRect *pRects); + +INSTANTIATE_FUNCTION_SERIALISED(void, vkCmdResolveImage, VkCommandBuffer commandBuffer, + VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, + VkImageLayout dstImageLayout, uint32_t regionCount, + const VkImageResolve *pRegions);