Split m_ImageInfo into creationinfo and just imagelayouts

* In future perhaps the imagelayouts could be stored under the record in
  capture, but need to handle that somehow in the resource manager
  functions that manipulate the states based on accumulated transitions.

renderdoc/driver/vulkan/vk_core.cpp

@@ -628,7 +628,10 @@ bool WrappedVulkan::Serialise_BeginCaptureFrame(bool applyInitialState)
 
 	vector<VkImageMemoryBarrier> imgTransitions;
 	
-	GetResourceManager()->SerialiseImageStates(m_ImageInfo, imgTransitions);
+	{
+		SCOPED_LOCK(m_ImageLayoutsLock); // not needed on replay, but harmless also
+		GetResourceManager()->SerialiseImageStates(m_ImageLayouts, imgTransitions);
+	}
 
 	if(applyInitialState && !imgTransitions.empty())
 	{
@@ -1369,7 +1372,7 @@ void WrappedVulkan::ReplayLog(uint32_t frameID, uint32_t startEventID, uint32_t
 			vkr = ObjDisp(cmd)->BeginCommandBuffer(Unwrap(cmd), &beginInfo);
 			RDCASSERT(vkr == VK_SUCCESS);
 
-			ImgState &st = m_ImageInfo[GetResourceManager()->GetLiveID(m_FakeBBImgId)];
+			ImageLayouts &st = m_ImageLayouts[GetResourceManager()->GetLiveID(m_FakeBBImgId)];
 			RDCASSERT(st.subresourceStates.size() == 1);
 
 			VkImageMemoryBarrier t;

renderdoc/driver/vulkan/vk_core.h

@@ -373,7 +373,10 @@ private:
 	map<ResourceId, MapState> m_CurrentMaps;
 	Threading::CriticalSection m_CurrentMapsLock;
 
-	map<ResourceId, ImgState> m_ImageInfo;
+	// used both on capture and replay side to track image layouts. Only locked
+	// in capture
+	map<ResourceId, ImageLayouts> m_ImageLayouts;
+	Threading::CriticalSection m_ImageLayoutsLock;
 
 	// below are replay-side data only, doesn't have to be thread protected
 

renderdoc/driver/vulkan/vk_info.cpp

@@ -253,6 +253,32 @@ void VulkanCreationInfo::BufferView::Init(const VkBufferViewCreateInfo* pCreateI
 	size = pCreateInfo->range;
 }
 
+void VulkanCreationInfo::Image::Init(const VkImageCreateInfo* pCreateInfo)
+{
+	view = VK_NULL_HANDLE;
+
+	type = pCreateInfo->imageType;
+	format = pCreateInfo->format;
+	extent = pCreateInfo->extent;
+	arraySize = pCreateInfo->arraySize;
+	mipLevels = pCreateInfo->mipLevels;
+	samples = pCreateInfo->samples;
+
+	creationFlags = 0;
+
+	if(pCreateInfo->usage & VK_IMAGE_USAGE_SAMPLED_BIT)
+		creationFlags |= eTextureCreate_SRV;
+	if(pCreateInfo->usage & (VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT|VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT))
+		creationFlags |= eTextureCreate_RTV;
+	if(pCreateInfo->usage & VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT)
+		creationFlags |= eTextureCreate_DSV;
+	if(pCreateInfo->usage & VK_IMAGE_USAGE_STORAGE_BIT)
+		creationFlags |= eTextureCreate_UAV;
+
+	if(pCreateInfo->flags & VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT)
+		cube = true;
+}
+
 void VulkanCreationInfo::ImageView::Init(const VkImageViewCreateInfo* pCreateInfo)
 {
 	image = VKMGR()->GetNonDispWrapper(pCreateInfo->image)->id;
@@ -274,4 +300,4 @@ void VulkanCreationInfo::Shader::Init(const VkShaderCreateInfo* pCreateInfo, Vul
 	refl.DebugInfo.entryFunc = pCreateInfo->pName;
 	// VKTODOLOW set this properly
 	refl.DebugInfo.entryFile = 0;
-}
+}

renderdoc/driver/vulkan/vk_info.h

@@ -187,6 +187,22 @@ struct VulkanCreationInfo
 		uint64_t size;
 	};
 	map<ResourceId, BufferView> m_BufferView;
+	
+	struct Image
+	{
+		void Init(const VkImageCreateInfo* pCreateInfo);
+	
+		VkImageView view;
+
+		VkImageType type;
+		VkFormat format;
+		VkExtent3D extent;
+		int arraySize, mipLevels, samples;
+
+		bool cube;
+		uint32_t creationFlags;
+	};
+	map<ResourceId, Image> m_Image;
 
 	struct ImageView
 	{

renderdoc/driver/vulkan/vk_initstate.cpp

@@ -134,12 +134,6 @@ bool WrappedVulkan::Prepare_InitialState(WrappedVkRes *res)
 	{
 		VULKANNOTIMP("image initial states not implemented");
 
-		if(m_ImageInfo.find(id) == m_ImageInfo.end())
-		{
-			RDCERR("Couldn't find image info");
-			return false;
-		}
-
 		// VKTODOHIGH: need to copy off contents to memory somewhere else
 
 		return true;
@@ -401,16 +395,16 @@ void WrappedVulkan::Create_InitialState(ResourceId id, WrappedVkRes *live, bool
 
 		ResourceId liveid = GetResourceManager()->GetLiveID(id);
 
-		if(m_ImageInfo.find(liveid) == m_ImageInfo.end())
+		if(m_ImageLayouts.find(liveid) == m_ImageLayouts.end())
 		{
 			RDCERR("Couldn't find image info for %llu", id);
 			GetResourceManager()->SetInitialContents(id, VulkanResourceManager::InitialContentData(NULL, eInitialContents_ClearColorImage, NULL));
 			return;
 		}
 
-		ImgState &img = m_ImageInfo[liveid];
+		ImageLayouts &layouts = m_ImageLayouts[liveid];
 
-		if(img.subresourceStates[0].range.aspectMask == VK_IMAGE_ASPECT_COLOR_BIT)
+		if(layouts.subresourceStates[0].range.aspectMask == VK_IMAGE_ASPECT_COLOR_BIT)
 			GetResourceManager()->SetInitialContents(id, VulkanResourceManager::InitialContentData(NULL, eInitialContents_ClearColorImage, NULL));
 		else
 			GetResourceManager()->SetInitialContents(id, VulkanResourceManager::InitialContentData(NULL, eInitialContents_ClearDepthStencilImage, NULL));

renderdoc/driver/vulkan/vk_manager.cpp

@@ -51,7 +51,7 @@ bool VulkanResourceManager::SerialisableResource(ResourceId id, VkResourceRecord
 #define TRDBG(...)
 #endif
 
-void VulkanResourceManager::RecordTransitions(vector< pair<ResourceId, ImageRegionState> > &trans, map<ResourceId, ImgState> &states,
+void VulkanResourceManager::RecordTransitions(vector< pair<ResourceId, ImageRegionState> > &trans, map<ResourceId, ImageLayouts> &states,
 											  uint32_t numTransitions, const VkImageMemoryBarrier *transitions)
 {
 	TRDBG("Recording %u transitions", numTransitions);
@@ -205,7 +205,7 @@ void VulkanResourceManager::RecordTransitions(vector< pair<ResourceId, ImageRegi
 	TRDBG("Post-record, there are %u transitions", (uint32_t)trans.size());
 }
 
-void VulkanResourceManager::SerialiseImageStates(map<ResourceId, ImgState> &states, vector<VkImageMemoryBarrier> &transitions)
+void VulkanResourceManager::SerialiseImageStates(map<ResourceId, ImageLayouts> &states, vector<VkImageMemoryBarrier> &transitions)
 {
 	Serialiser *localSerialiser = m_pSerialiser;
 
@@ -270,7 +270,7 @@ void VulkanResourceManager::SerialiseImageStates(map<ResourceId, ImgState> &stat
 	}
 }
 
-void VulkanResourceManager::ApplyTransitions(vector< pair<ResourceId, ImageRegionState> > &trans, map<ResourceId, ImgState> &states)
+void VulkanResourceManager::ApplyTransitions(vector< pair<ResourceId, ImageRegionState> > &trans, map<ResourceId, ImageLayouts> &states)
 {
 	TRDBG("Applying %u transitions", (uint32_t)trans.size());
 

renderdoc/driver/vulkan/vk_manager.h

@@ -89,12 +89,12 @@ class VulkanResourceManager : public ResourceManager<WrappedVkRes*, TypedRealHan
 		void Hack_PropagateReferencesToMemory();
 		
 		// handling memory & image transitions
-		void RecordTransitions(vector< pair<ResourceId, ImageRegionState> > &trans, map<ResourceId, ImgState> &states,
+		void RecordTransitions(vector< pair<ResourceId, ImageRegionState> > &trans, map<ResourceId, ImageLayouts> &states,
 			                   uint32_t numTransitions, const VkImageMemoryBarrier *transitions);
 
-		void ApplyTransitions(vector< pair<ResourceId, ImageRegionState> > &trans, map<ResourceId, ImgState> &states);
+		void ApplyTransitions(vector< pair<ResourceId, ImageRegionState> > &trans, map<ResourceId, ImageLayouts> &states);
 
-		void SerialiseImageStates(map<ResourceId, ImgState> &states, vector<VkImageMemoryBarrier> &transitions);
+		void SerialiseImageStates(map<ResourceId, ImageLayouts> &states, vector<VkImageMemoryBarrier> &transitions);
 
 		ResourceId GetID(WrappedVkRes *res)
 		{

renderdoc/driver/vulkan/vk_replay.cpp

@@ -510,7 +510,7 @@ vector<ResourceId> VulkanReplay::GetTextures()
 {
 	vector<ResourceId> texs;
 
-	for(auto it = m_pDriver->m_ImageInfo.begin(); it != m_pDriver->m_ImageInfo.end(); ++it)
+	for(auto it = m_pDriver->m_ImageLayouts.begin(); it != m_pDriver->m_ImageLayouts.end(); ++it)
 	{
 		// skip textures that aren't from the capture
 		if(m_pDriver->GetResourceManager()->GetOriginalID(it->first) == it->first)
@@ -671,11 +671,12 @@ bool VulkanReplay::RenderTextureInternal(TextureDisplay cfg, VkRenderPassBeginIn
 	VkCmdBuffer cmd = m_pDriver->GetNextCmd();
 	const VkLayerDispatchTable *vt = ObjDisp(dev);
 
-	ImgState &iminfo = m_pDriver->m_ImageInfo[cfg.texid];
+	ImageLayouts &layouts = m_pDriver->m_ImageLayouts[cfg.texid];
+	VulkanCreationInfo::Image &iminfo = m_pDriver->m_CreationInfo.m_Image[m_pDriver->GetResourceManager()->GetOriginalID(cfg.texid)];
 	VkImage liveIm = m_pDriver->GetResourceManager()->GetCurrentHandle<VkImage>(cfg.texid);
 
 	// VKTODOMED handle multiple subresources with different layouts etc
-	VkImageLayout origLayout = iminfo.subresourceStates[0].state;
+	VkImageLayout origLayout = layouts.subresourceStates[0].state;
 	VkImageView liveImView = iminfo.view;
 
 	if(liveImView == VK_NULL_HANDLE)
@@ -1293,10 +1294,11 @@ void VulkanReplay::FileChanged()
 
 FetchTexture VulkanReplay::GetTexture(ResourceId id)
 {
-	const ImgState &iminfo = m_pDriver->m_ImageInfo[id];
-
 	FetchTexture ret;
 	ret.ID = m_pDriver->GetResourceManager()->GetOriginalID(id);
+	
+	VulkanCreationInfo::Image &iminfo = m_pDriver->m_CreationInfo.m_Image[ret.ID];
+
 	ret.arraysize = iminfo.arraySize;
 	ret.creationFlags = iminfo.creationFlags;
 	ret.cubemap = iminfo.cube;

renderdoc/driver/vulkan/vk_resources.h

@@ -693,26 +693,12 @@ struct VkResourceRecord : public ResourceRecord
 		VkResourceRecord *memory;
 };
 
-struct ImgState
+struct ImageLayouts
 {
-	ImgState()
-		: view(VK_NULL_HANDLE), arraySize(0), mipLevels(0), samples(0), cube(false), creationFlags(0)
-	{
-		type = VK_IMAGE_TYPE_MAX_ENUM;
-		format = VK_FORMAT_UNDEFINED;
-		extent.width = extent.height = extent.depth = 0;
-	}
+	ImageLayouts() : arraySize(1), mipLevels(1) {}
 
-	VkImageView view;
 	vector<ImageRegionState> subresourceStates;
-
-	VkImageType type;
-	VkFormat format;
-	VkExtent3D extent;
-	int arraySize, mipLevels, samples;
-
-	bool cube;
-	uint32_t creationFlags;
+	int arraySize, mipLevels;
 };
 
 bool IsBlockFormat(VkFormat f);

renderdoc/driver/vulkan/wrappers/vk_cmd_funcs.cpp

@@ -1434,7 +1434,7 @@ bool WrappedVulkan::Serialise_vkCmdPipelineBarrier(
 			ObjDisp(cmdBuffer)->CmdPipelineBarrier(Unwrap(cmdBuffer), src, dest, region, (uint32_t)mems.size(), (const void **)&mems[0]);
 
 			ResourceId cmd = GetResID(PartialCmdBuf());
-			GetResourceManager()->RecordTransitions(m_BakedCmdBufferInfo[cmd].imgtransitions, m_ImageInfo, (uint32_t)imTrans.size(), &imTrans[0]);
+			GetResourceManager()->RecordTransitions(m_BakedCmdBufferInfo[cmd].imgtransitions, m_ImageLayouts, (uint32_t)imTrans.size(), &imTrans[0]);
 		}
 	}
 	else if(m_State == READING)
@@ -1444,7 +1444,7 @@ bool WrappedVulkan::Serialise_vkCmdPipelineBarrier(
 		ObjDisp(cmdBuffer)->CmdPipelineBarrier(Unwrap(cmdBuffer), src, dest, region, (uint32_t)mems.size(), (const void **)&mems[0]);
 		
 		ResourceId cmd = GetResID(cmdBuffer);
-		GetResourceManager()->RecordTransitions(m_BakedCmdBufferInfo[cmd].imgtransitions, m_ImageInfo, (uint32_t)imTrans.size(), &imTrans[0]);
+		GetResourceManager()->RecordTransitions(m_BakedCmdBufferInfo[cmd].imgtransitions, m_ImageLayouts, (uint32_t)imTrans.size(), &imTrans[0]);
 	}
 
 	for(size_t i=0; i < mems.size(); i++)
@@ -1527,7 +1527,10 @@ void WrappedVulkan::vkCmdPipelineBarrier(
 		}
 		
 		ResourceId cmd = GetResID(cmdBuffer);
-		GetResourceManager()->RecordTransitions(m_BakedCmdBufferInfo[cmd].imgtransitions, m_ImageInfo, (uint32_t)imTrans.size(), &imTrans[0]);
+		{
+			SCOPED_LOCK(m_ImageLayoutsLock);
+			GetResourceManager()->RecordTransitions(m_BakedCmdBufferInfo[cmd].imgtransitions, m_ImageLayouts, (uint32_t)imTrans.size(), &imTrans[0]);
+		}
 
 		// VKTODOMED do we need to mark frame referenced the resources in the barrier? if they're not referenced
 		// elsewhere, perhaps they can be dropped

renderdoc/driver/vulkan/wrappers/vk_misc_funcs.cpp

@@ -31,7 +31,6 @@
 #define DESTROY_IMPL(type, func) \
 	void WrappedVulkan::vk ## func(VkDevice device, type obj) \
 	{ \
-		if(m_ImageInfo.find(GetResID(obj)) != m_ImageInfo.end()) m_ImageInfo.erase(GetResID(obj)); \
 		type unwrappedObj = Unwrap(obj); \
 		if(GetResourceManager()->HasWrapper(ToTypedHandle(unwrappedObj))) GetResourceManager()->ReleaseWrappedResource(obj, true); \
 		ObjDisp(device)->func(Unwrap(device), unwrappedObj); \
@@ -39,7 +38,6 @@
 
 DESTROY_IMPL(VkBuffer, DestroyBuffer)
 DESTROY_IMPL(VkBufferView, DestroyBufferView)
-DESTROY_IMPL(VkImage, DestroyImage)
 DESTROY_IMPL(VkImageView, DestroyImageView)
 DESTROY_IMPL(VkShader, DestroyShader)
 DESTROY_IMPL(VkShaderModule, DestroyShaderModule)
@@ -62,12 +60,20 @@ DESTROY_IMPL(VkRenderPass, DestroyRenderPass)
 // needs to be separate because it returns VkResult still
 VkResult WrappedVulkan::vkDestroySwapchainKHR(VkDevice device, VkSwapchainKHR obj)
 {
-	if(m_ImageInfo.find(GetResID(obj)) != m_ImageInfo.end()) m_ImageInfo.erase(GetResID(obj));
 	VkSwapchainKHR unwrappedObj = Unwrap(obj);
 	if(GetResourceManager()->HasWrapper(ToTypedHandle(unwrappedObj))) GetResourceManager()->ReleaseWrappedResource(obj, true);
 	return ObjDisp(device)->DestroySwapchainKHR(Unwrap(device), unwrappedObj);
 }
 
+// needs to be separate so we don't erase from m_ImageLayouts in other destroy functions
+void WrappedVulkan::vkDestroyImage(VkDevice device, VkImage obj)
+{
+	m_ImageLayouts.erase(GetResID(obj));
+	VkImage unwrappedObj = Unwrap(obj);
+	if(GetResourceManager()->HasWrapper(ToTypedHandle(unwrappedObj))) GetResourceManager()->ReleaseWrappedResource(obj, true);
+	return ObjDisp(device)->DestroyImage(Unwrap(device), unwrappedObj);
+}
+
 // needs to be separate since it's dispatchable
 void WrappedVulkan::vkDestroyCommandBuffer(VkDevice device, VkCmdBuffer obj)
 {

renderdoc/driver/vulkan/wrappers/vk_queue_funcs.cpp

@@ -164,7 +164,7 @@ bool WrappedVulkan::Serialise_vkQueueSubmit(
 		for(uint32_t i=0; i < numCmds; i++)
 		{
 			ResourceId cmd = GetResourceManager()->GetLiveID(cmdIds[i]);
-			GetResourceManager()->ApplyTransitions(m_BakedCmdBufferInfo[cmd].imgtransitions, m_ImageInfo);
+			GetResourceManager()->ApplyTransitions(m_BakedCmdBufferInfo[cmd].imgtransitions, m_ImageLayouts);
 		}
 
 		AddEvent(QUEUE_SUBMIT, desc);
@@ -275,7 +275,7 @@ bool WrappedVulkan::Serialise_vkQueueSubmit(
 			for(uint32_t i=0; i < numCmds; i++)
 			{
 				ResourceId cmd = trimmedCmdIds[i];
-				GetResourceManager()->ApplyTransitions(m_BakedCmdBufferInfo[cmd].imgtransitions, m_ImageInfo);
+				GetResourceManager()->ApplyTransitions(m_BakedCmdBufferInfo[cmd].imgtransitions, m_ImageLayouts);
 			}
 		}
 		else
@@ -285,7 +285,7 @@ bool WrappedVulkan::Serialise_vkQueueSubmit(
 			for(uint32_t i=0; i < numCmds; i++)
 			{
 				ResourceId cmd = GetResourceManager()->GetLiveID(cmdIds[i]);
-				GetResourceManager()->ApplyTransitions(m_BakedCmdBufferInfo[cmd].imgtransitions, m_ImageInfo);
+				GetResourceManager()->ApplyTransitions(m_BakedCmdBufferInfo[cmd].imgtransitions, m_ImageLayouts);
 			}
 		}
 	}
@@ -329,7 +329,11 @@ VkResult WrappedVulkan::vkQueueSubmit(
 	for(uint32_t i=0; i < cmdBufferCount; i++)
 	{
 		ResourceId cmd = GetResID(pCmdBuffers[i]);
-		GetResourceManager()->ApplyTransitions(m_BakedCmdBufferInfo[cmd].imgtransitions, m_ImageInfo);
+
+		{
+			SCOPED_LOCK(m_ImageLayoutsLock);
+			GetResourceManager()->ApplyTransitions(m_BakedCmdBufferInfo[cmd].imgtransitions, m_ImageLayouts);
+		}
 
 		VkResourceRecord *record = GetRecord(pCmdBuffers[i]);
 

renderdoc/driver/vulkan/wrappers/vk_resource_funcs.cpp

@@ -769,7 +769,7 @@ bool WrappedVulkan::Serialise_vkCreateImage(
 		device = GetResourceManager()->GetLiveHandle<VkDevice>(devId);
 		VkImage img = VK_NULL_HANDLE;
 
-		VkImageUsageFlags origFlags = info.usage;
+		m_CreationInfo.m_Image[id].Init(&info);
 
 		// ensure we can always display and copy from textures
 		info.usage |= VK_IMAGE_USAGE_SAMPLED_BIT|VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT;
@@ -785,26 +785,6 @@ bool WrappedVulkan::Serialise_vkCreateImage(
 			ResourceId live = GetResourceManager()->WrapResource(Unwrap(device), img);
 			GetResourceManager()->AddLiveResource(id, img);
 
-			ImgState &iminfo = m_ImageInfo[live];
-			
-			iminfo.type = info.imageType;
-			iminfo.format = info.format;
-			iminfo.extent = info.extent;
-			iminfo.mipLevels = info.mipLevels;
-			iminfo.arraySize = info.arraySize;
-			iminfo.samples = info.samples;
-
-			if(origFlags & VK_IMAGE_USAGE_SAMPLED_BIT)
-				iminfo.creationFlags |= eTextureCreate_SRV;
-			if(origFlags & (VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT|VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT))
-				iminfo.creationFlags |= eTextureCreate_RTV;
-			if(origFlags & VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT)
-				iminfo.creationFlags |= eTextureCreate_DSV;
-			if(origFlags & VK_IMAGE_USAGE_STORAGE_BIT)
-				iminfo.creationFlags |= eTextureCreate_UAV;
-
-			if(info.flags & VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT)
-				iminfo.cube = true;
 			
 			VkImageSubresourceRange range;
 			range.baseMipLevel = range.baseArrayLayer = 0;
@@ -812,17 +792,18 @@ bool WrappedVulkan::Serialise_vkCreateImage(
 			range.arraySize = info.arraySize;
 			if(info.imageType == VK_IMAGE_TYPE_3D)
 				range.arraySize = info.extent.depth;
-
-			iminfo.subresourceStates.clear();
+			
+			ImageLayouts &layouts = m_ImageLayouts[live];
+			layouts.subresourceStates.clear();
 			
 			if(!IsDepthStencilFormat(info.format))
 			{
-				range.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;  iminfo.subresourceStates.push_back(ImageRegionState(range, UNTRANSITIONED_IMG_STATE, VK_IMAGE_LAYOUT_UNDEFINED));
+				range.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;  layouts.subresourceStates.push_back(ImageRegionState(range, UNTRANSITIONED_IMG_STATE, VK_IMAGE_LAYOUT_UNDEFINED));
 			}
 			else
 			{
-				range.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;  iminfo.subresourceStates.push_back(ImageRegionState(range, UNTRANSITIONED_IMG_STATE, VK_IMAGE_LAYOUT_UNDEFINED));
-				range.aspectMask = VK_IMAGE_ASPECT_STENCIL_BIT;iminfo.subresourceStates.push_back(ImageRegionState(range, UNTRANSITIONED_IMG_STATE, VK_IMAGE_LAYOUT_UNDEFINED));
+				range.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;  layouts.subresourceStates.push_back(ImageRegionState(range, UNTRANSITIONED_IMG_STATE, VK_IMAGE_LAYOUT_UNDEFINED));
+				range.aspectMask = VK_IMAGE_ASPECT_STENCIL_BIT;layouts.subresourceStates.push_back(ImageRegionState(range, UNTRANSITIONED_IMG_STATE, VK_IMAGE_LAYOUT_UNDEFINED));
 			}
 		}
 	}
@@ -861,12 +842,6 @@ VkResult WrappedVulkan::vkCreateImage(
 		{
 			GetResourceManager()->AddLiveResource(id, *pImage);
 		}
-		
-		m_ImageInfo[id].type = pCreateInfo->imageType;
-		m_ImageInfo[id].format = pCreateInfo->format;
-		m_ImageInfo[id].extent = pCreateInfo->extent;
-		m_ImageInfo[id].mipLevels = pCreateInfo->mipLevels;
-		m_ImageInfo[id].arraySize = pCreateInfo->arraySize;
 
 		VkImageSubresourceRange range;
 		range.baseMipLevel = range.baseArrayLayer = 0;
@@ -875,16 +850,18 @@ VkResult WrappedVulkan::vkCreateImage(
 		if(pCreateInfo->imageType == VK_IMAGE_TYPE_3D)
 			range.arraySize = pCreateInfo->extent.depth;
 
-		m_ImageInfo[id].subresourceStates.clear();
-
-		if(!IsDepthStencilFormat(pCreateInfo->format))
 		{
-			range.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;  m_ImageInfo[id].subresourceStates.push_back(ImageRegionState(range, UNTRANSITIONED_IMG_STATE, VK_IMAGE_LAYOUT_UNDEFINED));
-		}
-		else
-		{
-			range.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;  m_ImageInfo[id].subresourceStates.push_back(ImageRegionState(range, UNTRANSITIONED_IMG_STATE, VK_IMAGE_LAYOUT_UNDEFINED));
-			range.aspectMask = VK_IMAGE_ASPECT_STENCIL_BIT;m_ImageInfo[id].subresourceStates.push_back(ImageRegionState(range, UNTRANSITIONED_IMG_STATE, VK_IMAGE_LAYOUT_UNDEFINED));
+			SCOPED_LOCK(m_ImageLayoutsLock);
+			m_ImageLayouts[id].subresourceStates.clear();
+			if(!IsDepthStencilFormat(pCreateInfo->format))
+			{
+				range.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;  m_ImageLayouts[id].subresourceStates.push_back(ImageRegionState(range, UNTRANSITIONED_IMG_STATE, VK_IMAGE_LAYOUT_UNDEFINED));
+			}
+			else
+			{
+				range.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;  m_ImageLayouts[id].subresourceStates.push_back(ImageRegionState(range, UNTRANSITIONED_IMG_STATE, VK_IMAGE_LAYOUT_UNDEFINED));
+				range.aspectMask = VK_IMAGE_ASPECT_STENCIL_BIT;m_ImageLayouts[id].subresourceStates.push_back(ImageRegionState(range, UNTRANSITIONED_IMG_STATE, VK_IMAGE_LAYOUT_UNDEFINED));
+			}
 		}
 	}
 

renderdoc/driver/vulkan/wrappers/vk_sync_funcs.cpp

@@ -702,7 +702,7 @@ bool WrappedVulkan::Serialise_vkCmdWaitEvents(
 			ObjDisp(cmdBuffer)->CmdWaitEvents(Unwrap(cmdBuffer), evcount, &events[0], src, dest, (uint32_t)mems.size(), (const void **)&mems[0]);
 
 			ResourceId cmd = GetResID(PartialCmdBuf());
-			GetResourceManager()->RecordTransitions(m_BakedCmdBufferInfo[cmd].imgtransitions, m_ImageInfo, (uint32_t)imTrans.size(), &imTrans[0]);
+			GetResourceManager()->RecordTransitions(m_BakedCmdBufferInfo[cmd].imgtransitions, m_ImageLayouts, (uint32_t)imTrans.size(), &imTrans[0]);
 		}
 	}
 	else if(m_State == READING)
@@ -712,7 +712,7 @@ bool WrappedVulkan::Serialise_vkCmdWaitEvents(
 		ObjDisp(cmdBuffer)->CmdWaitEvents(Unwrap(cmdBuffer), evcount, &events[0], src, dest, (uint32_t)mems.size(), (const void **)&mems[0]);
 		
 		ResourceId cmd = GetResID(cmdBuffer);
-		GetResourceManager()->RecordTransitions(m_BakedCmdBufferInfo[cmd].imgtransitions, m_ImageInfo, (uint32_t)imTrans.size(), &imTrans[0]);
+		GetResourceManager()->RecordTransitions(m_BakedCmdBufferInfo[cmd].imgtransitions, m_ImageLayouts, (uint32_t)imTrans.size(), &imTrans[0]);
 	}
 
 	for(size_t i=0; i < mems.size(); i++)
@@ -797,7 +797,10 @@ void WrappedVulkan::vkCmdWaitEvents(
 		}
 		
 		ResourceId cmd = GetResID(cmdBuffer);
-		GetResourceManager()->RecordTransitions(m_BakedCmdBufferInfo[cmd].imgtransitions, m_ImageInfo, (uint32_t)imTrans.size(), &imTrans[0]);
+		{
+			SCOPED_LOCK(m_ImageLayoutsLock);
+			GetResourceManager()->RecordTransitions(m_BakedCmdBufferInfo[cmd].imgtransitions, m_ImageLayouts, (uint32_t)imTrans.size(), &imTrans[0]);
+		}
 
 		record->AddChunk(scope.Get());
 		for(uint32_t i=0; i < eventCount; i++)

renderdoc/driver/vulkan/wrappers/vk_wsi_funcs.cpp

@@ -92,6 +92,8 @@ bool WrappedVulkan::Serialise_vkGetSwapchainImagesKHR(
 		// VKTODOLOW what if num images is less than on capture?
 		RDCASSERT(idx < m_CreationInfo.m_SwapChain[swapId].images.size());
 		GetResourceManager()->AddLiveResource(id, m_CreationInfo.m_SwapChain[swapId].images[idx].im);
+
+		m_CreationInfo.m_Image[id] = m_CreationInfo.m_Image[swapId];
 	}
 
 	return true;
@@ -277,14 +279,17 @@ bool WrappedVulkan::Serialise_vkCreateSwapchainKHR(
 			swapinfo.images[i].im = im;
 
 			// fill out image info so we track resource state transitions
-			m_ImageInfo[liveId].type = VK_IMAGE_TYPE_2D;
-			m_ImageInfo[liveId].format = info.imageFormat;
-			m_ImageInfo[liveId].extent.width = info.imageExtent.width;
-			m_ImageInfo[liveId].extent.height = info.imageExtent.height;
-			m_ImageInfo[liveId].extent.depth = 1;
-			m_ImageInfo[liveId].mipLevels = 1;
-			m_ImageInfo[liveId].arraySize = info.imageArraySize;
-			m_ImageInfo[liveId].creationFlags = eTextureCreate_SRV|eTextureCreate_RTV|eTextureCreate_SwapBuffer;
+			VulkanCreationInfo::Image &iminfo = m_CreationInfo.m_Image[id];
+			iminfo.type = VK_IMAGE_TYPE_2D;
+			iminfo.format = info.imageFormat;
+			iminfo.extent.width = info.imageExtent.width;
+			iminfo.extent.height = info.imageExtent.height;
+			iminfo.extent.depth = 1;
+			iminfo.mipLevels = 1;
+			iminfo.arraySize = info.imageArraySize;
+			iminfo.creationFlags = eTextureCreate_SRV|eTextureCreate_RTV|eTextureCreate_SwapBuffer;
+			iminfo.cube = false;
+			iminfo.samples = 1;
 
 			m_CreationInfo.m_Names[liveId] = StringFormat::Fmt("Presentable Image %u", i);
 
@@ -294,8 +299,8 @@ bool WrappedVulkan::Serialise_vkCreateSwapchainKHR(
 			range.arraySize = info.imageArraySize;
 			range.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
 
-			m_ImageInfo[liveId].subresourceStates.clear();
-			m_ImageInfo[liveId].subresourceStates.push_back(ImageRegionState(range, UNTRANSITIONED_IMG_STATE, VK_IMAGE_LAYOUT_UNDEFINED));
+			m_ImageLayouts[liveId].subresourceStates.clear();
+			m_ImageLayouts[liveId].subresourceStates.push_back(ImageRegionState(range, UNTRANSITIONED_IMG_STATE, VK_IMAGE_LAYOUT_UNDEFINED));
 		}
 	}
 
@@ -409,23 +414,18 @@ VkResult WrappedVulkan::vkCreateSwapchainKHR(
 
 					ResourceId imid = GetResID(images[i]);
 
-					// fill out image info so we track resource state transitions
-					m_ImageInfo[imid].type = VK_IMAGE_TYPE_2D;
-					m_ImageInfo[imid].format = pCreateInfo->imageFormat;
-					m_ImageInfo[imid].extent.width = pCreateInfo->imageExtent.width;
-					m_ImageInfo[imid].extent.height = pCreateInfo->imageExtent.height;
-					m_ImageInfo[imid].extent.depth = 1;
-					m_ImageInfo[imid].mipLevels = 1;
-					m_ImageInfo[imid].arraySize = pCreateInfo->imageArraySize;
-
 					VkImageSubresourceRange range;
 					range.baseMipLevel = range.baseArrayLayer = 0;
 					range.mipLevels = 1;
 					range.arraySize = pCreateInfo->imageArraySize;
 					range.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
-
-					m_ImageInfo[imid].subresourceStates.clear();
-					m_ImageInfo[imid].subresourceStates.push_back(ImageRegionState(range, UNTRANSITIONED_IMG_STATE, VK_IMAGE_LAYOUT_UNDEFINED));
+					
+					// fill out image info so we track resource state transitions
+					{
+						SCOPED_LOCK(m_ImageLayoutsLock);
+						m_ImageLayouts[imid].subresourceStates.clear();
+						m_ImageLayouts[imid].subresourceStates.push_back(ImageRegionState(range, UNTRANSITIONED_IMG_STATE, VK_IMAGE_LAYOUT_UNDEFINED));
+					}
 
 					{
 						VkImageViewCreateInfo info = {