From 188779e298c0fffab8df52f66cb890beb293a400 Mon Sep 17 00:00:00 2001 From: baldurk Date: Thu, 5 May 2016 14:58:42 +0200 Subject: [PATCH] Add debug message catching & serialising to all relevent chunks * i.e. any chunk that could actually become an EID and where we can get the debug messages before serialising (which excludes vkUnmapMemory) --- .../driver/vulkan/wrappers/vk_cmd_funcs.cpp | 68 +++++++++++++++++++ .../vulkan/wrappers/vk_descriptor_funcs.cpp | 4 ++ .../driver/vulkan/wrappers/vk_draw_funcs.cpp | 60 ++++++++++++++++ .../vulkan/wrappers/vk_dynamic_funcs.cpp | 37 ++++++++++ .../driver/vulkan/wrappers/vk_queue_funcs.cpp | 4 ++ .../driver/vulkan/wrappers/vk_sync_funcs.cpp | 32 +++++++++ 6 files changed, 205 insertions(+) diff --git a/renderdoc/driver/vulkan/wrappers/vk_cmd_funcs.cpp b/renderdoc/driver/vulkan/wrappers/vk_cmd_funcs.cpp index b995c724b..6338b18fc 100644 --- a/renderdoc/driver/vulkan/wrappers/vk_cmd_funcs.cpp +++ b/renderdoc/driver/vulkan/wrappers/vk_cmd_funcs.cpp @@ -642,6 +642,8 @@ bool WrappedVulkan::Serialise_vkCmdBeginRenderPass( SERIALISE_ELEMENT(VkRenderPassBeginInfo, beginInfo, *pRenderPassBegin); SERIALISE_ELEMENT(VkSubpassContents, cont, contents); + Serialise_DebugMessages(localSerialiser, false); + if(m_State < WRITING) m_LastCmdBufferID = cmdid; @@ -692,6 +694,8 @@ void WrappedVulkan::vkCmdBeginRenderPass( const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents) { + SCOPED_DBG_SINK(); + VkRenderPassBeginInfo unwrappedInfo = *pRenderPassBegin; unwrappedInfo.renderPass = Unwrap(unwrappedInfo.renderPass); unwrappedInfo.framebuffer = Unwrap(unwrappedInfo.framebuffer); @@ -733,6 +737,8 @@ bool WrappedVulkan::Serialise_vkCmdNextSubpass( { SERIALISE_ELEMENT(ResourceId, cmdid, GetResID(commandBuffer)); SERIALISE_ELEMENT(VkSubpassContents, cont, contents); + + Serialise_DebugMessages(localSerialiser, false); if(m_State < WRITING) m_LastCmdBufferID = cmdid; @@ -774,6 +780,8 @@ void WrappedVulkan::vkCmdNextSubpass( VkCommandBuffer commandBuffer, VkSubpassContents contents) { + SCOPED_DBG_SINK(); + ObjDisp(commandBuffer)->CmdNextSubpass(Unwrap(commandBuffer), contents); if(m_State >= WRITING) @@ -797,6 +805,8 @@ bool WrappedVulkan::Serialise_vkCmdExecuteCommands( { SERIALISE_ELEMENT(ResourceId, cmdid, GetResID(commandBuffer)); SERIALISE_ELEMENT(uint32_t, count, commandBufferCount); + + Serialise_DebugMessages(localSerialiser, false); if(m_State < WRITING) m_LastCmdBufferID = cmdid; @@ -858,6 +868,8 @@ void WrappedVulkan::vkCmdExecuteCommands( uint32_t commandBufferCount, const VkCommandBuffer* pCmdBuffers) { + SCOPED_DBG_SINK(); + VkCommandBuffer *unwrapped = GetTempArray(commandBufferCount); for(uint32_t i=0; i < commandBufferCount; i++) unwrapped[i] = Unwrap(pCmdBuffers[i]); ObjDisp(commandBuffer)->CmdExecuteCommands(Unwrap(commandBuffer), commandBufferCount, unwrapped); @@ -894,6 +906,8 @@ bool WrappedVulkan::Serialise_vkCmdEndRenderPass( { SERIALISE_ELEMENT(ResourceId, cmdid, GetResID(commandBuffer)); + Serialise_DebugMessages(localSerialiser, false); + if(m_State < WRITING) m_LastCmdBufferID = cmdid; @@ -936,6 +950,8 @@ bool WrappedVulkan::Serialise_vkCmdEndRenderPass( void WrappedVulkan::vkCmdEndRenderPass( VkCommandBuffer commandBuffer) { + SCOPED_DBG_SINK(); + ObjDisp(commandBuffer)->CmdEndRenderPass(Unwrap(commandBuffer)); if(m_State >= WRITING) @@ -961,6 +977,8 @@ bool WrappedVulkan::Serialise_vkCmdBindPipeline( SERIALISE_ELEMENT(VkPipelineBindPoint, bind, pipelineBindPoint); SERIALISE_ELEMENT(ResourceId, pipeid, GetResID(pipeline)); + Serialise_DebugMessages(localSerialiser, false); + if(m_State < WRITING) m_LastCmdBufferID = cmdid; @@ -1043,6 +1061,8 @@ void WrappedVulkan::vkCmdBindPipeline( VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) { + SCOPED_DBG_SINK(); + ObjDisp(commandBuffer)->CmdBindPipeline(Unwrap(commandBuffer), pipelineBindPoint, Unwrap(pipeline)); if(m_State >= WRITING) @@ -1077,6 +1097,8 @@ bool WrappedVulkan::Serialise_vkCmdBindDescriptorSets( SERIALISE_ELEMENT(uint32_t, numSets, setCount); + Serialise_DebugMessages(localSerialiser, false); + if(m_State < WRITING) m_LastCmdBufferID = cmdid; @@ -1219,6 +1241,8 @@ void WrappedVulkan::vkCmdBindDescriptorSets( uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets) { + SCOPED_DBG_SINK(); + VkDescriptorSet *unwrapped = GetTempArray(setCount); for(uint32_t i=0; i < setCount; i++) unwrapped[i] = Unwrap(pDescriptorSets[i]); @@ -1251,6 +1275,8 @@ bool WrappedVulkan::Serialise_vkCmdBindVertexBuffers( SERIALISE_ELEMENT(uint32_t, first, firstBinding); SERIALISE_ELEMENT(uint32_t, count, bindingCount); + Serialise_DebugMessages(localSerialiser, false); + if(m_State < WRITING) m_LastCmdBufferID = cmdid; @@ -1321,6 +1347,8 @@ void WrappedVulkan::vkCmdBindVertexBuffers( const VkBuffer* pBuffers, const VkDeviceSize* pOffsets) { + SCOPED_DBG_SINK(); + VkBuffer *unwrapped = GetTempArray(bindingCount); for(uint32_t i=0; i < bindingCount; i++) unwrapped[i] = Unwrap(pBuffers[i]); @@ -1359,6 +1387,8 @@ bool WrappedVulkan::Serialise_vkCmdBindIndexBuffer( SERIALISE_ELEMENT(uint64_t, offs, offset); SERIALISE_ELEMENT(VkIndexType, idxType, indexType); + Serialise_DebugMessages(localSerialiser, false); + if(m_State < WRITING) m_LastCmdBufferID = cmdid; @@ -1399,6 +1429,8 @@ void WrappedVulkan::vkCmdBindIndexBuffer( VkDeviceSize offset, VkIndexType indexType) { + SCOPED_DBG_SINK(); + ObjDisp(commandBuffer)->CmdBindIndexBuffer(Unwrap(commandBuffer), Unwrap(buffer), offset, indexType); if(m_State >= WRITING) @@ -1432,6 +1464,8 @@ bool WrappedVulkan::Serialise_vkCmdUpdateBuffer( SERIALISE_ELEMENT(VkDeviceSize, sz, dataSize); SERIALISE_ELEMENT_BUF(byte *, bufdata, (byte *)pData, (size_t)dataSize); + Serialise_DebugMessages(localSerialiser, false); + if(m_State < WRITING) m_LastCmdBufferID = cmdid; @@ -1466,6 +1500,8 @@ void WrappedVulkan::vkCmdUpdateBuffer( VkDeviceSize dataSize, const uint32_t* pData) { + SCOPED_DBG_SINK(); + ObjDisp(commandBuffer)->CmdUpdateBuffer(Unwrap(commandBuffer), Unwrap(destBuffer), destOffset, dataSize, pData); if(m_State >= WRITING) @@ -1505,6 +1541,8 @@ bool WrappedVulkan::Serialise_vkCmdFillBuffer( SERIALISE_ELEMENT(VkDeviceSize, sz, fillSize); SERIALISE_ELEMENT(uint32_t, d, data); + Serialise_DebugMessages(localSerialiser, false); + if(m_State < WRITING) m_LastCmdBufferID = cmdid; @@ -1536,6 +1574,8 @@ void WrappedVulkan::vkCmdFillBuffer( VkDeviceSize fillSize, uint32_t data) { + SCOPED_DBG_SINK(); + ObjDisp(commandBuffer)->CmdFillBuffer(Unwrap(commandBuffer), Unwrap(destBuffer), destOffset, fillSize, data); if(m_State >= WRITING) @@ -1577,6 +1617,8 @@ bool WrappedVulkan::Serialise_vkCmdPushConstants( SERIALISE_ELEMENT(uint32_t, len, length); SERIALISE_ELEMENT_BUF(byte *, vals, (byte *)values, (size_t)len); + Serialise_DebugMessages(localSerialiser, false); + if(m_State < WRITING) m_LastCmdBufferID = cmdid; @@ -1615,6 +1657,8 @@ void WrappedVulkan::vkCmdPushConstants( uint32_t length, const void* values) { + SCOPED_DBG_SINK(); + ObjDisp(commandBuffer)->CmdPushConstants(Unwrap(commandBuffer), Unwrap(layout), stageFlags, start, length, values); if(m_State >= WRITING) @@ -1660,6 +1704,8 @@ bool WrappedVulkan::Serialise_vkCmdPipelineBarrier( SERIALISE_ELEMENT_ARR(VkBufferMemoryBarrier, bufMemBarriers, pBufferMemoryBarriers, bufCount); SERIALISE_ELEMENT_ARR(VkImageMemoryBarrier, imgMemBarriers, pImageMemoryBarriers, imgCount); + Serialise_DebugMessages(localSerialiser, false); + vector imgBarriers; vector bufBarriers; @@ -1731,6 +1777,8 @@ void WrappedVulkan::vkCmdPipelineBarrier( uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers) { + SCOPED_DBG_SINK(); + { byte *memory = GetTempMemory(sizeof(VkBufferMemoryBarrier)*bufferMemoryBarrierCount + sizeof(VkImageMemoryBarrier)*imageMemoryBarrierCount); @@ -1790,6 +1838,8 @@ bool WrappedVulkan::Serialise_vkCmdWriteTimestamp( SERIALISE_ELEMENT(ResourceId, poolid, GetResID(queryPool)); SERIALISE_ELEMENT(uint32_t, q, query); + Serialise_DebugMessages(localSerialiser, false); + if(m_State < WRITING) m_LastCmdBufferID = cmdid; @@ -1820,6 +1870,8 @@ void WrappedVulkan::vkCmdWriteTimestamp( VkQueryPool queryPool, uint32_t query) { + SCOPED_DBG_SINK(); + ObjDisp(commandBuffer)->CmdWriteTimestamp(Unwrap(commandBuffer), pipelineStage, Unwrap(queryPool), query); if(m_State >= WRITING) @@ -1857,6 +1909,8 @@ bool WrappedVulkan::Serialise_vkCmdCopyQueryPoolResults( SERIALISE_ELEMENT(VkDeviceSize, stride, destStride); SERIALISE_ELEMENT(VkQueryResultFlagBits, f, (VkQueryResultFlagBits)flags); + Serialise_DebugMessages(localSerialiser, false); + if(m_State < WRITING) m_LastCmdBufferID = cmdid; @@ -1893,6 +1947,8 @@ void WrappedVulkan::vkCmdCopyQueryPoolResults( VkDeviceSize destStride, VkQueryResultFlags flags) { + SCOPED_DBG_SINK(); + ObjDisp(commandBuffer)->CmdCopyQueryPoolResults(Unwrap(commandBuffer), Unwrap(queryPool), firstQuery, queryCount, Unwrap(destBuffer), destOffset, destStride, flags); if(m_State >= WRITING) @@ -1931,6 +1987,8 @@ bool WrappedVulkan::Serialise_vkCmdBeginQuery( SERIALISE_ELEMENT(uint32_t, q, query); SERIALISE_ELEMENT(VkQueryControlFlagBits, f, (VkQueryControlFlagBits)flags); // serialise as 'bits' type to get nice enum values + Serialise_DebugMessages(localSerialiser, false); + if(m_State < WRITING) m_LastCmdBufferID = cmdid; @@ -1961,6 +2019,8 @@ void WrappedVulkan::vkCmdBeginQuery( uint32_t query, VkQueryControlFlags flags) { + SCOPED_DBG_SINK(); + ObjDisp(commandBuffer)->CmdBeginQuery(Unwrap(commandBuffer), Unwrap(queryPool), query, flags); if(m_State >= WRITING) @@ -1987,6 +2047,8 @@ bool WrappedVulkan::Serialise_vkCmdEndQuery( SERIALISE_ELEMENT(ResourceId, qid, GetResID(queryPool)); SERIALISE_ELEMENT(uint32_t, q, query); + Serialise_DebugMessages(localSerialiser, false); + if(m_State < WRITING) m_LastCmdBufferID = cmdid; @@ -2016,6 +2078,8 @@ void WrappedVulkan::vkCmdEndQuery( VkQueryPool queryPool, uint32_t query) { + SCOPED_DBG_SINK(); + ObjDisp(commandBuffer)->CmdEndQuery(Unwrap(commandBuffer), Unwrap(queryPool), query); if(m_State >= WRITING) @@ -2044,6 +2108,8 @@ bool WrappedVulkan::Serialise_vkCmdResetQueryPool( SERIALISE_ELEMENT(uint32_t, first, firstQuery); SERIALISE_ELEMENT(uint32_t, count, queryCount); + Serialise_DebugMessages(localSerialiser, false); + if(m_State < WRITING) m_LastCmdBufferID = cmdid; @@ -2074,6 +2140,8 @@ void WrappedVulkan::vkCmdResetQueryPool( uint32_t firstQuery, uint32_t queryCount) { + SCOPED_DBG_SINK(); + ObjDisp(commandBuffer)->CmdResetQueryPool(Unwrap(commandBuffer), Unwrap(queryPool), firstQuery, queryCount); if(m_State >= WRITING) diff --git a/renderdoc/driver/vulkan/wrappers/vk_descriptor_funcs.cpp b/renderdoc/driver/vulkan/wrappers/vk_descriptor_funcs.cpp index 74b65806c..b3530e469 100644 --- a/renderdoc/driver/vulkan/wrappers/vk_descriptor_funcs.cpp +++ b/renderdoc/driver/vulkan/wrappers/vk_descriptor_funcs.cpp @@ -402,6 +402,8 @@ bool WrappedVulkan::Serialise_vkUpdateDescriptorSets( SERIALISE_ELEMENT(VkCopyDescriptorSet, c, *pDescriptorCopies); copyDesc = c; } + + Serialise_DebugMessages(localSerialiser, false); if(m_State < WRITING) { @@ -541,6 +543,8 @@ void WrappedVulkan::vkUpdateDescriptorSets( uint32_t copyCount, const VkCopyDescriptorSet* pDescriptorCopies) { + SCOPED_DBG_SINK(); + { // need to count up number of descriptor infos, to be able to alloc enough space uint32_t numInfos = 0; diff --git a/renderdoc/driver/vulkan/wrappers/vk_draw_funcs.cpp b/renderdoc/driver/vulkan/wrappers/vk_draw_funcs.cpp index c1729ec62..f0f8cc361 100644 --- a/renderdoc/driver/vulkan/wrappers/vk_draw_funcs.cpp +++ b/renderdoc/driver/vulkan/wrappers/vk_draw_funcs.cpp @@ -38,6 +38,8 @@ bool WrappedVulkan::Serialise_vkCmdDraw( SERIALISE_ELEMENT(uint32_t, instCount, instanceCount); SERIALISE_ELEMENT(uint32_t, firstVtx, firstVertex); SERIALISE_ELEMENT(uint32_t, firstInst, firstInstance); + + Serialise_DebugMessages(localSerialiser, true); if(m_State < WRITING) m_LastCmdBufferID = cmdid; @@ -97,6 +99,8 @@ void WrappedVulkan::vkCmdDraw( uint32_t firstVertex, uint32_t firstInstance) { + SCOPED_DBG_SINK(); + ObjDisp(commandBuffer)->CmdDraw(Unwrap(commandBuffer), vertexCount, instanceCount, firstVertex, firstInstance); if(m_State >= WRITING) @@ -127,6 +131,8 @@ bool WrappedVulkan::Serialise_vkCmdDrawIndexed( SERIALISE_ELEMENT(uint32_t, firstIdx, firstIndex); SERIALISE_ELEMENT(int32_t, vtxOffs, vertexOffset); SERIALISE_ELEMENT(uint32_t, firstInst, firstInstance); + + Serialise_DebugMessages(localSerialiser, true); if(m_State < WRITING) m_LastCmdBufferID = cmdid; @@ -187,6 +193,8 @@ void WrappedVulkan::vkCmdDrawIndexed( int32_t vertexOffset, uint32_t firstInstance) { + SCOPED_DBG_SINK(); + ObjDisp(commandBuffer)->CmdDrawIndexed(Unwrap(commandBuffer), indexCount, instanceCount, firstIndex, vertexOffset, firstInstance); if(m_State >= WRITING) @@ -216,6 +224,8 @@ bool WrappedVulkan::Serialise_vkCmdDrawIndirect( SERIALISE_ELEMENT(uint32_t, cnt, count); SERIALISE_ELEMENT(uint32_t, strd, stride); + + Serialise_DebugMessages(localSerialiser, true); if(m_State < WRITING) m_LastCmdBufferID = cmdid; @@ -294,6 +304,8 @@ void WrappedVulkan::vkCmdDrawIndirect( uint32_t count, uint32_t stride) { + SCOPED_DBG_SINK(); + ObjDisp(commandBuffer)->CmdDrawIndirect(Unwrap(commandBuffer), Unwrap(buffer), offset, count, stride); if(m_State >= WRITING) @@ -328,6 +340,8 @@ bool WrappedVulkan::Serialise_vkCmdDrawIndexedIndirect( SERIALISE_ELEMENT(uint32_t, cnt, count); SERIALISE_ELEMENT(uint32_t, strd, stride); + + Serialise_DebugMessages(localSerialiser, true); if(m_State < WRITING) m_LastCmdBufferID = cmdid; @@ -406,6 +420,8 @@ void WrappedVulkan::vkCmdDrawIndexedIndirect( uint32_t count, uint32_t stride) { + SCOPED_DBG_SINK(); + ObjDisp(commandBuffer)->CmdDrawIndexedIndirect(Unwrap(commandBuffer), Unwrap(buffer), offset, count, stride); if(m_State >= WRITING) @@ -437,6 +453,8 @@ bool WrappedVulkan::Serialise_vkCmdDispatch( SERIALISE_ELEMENT(uint32_t, X, x); SERIALISE_ELEMENT(uint32_t, Y, y); SERIALISE_ELEMENT(uint32_t, Z, z); + + Serialise_DebugMessages(localSerialiser, true); if(m_State < WRITING) m_LastCmdBufferID = cmdid; @@ -494,6 +512,8 @@ void WrappedVulkan::vkCmdDispatch( uint32_t y, uint32_t z) { + SCOPED_DBG_SINK(); + ObjDisp(commandBuffer)->CmdDispatch(Unwrap(commandBuffer), x, y, z); if(m_State >= WRITING) @@ -518,6 +538,8 @@ bool WrappedVulkan::Serialise_vkCmdDispatchIndirect( SERIALISE_ELEMENT(ResourceId, cmdid, GetResID(commandBuffer)); SERIALISE_ELEMENT(ResourceId, bufid, GetResID(buffer)); SERIALISE_ELEMENT(uint64_t, offs, offset); + + Serialise_DebugMessages(localSerialiser, true); if(m_State < WRITING) m_LastCmdBufferID = cmdid; @@ -588,6 +610,8 @@ void WrappedVulkan::vkCmdDispatchIndirect( VkBuffer buffer, VkDeviceSize offset) { + SCOPED_DBG_SINK(); + ObjDisp(commandBuffer)->CmdDispatchIndirect(Unwrap(commandBuffer), Unwrap(buffer), offset); if(m_State >= WRITING) @@ -629,6 +653,8 @@ bool WrappedVulkan::Serialise_vkCmdBlitImage( SERIALISE_ELEMENT(uint32_t, count, regionCount); SERIALISE_ELEMENT_ARR(VkImageBlit, regions, pRegions, count); + + Serialise_DebugMessages(localSerialiser, true); if(m_State < WRITING) m_LastCmdBufferID = cmdid; @@ -698,6 +724,8 @@ void WrappedVulkan::vkCmdBlitImage( const VkImageBlit* pRegions, VkFilter filter) { + SCOPED_DBG_SINK(); + ObjDisp(commandBuffer)->CmdBlitImage(Unwrap(commandBuffer), Unwrap(srcImage), srcImageLayout, Unwrap(destImage), destImageLayout, regionCount, pRegions, filter); if(m_State >= WRITING) @@ -741,6 +769,8 @@ bool WrappedVulkan::Serialise_vkCmdResolveImage( SERIALISE_ELEMENT(uint32_t, count, regionCount); SERIALISE_ELEMENT_ARR(VkImageResolve, regions, pRegions, count); + + Serialise_DebugMessages(localSerialiser, true); if(m_State < WRITING) m_LastCmdBufferID = cmdid; @@ -809,6 +839,8 @@ void WrappedVulkan::vkCmdResolveImage( uint32_t regionCount, const VkImageResolve* pRegions) { + SCOPED_DBG_SINK(); + ObjDisp(commandBuffer)->CmdResolveImage(Unwrap(commandBuffer), Unwrap(srcImage), srcImageLayout, Unwrap(destImage), destImageLayout, regionCount, pRegions); if(m_State >= WRITING) @@ -852,6 +884,8 @@ bool WrappedVulkan::Serialise_vkCmdCopyImage( SERIALISE_ELEMENT(uint32_t, count, regionCount); SERIALISE_ELEMENT_ARR(VkImageCopy, regions, pRegions, count); + + Serialise_DebugMessages(localSerialiser, true); if(m_State < WRITING) m_LastCmdBufferID = cmdid; @@ -920,6 +954,8 @@ void WrappedVulkan::vkCmdCopyImage( uint32_t regionCount, const VkImageCopy* pRegions) { + SCOPED_DBG_SINK(); + ObjDisp(commandBuffer)->CmdCopyImage(Unwrap(commandBuffer), Unwrap(srcImage), srcImageLayout, Unwrap(destImage), destImageLayout, regionCount, pRegions); if(m_State >= WRITING) @@ -961,6 +997,8 @@ bool WrappedVulkan::Serialise_vkCmdCopyBufferToImage( SERIALISE_ELEMENT(uint32_t, count, regionCount); SERIALISE_ELEMENT_ARR(VkBufferImageCopy, regions, pRegions, count); + + Serialise_DebugMessages(localSerialiser, true); if(m_State < WRITING) m_LastCmdBufferID = cmdid; @@ -1021,6 +1059,8 @@ void WrappedVulkan::vkCmdCopyBufferToImage( uint32_t regionCount, const VkBufferImageCopy* pRegions) { + SCOPED_DBG_SINK(); + ObjDisp(commandBuffer)->CmdCopyBufferToImage(Unwrap(commandBuffer), Unwrap(srcBuffer), Unwrap(destImage), destImageLayout, regionCount, pRegions); if(m_State >= WRITING) @@ -1063,6 +1103,8 @@ bool WrappedVulkan::Serialise_vkCmdCopyImageToBuffer( SERIALISE_ELEMENT(uint32_t, count, regionCount); SERIALISE_ELEMENT_ARR(VkBufferImageCopy, regions, pRegions, count); + + Serialise_DebugMessages(localSerialiser, true); if(m_State < WRITING) m_LastCmdBufferID = cmdid; @@ -1123,6 +1165,8 @@ void WrappedVulkan::vkCmdCopyImageToBuffer( uint32_t regionCount, const VkBufferImageCopy* pRegions) { + SCOPED_DBG_SINK(); + ObjDisp(commandBuffer)->CmdCopyImageToBuffer(Unwrap(commandBuffer), Unwrap(srcImage), srcImageLayout, Unwrap(destBuffer), regionCount, pRegions); if(m_State >= WRITING) @@ -1166,6 +1210,8 @@ bool WrappedVulkan::Serialise_vkCmdCopyBuffer( SERIALISE_ELEMENT(uint32_t, count, regionCount); SERIALISE_ELEMENT_ARR(VkBufferCopy, regions, pRegions, count); + + Serialise_DebugMessages(localSerialiser, true); if(m_State < WRITING) m_LastCmdBufferID = cmdid; @@ -1232,6 +1278,8 @@ void WrappedVulkan::vkCmdCopyBuffer( uint32_t regionCount, const VkBufferCopy* pRegions) { + SCOPED_DBG_SINK(); + ObjDisp(commandBuffer)->CmdCopyBuffer(Unwrap(commandBuffer), Unwrap(srcBuffer), Unwrap(destBuffer), regionCount, pRegions); if(m_State >= WRITING) @@ -1277,6 +1325,8 @@ bool WrappedVulkan::Serialise_vkCmdClearColorImage( SERIALISE_ELEMENT(uint32_t, count, rangeCount); SERIALISE_ELEMENT_ARR(VkImageSubresourceRange, ranges, pRanges, count); + + Serialise_DebugMessages(localSerialiser, true); if(m_State < WRITING) m_LastCmdBufferID = cmdid; @@ -1330,6 +1380,8 @@ void WrappedVulkan::vkCmdClearColorImage( uint32_t rangeCount, const VkImageSubresourceRange* pRanges) { + SCOPED_DBG_SINK(); + ObjDisp(commandBuffer)->CmdClearColorImage(Unwrap(commandBuffer), Unwrap(image), imageLayout, pColor, rangeCount, pRanges); if(m_State >= WRITING) @@ -1364,6 +1416,8 @@ bool WrappedVulkan::Serialise_vkCmdClearDepthStencilImage( SERIALISE_ELEMENT(VkClearDepthStencilValue, ds, *pDepthStencil); SERIALISE_ELEMENT(uint32_t, count, rangeCount); SERIALISE_ELEMENT_ARR(VkImageSubresourceRange, ranges, pRanges, count); + + Serialise_DebugMessages(localSerialiser, true); if(m_State < WRITING) m_LastCmdBufferID = cmdid; @@ -1418,6 +1472,8 @@ void WrappedVulkan::vkCmdClearDepthStencilImage( uint32_t rangeCount, const VkImageSubresourceRange* pRanges) { + SCOPED_DBG_SINK(); + ObjDisp(commandBuffer)->CmdClearDepthStencilImage(Unwrap(commandBuffer), Unwrap(image), imageLayout, pDepthStencil, rangeCount, pRanges); if(m_State >= WRITING) @@ -1452,6 +1508,8 @@ bool WrappedVulkan::Serialise_vkCmdClearAttachments( SERIALISE_ELEMENT(uint32_t, rcount, rectCount); SERIALISE_ELEMENT_ARR(VkClearRect, rects, pRects, rcount); + + Serialise_DebugMessages(localSerialiser, true); if(m_State < WRITING) m_LastCmdBufferID = cmdid; @@ -1532,6 +1590,8 @@ void WrappedVulkan::vkCmdClearAttachments( uint32_t rectCount, const VkClearRect* pRects) { + SCOPED_DBG_SINK(); + ObjDisp(commandBuffer)->CmdClearAttachments(Unwrap(commandBuffer), attachmentCount, pAttachments, rectCount, pRects); if(m_State >= WRITING) diff --git a/renderdoc/driver/vulkan/wrappers/vk_dynamic_funcs.cpp b/renderdoc/driver/vulkan/wrappers/vk_dynamic_funcs.cpp index 2cb40e486..a46632e6a 100644 --- a/renderdoc/driver/vulkan/wrappers/vk_dynamic_funcs.cpp +++ b/renderdoc/driver/vulkan/wrappers/vk_dynamic_funcs.cpp @@ -35,6 +35,8 @@ bool WrappedVulkan::Serialise_vkCmdSetViewport( SERIALISE_ELEMENT(uint32_t, first, firstViewport); SERIALISE_ELEMENT(uint32_t, count, viewportCount); SERIALISE_ELEMENT_ARR(VkViewport, views, pViewports, count); + + Serialise_DebugMessages(localSerialiser, false); if(m_State < WRITING) m_LastCmdBufferID = cmdid; @@ -71,6 +73,8 @@ void WrappedVulkan::vkCmdSetViewport( uint32_t viewportCount, const VkViewport* pViewports) { + SCOPED_DBG_SINK(); + ObjDisp(cmdBuffer)->CmdSetViewport(Unwrap(cmdBuffer), firstViewport, viewportCount, pViewports); if(m_State >= WRITING) @@ -97,6 +101,8 @@ bool WrappedVulkan::Serialise_vkCmdSetScissor( SERIALISE_ELEMENT(uint32_t, first, firstScissor); SERIALISE_ELEMENT(uint32_t, count, scissorCount); SERIALISE_ELEMENT_ARR(VkRect2D, scissors, pScissors, count); + + Serialise_DebugMessages(localSerialiser, false); if(m_State < WRITING) m_LastCmdBufferID = cmdid; @@ -133,6 +139,8 @@ void WrappedVulkan::vkCmdSetScissor( uint32_t scissorCount, const VkRect2D* pScissors) { + SCOPED_DBG_SINK(); + ObjDisp(cmdBuffer)->CmdSetScissor(Unwrap(cmdBuffer), firstScissor, scissorCount, pScissors); if(m_State >= WRITING) @@ -156,6 +164,8 @@ bool WrappedVulkan::Serialise_vkCmdSetLineWidth( SERIALISE_ELEMENT(ResourceId, cmdid, GetResID(cmdBuffer)); SERIALISE_ELEMENT(float, width, lineWidth); + Serialise_DebugMessages(localSerialiser, false); + if(m_State < WRITING) m_LastCmdBufferID = cmdid; @@ -182,6 +192,8 @@ void WrappedVulkan::vkCmdSetLineWidth( VkCommandBuffer cmdBuffer, float lineWidth) { + SCOPED_DBG_SINK(); + ObjDisp(cmdBuffer)->CmdSetLineWidth(Unwrap(cmdBuffer), lineWidth); if(m_State >= WRITING) @@ -208,6 +220,8 @@ bool WrappedVulkan::Serialise_vkCmdSetDepthBias( SERIALISE_ELEMENT(float, bias, depthBias); SERIALISE_ELEMENT(float, biasclamp, depthBiasClamp); SERIALISE_ELEMENT(float, slope, slopeScaledDepthBias); + + Serialise_DebugMessages(localSerialiser, false); if(m_State < WRITING) m_LastCmdBufferID = cmdid; @@ -239,6 +253,8 @@ void WrappedVulkan::vkCmdSetDepthBias( float depthBiasClamp, float slopeScaledDepthBias) { + SCOPED_DBG_SINK(); + ObjDisp(cmdBuffer)->CmdSetDepthBias(Unwrap(cmdBuffer), depthBias, depthBiasClamp, slopeScaledDepthBias); if(m_State >= WRITING) @@ -260,6 +276,7 @@ bool WrappedVulkan::Serialise_vkCmdSetBlendConstants( const float* blendConst) { SERIALISE_ELEMENT(ResourceId, cmdid, GetResID(cmdBuffer)); + float blendFactor[4]; if(m_State >= WRITING) { @@ -269,6 +286,8 @@ bool WrappedVulkan::Serialise_vkCmdSetBlendConstants( blendFactor[3] = blendConst[3]; } localSerialiser->SerialisePODArray<4>("blendConst", blendFactor); + + Serialise_DebugMessages(localSerialiser, false); if(m_State < WRITING) m_LastCmdBufferID = cmdid; @@ -296,6 +315,8 @@ void WrappedVulkan::vkCmdSetBlendConstants( VkCommandBuffer cmdBuffer, const float* blendConst) { + SCOPED_DBG_SINK(); + ObjDisp(cmdBuffer)->CmdSetBlendConstants(Unwrap(cmdBuffer), blendConst); if(m_State >= WRITING) @@ -320,6 +341,8 @@ bool WrappedVulkan::Serialise_vkCmdSetDepthBounds( SERIALISE_ELEMENT(ResourceId, cmdid, GetResID(cmdBuffer)); SERIALISE_ELEMENT(float, mind, minDepthBounds); SERIALISE_ELEMENT(float, maxd, maxDepthBounds); + + Serialise_DebugMessages(localSerialiser, false); if(m_State < WRITING) m_LastCmdBufferID = cmdid; @@ -349,6 +372,8 @@ void WrappedVulkan::vkCmdSetDepthBounds( float minDepthBounds, float maxDepthBounds) { + SCOPED_DBG_SINK(); + ObjDisp(cmdBuffer)->CmdSetDepthBounds(Unwrap(cmdBuffer), minDepthBounds, maxDepthBounds); if(m_State >= WRITING) @@ -373,6 +398,8 @@ bool WrappedVulkan::Serialise_vkCmdSetStencilCompareMask( SERIALISE_ELEMENT(ResourceId, cmdid, GetResID(cmdBuffer)); SERIALISE_ELEMENT(VkStencilFaceFlagBits, face, (VkStencilFaceFlagBits)faceMask); SERIALISE_ELEMENT(uint32_t, mask, compareMask); + + Serialise_DebugMessages(localSerialiser, false); if(m_State < WRITING) m_LastCmdBufferID = cmdid; @@ -405,6 +432,8 @@ void WrappedVulkan::vkCmdSetStencilCompareMask( VkStencilFaceFlags faceMask, uint32_t compareMask) { + SCOPED_DBG_SINK(); + ObjDisp(cmdBuffer)->CmdSetStencilCompareMask(Unwrap(cmdBuffer), faceMask, compareMask); if(m_State >= WRITING) @@ -429,6 +458,8 @@ bool WrappedVulkan::Serialise_vkCmdSetStencilWriteMask( SERIALISE_ELEMENT(ResourceId, cmdid, GetResID(cmdBuffer)); SERIALISE_ELEMENT(VkStencilFaceFlagBits, face, (VkStencilFaceFlagBits)faceMask); SERIALISE_ELEMENT(uint32_t, mask, writeMask); + + Serialise_DebugMessages(localSerialiser, false); if(m_State < WRITING) m_LastCmdBufferID = cmdid; @@ -461,6 +492,8 @@ void WrappedVulkan::vkCmdSetStencilWriteMask( VkStencilFaceFlags faceMask, uint32_t writeMask) { + SCOPED_DBG_SINK(); + ObjDisp(cmdBuffer)->CmdSetStencilWriteMask(Unwrap(cmdBuffer), faceMask, writeMask); if(m_State >= WRITING) @@ -485,6 +518,8 @@ bool WrappedVulkan::Serialise_vkCmdSetStencilReference( SERIALISE_ELEMENT(ResourceId, cmdid, GetResID(cmdBuffer)); SERIALISE_ELEMENT(VkStencilFaceFlagBits, face, (VkStencilFaceFlagBits)faceMask); SERIALISE_ELEMENT(uint32_t, mask, reference); + + Serialise_DebugMessages(localSerialiser, false); if(m_State < WRITING) m_LastCmdBufferID = cmdid; @@ -517,6 +552,8 @@ void WrappedVulkan::vkCmdSetStencilReference( VkStencilFaceFlags faceMask, uint32_t reference) { + SCOPED_DBG_SINK(); + ObjDisp(cmdBuffer)->CmdSetStencilReference(Unwrap(cmdBuffer), faceMask, reference); if(m_State >= WRITING) diff --git a/renderdoc/driver/vulkan/wrappers/vk_queue_funcs.cpp b/renderdoc/driver/vulkan/wrappers/vk_queue_funcs.cpp index 1b28a43e5..e8bca4cfe 100644 --- a/renderdoc/driver/vulkan/wrappers/vk_queue_funcs.cpp +++ b/renderdoc/driver/vulkan/wrappers/vk_queue_funcs.cpp @@ -187,6 +187,8 @@ bool WrappedVulkan::Serialise_vkQueueSubmit( }; const string desc = localSerialiser->GetDebugStr(); + + Serialise_DebugMessages(localSerialiser, true); if(m_State == READING) { @@ -422,6 +424,8 @@ VkResult WrappedVulkan::vkQueueSubmit( const VkSubmitInfo* pSubmits, VkFence fence) { + SCOPED_DBG_SINK(); + size_t tempmemSize = sizeof(VkSubmitInfo)*submitCount; // need to count how many semaphore and command buffer arrays to allocate for diff --git a/renderdoc/driver/vulkan/wrappers/vk_sync_funcs.cpp b/renderdoc/driver/vulkan/wrappers/vk_sync_funcs.cpp index d1396ebf7..a06e40ee8 100644 --- a/renderdoc/driver/vulkan/wrappers/vk_sync_funcs.cpp +++ b/renderdoc/driver/vulkan/wrappers/vk_sync_funcs.cpp @@ -148,6 +148,8 @@ bool WrappedVulkan::Serialise_vkGetFenceStatus( SERIALISE_ELEMENT(ResourceId, id, GetResID(device)); SERIALISE_ELEMENT(ResourceId, fid, GetResID(fence)); + Serialise_DebugMessages(localSerialiser, false); + if(m_State < WRITING) { device = GetResourceManager()->GetLiveHandle(id); @@ -162,6 +164,8 @@ VkResult WrappedVulkan::vkGetFenceStatus( VkDevice device, VkFence fence) { + SCOPED_DBG_SINK(); + VkResult ret = ObjDisp(device)->GetFenceStatus(Unwrap(device), Unwrap(fence)); if(m_State >= WRITING_CAPFRAME) @@ -186,6 +190,8 @@ bool WrappedVulkan::Serialise_vkResetFences( SERIALISE_ELEMENT(ResourceId, id, GetResID(device)); SERIALISE_ELEMENT(uint32_t, count, fenceCount); + Serialise_DebugMessages(localSerialiser, false); + vector fences; for(uint32_t i=0; i < count; i++) @@ -219,6 +225,8 @@ VkResult WrappedVulkan::vkResetFences( uint32_t fenceCount, const VkFence* pFences) { + SCOPED_DBG_SINK(); + VkFence *unwrapped = GetTempArray(fenceCount); for(uint32_t i=0; i < fenceCount; i++) unwrapped[i] = Unwrap(pFences[i]); VkResult ret = ObjDisp(device)->ResetFences(Unwrap(device), fenceCount, unwrapped); @@ -248,6 +256,8 @@ bool WrappedVulkan::Serialise_vkWaitForFences( SERIALISE_ELEMENT(VkBool32, wait, waitAll); SERIALISE_ELEMENT(uint64_t, tmout, timeout); SERIALISE_ELEMENT(uint32_t, count, fenceCount); + + Serialise_DebugMessages(localSerialiser, false); vector fences; @@ -280,6 +290,8 @@ VkResult WrappedVulkan::vkWaitForFences( VkBool32 waitAll, uint64_t timeout) { + SCOPED_DBG_SINK(); + VkFence *unwrapped = GetTempArray(fenceCount); for (uint32_t i = 0; i < fenceCount; i++) unwrapped[i] = Unwrap(pFences[i]); VkResult ret = ObjDisp(device)->WaitForFences(Unwrap(device), fenceCount, unwrapped, waitAll, timeout); @@ -376,6 +388,8 @@ bool WrappedVulkan::Serialise_vkSetEvent( { SERIALISE_ELEMENT(ResourceId, id, GetResID(device)); SERIALISE_ELEMENT(ResourceId, eid, GetResID(event)); + + Serialise_DebugMessages(localSerialiser, false); if(m_State < WRITING) { @@ -389,6 +403,8 @@ VkResult WrappedVulkan::vkSetEvent( VkDevice device, VkEvent event) { + SCOPED_DBG_SINK(); + VkResult ret = ObjDisp(device)->SetEvent(Unwrap(device), Unwrap(event)); if(m_State >= WRITING_CAPFRAME) @@ -411,6 +427,8 @@ bool WrappedVulkan::Serialise_vkResetEvent( { SERIALISE_ELEMENT(ResourceId, id, GetResID(device)); SERIALISE_ELEMENT(ResourceId, eid, GetResID(event)); + + Serialise_DebugMessages(localSerialiser, false); if(m_State < WRITING) { @@ -424,6 +442,8 @@ VkResult WrappedVulkan::vkResetEvent( VkDevice device, VkEvent event) { + SCOPED_DBG_SINK(); + VkResult ret = ObjDisp(device)->ResetEvent(Unwrap(device), Unwrap(event)); if(m_State >= WRITING_CAPFRAME) @@ -446,6 +466,8 @@ bool WrappedVulkan::Serialise_vkGetEventStatus( { SERIALISE_ELEMENT(ResourceId, id, GetResID(device)); SERIALISE_ELEMENT(ResourceId, eid, GetResID(event)); + + Serialise_DebugMessages(localSerialiser, false); if(m_State < WRITING) { @@ -461,6 +483,8 @@ VkResult WrappedVulkan::vkGetEventStatus( VkDevice device, VkEvent event) { + SCOPED_DBG_SINK(); + VkResult ret = ObjDisp(device)->GetEventStatus(Unwrap(device), Unwrap(event)); if(m_State >= WRITING_CAPFRAME) @@ -555,6 +579,8 @@ bool WrappedVulkan::Serialise_vkCmdSetEvent( SERIALISE_ELEMENT(ResourceId, cmdid, GetResID(cmdBuffer)); SERIALISE_ELEMENT(ResourceId, eid, GetResID(event)); SERIALISE_ELEMENT(VkPipelineStageFlagBits, mask, (VkPipelineStageFlagBits)stageMask); + + Serialise_DebugMessages(localSerialiser, false); if(m_State < WRITING) m_LastCmdBufferID = cmdid; @@ -587,6 +613,8 @@ void WrappedVulkan::vkCmdSetEvent( VkEvent event, VkPipelineStageFlags stageMask) { + SCOPED_DBG_SINK(); + ObjDisp(cmdBuffer)->CmdSetEvent(Unwrap(cmdBuffer), Unwrap(event), stageMask); if(m_State >= WRITING) @@ -612,6 +640,8 @@ bool WrappedVulkan::Serialise_vkCmdResetEvent( SERIALISE_ELEMENT(ResourceId, cmdid, GetResID(cmdBuffer)); SERIALISE_ELEMENT(ResourceId, eid, GetResID(event)); SERIALISE_ELEMENT(VkPipelineStageFlagBits, mask, (VkPipelineStageFlagBits)stageMask); + + Serialise_DebugMessages(localSerialiser, false); if(m_State < WRITING) m_LastCmdBufferID = cmdid; @@ -644,6 +674,8 @@ void WrappedVulkan::vkCmdResetEvent( VkEvent event, VkPipelineStageFlags stageMask) { + SCOPED_DBG_SINK(); + ObjDisp(cmdBuffer)->CmdResetEvent(Unwrap(cmdBuffer), Unwrap(event), stageMask); if(m_State >= WRITING)