Vulkan: Fixing more bugs

src/anki/gr/vulkan/Common.cpp

@@ -46,207 +46,220 @@ VkCompareOp convertCompareOp(CompareOperation ak)
 }
 
 //==============================================================================
+enum class Aspect
+{
+	C = VK_IMAGE_ASPECT_COLOR_BIT,
+	D = VK_IMAGE_ASPECT_DEPTH_BIT,
+	S = VK_IMAGE_ASPECT_STENCIL_BIT,
+	DS = D | S,
+};
+ANKI_ENUM_ALLOW_NUMERIC_OPERATIONS(Aspect, inline)
+
 class ConvertFormat
 {
 public:
 	PixelFormat m_ak;
 	VkFormat m_vk;
+	Aspect m_aspect;
 
-	ConvertFormat(const PixelFormat& ak, VkFormat vk)
+	ConvertFormat(const PixelFormat& ak, VkFormat vk, Aspect aspect)
 		: m_ak(ak)
 		, m_vk(vk)
+		, m_aspect(aspect)
 	{
 	}
 };
 
-#define ANKI_FMT(fmt, trf, vk)                                                 \
-	ConvertFormat(PixelFormat(ComponentFormat::fmt, TransformFormat::trf), vk)
+#define ANKI_FMT(fmt, trf, vk, as)                                             \
+	ConvertFormat(PixelFormat(ComponentFormat::fmt, TransformFormat::trf),     \
+		vk,                                                                    \
+		Aspect::as)
 
 static const ConvertFormat CONVERT_FORMAT_TABLE[] = {
-	ANKI_FMT(NONE, NONE, VK_FORMAT_R4G4_UNORM_PACK8),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_R4G4B4A4_UNORM_PACK16),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_B4G4R4A4_UNORM_PACK16),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_R5G6B5_UNORM_PACK16),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_B5G6R5_UNORM_PACK16),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_R5G5B5A1_UNORM_PACK16),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_B5G5R5A1_UNORM_PACK16),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_A1R5G5B5_UNORM_PACK16),
-	ANKI_FMT(R8, UNORM, VK_FORMAT_R8_UNORM),
-	ANKI_FMT(R8, SNORM, VK_FORMAT_R8_SNORM),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_R8_USCALED),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_R8_SSCALED),
-	ANKI_FMT(R8, UINT, VK_FORMAT_R8_UINT),
-	ANKI_FMT(R8, SINT, VK_FORMAT_R8_SINT),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_R8_SRGB),
-	ANKI_FMT(R8G8, UNORM, VK_FORMAT_R8G8_UNORM),
-	ANKI_FMT(R8G8, SNORM, VK_FORMAT_R8G8_SNORM),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_R8G8_USCALED),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_R8G8_SSCALED),
-	ANKI_FMT(R8G8, UINT, VK_FORMAT_R8G8_UINT),
-	ANKI_FMT(R8G8, SINT, VK_FORMAT_R8G8_SINT),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_R8G8_SRGB),
-	ANKI_FMT(R8G8B8, UNORM, VK_FORMAT_R8G8B8_UNORM),
-	ANKI_FMT(R8G8B8, SNORM, VK_FORMAT_R8G8B8_SNORM),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_R8G8B8_USCALED),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_R8G8B8_SSCALED),
-	ANKI_FMT(R8G8B8, UINT, VK_FORMAT_R8G8B8_UINT),
-	ANKI_FMT(R8G8B8, SINT, VK_FORMAT_R8G8B8_SINT),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_R8G8B8_SRGB),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_B8G8R8_UNORM),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_B8G8R8_SNORM),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_B8G8R8_USCALED),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_B8G8R8_SSCALED),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_B8G8R8_UINT),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_B8G8R8_SINT),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_B8G8R8_SRGB),
-	ANKI_FMT(R8G8B8A8, UNORM, VK_FORMAT_R8G8B8A8_UNORM),
-	ANKI_FMT(R8G8B8A8, SNORM, VK_FORMAT_R8G8B8A8_SNORM),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_R8G8B8A8_USCALED),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_R8G8B8A8_SSCALED),
-	ANKI_FMT(R8G8B8A8, UINT, VK_FORMAT_R8G8B8A8_UINT),
-	ANKI_FMT(R8G8B8A8, SINT, VK_FORMAT_R8G8B8A8_SINT),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_R8G8B8A8_SRGB),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_B8G8R8A8_UNORM),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_B8G8R8A8_SNORM),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_B8G8R8A8_USCALED),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_B8G8R8A8_SSCALED),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_B8G8R8A8_UINT),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_B8G8R8A8_SINT),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_B8G8R8A8_SRGB),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_A8B8G8R8_UNORM_PACK32),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_A8B8G8R8_SNORM_PACK32),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_A8B8G8R8_USCALED_PACK32),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_A8B8G8R8_SSCALED_PACK32),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_A8B8G8R8_UINT_PACK32),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_A8B8G8R8_SINT_PACK32),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_A8B8G8R8_SRGB_PACK32),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_A2R10G10B10_UNORM_PACK32),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_A2R10G10B10_SNORM_PACK32),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_A2R10G10B10_USCALED_PACK32),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_A2R10G10B10_SSCALED_PACK32),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_A2R10G10B10_UINT_PACK32),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_A2R10G10B10_SINT_PACK32),
-	ANKI_FMT(R10G10B10A2, UNORM, VK_FORMAT_A2B10G10R10_UNORM_PACK32),
-	ANKI_FMT(R10G10B10A2, SNORM, VK_FORMAT_A2B10G10R10_SNORM_PACK32),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_A2B10G10R10_USCALED_PACK32),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_A2B10G10R10_SSCALED_PACK32),
-	ANKI_FMT(R10G10B10A2, UINT, VK_FORMAT_A2B10G10R10_UINT_PACK32),
-	ANKI_FMT(R10G10B10A2, SINT, VK_FORMAT_A2B10G10R10_SINT_PACK32),
-	ANKI_FMT(R16, UNORM, VK_FORMAT_R16_UNORM),
-	ANKI_FMT(R16, SNORM, VK_FORMAT_R16_SNORM),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_R16_USCALED),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_R16_SSCALED),
-	ANKI_FMT(R16, UINT, VK_FORMAT_R16_UINT),
-	ANKI_FMT(R16, SINT, VK_FORMAT_R16_SINT),
-	ANKI_FMT(R16, FLOAT, VK_FORMAT_R16_SFLOAT),
-	ANKI_FMT(R16G16, UNORM, VK_FORMAT_R16G16_UNORM),
-	ANKI_FMT(R16G16, SNORM, VK_FORMAT_R16G16_SNORM),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_R16G16_USCALED),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_R16G16_SSCALED),
-	ANKI_FMT(R16G16, UINT, VK_FORMAT_R16G16_UINT),
-	ANKI_FMT(R16G16, SINT, VK_FORMAT_R16G16_SINT),
-	ANKI_FMT(R16G16, FLOAT, VK_FORMAT_R16G16_SFLOAT),
-	ANKI_FMT(R16G16B16, UNORM, VK_FORMAT_R16G16B16_UNORM),
-	ANKI_FMT(R16G16B16, SNORM, VK_FORMAT_R16G16B16_SNORM),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_R16G16B16_USCALED),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_R16G16B16_SSCALED),
-	ANKI_FMT(R16G16B16, UINT, VK_FORMAT_R16G16B16_UINT),
-	ANKI_FMT(R16G16B16, SINT, VK_FORMAT_R16G16B16_SINT),
-	ANKI_FMT(R16G16B16, FLOAT, VK_FORMAT_R16G16B16_SFLOAT),
-	ANKI_FMT(R16G16B16A16, UNORM, VK_FORMAT_R16G16B16A16_UNORM),
-	ANKI_FMT(R16G16B16A16, SNORM, VK_FORMAT_R16G16B16A16_SNORM),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_R16G16B16A16_USCALED),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_R16G16B16A16_SSCALED),
-	ANKI_FMT(R16G16B16A16, UINT, VK_FORMAT_R16G16B16A16_UINT),
-	ANKI_FMT(R16G16B16A16, SINT, VK_FORMAT_R16G16B16A16_SINT),
-	ANKI_FMT(R16G16B16A16, FLOAT, VK_FORMAT_R16G16B16A16_SFLOAT),
-	ANKI_FMT(R32, UINT, VK_FORMAT_R32_UINT),
-	ANKI_FMT(R32, SINT, VK_FORMAT_R32_SINT),
-	ANKI_FMT(R32, FLOAT, VK_FORMAT_R32_SFLOAT),
-	ANKI_FMT(R32G32, UINT, VK_FORMAT_R32G32_UINT),
-	ANKI_FMT(R32G32, SINT, VK_FORMAT_R32G32_SINT),
-	ANKI_FMT(R32G32, FLOAT, VK_FORMAT_R32G32_SFLOAT),
-	ANKI_FMT(R32G32B32, UINT, VK_FORMAT_R32G32B32_UINT),
-	ANKI_FMT(R32G32B32, SINT, VK_FORMAT_R32G32B32_SINT),
-	ANKI_FMT(R32G32B32, FLOAT, VK_FORMAT_R32G32B32_SFLOAT),
-	ANKI_FMT(R32G32B32A32, UINT, VK_FORMAT_R32G32B32A32_UINT),
-	ANKI_FMT(R32G32B32A32, SINT, VK_FORMAT_R32G32B32A32_SINT),
-	ANKI_FMT(R32G32B32A32, FLOAT, VK_FORMAT_R32G32B32A32_SFLOAT),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_R64_UINT),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_R64_SINT),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_R64_SFLOAT),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_R64G64_UINT),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_R64G64_SINT),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_R64G64_SFLOAT),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_R64G64B64_UINT),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_R64G64B64_SINT),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_R64G64B64_SFLOAT),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_R64G64B64A64_UINT),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_R64G64B64A64_SINT),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_R64G64B64A64_SFLOAT),
-	ANKI_FMT(R11G11B10, FLOAT, VK_FORMAT_B10G11R11_UFLOAT_PACK32),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_E5B9G9R9_UFLOAT_PACK32),
-	ANKI_FMT(D16, UNORM, VK_FORMAT_D16_UNORM),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_X8_D24_UNORM_PACK32),
-	ANKI_FMT(D32, FLOAT, VK_FORMAT_D32_SFLOAT),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_S8_UINT),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_D16_UNORM_S8_UINT),
-	ANKI_FMT(D24, UNORM, VK_FORMAT_D24_UNORM_S8_UINT),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_D32_SFLOAT_S8_UINT),
-	ANKI_FMT(R8G8B8_S3TC, UNORM, VK_FORMAT_BC1_RGB_UNORM_BLOCK),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_BC1_RGB_SRGB_BLOCK),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_BC1_RGBA_UNORM_BLOCK),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_BC1_RGBA_SRGB_BLOCK),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_BC2_UNORM_BLOCK),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_BC2_SRGB_BLOCK),
-	ANKI_FMT(R8G8B8A8_S3TC, UNORM, VK_FORMAT_BC3_UNORM_BLOCK),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_BC3_SRGB_BLOCK),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_BC4_UNORM_BLOCK),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_BC4_SNORM_BLOCK),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_BC5_UNORM_BLOCK),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_BC5_SNORM_BLOCK),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_BC6H_UFLOAT_BLOCK),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_BC6H_SFLOAT_BLOCK),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_BC7_UNORM_BLOCK),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_BC7_SRGB_BLOCK),
-	ANKI_FMT(R8G8B8_ETC2, NONE, VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK),
-	ANKI_FMT(R8G8B8A8_ETC2, NONE, VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_EAC_R11_UNORM_BLOCK),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_EAC_R11_SNORM_BLOCK),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_EAC_R11G11_UNORM_BLOCK),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_EAC_R11G11_SNORM_BLOCK),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_ASTC_4x4_UNORM_BLOCK),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_ASTC_4x4_SRGB_BLOCK),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_ASTC_5x4_UNORM_BLOCK),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_ASTC_5x4_SRGB_BLOCK),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_ASTC_5x5_UNORM_BLOCK),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_ASTC_5x5_SRGB_BLOCK),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_ASTC_6x5_UNORM_BLOCK),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_ASTC_6x5_SRGB_BLOCK),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_ASTC_6x6_UNORM_BLOCK),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_ASTC_6x6_SRGB_BLOCK),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_ASTC_8x5_UNORM_BLOCK),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_ASTC_8x5_SRGB_BLOCK),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_ASTC_8x6_UNORM_BLOCK),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_ASTC_8x6_SRGB_BLOCK),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_ASTC_8x8_UNORM_BLOCK),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_ASTC_8x8_SRGB_BLOCK),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_ASTC_10x5_UNORM_BLOCK),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_ASTC_10x5_SRGB_BLOCK),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_ASTC_10x6_UNORM_BLOCK),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_ASTC_10x6_SRGB_BLOCK),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_ASTC_10x8_UNORM_BLOCK),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_ASTC_10x8_SRGB_BLOCK),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_ASTC_10x10_UNORM_BLOCK),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_ASTC_10x10_SRGB_BLOCK),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_ASTC_12x10_UNORM_BLOCK),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_ASTC_12x10_SRGB_BLOCK),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_ASTC_12x12_UNORM_BLOCK),
-	ANKI_FMT(NONE, NONE, VK_FORMAT_ASTC_12x12_SRGB_BLOCK)};
+	ANKI_FMT(NONE, NONE, VK_FORMAT_R4G4_UNORM_PACK8, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_R4G4B4A4_UNORM_PACK16, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_B4G4R4A4_UNORM_PACK16, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_R5G6B5_UNORM_PACK16, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_B5G6R5_UNORM_PACK16, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_R5G5B5A1_UNORM_PACK16, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_B5G5R5A1_UNORM_PACK16, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_A1R5G5B5_UNORM_PACK16, C),
+	ANKI_FMT(R8, UNORM, VK_FORMAT_R8_UNORM, C),
+	ANKI_FMT(R8, SNORM, VK_FORMAT_R8_SNORM, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_R8_USCALED, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_R8_SSCALED, C),
+	ANKI_FMT(R8, UINT, VK_FORMAT_R8_UINT, C),
+	ANKI_FMT(R8, SINT, VK_FORMAT_R8_SINT, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_R8_SRGB, C),
+	ANKI_FMT(R8G8, UNORM, VK_FORMAT_R8G8_UNORM, C),
+	ANKI_FMT(R8G8, SNORM, VK_FORMAT_R8G8_SNORM, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_R8G8_USCALED, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_R8G8_SSCALED, C),
+	ANKI_FMT(R8G8, UINT, VK_FORMAT_R8G8_UINT, C),
+	ANKI_FMT(R8G8, SINT, VK_FORMAT_R8G8_SINT, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_R8G8_SRGB, C),
+	ANKI_FMT(R8G8B8, UNORM, VK_FORMAT_R8G8B8_UNORM, C),
+	ANKI_FMT(R8G8B8, SNORM, VK_FORMAT_R8G8B8_SNORM, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_R8G8B8_USCALED, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_R8G8B8_SSCALED, C),
+	ANKI_FMT(R8G8B8, UINT, VK_FORMAT_R8G8B8_UINT, C),
+	ANKI_FMT(R8G8B8, SINT, VK_FORMAT_R8G8B8_SINT, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_R8G8B8_SRGB, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_B8G8R8_UNORM, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_B8G8R8_SNORM, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_B8G8R8_USCALED, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_B8G8R8_SSCALED, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_B8G8R8_UINT, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_B8G8R8_SINT, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_B8G8R8_SRGB, C),
+	ANKI_FMT(R8G8B8A8, UNORM, VK_FORMAT_R8G8B8A8_UNORM, C),
+	ANKI_FMT(R8G8B8A8, SNORM, VK_FORMAT_R8G8B8A8_SNORM, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_R8G8B8A8_USCALED, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_R8G8B8A8_SSCALED, C),
+	ANKI_FMT(R8G8B8A8, UINT, VK_FORMAT_R8G8B8A8_UINT, C),
+	ANKI_FMT(R8G8B8A8, SINT, VK_FORMAT_R8G8B8A8_SINT, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_R8G8B8A8_SRGB, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_B8G8R8A8_UNORM, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_B8G8R8A8_SNORM, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_B8G8R8A8_USCALED, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_B8G8R8A8_SSCALED, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_B8G8R8A8_UINT, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_B8G8R8A8_SINT, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_B8G8R8A8_SRGB, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_A8B8G8R8_UNORM_PACK32, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_A8B8G8R8_SNORM_PACK32, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_A8B8G8R8_USCALED_PACK32, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_A8B8G8R8_SSCALED_PACK32, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_A8B8G8R8_UINT_PACK32, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_A8B8G8R8_SINT_PACK32, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_A8B8G8R8_SRGB_PACK32, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_A2R10G10B10_UNORM_PACK32, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_A2R10G10B10_SNORM_PACK32, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_A2R10G10B10_USCALED_PACK32, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_A2R10G10B10_SSCALED_PACK32, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_A2R10G10B10_UINT_PACK32, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_A2R10G10B10_SINT_PACK32, C),
+	ANKI_FMT(R10G10B10A2, UNORM, VK_FORMAT_A2B10G10R10_UNORM_PACK32, C),
+	ANKI_FMT(R10G10B10A2, SNORM, VK_FORMAT_A2B10G10R10_SNORM_PACK32, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_A2B10G10R10_USCALED_PACK32, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_A2B10G10R10_SSCALED_PACK32, C),
+	ANKI_FMT(R10G10B10A2, UINT, VK_FORMAT_A2B10G10R10_UINT_PACK32, C),
+	ANKI_FMT(R10G10B10A2, SINT, VK_FORMAT_A2B10G10R10_SINT_PACK32, C),
+	ANKI_FMT(R16, UNORM, VK_FORMAT_R16_UNORM, C),
+	ANKI_FMT(R16, SNORM, VK_FORMAT_R16_SNORM, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_R16_USCALED, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_R16_SSCALED, C),
+	ANKI_FMT(R16, UINT, VK_FORMAT_R16_UINT, C),
+	ANKI_FMT(R16, SINT, VK_FORMAT_R16_SINT, C),
+	ANKI_FMT(R16, FLOAT, VK_FORMAT_R16_SFLOAT, C),
+	ANKI_FMT(R16G16, UNORM, VK_FORMAT_R16G16_UNORM, C),
+	ANKI_FMT(R16G16, SNORM, VK_FORMAT_R16G16_SNORM, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_R16G16_USCALED, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_R16G16_SSCALED, C),
+	ANKI_FMT(R16G16, UINT, VK_FORMAT_R16G16_UINT, C),
+	ANKI_FMT(R16G16, SINT, VK_FORMAT_R16G16_SINT, C),
+	ANKI_FMT(R16G16, FLOAT, VK_FORMAT_R16G16_SFLOAT, C),
+	ANKI_FMT(R16G16B16, UNORM, VK_FORMAT_R16G16B16_UNORM, C),
+	ANKI_FMT(R16G16B16, SNORM, VK_FORMAT_R16G16B16_SNORM, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_R16G16B16_USCALED, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_R16G16B16_SSCALED, C),
+	ANKI_FMT(R16G16B16, UINT, VK_FORMAT_R16G16B16_UINT, C),
+	ANKI_FMT(R16G16B16, SINT, VK_FORMAT_R16G16B16_SINT, C),
+	ANKI_FMT(R16G16B16, FLOAT, VK_FORMAT_R16G16B16_SFLOAT, C),
+	ANKI_FMT(R16G16B16A16, UNORM, VK_FORMAT_R16G16B16A16_UNORM, C),
+	ANKI_FMT(R16G16B16A16, SNORM, VK_FORMAT_R16G16B16A16_SNORM, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_R16G16B16A16_USCALED, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_R16G16B16A16_SSCALED, C),
+	ANKI_FMT(R16G16B16A16, UINT, VK_FORMAT_R16G16B16A16_UINT, C),
+	ANKI_FMT(R16G16B16A16, SINT, VK_FORMAT_R16G16B16A16_SINT, C),
+	ANKI_FMT(R16G16B16A16, FLOAT, VK_FORMAT_R16G16B16A16_SFLOAT, C),
+	ANKI_FMT(R32, UINT, VK_FORMAT_R32_UINT, C),
+	ANKI_FMT(R32, SINT, VK_FORMAT_R32_SINT, C),
+	ANKI_FMT(R32, FLOAT, VK_FORMAT_R32_SFLOAT, C),
+	ANKI_FMT(R32G32, UINT, VK_FORMAT_R32G32_UINT, C),
+	ANKI_FMT(R32G32, SINT, VK_FORMAT_R32G32_SINT, C),
+	ANKI_FMT(R32G32, FLOAT, VK_FORMAT_R32G32_SFLOAT, C),
+	ANKI_FMT(R32G32B32, UINT, VK_FORMAT_R32G32B32_UINT, C),
+	ANKI_FMT(R32G32B32, SINT, VK_FORMAT_R32G32B32_SINT, C),
+	ANKI_FMT(R32G32B32, FLOAT, VK_FORMAT_R32G32B32_SFLOAT, C),
+	ANKI_FMT(R32G32B32A32, UINT, VK_FORMAT_R32G32B32A32_UINT, C),
+	ANKI_FMT(R32G32B32A32, SINT, VK_FORMAT_R32G32B32A32_SINT, C),
+	ANKI_FMT(R32G32B32A32, FLOAT, VK_FORMAT_R32G32B32A32_SFLOAT, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_R64_UINT, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_R64_SINT, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_R64_SFLOAT, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_R64G64_UINT, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_R64G64_SINT, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_R64G64_SFLOAT, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_R64G64B64_UINT, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_R64G64B64_SINT, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_R64G64B64_SFLOAT, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_R64G64B64A64_UINT, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_R64G64B64A64_SINT, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_R64G64B64A64_SFLOAT, C),
+	ANKI_FMT(R11G11B10, FLOAT, VK_FORMAT_B10G11R11_UFLOAT_PACK32, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_E5B9G9R9_UFLOAT_PACK32, C),
+	ANKI_FMT(D16, UNORM, VK_FORMAT_D16_UNORM, D),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_X8_D24_UNORM_PACK32, DS),
+	ANKI_FMT(D32, FLOAT, VK_FORMAT_D32_SFLOAT, D),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_S8_UINT, S),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_D16_UNORM_S8_UINT, DS),
+	ANKI_FMT(D24, UNORM, VK_FORMAT_D24_UNORM_S8_UINT, DS),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_D32_SFLOAT_S8_UINT, C),
+	ANKI_FMT(R8G8B8_S3TC, UNORM, VK_FORMAT_BC1_RGB_UNORM_BLOCK, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_BC1_RGB_SRGB_BLOCK, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_BC1_RGBA_UNORM_BLOCK, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_BC1_RGBA_SRGB_BLOCK, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_BC2_UNORM_BLOCK, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_BC2_SRGB_BLOCK, C),
+	ANKI_FMT(R8G8B8A8_S3TC, UNORM, VK_FORMAT_BC3_UNORM_BLOCK, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_BC3_SRGB_BLOCK, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_BC4_UNORM_BLOCK, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_BC4_SNORM_BLOCK, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_BC5_UNORM_BLOCK, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_BC5_SNORM_BLOCK, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_BC6H_UFLOAT_BLOCK, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_BC6H_SFLOAT_BLOCK, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_BC7_UNORM_BLOCK, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_BC7_SRGB_BLOCK, C),
+	ANKI_FMT(R8G8B8_ETC2, NONE, VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK, C),
+	ANKI_FMT(R8G8B8A8_ETC2, NONE, VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_EAC_R11_UNORM_BLOCK, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_EAC_R11_SNORM_BLOCK, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_EAC_R11G11_UNORM_BLOCK, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_EAC_R11G11_SNORM_BLOCK, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_ASTC_4x4_UNORM_BLOCK, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_ASTC_4x4_SRGB_BLOCK, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_ASTC_5x4_UNORM_BLOCK, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_ASTC_5x4_SRGB_BLOCK, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_ASTC_5x5_UNORM_BLOCK, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_ASTC_5x5_SRGB_BLOCK, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_ASTC_6x5_UNORM_BLOCK, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_ASTC_6x5_SRGB_BLOCK, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_ASTC_6x6_UNORM_BLOCK, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_ASTC_6x6_SRGB_BLOCK, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_ASTC_8x5_UNORM_BLOCK, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_ASTC_8x5_SRGB_BLOCK, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_ASTC_8x6_UNORM_BLOCK, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_ASTC_8x6_SRGB_BLOCK, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_ASTC_8x8_UNORM_BLOCK, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_ASTC_8x8_SRGB_BLOCK, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_ASTC_10x5_UNORM_BLOCK, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_ASTC_10x5_SRGB_BLOCK, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_ASTC_10x6_UNORM_BLOCK, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_ASTC_10x6_SRGB_BLOCK, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_ASTC_10x8_UNORM_BLOCK, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_ASTC_10x8_SRGB_BLOCK, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_ASTC_10x10_UNORM_BLOCK, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_ASTC_10x10_SRGB_BLOCK, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_ASTC_12x10_UNORM_BLOCK, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_ASTC_12x10_SRGB_BLOCK, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_ASTC_12x12_UNORM_BLOCK, C),
+	ANKI_FMT(NONE, NONE, VK_FORMAT_ASTC_12x12_SRGB_BLOCK, C)};
 
 #undef ANKI_FMT
 
