Tidy up FetchTexture data for vulkan, fill out all fields properly

renderdoc/driver/gl/gl_driver.cpp

@@ -3869,6 +3869,8 @@ void WrappedOpenGL::ProcessChunk(uint64_t offset, GLChunkType context)
 				draw.name = "SwapBuffers()";
 				draw.flags |= eDraw_Present;
 
+				draw.copyDestination = GetResourceManager()->GetOriginalID(GetResourceManager()->GetID(TextureRes(GetCtx(), m_FakeBB_Color)));
+
 				AddDrawcall(draw, true);
 			}
 		}

renderdoc/driver/vulkan/vk_common.cpp

@@ -828,7 +828,7 @@ string ToStrHelper<false, VkPipelineStageFlagBits>::Get(const VkPipelineStageFla
 template<>
 string ToStrHelper<false, VkBufferUsageFlagBits>::Get(const VkBufferUsageFlagBits &el)
 {
-	string ret = "VK_BUFFER_USAGE_GENERAL";
+	string ret = "";
 
 	if(el & VK_BUFFER_USAGE_TRANSFER_SOURCE_BIT)       ret += " | VK_BUFFER_USAGE_TRANSFER_SOURCE_BIT";
 	if(el & VK_BUFFER_USAGE_TRANSFER_DESTINATION_BIT)  ret += " | VK_BUFFER_USAGE_TRANSFER_DESTINATION_BIT";
@@ -839,6 +839,9 @@ string ToStrHelper<false, VkBufferUsageFlagBits>::Get(const VkBufferUsageFlagBit
 	if(el & VK_BUFFER_USAGE_INDEX_BUFFER_BIT)          ret += " | VK_BUFFER_USAGE_INDEX_BUFFER_BIT";
 	if(el & VK_BUFFER_USAGE_VERTEX_BUFFER_BIT)         ret += " | VK_BUFFER_USAGE_VERTEX_BUFFER_BIT";
 	if(el & VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT)       ret += " | VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT";
+	
+	if(!ret.empty())
+		ret = ret.substr(3);
 
 	return ret;
 }
@@ -846,7 +849,7 @@ string ToStrHelper<false, VkBufferUsageFlagBits>::Get(const VkBufferUsageFlagBit
 template<>
 string ToStrHelper<false, VkImageUsageFlagBits>::Get(const VkImageUsageFlagBits &el)
 {
-	string ret = "VK_IMAGE_USAGE_GENERAL";
+	string ret = "";
 
 	if(el & VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT)          ret += " | VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT";
 	if(el & VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT)     ret += " | VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT";
@@ -856,6 +859,9 @@ string ToStrHelper<false, VkImageUsageFlagBits>::Get(const VkImageUsageFlagBits
 	if(el & VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) ret += " | VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT";
 	if(el & VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT)     ret += " | VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT";
 	if(el & VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT)         ret += " | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT";
+	
+	if(!ret.empty())
+		ret = ret.substr(3);
 
 	return ret;
 }

renderdoc/driver/vulkan/vk_core.cpp

@@ -1268,6 +1268,8 @@ void WrappedVulkan::ProcessChunk(uint64_t offset, VulkanChunkType context)
 				draw.name = "vkQueuePresentKHR()";
 				draw.flags |= eDraw_Present;
 
+				draw.copyDestination = bbid;
+
 				AddDrawcall(draw, true);
 			}
 		}

renderdoc/driver/vulkan/vk_core.h

@@ -210,6 +210,7 @@ private:
 	map<ResourceId, MemState> m_MemoryInfo;
 	map<ResourceId, ImgState> m_ImageInfo;
 	map<ResourceId, ResourceId> m_BufferMemBinds;
+	map<ResourceId, string> m_ObjectNames;
 
 	struct CmdBufferInfo
 	{

renderdoc/driver/vulkan/vk_replay.cpp

@@ -1341,39 +1341,81 @@ FetchTexture VulkanReplay::GetTexture(ResourceId id)
 	
 	const ImgState &iminfo = m_pDriver->m_ImageInfo[id];
 
-	// VKTODOMED this should be fleshed out
 	FetchTexture ret;
 	ret.ID = m_pDriver->GetResourceManager()->GetOriginalID(id);
 	ret.arraysize = iminfo.arraySize;
-	ret.byteSize = iminfo.extent.width*iminfo.extent.height*4; // VKTODOMED calculate proper byte size
-	ret.creationFlags = (ret.ID == m_pDriver->m_FakeBBImgId ? eTextureCreate_SwapBuffer : 0)|eTextureCreate_SRV|eTextureCreate_RTV;
-	ret.cubemap = false;
-	ret.customName = false;
+	ret.creationFlags = iminfo.creationFlags;
+	ret.cubemap = iminfo.cube;
 	ret.width = iminfo.extent.width;
 	ret.height = iminfo.extent.height;
 	ret.depth = iminfo.extent.depth;
-	ret.dimension = 2;
 	ret.mips = iminfo.mipLevels;
-	ret.msQual = 0;
-	ret.msSamp = 1;
-	ret.name = (ret.ID == m_pDriver->m_FakeBBImgId ? "WSI Presentable Image" : StringFormat::Fmt("Image %llu", ret.ID));
 	ret.numSubresources = ret.mips*ret.arraysize;
+	
+	ret.byteSize = 0;
+	for(uint32_t s=0; s < ret.mips; s++)
+		ret.byteSize += GetByteSize(ret.width, ret.height, ret.depth, iminfo.format, s);
+	ret.byteSize *= ret.arraysize;
+
+	ret.msQual = 0;
+	ret.msSamp = iminfo.samples;
+
 	ret.format = MakeResourceFormat(iminfo.format);
+
 	switch(iminfo.type)
 	{
 		case VK_IMAGE_TYPE_1D:
 			ret.resType = iminfo.arraySize > 1 ? eResType_Texture1DArray : eResType_Texture1D;
+			ret.dimension = 1;
 			break;
-		default:
-			RDCWARN("Unexpected image type");
 		case VK_IMAGE_TYPE_2D:
-			// VKTODOLOW multisampled images
-			ret.resType = iminfo.arraySize > 1 ? eResType_Texture2DArray : eResType_Texture2D;
+			     if(ret.msSamp > 1) ret.resType = iminfo.arraySize > 1 ? eResType_Texture2DMSArray : eResType_Texture2DMS;
+			else if(ret.cubemap)    ret.resType = iminfo.arraySize > 6 ? eResType_TextureCubeArray : eResType_TextureCube;
+			else                    ret.resType = iminfo.arraySize > 1 ? eResType_Texture2DArray : eResType_Texture2D;
+			ret.dimension = 2;
 			break;
 		case VK_IMAGE_TYPE_3D:
 			ret.resType = eResType_Texture3D;
+			ret.dimension = 3;
+			break;
+		default:
+			RDCERR("Unexpected image type");
 			break;
 	}
+
+	ret.customName = true;
+	ret.name = m_pDriver->m_ObjectNames[id];
+	if(ret.name.count == 0)
+	{
+		ret.customName = false;
+		
+		const char *suffix = "";
+		const char *ms = "";
+
+		if(ret.msSamp > 1)
+			ms = "MS";
+
+		if(ret.creationFlags & eTextureCreate_RTV)
+			suffix = " RTV";
+		if(ret.creationFlags & eTextureCreate_DSV)
+			suffix = " DSV";
+
+		if(ret.cubemap)
+		{
+			if(ret.arraysize > 6)
+				ret.name = StringFormat::Fmt("TextureCube%sArray%s %llu", ms, suffix, ret.ID);
+			else
+				ret.name = StringFormat::Fmt("TextureCube%s%s %llu", ms, suffix, ret.ID);
+		}
+		else
+		{
+			if(ret.arraysize > 1)
+				ret.name = StringFormat::Fmt("Texture%dD%sArray%s %llu", ret.dimension, ms, suffix, ret.ID);
+			else
+				ret.name = StringFormat::Fmt("Texture%dD%s%s %llu", ret.dimension, ms, suffix, ret.ID);
+		}
+	}
+
 	return ret;
 }
 

renderdoc/driver/vulkan/vk_resources.cpp

@@ -217,4 +217,263 @@ bool IsSRGBFormat(VkFormat f)
 	}
 
 	return false;
-}
+}
+
+uint32_t GetByteSize(uint32_t Width, uint32_t Height, uint32_t Depth, VkFormat Format, uint32_t mip)
+{
+	uint32_t w = RDCMAX(Width>>mip, 1U);
+	uint32_t d = RDCMAX(Height>>mip, 1U);
+	uint32_t h = RDCMAX(Depth>>mip, 1U);
+
+	uint32_t ret = w*h*d;
+	
+	uint32_t astc[2] = { 0, 0 };
+
+	switch(Format)
+	{
+		case VK_FORMAT_R64G64B64A64_SFLOAT:
+			ret *= 32;
+			break;
+		case VK_FORMAT_R64G64B64_SFLOAT:
+			ret *= 24;
+			break;
+		case VK_FORMAT_R32G32B32A32_UINT:
+		case VK_FORMAT_R32G32B32A32_SINT:
+		case VK_FORMAT_R32G32B32A32_SFLOAT:
+		case VK_FORMAT_R64G64_SFLOAT:
+			ret *= 16;
+			break;
+		case VK_FORMAT_R32G32B32_UINT:
+		case VK_FORMAT_R32G32B32_SINT:
+		case VK_FORMAT_R32G32B32_SFLOAT:
+			ret *= 12;
+			break;
+		case VK_FORMAT_R16G16B16A16_UNORM:
+		case VK_FORMAT_R16G16B16A16_SNORM:
+		case VK_FORMAT_R16G16B16A16_USCALED:
+		case VK_FORMAT_R16G16B16A16_SSCALED:
+		case VK_FORMAT_R16G16B16A16_UINT:
+		case VK_FORMAT_R16G16B16A16_SINT:
+		case VK_FORMAT_R16G16B16A16_SFLOAT:
+		case VK_FORMAT_R32G32_UINT:
+		case VK_FORMAT_R32G32_SINT:
+		case VK_FORMAT_R32G32_SFLOAT:
+		case VK_FORMAT_R64_SFLOAT:
+		case VK_FORMAT_D32_SFLOAT_S8_UINT:
+			ret *= 8;
+			break;
+		case VK_FORMAT_R16G16B16_UNORM:
+		case VK_FORMAT_R16G16B16_SNORM:
+		case VK_FORMAT_R16G16B16_USCALED:
+		case VK_FORMAT_R16G16B16_SSCALED:
+		case VK_FORMAT_R16G16B16_UINT:
+		case VK_FORMAT_R16G16B16_SINT:
+		case VK_FORMAT_R16G16B16_SFLOAT:
+			ret *= 6;
+			break;
+		case VK_FORMAT_R8G8B8_UNORM:
+		case VK_FORMAT_R8G8B8_SNORM:
+		case VK_FORMAT_R8G8B8_USCALED:
+		case VK_FORMAT_R8G8B8_SSCALED:
+		case VK_FORMAT_R8G8B8_UINT:
+		case VK_FORMAT_R8G8B8_SINT:
+		case VK_FORMAT_R8G8B8_SRGB:
+		case VK_FORMAT_B8G8R8_UNORM:
+		case VK_FORMAT_B8G8R8_SNORM:
+		case VK_FORMAT_B8G8R8_USCALED:
+		case VK_FORMAT_B8G8R8_SSCALED:
+		case VK_FORMAT_B8G8R8_UINT:
+		case VK_FORMAT_B8G8R8_SINT:
+		case VK_FORMAT_B8G8R8_SRGB:
+			ret *= 3;
+			break;
+		case VK_FORMAT_B10G10R10A2_UNORM:
+		case VK_FORMAT_B10G10R10A2_SNORM:
+		case VK_FORMAT_B10G10R10A2_USCALED:
+		case VK_FORMAT_B10G10R10A2_SSCALED:
+		case VK_FORMAT_B10G10R10A2_UINT:
+		case VK_FORMAT_B10G10R10A2_SINT:
+		case VK_FORMAT_R10G10B10A2_UNORM:
+		case VK_FORMAT_R10G10B10A2_SNORM:
+		case VK_FORMAT_R10G10B10A2_USCALED:
+		case VK_FORMAT_R10G10B10A2_SSCALED:
+		case VK_FORMAT_R10G10B10A2_UINT:
+		case VK_FORMAT_R10G10B10A2_SINT:
+		case VK_FORMAT_R11G11B10_UFLOAT:
+		case VK_FORMAT_R8G8B8A8_UNORM:
+		case VK_FORMAT_R8G8B8A8_SNORM:
+		case VK_FORMAT_R8G8B8A8_USCALED:
+		case VK_FORMAT_R8G8B8A8_SSCALED:
+		case VK_FORMAT_R8G8B8A8_UINT:
+		case VK_FORMAT_R8G8B8A8_SINT:
+		case VK_FORMAT_R8G8B8A8_SRGB:
+		case VK_FORMAT_B8G8R8A8_UNORM:
+		case VK_FORMAT_B8G8R8A8_SNORM:
+		case VK_FORMAT_B8G8R8A8_USCALED:
+		case VK_FORMAT_B8G8R8A8_SSCALED:
+		case VK_FORMAT_B8G8R8A8_UINT:
+		case VK_FORMAT_B8G8R8A8_SINT:
+		case VK_FORMAT_B8G8R8A8_SRGB:
+		case VK_FORMAT_R16G16_UNORM:
+		case VK_FORMAT_R16G16_SNORM:
+		case VK_FORMAT_R16G16_USCALED:
+		case VK_FORMAT_R16G16_SSCALED:
+		case VK_FORMAT_R16G16_UINT:
+		case VK_FORMAT_R16G16_SINT:
+		case VK_FORMAT_R16G16_SFLOAT:
+		case VK_FORMAT_R32_UINT:
+		case VK_FORMAT_R32_SINT:
+		case VK_FORMAT_R32_SFLOAT:
+		case VK_FORMAT_D24_UNORM_X8:
+		case VK_FORMAT_D24_UNORM_S8_UINT:
+		case VK_FORMAT_D32_SFLOAT:
+		case VK_FORMAT_R9G9B9E5_UFLOAT:
+		case VK_FORMAT_D16_UNORM_S8_UINT:
+			ret *= 4;
+			break;
+		case VK_FORMAT_R8G8_UNORM:
+		case VK_FORMAT_R8G8_SNORM:
+		case VK_FORMAT_R8G8_USCALED:
+		case VK_FORMAT_R8G8_SSCALED:
+		case VK_FORMAT_R8G8_UINT:
+		case VK_FORMAT_R8G8_SINT:
+		case VK_FORMAT_R8G8_SRGB:
+		case VK_FORMAT_R16_UNORM:
+		case VK_FORMAT_R16_SNORM:
+		case VK_FORMAT_R16_USCALED:
+		case VK_FORMAT_R16_SSCALED:
+		case VK_FORMAT_R16_UINT:
+		case VK_FORMAT_R16_SINT:
+		case VK_FORMAT_R16_SFLOAT:
+		case VK_FORMAT_D16_UNORM:
+		case VK_FORMAT_R5G6B5_UNORM:
+		case VK_FORMAT_R5G6B5_USCALED:
+		case VK_FORMAT_R5G5B5A1_UNORM:
+		case VK_FORMAT_R5G5B5A1_USCALED:
+		case VK_FORMAT_B5G5R5A1_UNORM:
+		case VK_FORMAT_B5G6R5_UNORM:
+		case VK_FORMAT_B5G6R5_USCALED:
+		case VK_FORMAT_R4G4B4A4_UNORM:
+		case VK_FORMAT_R4G4B4A4_USCALED:
+		case VK_FORMAT_B4G4R4A4_UNORM:
+			ret *= 2;
+			break;
+		case VK_FORMAT_R4G4_UNORM:
+		case VK_FORMAT_R4G4_USCALED:
+		case VK_FORMAT_R8_UNORM:
+		case VK_FORMAT_R8_SNORM:
+		case VK_FORMAT_R8_USCALED:
+		case VK_FORMAT_R8_SSCALED:
+		case VK_FORMAT_R8_UINT:
+		case VK_FORMAT_R8_SINT:
+		case VK_FORMAT_R8_SRGB:
+		case VK_FORMAT_S8_UINT:
+			ret *= 1;
+			break;
+		case VK_FORMAT_BC1_RGB_UNORM:
+		case VK_FORMAT_BC1_RGB_SRGB:
+		case VK_FORMAT_BC1_RGBA_UNORM:
+		case VK_FORMAT_BC1_RGBA_SRGB:
+		case VK_FORMAT_BC4_UNORM:
+		case VK_FORMAT_BC4_SNORM:
+		case VK_FORMAT_ETC2_R8G8B8_UNORM:
+		case VK_FORMAT_ETC2_R8G8B8_SRGB:
+		case VK_FORMAT_ETC2_R8G8B8A1_UNORM:
+		case VK_FORMAT_ETC2_R8G8B8A1_SRGB:
+		case VK_FORMAT_ETC2_R8G8B8A8_UNORM:
+		case VK_FORMAT_ETC2_R8G8B8A8_SRGB:
+		case VK_FORMAT_EAC_R11_UNORM:
+		case VK_FORMAT_EAC_R11_SNORM:
+			ret = AlignUp4(w)*AlignUp4(h)*d;
+			ret /= 2;
+			break;
+		case VK_FORMAT_BC2_UNORM:
+		case VK_FORMAT_BC2_SRGB:
+		case VK_FORMAT_BC3_UNORM:
+		case VK_FORMAT_BC3_SRGB:
+		case VK_FORMAT_BC5_UNORM:
+		case VK_FORMAT_BC5_SNORM:
+		case VK_FORMAT_BC6H_UFLOAT:
+		case VK_FORMAT_BC6H_SFLOAT:
+		case VK_FORMAT_BC7_UNORM:
+		case VK_FORMAT_BC7_SRGB:
+		case VK_FORMAT_EAC_R11G11_UNORM:
+		case VK_FORMAT_EAC_R11G11_SNORM:
+			ret = AlignUp4(w)*AlignUp4(h)*d;
+			ret *= 1;
+			break;
+		case VK_FORMAT_ASTC_4x4_UNORM:
+		case VK_FORMAT_ASTC_4x4_SRGB:
+			astc[0] = 4; astc[1] = 4;
+			break;
+		case VK_FORMAT_ASTC_5x4_UNORM:
+		case VK_FORMAT_ASTC_5x4_SRGB:
+			astc[0] = 5; astc[1] = 4;
+			break;
+		case VK_FORMAT_ASTC_5x5_UNORM:
+		case VK_FORMAT_ASTC_5x5_SRGB:
+			astc[0] = 5; astc[1] = 5;
+			break;
+		case VK_FORMAT_ASTC_6x5_UNORM:
+		case VK_FORMAT_ASTC_6x5_SRGB:
+			astc[0] = 6; astc[1] = 5;
+			break;
+		case VK_FORMAT_ASTC_6x6_UNORM:
+		case VK_FORMAT_ASTC_6x6_SRGB:
+			astc[0] = 6; astc[1] = 6;
+			break;
+		case VK_FORMAT_ASTC_8x5_UNORM:
+		case VK_FORMAT_ASTC_8x5_SRGB:
+			astc[0] = 8; astc[1] = 5;
+			break;
+		case VK_FORMAT_ASTC_8x6_UNORM:
+		case VK_FORMAT_ASTC_8x6_SRGB:
+			astc[0] = 8; astc[1] = 6;
+			break;
+		case VK_FORMAT_ASTC_8x8_UNORM:
+		case VK_FORMAT_ASTC_8x8_SRGB:
+			astc[0] = 8; astc[1] = 8;
+			break;
+		case VK_FORMAT_ASTC_10x5_UNORM:
+		case VK_FORMAT_ASTC_10x5_SRGB:
+			astc[0] = 10; astc[1] = 5;
+			break;
+		case VK_FORMAT_ASTC_10x6_UNORM:
+		case VK_FORMAT_ASTC_10x6_SRGB:
+			astc[0] = 10; astc[1] = 6;
+			break;
+		case VK_FORMAT_ASTC_10x8_UNORM:
+		case VK_FORMAT_ASTC_10x8_SRGB:
+			astc[0] = 10; astc[1] = 8;
+			break;
+		case VK_FORMAT_ASTC_10x10_UNORM:
+		case VK_FORMAT_ASTC_10x10_SRGB:
+			astc[0] = 10; astc[1] = 10;
+			break;
+		case VK_FORMAT_ASTC_12x10_UNORM:
+		case VK_FORMAT_ASTC_12x10_SRGB:
+			astc[0] = 12; astc[1] = 10;
+			break;
+		case VK_FORMAT_ASTC_12x12_UNORM:
+		case VK_FORMAT_ASTC_12x12_SRGB:
+			astc[0] = 12; astc[1] = 12;
+			break;
+		default:
+			RDCFATAL("Unrecognised Vulkan Format: %d", Format);
+			break;
+	}
+	
+	if(astc[0] > 0 && astc[1] > 0)
+	{
+		uint32_t blocks[2] = { (w / astc[0]), (h / astc[1]) };
+
+		// how many blocks are needed - including any extra partial blocks
+		blocks[0] += (w % astc[0]) ? 1 : 0;
+		blocks[1] += (h % astc[1]) ? 1 : 0;
+
+		// ASTC blocks are all 128 bits each
+		return blocks[0]*blocks[1]*16*d;
+	}
+
+	return ret;
+}

