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)

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<VkCommandBuffer>(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<VkDescriptorSet>(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<VkBuffer>(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<VkImageMemoryBarrier> imgBarriers;
 	vector<VkBufferMemoryBarrier> 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)

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;

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)

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)

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

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<VkDevice>(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<VkFence> 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<VkFence>(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<VkFence> fences;
 
@@ -280,6 +290,8 @@ VkResult WrappedVulkan::vkWaitForFences(
 			VkBool32                                waitAll,
 			uint64_t                                timeout)
 {
+	SCOPED_DBG_SINK();
+
 	VkFence *unwrapped = GetTempArray<VkFence>(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)