@@ -269,6 +282,23 @@ VkFormat convertFormat(PixelFormat ak)
 	return out;
 }
 
+//==============================================================================
+VkImageAspectFlags convertImageAspect(PixelFormat ak)
+{
+	VkImageAspectFlags out = 0;
+	for(U i = 0; i < CONVERT_FORMAT_TABLE_SIZE; ++i)
+	{
+		const ConvertFormat& entry = CONVERT_FORMAT_TABLE[i];
+		if(ak == entry.m_ak)
+		{
+			out = static_cast<VkImageAspectFlags>(entry.m_aspect);
+		}
+	}
+
+	ANKI_ASSERT(out);
+	return out;
+}
+
 //==============================================================================
 VkPrimitiveTopology convertTopology(PrimitiveTopology ak)
 {

src/anki/gr/vulkan/Common.h

@@ -64,6 +64,9 @@ ANKI_USE_RESULT VkCompareOp convertCompareOp(CompareOperation ak);
 /// Convert format.
 ANKI_USE_RESULT VkFormat convertFormat(PixelFormat ak);
 
+/// Get format aspect mask.
+ANKI_USE_RESULT VkImageAspectFlags convertImageAspect(PixelFormat ak);
+
 /// Convert topology.
 ANKI_USE_RESULT VkPrimitiveTopology convertTopology(PrimitiveTopology ak);
 

src/anki/gr/vulkan/ShaderImpl.cpp

@@ -9,6 +9,13 @@
 #include <glslang/Public/ShaderLang.h>
 #include <SPIRV/GlslangToSpv.h>
 
+#define ANKI_DUMP_SHADERS ANKI_DEBUG
+
+#if ANKI_DUMP_SHADERS
+#include <anki/util/File.h>
+#include <anki/gr/GrManager.h>
+#endif
+
 namespace anki
 {
 
@@ -251,6 +258,62 @@ Error ShaderImpl::init(ShaderType shaderType, const CString& source)
 	ANKI_CHECK(genSpirv(fullSrc.toCString(), spirv));
 	ANKI_ASSERT(!spirv.empty());
 
+#if ANKI_DUMP_SHADERS
+	{
+		static U32 name = 0;
+		SpinLock m_nameLock;
+		const char* ext;
+
+		U32 newName;
+		{
+			LockGuard<SpinLock> lock(m_nameLock);
+			newName = name++;
+		}
+
+		switch(shaderType)
+		{
+		case ShaderType::VERTEX:
+			ext = "vert";
+			break;
+		case ShaderType::TESSELLATION_CONTROL:
+			ext = "tesc";
+			break;
+		case ShaderType::TESSELLATION_EVALUATION:
+			ext = "tese";
+			break;
+		case ShaderType::GEOMETRY:
+			ext = "geom";
+			break;
+		case ShaderType::FRAGMENT:
+			ext = "frag";
+			break;
+		case ShaderType::COMPUTE:
+			ext = "comp";
+			break;
+		default:
+			ext = nullptr;
+			ANKI_ASSERT(0);
+		}
+
+		StringAuto fname(alloc);
+		CString cacheDir = getGrManager().getCacheDirectory();
+		fname.sprintf("%s/%05u.%s", &cacheDir[0], newName, ext);
+
+		File file;
+		ANKI_CHECK(file.open(fname.toCString(), File::OpenFlag::WRITE));
+		ANKI_CHECK(file.writeText("%s", &fullSrc[0]));
+
+		StringAuto fnameSpirv(alloc);
+		fnameSpirv.sprintf("%s/%05u.%s.spv", &cacheDir[0], newName, ext);
+
+		File fileSpirv;
+		ANKI_CHECK(fileSpirv.open(fnameSpirv.toCString(),
+			File::OpenFlag::BINARY | File::OpenFlag::WRITE));
+		ANKI_CHECK(
+			fileSpirv.write(&spirv[0], spirv.size() * sizeof(unsigned int)));
+	}
+#endif
+
 	VkShaderModuleCreateInfo ci = {VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO,
 		nullptr,
 		0,

src/anki/gr/vulkan/TextureImpl.cpp

@@ -119,7 +119,7 @@ Bool TextureImpl::imageSupported(const TextureInitInfo& init)
 
 	VkResult res = vkGetPhysicalDeviceImageFormatProperties(
 		getGrManagerImpl().getPhysicalDevice(),
-		convertFormat(init.m_format),
+		m_vkFormat,
 		convertTextureType(init.m_type),
 		VK_IMAGE_TILING_OPTIMAL,
 		convertTextureUsage(init.m_usage, init.m_format),
@@ -165,16 +165,9 @@ Error TextureImpl::init(const TextureInitInfo& init_, Texture* tex)
 	m_layerCount = init.m_layerCount;
 
 	m_format = init.m_format;
+	m_vkFormat = convertFormat(m_format);
 	m_depthStencil = formatIsDepthStencil(m_format);
-	if(m_depthStencil)
-	{
-		m_aspect = VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT;
-	}
-	else
-	{
-		m_aspect = VK_IMAGE_ASPECT_COLOR_BIT;
-	}
-
+	m_aspect = convertImageAspect(m_format);
 	m_usage = init.m_usage;
 
 	CreateContext ctx;
@@ -237,6 +230,7 @@ Error TextureImpl::initImage(CreateContext& ctx)
 				&& "Can't do that ATM");
 			init.m_format.m_components = ComponentFormat::R8G8B8A8;
 			m_format = init.m_format;
+			m_vkFormat = convertFormat(m_format);
 			m_workarounds = TextureImplWorkaround::R8G8B8_TO_R8G8B8A8;
 		}
 		else
@@ -259,7 +253,7 @@ Error TextureImpl::initImage(CreateContext& ctx)
 	ci.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
 	ci.flags = calcCreateFlags(init);
 	ci.imageType = convertTextureType(init.m_type);
-	ci.format = convertFormat(init.m_format);
+	ci.format = m_vkFormat;
 	ci.extent.width = init.m_width;
 	ci.extent.height = init.m_height;
 
@@ -697,8 +691,8 @@ VkImageView TextureImpl::getOrCreateSingleSurfaceView(
 		VkImageViewCreateInfo ci = {};
 		ci.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
 		ci.image = m_imageHandle;
-		ci.viewType = convertTextureViewType(m_type);
-		ci.format = convertFormat(m_format);
+		ci.viewType = VK_IMAGE_VIEW_TYPE_2D;
+		ci.format = m_vkFormat;
 		ci.components.r = VK_COMPONENT_SWIZZLE_IDENTITY;
 		ci.components.g = VK_COMPONENT_SWIZZLE_IDENTITY;
 		ci.components.b = VK_COMPONENT_SWIZZLE_IDENTITY;
@@ -749,7 +743,7 @@ VkImageView TextureImpl::getOrCreateSingleLevelView(U level)
 		ci.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
 		ci.image = m_imageHandle;
 		ci.viewType = convertTextureViewType(m_type);
-		ci.format = convertFormat(m_format);
+		ci.format = m_vkFormat;
 		ci.components.r = VK_COMPONENT_SWIZZLE_IDENTITY;
 		ci.components.g = VK_COMPONENT_SWIZZLE_IDENTITY;
 		ci.components.b = VK_COMPONENT_SWIZZLE_IDENTITY;

src/anki/gr/vulkan/TextureImpl.h

@@ -44,6 +44,7 @@ public:
 	VkImageAspectFlags m_aspect = 0;
 	TextureUsageBit m_usage = TextureUsageBit::NONE;
 	PixelFormat m_format;
+	VkFormat m_vkFormat = VK_FORMAT_UNDEFINED;
 
 	Bool m_depthStencil = false;
 	TextureImplWorkaround m_workarounds = TextureImplWorkaround::NONE;

thirdparty

@@ -1 +1 @@
-Subproject commit 6e44be6e6d42abc25b5ee7c7f53e7a6adedc271f
+Subproject commit fbe40db19e871634fb9b526ac861559493d99dcd