renderdoc/driver/vulkan/vk_resources.h

@@ -680,7 +680,7 @@ struct MemState
 struct ImgState
 {
 	ImgState()
-		: mem(VK_NULL_HANDLE), arraySize(0), mipLevels(0)
+		: mem(VK_NULL_HANDLE), arraySize(0), mipLevels(0), samples(0), cube(false), creationFlags(0)
 	{
 		type = VK_IMAGE_TYPE_MAX_ENUM;
 		format = VK_FORMAT_UNDEFINED;
@@ -693,9 +693,14 @@ struct ImgState
 	VkImageType type;
 	VkFormat format;
 	VkExtent3D extent;
-	int arraySize, mipLevels;
+	int arraySize, mipLevels, samples;
+
+	bool cube;
+	uint32_t creationFlags;
 };
 
 bool IsBlockFormat(VkFormat f);
 bool IsDepthStencilFormat(VkFormat f);
 bool IsSRGBFormat(VkFormat f);
+
+uint32_t GetByteSize(uint32_t Width, uint32_t Height, uint32_t Depth, VkFormat Format, uint32_t mip);

renderdoc/driver/vulkan/wrappers/vk_resource_funcs.cpp

@@ -761,6 +761,19 @@ bool WrappedVulkan::Serialise_vkCreateImage(
 			m_ImageInfo[live].extent = info.extent;
 			m_ImageInfo[live].mipLevels = info.mipLevels;
 			m_ImageInfo[live].arraySize = info.arraySize;
+			m_ImageInfo[live].samples = info.samples;
+
+			if(info.usage & VK_IMAGE_USAGE_SAMPLED_BIT)
+				m_ImageInfo[live].creationFlags |= eTextureCreate_SRV;
+			if(info.usage & (VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT|VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT))
+				m_ImageInfo[live].creationFlags |= eTextureCreate_RTV;
+			if(info.usage & VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT)
+				m_ImageInfo[live].creationFlags |= eTextureCreate_DSV;
+			if(info.usage & VK_IMAGE_USAGE_STORAGE_BIT)
+				m_ImageInfo[live].creationFlags |= eTextureCreate_UAV;
+
+			if(info.flags & VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT)
+				m_ImageInfo[live].cube = true;
 			
 			VkImageSubresourceRange range;
 			range.baseMipLevel = range.baseArrayLayer = 0;

renderdoc/driver/vulkan/wrappers/vk_wsi_funcs.cpp

@@ -284,6 +284,9 @@ bool WrappedVulkan::Serialise_vkCreateSwapchainKHR(
 			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;
+
+			m_ObjectNames[liveId] = StringFormat::Fmt("Presentable Image %u", i);
 
 			VkImageSubresourceRange range;
 			range.baseMipLevel = range.baseArrayLayer = 0;

renderdocui/Windows/TextureViewer.cs

@@ -279,6 +279,9 @@ namespace renderdocui.Windows
 
                     if (ret.Length == 0 && curDraw != null && (curDraw.flags & DrawcallFlags.Present) != 0)
                     {
+                        if (curDraw.copyDestination != ResourceId.Null)
+                            return new ResourceId[] { curDraw.copyDestination };
+
                         foreach (var t in core.CurTextures)
                             if ((t.creationFlags & TextureCreationFlags.SwapBuffer) != 0)
                                 return new ResourceId[] { t.ID };