VK_DEFINE_NON_DISPATCHABLE_HANDLE (VkDisplayKHR, HANDLE_TYPE_DISPLAY_KHR);
VK_DEFINE_NON_DISPATCHABLE_HANDLE (VkDisplayModeKHR, HANDLE_TYPE_DISPLAY_MODE_KHR);
VK_DEFINE_NON_DISPATCHABLE_HANDLE (VkDescriptorUpdateTemplateKHR, HANDLE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR);
+VK_DEFINE_NON_DISPATCHABLE_HANDLE (VkSamplerYcbcrConversionKHR, HANDLE_TYPE_SAMPLER_YCBCR_CONVERSION_KHR);
VK_DEFINE_NON_DISPATCHABLE_HANDLE (VkDebugReportCallbackEXT, HANDLE_TYPE_DEBUG_REPORT_CALLBACK_EXT);
enum VkPipelineCacheHeaderVersion
VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2_KHR = 1000146002,
VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR = 1000146003,
VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2_KHR = 1000146004,
+ VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO_KHR = 1000156000,
+ VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO_KHR = 1000156001,
+ VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO_KHR = 1000156002,
+ VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO_KHR = 1000156003,
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES_KHR = 1000156004,
+ VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES_KHR = 1000156005,
VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHR = 1000157000,
VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHR = 1000157001,
};
enum VkFormat
{
- VK_FORMAT_UNDEFINED = 0,
- VK_FORMAT_R4G4_UNORM_PACK8 = 1,
- VK_FORMAT_R4G4B4A4_UNORM_PACK16 = 2,
- VK_FORMAT_B4G4R4A4_UNORM_PACK16 = 3,
- VK_FORMAT_R5G6B5_UNORM_PACK16 = 4,
- VK_FORMAT_B5G6R5_UNORM_PACK16 = 5,
- VK_FORMAT_R5G5B5A1_UNORM_PACK16 = 6,
- VK_FORMAT_B5G5R5A1_UNORM_PACK16 = 7,
- VK_FORMAT_A1R5G5B5_UNORM_PACK16 = 8,
- VK_FORMAT_R8_UNORM = 9,
- VK_FORMAT_R8_SNORM = 10,
- VK_FORMAT_R8_USCALED = 11,
- VK_FORMAT_R8_SSCALED = 12,
- VK_FORMAT_R8_UINT = 13,
- VK_FORMAT_R8_SINT = 14,
- VK_FORMAT_R8_SRGB = 15,
- VK_FORMAT_R8G8_UNORM = 16,
- VK_FORMAT_R8G8_SNORM = 17,
- VK_FORMAT_R8G8_USCALED = 18,
- VK_FORMAT_R8G8_SSCALED = 19,
- VK_FORMAT_R8G8_UINT = 20,
- VK_FORMAT_R8G8_SINT = 21,
- VK_FORMAT_R8G8_SRGB = 22,
- VK_FORMAT_R8G8B8_UNORM = 23,
- VK_FORMAT_R8G8B8_SNORM = 24,
- VK_FORMAT_R8G8B8_USCALED = 25,
- VK_FORMAT_R8G8B8_SSCALED = 26,
- VK_FORMAT_R8G8B8_UINT = 27,
- VK_FORMAT_R8G8B8_SINT = 28,
- VK_FORMAT_R8G8B8_SRGB = 29,
- VK_FORMAT_B8G8R8_UNORM = 30,
- VK_FORMAT_B8G8R8_SNORM = 31,
- VK_FORMAT_B8G8R8_USCALED = 32,
- VK_FORMAT_B8G8R8_SSCALED = 33,
- VK_FORMAT_B8G8R8_UINT = 34,
- VK_FORMAT_B8G8R8_SINT = 35,
- VK_FORMAT_B8G8R8_SRGB = 36,
- VK_FORMAT_R8G8B8A8_UNORM = 37,
- VK_FORMAT_R8G8B8A8_SNORM = 38,
- VK_FORMAT_R8G8B8A8_USCALED = 39,
- VK_FORMAT_R8G8B8A8_SSCALED = 40,
- VK_FORMAT_R8G8B8A8_UINT = 41,
- VK_FORMAT_R8G8B8A8_SINT = 42,
- VK_FORMAT_R8G8B8A8_SRGB = 43,
- VK_FORMAT_B8G8R8A8_UNORM = 44,
- VK_FORMAT_B8G8R8A8_SNORM = 45,
- VK_FORMAT_B8G8R8A8_USCALED = 46,
- VK_FORMAT_B8G8R8A8_SSCALED = 47,
- VK_FORMAT_B8G8R8A8_UINT = 48,
- VK_FORMAT_B8G8R8A8_SINT = 49,
- VK_FORMAT_B8G8R8A8_SRGB = 50,
- VK_FORMAT_A8B8G8R8_UNORM_PACK32 = 51,
- VK_FORMAT_A8B8G8R8_SNORM_PACK32 = 52,
- VK_FORMAT_A8B8G8R8_USCALED_PACK32 = 53,
- VK_FORMAT_A8B8G8R8_SSCALED_PACK32 = 54,
- VK_FORMAT_A8B8G8R8_UINT_PACK32 = 55,
- VK_FORMAT_A8B8G8R8_SINT_PACK32 = 56,
- VK_FORMAT_A8B8G8R8_SRGB_PACK32 = 57,
- VK_FORMAT_A2R10G10B10_UNORM_PACK32 = 58,
- VK_FORMAT_A2R10G10B10_SNORM_PACK32 = 59,
- VK_FORMAT_A2R10G10B10_USCALED_PACK32 = 60,
- VK_FORMAT_A2R10G10B10_SSCALED_PACK32 = 61,
- VK_FORMAT_A2R10G10B10_UINT_PACK32 = 62,
- VK_FORMAT_A2R10G10B10_SINT_PACK32 = 63,
- VK_FORMAT_A2B10G10R10_UNORM_PACK32 = 64,
- VK_FORMAT_A2B10G10R10_SNORM_PACK32 = 65,
- VK_FORMAT_A2B10G10R10_USCALED_PACK32 = 66,
- VK_FORMAT_A2B10G10R10_SSCALED_PACK32 = 67,
- VK_FORMAT_A2B10G10R10_UINT_PACK32 = 68,
- VK_FORMAT_A2B10G10R10_SINT_PACK32 = 69,
- VK_FORMAT_R16_UNORM = 70,
- VK_FORMAT_R16_SNORM = 71,
- VK_FORMAT_R16_USCALED = 72,
- VK_FORMAT_R16_SSCALED = 73,
- VK_FORMAT_R16_UINT = 74,
- VK_FORMAT_R16_SINT = 75,
- VK_FORMAT_R16_SFLOAT = 76,
- VK_FORMAT_R16G16_UNORM = 77,
- VK_FORMAT_R16G16_SNORM = 78,
- VK_FORMAT_R16G16_USCALED = 79,
- VK_FORMAT_R16G16_SSCALED = 80,
- VK_FORMAT_R16G16_UINT = 81,
- VK_FORMAT_R16G16_SINT = 82,
- VK_FORMAT_R16G16_SFLOAT = 83,
- VK_FORMAT_R16G16B16_UNORM = 84,
- VK_FORMAT_R16G16B16_SNORM = 85,
- VK_FORMAT_R16G16B16_USCALED = 86,
- VK_FORMAT_R16G16B16_SSCALED = 87,
- VK_FORMAT_R16G16B16_UINT = 88,
- VK_FORMAT_R16G16B16_SINT = 89,
- VK_FORMAT_R16G16B16_SFLOAT = 90,
- VK_FORMAT_R16G16B16A16_UNORM = 91,
- VK_FORMAT_R16G16B16A16_SNORM = 92,
- VK_FORMAT_R16G16B16A16_USCALED = 93,
- VK_FORMAT_R16G16B16A16_SSCALED = 94,
- VK_FORMAT_R16G16B16A16_UINT = 95,
- VK_FORMAT_R16G16B16A16_SINT = 96,
- VK_FORMAT_R16G16B16A16_SFLOAT = 97,
- VK_FORMAT_R32_UINT = 98,
- VK_FORMAT_R32_SINT = 99,
- VK_FORMAT_R32_SFLOAT = 100,
- VK_FORMAT_R32G32_UINT = 101,
- VK_FORMAT_R32G32_SINT = 102,
- VK_FORMAT_R32G32_SFLOAT = 103,
- VK_FORMAT_R32G32B32_UINT = 104,
- VK_FORMAT_R32G32B32_SINT = 105,
- VK_FORMAT_R32G32B32_SFLOAT = 106,
- VK_FORMAT_R32G32B32A32_UINT = 107,
- VK_FORMAT_R32G32B32A32_SINT = 108,
- VK_FORMAT_R32G32B32A32_SFLOAT = 109,
- VK_FORMAT_R64_UINT = 110,
- VK_FORMAT_R64_SINT = 111,
- VK_FORMAT_R64_SFLOAT = 112,
- VK_FORMAT_R64G64_UINT = 113,
- VK_FORMAT_R64G64_SINT = 114,
- VK_FORMAT_R64G64_SFLOAT = 115,
- VK_FORMAT_R64G64B64_UINT = 116,
- VK_FORMAT_R64G64B64_SINT = 117,
- VK_FORMAT_R64G64B64_SFLOAT = 118,
- VK_FORMAT_R64G64B64A64_UINT = 119,
- VK_FORMAT_R64G64B64A64_SINT = 120,
- VK_FORMAT_R64G64B64A64_SFLOAT = 121,
- VK_FORMAT_B10G11R11_UFLOAT_PACK32 = 122,
- VK_FORMAT_E5B9G9R9_UFLOAT_PACK32 = 123,
- VK_FORMAT_D16_UNORM = 124,
- VK_FORMAT_X8_D24_UNORM_PACK32 = 125,
- VK_FORMAT_D32_SFLOAT = 126,
- VK_FORMAT_S8_UINT = 127,
- VK_FORMAT_D16_UNORM_S8_UINT = 128,
- VK_FORMAT_D24_UNORM_S8_UINT = 129,
- VK_FORMAT_D32_SFLOAT_S8_UINT = 130,
- VK_FORMAT_BC1_RGB_UNORM_BLOCK = 131,
- VK_FORMAT_BC1_RGB_SRGB_BLOCK = 132,
- VK_FORMAT_BC1_RGBA_UNORM_BLOCK = 133,
- VK_FORMAT_BC1_RGBA_SRGB_BLOCK = 134,
- VK_FORMAT_BC2_UNORM_BLOCK = 135,
- VK_FORMAT_BC2_SRGB_BLOCK = 136,
- VK_FORMAT_BC3_UNORM_BLOCK = 137,
- VK_FORMAT_BC3_SRGB_BLOCK = 138,
- VK_FORMAT_BC4_UNORM_BLOCK = 139,
- VK_FORMAT_BC4_SNORM_BLOCK = 140,
- VK_FORMAT_BC5_UNORM_BLOCK = 141,
- VK_FORMAT_BC5_SNORM_BLOCK = 142,
- VK_FORMAT_BC6H_UFLOAT_BLOCK = 143,
- VK_FORMAT_BC6H_SFLOAT_BLOCK = 144,
- VK_FORMAT_BC7_UNORM_BLOCK = 145,
- VK_FORMAT_BC7_SRGB_BLOCK = 146,
- VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK = 147,
- VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK = 148,
- VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK = 149,
- VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK = 150,
- VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK = 151,
- VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK = 152,
- VK_FORMAT_EAC_R11_UNORM_BLOCK = 153,
- VK_FORMAT_EAC_R11_SNORM_BLOCK = 154,
- VK_FORMAT_EAC_R11G11_UNORM_BLOCK = 155,
- VK_FORMAT_EAC_R11G11_SNORM_BLOCK = 156,
- VK_FORMAT_ASTC_4x4_UNORM_BLOCK = 157,
- VK_FORMAT_ASTC_4x4_SRGB_BLOCK = 158,
- VK_FORMAT_ASTC_5x4_UNORM_BLOCK = 159,
- VK_FORMAT_ASTC_5x4_SRGB_BLOCK = 160,
- VK_FORMAT_ASTC_5x5_UNORM_BLOCK = 161,
- VK_FORMAT_ASTC_5x5_SRGB_BLOCK = 162,
- VK_FORMAT_ASTC_6x5_UNORM_BLOCK = 163,
- VK_FORMAT_ASTC_6x5_SRGB_BLOCK = 164,
- VK_FORMAT_ASTC_6x6_UNORM_BLOCK = 165,
- VK_FORMAT_ASTC_6x6_SRGB_BLOCK = 166,
- VK_FORMAT_ASTC_8x5_UNORM_BLOCK = 167,
- VK_FORMAT_ASTC_8x5_SRGB_BLOCK = 168,
- VK_FORMAT_ASTC_8x6_UNORM_BLOCK = 169,
- VK_FORMAT_ASTC_8x6_SRGB_BLOCK = 170,
- VK_FORMAT_ASTC_8x8_UNORM_BLOCK = 171,
- VK_FORMAT_ASTC_8x8_SRGB_BLOCK = 172,
- VK_FORMAT_ASTC_10x5_UNORM_BLOCK = 173,
- VK_FORMAT_ASTC_10x5_SRGB_BLOCK = 174,
- VK_FORMAT_ASTC_10x6_UNORM_BLOCK = 175,
- VK_FORMAT_ASTC_10x6_SRGB_BLOCK = 176,
- VK_FORMAT_ASTC_10x8_UNORM_BLOCK = 177,
- VK_FORMAT_ASTC_10x8_SRGB_BLOCK = 178,
- VK_FORMAT_ASTC_10x10_UNORM_BLOCK = 179,
- VK_FORMAT_ASTC_10x10_SRGB_BLOCK = 180,
- VK_FORMAT_ASTC_12x10_UNORM_BLOCK = 181,
- VK_FORMAT_ASTC_12x10_SRGB_BLOCK = 182,
- VK_FORMAT_ASTC_12x12_UNORM_BLOCK = 183,
- VK_FORMAT_ASTC_12x12_SRGB_BLOCK = 184,
-
- VK_FORMAT_LAST
+ VK_FORMAT_UNDEFINED = 0,
+ VK_FORMAT_R4G4_UNORM_PACK8 = 1,
+ VK_FORMAT_R4G4B4A4_UNORM_PACK16 = 2,
+ VK_FORMAT_B4G4R4A4_UNORM_PACK16 = 3,
+ VK_FORMAT_R5G6B5_UNORM_PACK16 = 4,
+ VK_FORMAT_B5G6R5_UNORM_PACK16 = 5,
+ VK_FORMAT_R5G5B5A1_UNORM_PACK16 = 6,
+ VK_FORMAT_B5G5R5A1_UNORM_PACK16 = 7,
+ VK_FORMAT_A1R5G5B5_UNORM_PACK16 = 8,
+ VK_FORMAT_R8_UNORM = 9,
+ VK_FORMAT_R8_SNORM = 10,
+ VK_FORMAT_R8_USCALED = 11,
+ VK_FORMAT_R8_SSCALED = 12,
+ VK_FORMAT_R8_UINT = 13,
+ VK_FORMAT_R8_SINT = 14,
+ VK_FORMAT_R8_SRGB = 15,
+ VK_FORMAT_R8G8_UNORM = 16,
+ VK_FORMAT_R8G8_SNORM = 17,
+ VK_FORMAT_R8G8_USCALED = 18,
+ VK_FORMAT_R8G8_SSCALED = 19,
+ VK_FORMAT_R8G8_UINT = 20,
+ VK_FORMAT_R8G8_SINT = 21,
+ VK_FORMAT_R8G8_SRGB = 22,
+ VK_FORMAT_R8G8B8_UNORM = 23,
+ VK_FORMAT_R8G8B8_SNORM = 24,
+ VK_FORMAT_R8G8B8_USCALED = 25,
+ VK_FORMAT_R8G8B8_SSCALED = 26,
+ VK_FORMAT_R8G8B8_UINT = 27,
+ VK_FORMAT_R8G8B8_SINT = 28,
+ VK_FORMAT_R8G8B8_SRGB = 29,
+ VK_FORMAT_B8G8R8_UNORM = 30,
+ VK_FORMAT_B8G8R8_SNORM = 31,
+ VK_FORMAT_B8G8R8_USCALED = 32,
+ VK_FORMAT_B8G8R8_SSCALED = 33,
+ VK_FORMAT_B8G8R8_UINT = 34,
+ VK_FORMAT_B8G8R8_SINT = 35,
+ VK_FORMAT_B8G8R8_SRGB = 36,
+ VK_FORMAT_R8G8B8A8_UNORM = 37,
+ VK_FORMAT_R8G8B8A8_SNORM = 38,
+ VK_FORMAT_R8G8B8A8_USCALED = 39,
+ VK_FORMAT_R8G8B8A8_SSCALED = 40,
+ VK_FORMAT_R8G8B8A8_UINT = 41,
+ VK_FORMAT_R8G8B8A8_SINT = 42,
+ VK_FORMAT_R8G8B8A8_SRGB = 43,
+ VK_FORMAT_B8G8R8A8_UNORM = 44,
+ VK_FORMAT_B8G8R8A8_SNORM = 45,
+ VK_FORMAT_B8G8R8A8_USCALED = 46,
+ VK_FORMAT_B8G8R8A8_SSCALED = 47,
+ VK_FORMAT_B8G8R8A8_UINT = 48,
+ VK_FORMAT_B8G8R8A8_SINT = 49,
+ VK_FORMAT_B8G8R8A8_SRGB = 50,
+ VK_FORMAT_A8B8G8R8_UNORM_PACK32 = 51,
+ VK_FORMAT_A8B8G8R8_SNORM_PACK32 = 52,
+ VK_FORMAT_A8B8G8R8_USCALED_PACK32 = 53,
+ VK_FORMAT_A8B8G8R8_SSCALED_PACK32 = 54,
+ VK_FORMAT_A8B8G8R8_UINT_PACK32 = 55,
+ VK_FORMAT_A8B8G8R8_SINT_PACK32 = 56,
+ VK_FORMAT_A8B8G8R8_SRGB_PACK32 = 57,
+ VK_FORMAT_A2R10G10B10_UNORM_PACK32 = 58,
+ VK_FORMAT_A2R10G10B10_SNORM_PACK32 = 59,
+ VK_FORMAT_A2R10G10B10_USCALED_PACK32 = 60,
+ VK_FORMAT_A2R10G10B10_SSCALED_PACK32 = 61,
+ VK_FORMAT_A2R10G10B10_UINT_PACK32 = 62,
+ VK_FORMAT_A2R10G10B10_SINT_PACK32 = 63,
+ VK_FORMAT_A2B10G10R10_UNORM_PACK32 = 64,
+ VK_FORMAT_A2B10G10R10_SNORM_PACK32 = 65,
+ VK_FORMAT_A2B10G10R10_USCALED_PACK32 = 66,
+ VK_FORMAT_A2B10G10R10_SSCALED_PACK32 = 67,
+ VK_FORMAT_A2B10G10R10_UINT_PACK32 = 68,
+ VK_FORMAT_A2B10G10R10_SINT_PACK32 = 69,
+ VK_FORMAT_R16_UNORM = 70,
+ VK_FORMAT_R16_SNORM = 71,
+ VK_FORMAT_R16_USCALED = 72,
+ VK_FORMAT_R16_SSCALED = 73,
+ VK_FORMAT_R16_UINT = 74,
+ VK_FORMAT_R16_SINT = 75,
+ VK_FORMAT_R16_SFLOAT = 76,
+ VK_FORMAT_R16G16_UNORM = 77,
+ VK_FORMAT_R16G16_SNORM = 78,
+ VK_FORMAT_R16G16_USCALED = 79,
+ VK_FORMAT_R16G16_SSCALED = 80,
+ VK_FORMAT_R16G16_UINT = 81,
+ VK_FORMAT_R16G16_SINT = 82,
+ VK_FORMAT_R16G16_SFLOAT = 83,
+ VK_FORMAT_R16G16B16_UNORM = 84,
+ VK_FORMAT_R16G16B16_SNORM = 85,
+ VK_FORMAT_R16G16B16_USCALED = 86,
+ VK_FORMAT_R16G16B16_SSCALED = 87,
+ VK_FORMAT_R16G16B16_UINT = 88,
+ VK_FORMAT_R16G16B16_SINT = 89,
+ VK_FORMAT_R16G16B16_SFLOAT = 90,
+ VK_FORMAT_R16G16B16A16_UNORM = 91,
+ VK_FORMAT_R16G16B16A16_SNORM = 92,
+ VK_FORMAT_R16G16B16A16_USCALED = 93,
+ VK_FORMAT_R16G16B16A16_SSCALED = 94,
+ VK_FORMAT_R16G16B16A16_UINT = 95,
+ VK_FORMAT_R16G16B16A16_SINT = 96,
+ VK_FORMAT_R16G16B16A16_SFLOAT = 97,
+ VK_FORMAT_R32_UINT = 98,
+ VK_FORMAT_R32_SINT = 99,
+ VK_FORMAT_R32_SFLOAT = 100,
+ VK_FORMAT_R32G32_UINT = 101,
+ VK_FORMAT_R32G32_SINT = 102,
+ VK_FORMAT_R32G32_SFLOAT = 103,
+ VK_FORMAT_R32G32B32_UINT = 104,
+ VK_FORMAT_R32G32B32_SINT = 105,
+ VK_FORMAT_R32G32B32_SFLOAT = 106,
+ VK_FORMAT_R32G32B32A32_UINT = 107,
+ VK_FORMAT_R32G32B32A32_SINT = 108,
+ VK_FORMAT_R32G32B32A32_SFLOAT = 109,
+ VK_FORMAT_R64_UINT = 110,
+ VK_FORMAT_R64_SINT = 111,
+ VK_FORMAT_R64_SFLOAT = 112,
+ VK_FORMAT_R64G64_UINT = 113,
+ VK_FORMAT_R64G64_SINT = 114,
+ VK_FORMAT_R64G64_SFLOAT = 115,
+ VK_FORMAT_R64G64B64_UINT = 116,
+ VK_FORMAT_R64G64B64_SINT = 117,
+ VK_FORMAT_R64G64B64_SFLOAT = 118,
+ VK_FORMAT_R64G64B64A64_UINT = 119,
+ VK_FORMAT_R64G64B64A64_SINT = 120,
+ VK_FORMAT_R64G64B64A64_SFLOAT = 121,
+ VK_FORMAT_B10G11R11_UFLOAT_PACK32 = 122,
+ VK_FORMAT_E5B9G9R9_UFLOAT_PACK32 = 123,
+ VK_FORMAT_D16_UNORM = 124,
+ VK_FORMAT_X8_D24_UNORM_PACK32 = 125,
+ VK_FORMAT_D32_SFLOAT = 126,
+ VK_FORMAT_S8_UINT = 127,
+ VK_FORMAT_D16_UNORM_S8_UINT = 128,
+ VK_FORMAT_D24_UNORM_S8_UINT = 129,
+ VK_FORMAT_D32_SFLOAT_S8_UINT = 130,
+ VK_FORMAT_BC1_RGB_UNORM_BLOCK = 131,
+ VK_FORMAT_BC1_RGB_SRGB_BLOCK = 132,
+ VK_FORMAT_BC1_RGBA_UNORM_BLOCK = 133,
+ VK_FORMAT_BC1_RGBA_SRGB_BLOCK = 134,
+ VK_FORMAT_BC2_UNORM_BLOCK = 135,
+ VK_FORMAT_BC2_SRGB_BLOCK = 136,
+ VK_FORMAT_BC3_UNORM_BLOCK = 137,
+ VK_FORMAT_BC3_SRGB_BLOCK = 138,
+ VK_FORMAT_BC4_UNORM_BLOCK = 139,
+ VK_FORMAT_BC4_SNORM_BLOCK = 140,
+ VK_FORMAT_BC5_UNORM_BLOCK = 141,
+ VK_FORMAT_BC5_SNORM_BLOCK = 142,
+ VK_FORMAT_BC6H_UFLOAT_BLOCK = 143,
+ VK_FORMAT_BC6H_SFLOAT_BLOCK = 144,
+ VK_FORMAT_BC7_UNORM_BLOCK = 145,
+ VK_FORMAT_BC7_SRGB_BLOCK = 146,
+ VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK = 147,
+ VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK = 148,
+ VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK = 149,
+ VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK = 150,
+ VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK = 151,
+ VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK = 152,
+ VK_FORMAT_EAC_R11_UNORM_BLOCK = 153,
+ VK_FORMAT_EAC_R11_SNORM_BLOCK = 154,
+ VK_FORMAT_EAC_R11G11_UNORM_BLOCK = 155,
+ VK_FORMAT_EAC_R11G11_SNORM_BLOCK = 156,
+ VK_FORMAT_ASTC_4x4_UNORM_BLOCK = 157,
+ VK_FORMAT_ASTC_4x4_SRGB_BLOCK = 158,
+ VK_FORMAT_ASTC_5x4_UNORM_BLOCK = 159,
+ VK_FORMAT_ASTC_5x4_SRGB_BLOCK = 160,
+ VK_FORMAT_ASTC_5x5_UNORM_BLOCK = 161,
+ VK_FORMAT_ASTC_5x5_SRGB_BLOCK = 162,
+ VK_FORMAT_ASTC_6x5_UNORM_BLOCK = 163,
+ VK_FORMAT_ASTC_6x5_SRGB_BLOCK = 164,
+ VK_FORMAT_ASTC_6x6_UNORM_BLOCK = 165,
+ VK_FORMAT_ASTC_6x6_SRGB_BLOCK = 166,
+ VK_FORMAT_ASTC_8x5_UNORM_BLOCK = 167,
+ VK_FORMAT_ASTC_8x5_SRGB_BLOCK = 168,
+ VK_FORMAT_ASTC_8x6_UNORM_BLOCK = 169,
+ VK_FORMAT_ASTC_8x6_SRGB_BLOCK = 170,
+ VK_FORMAT_ASTC_8x8_UNORM_BLOCK = 171,
+ VK_FORMAT_ASTC_8x8_SRGB_BLOCK = 172,
+ VK_FORMAT_ASTC_10x5_UNORM_BLOCK = 173,
+ VK_FORMAT_ASTC_10x5_SRGB_BLOCK = 174,
+ VK_FORMAT_ASTC_10x6_UNORM_BLOCK = 175,
+ VK_FORMAT_ASTC_10x6_SRGB_BLOCK = 176,
+ VK_FORMAT_ASTC_10x8_UNORM_BLOCK = 177,
+ VK_FORMAT_ASTC_10x8_SRGB_BLOCK = 178,
+ VK_FORMAT_ASTC_10x10_UNORM_BLOCK = 179,
+ VK_FORMAT_ASTC_10x10_SRGB_BLOCK = 180,
+ VK_FORMAT_ASTC_12x10_UNORM_BLOCK = 181,
+ VK_FORMAT_ASTC_12x10_SRGB_BLOCK = 182,
+ VK_FORMAT_ASTC_12x12_UNORM_BLOCK = 183,
+ VK_FORMAT_ASTC_12x12_SRGB_BLOCK = 184,
+ VK_FORMAT_G8B8G8R8_422_UNORM_KHR = 1000156000,
+ VK_FORMAT_B8G8R8G8_422_UNORM_KHR = 1000156001,
+ VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM_KHR = 1000156002,
+ VK_FORMAT_G8_B8R8_2PLANE_420_UNORM_KHR = 1000156003,
+ VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM_KHR = 1000156004,
+ VK_FORMAT_G8_B8R8_2PLANE_422_UNORM_KHR = 1000156005,
+ VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM_KHR = 1000156006,
+ VK_FORMAT_R10X6_UNORM_PACK16_KHR = 1000156007,
+ VK_FORMAT_R10X6G10X6_UNORM_2PACK16_KHR = 1000156008,
+ VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16_KHR = 1000156009,
+ VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16_KHR = 1000156010,
+ VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16_KHR = 1000156011,
+ VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16_KHR = 1000156012,
+ VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16_KHR = 1000156013,
+ VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16_KHR = 1000156014,
+ VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16_KHR = 1000156015,
+ VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16_KHR = 1000156016,
+ VK_FORMAT_R12X4_UNORM_PACK16_KHR = 1000156017,
+ VK_FORMAT_R12X4G12X4_UNORM_2PACK16_KHR = 1000156018,
+ VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16_KHR = 1000156019,
+ VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16_KHR = 1000156020,
+ VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16_KHR = 1000156021,
+ VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16_KHR = 1000156022,
+ VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16_KHR = 1000156023,
+ VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16_KHR = 1000156024,
+ VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16_KHR = 1000156025,
+ VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16_KHR = 1000156026,
+ VK_FORMAT_G16B16G16R16_422_UNORM_KHR = 1000156027,
+ VK_FORMAT_B16G16R16G16_422_UNORM_KHR = 1000156028,
+ VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM_KHR = 1000156029,
+ VK_FORMAT_G16_B16R16_2PLANE_420_UNORM_KHR = 1000156030,
+ VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM_KHR = 1000156031,
+ VK_FORMAT_G16_B16R16_2PLANE_422_UNORM_KHR = 1000156032,
+ VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM_KHR = 1000156033,
};
enum VkImageType
VK_TESSELLATION_DOMAIN_ORIGIN_KHR_LAST
};
+enum VkSamplerYcbcrModelConversionKHR
+{
+ VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY_KHR = 0,
+ VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY_KHR = 1,
+ VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709_KHR = 2,
+ VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601_KHR = 3,
+ VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020_KHR = 4,
+
+ VK_SAMPLER_YCBCR_MODEL_CONVERSION_KHR_LAST
+};
+
+enum VkSamplerYcbcrRangeKHR
+{
+ VK_SAMPLER_YCBCR_RANGE_ITU_FULL_KHR = 0,
+ VK_SAMPLER_YCBCR_RANGE_ITU_NARROW_KHR = 1,
+
+ VK_SAMPLER_YCBCR_RANGE_KHR_LAST
+};
+
+enum VkChromaLocationKHR
+{
+ VK_CHROMA_LOCATION_COSITED_EVEN_KHR = 0,
+ VK_CHROMA_LOCATION_MIDPOINT_KHR = 1,
+
+ VK_CHROMA_LOCATION_KHR_LAST
+};
+
enum VkDebugReportObjectTypeEXT
{
VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT = 0,
VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT = 29,
VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT = 30,
VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR_EXT = 1000085000,
+ VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR_EXT = 1000156000,
};
enum VkDebugReportErrorEXT
enum VkFormatFeatureFlagBits
{
- VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT = 0x00000001,
- VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT = 0x00000002,
- VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT = 0x00000004,
- VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000008,
- VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT = 0x00000010,
- VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT = 0x00000020,
- VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT = 0x00000040,
- VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT = 0x00000080,
- VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT = 0x00000100,
- VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000200,
- VK_FORMAT_FEATURE_BLIT_SRC_BIT = 0x00000400,
- VK_FORMAT_FEATURE_BLIT_DST_BIT = 0x00000800,
- VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT = 0x00001000,
- VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR = 0x00004000,
- VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR = 0x00008000,
+ VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT = 0x00000001,
+ VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT = 0x00000002,
+ VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT = 0x00000004,
+ VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000008,
+ VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT = 0x00000010,
+ VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT = 0x00000020,
+ VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT = 0x00000040,
+ VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT = 0x00000080,
+ VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT = 0x00000100,
+ VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000200,
+ VK_FORMAT_FEATURE_BLIT_SRC_BIT = 0x00000400,
+ VK_FORMAT_FEATURE_BLIT_DST_BIT = 0x00000800,
+ VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT = 0x00001000,
+ VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR = 0x00004000,
+ VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR = 0x00008000,
+ VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT_KHR = 0x00010000,
+ VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT_KHR = 0x00020000,
+ VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT_KHR = 0x00040000,
+ VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT_KHR = 0x00080000,
+ VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT_KHR = 0x00100000,
+ VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT_KHR = 0x00200000,
+ VK_FORMAT_FEATURE_DISJOINT_BIT_KHR = 0x00400000,
+ VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT_KHR = 0x00800000,
};
typedef deUint32 VkFormatFeatureFlags;
VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_KHR = 0x00000080,
VK_IMAGE_CREATE_EXTENDED_USAGE_BIT_KHR = 0x00000100,
VK_IMAGE_CREATE_ALIAS_BIT_KHR = 0x00000400,
+ VK_IMAGE_CREATE_DISJOINT_BIT_KHR = 0x00000200,
};
typedef deUint32 VkImageCreateFlags;
VK_IMAGE_ASPECT_DEPTH_BIT = 0x00000002,
VK_IMAGE_ASPECT_STENCIL_BIT = 0x00000004,
VK_IMAGE_ASPECT_METADATA_BIT = 0x00000008,
+ VK_IMAGE_ASPECT_PLANE_0_BIT_KHR = 0x00000010,
+ VK_IMAGE_ASPECT_PLANE_1_BIT_KHR = 0x00000020,
+ VK_IMAGE_ASPECT_PLANE_2_BIT_KHR = 0x00000040,
};
typedef deUint32 VkImageAspectFlags;
virtual void getImageMemoryRequirements2KHR (VkDevice device, const VkImageMemoryRequirementsInfo2KHR* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements) const;
virtual void getBufferMemoryRequirements2KHR (VkDevice device, const VkBufferMemoryRequirementsInfo2KHR* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements) const;
virtual void getImageSparseMemoryRequirements2KHR (VkDevice device, const VkImageSparseMemoryRequirementsInfo2KHR* pInfo, deUint32* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2KHR* pSparseMemoryRequirements) const;
+virtual VkResult createSamplerYcbcrConversionKHR (VkDevice device, const VkSamplerYcbcrConversionCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversionKHR* pYcbcrConversion) const;
+virtual void destroySamplerYcbcrConversionKHR (VkDevice device, VkSamplerYcbcrConversionKHR YcbcrConversion, const VkAllocationCallbacks* pAllocator) const;
virtual VkResult getMemoryWin32HandleKHR (VkDevice device, const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, pt::Win32Handle* pHandle) const;
virtual VkResult getMemoryWin32HandlePropertiesKHR (VkDevice device, VkExternalMemoryHandleTypeFlagBitsKHR handleType, pt::Win32Handle handle, VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties) const;
virtual VkResult getMemoryFdKHR (VkDevice device, const VkMemoryGetFdInfoKHR* pGetFdInfo, int* pFd) const;
m_vk.getImageSparseMemoryRequirements2KHR(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
}
+VkResult DeviceDriver::createSamplerYcbcrConversionKHR (VkDevice device, const VkSamplerYcbcrConversionCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversionKHR* pYcbcrConversion) const
+{
+ return m_vk.createSamplerYcbcrConversionKHR(device, pCreateInfo, pAllocator, pYcbcrConversion);
+}
+
+void DeviceDriver::destroySamplerYcbcrConversionKHR (VkDevice device, VkSamplerYcbcrConversionKHR YcbcrConversion, const VkAllocationCallbacks* pAllocator) const
+{
+ m_vk.destroySamplerYcbcrConversionKHR(device, YcbcrConversion, pAllocator);
+}
+
VkResult DeviceDriver::getMemoryWin32HandleKHR (VkDevice device, const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, pt::Win32Handle* pHandle) const
{
return m_vk.getMemoryWin32HandleKHR(device, pGetWin32HandleInfo, pHandle);
GetImageMemoryRequirements2KHRFunc getImageMemoryRequirements2KHR;
GetBufferMemoryRequirements2KHRFunc getBufferMemoryRequirements2KHR;
GetImageSparseMemoryRequirements2KHRFunc getImageSparseMemoryRequirements2KHR;
+CreateSamplerYcbcrConversionKHRFunc createSamplerYcbcrConversionKHR;
+DestroySamplerYcbcrConversionKHRFunc destroySamplerYcbcrConversionKHR;
GetMemoryWin32HandleKHRFunc getMemoryWin32HandleKHR;
GetMemoryWin32HandlePropertiesKHRFunc getMemoryWin32HandlePropertiesKHR;
GetMemoryFdKHRFunc getMemoryFdKHR;
typedef VKAPI_ATTR void (VKAPI_CALL* GetImageMemoryRequirements2KHRFunc) (VkDevice device, const VkImageMemoryRequirementsInfo2KHR* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements);
typedef VKAPI_ATTR void (VKAPI_CALL* GetBufferMemoryRequirements2KHRFunc) (VkDevice device, const VkBufferMemoryRequirementsInfo2KHR* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements);
typedef VKAPI_ATTR void (VKAPI_CALL* GetImageSparseMemoryRequirements2KHRFunc) (VkDevice device, const VkImageSparseMemoryRequirementsInfo2KHR* pInfo, deUint32* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2KHR* pSparseMemoryRequirements);
+typedef VKAPI_ATTR VkResult (VKAPI_CALL* CreateSamplerYcbcrConversionKHRFunc) (VkDevice device, const VkSamplerYcbcrConversionCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversionKHR* pYcbcrConversion);
+typedef VKAPI_ATTR void (VKAPI_CALL* DestroySamplerYcbcrConversionKHRFunc) (VkDevice device, VkSamplerYcbcrConversionKHR YcbcrConversion, const VkAllocationCallbacks* pAllocator);
typedef VKAPI_ATTR VkResult (VKAPI_CALL* CreateDebugReportCallbackEXTFunc) (VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback);
typedef VKAPI_ATTR void (VKAPI_CALL* DestroyDebugReportCallbackEXTFunc) (VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks* pAllocator);
typedef VKAPI_ATTR void (VKAPI_CALL* DebugReportMessageEXTFunc) (VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, deUint64 object, deUintptr location, deInt32 messageCode, const char* pLayerPrefix, const char* pMessage);
--- /dev/null
+/* WARNING: This is auto-generated file. Do not modify, since changes will
+ * be lost! Modify the generating script instead.
+ */
+template<> VkStructureType getStructureType<VkApplicationInfo> (void)
+{
+ return VK_STRUCTURE_TYPE_APPLICATION_INFO;
+}
+
+template<> VkStructureType getStructureType<VkInstanceCreateInfo> (void)
+{
+ return VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
+}
+
+template<> VkStructureType getStructureType<VkDeviceQueueCreateInfo> (void)
+{
+ return VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
+}
+
+template<> VkStructureType getStructureType<VkDeviceCreateInfo> (void)
+{
+ return VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
+}
+
+template<> VkStructureType getStructureType<VkSubmitInfo> (void)
+{
+ return VK_STRUCTURE_TYPE_SUBMIT_INFO;
+}
+
+template<> VkStructureType getStructureType<VkMemoryAllocateInfo> (void)
+{
+ return VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
+}
+
+template<> VkStructureType getStructureType<VkMappedMemoryRange> (void)
+{
+ return VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE;
+}
+
+template<> VkStructureType getStructureType<VkBindSparseInfo> (void)
+{
+ return VK_STRUCTURE_TYPE_BIND_SPARSE_INFO;
+}
+
+template<> VkStructureType getStructureType<VkFenceCreateInfo> (void)
+{
+ return VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
+}
+
+template<> VkStructureType getStructureType<VkSemaphoreCreateInfo> (void)
+{
+ return VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
+}
+
+template<> VkStructureType getStructureType<VkEventCreateInfo> (void)
+{
+ return VK_STRUCTURE_TYPE_EVENT_CREATE_INFO;
+}
+
+template<> VkStructureType getStructureType<VkQueryPoolCreateInfo> (void)
+{
+ return VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO;
+}
+
+template<> VkStructureType getStructureType<VkBufferCreateInfo> (void)
+{
+ return VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
+}
+
+template<> VkStructureType getStructureType<VkBufferViewCreateInfo> (void)
+{
+ return VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO;
+}
+
+template<> VkStructureType getStructureType<VkImageCreateInfo> (void)
+{
+ return VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
+}
+
+template<> VkStructureType getStructureType<VkImageViewCreateInfo> (void)
+{
+ return VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
+}
+
+template<> VkStructureType getStructureType<VkShaderModuleCreateInfo> (void)
+{
+ return VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
+}
+
+template<> VkStructureType getStructureType<VkPipelineCacheCreateInfo> (void)
+{
+ return VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO;
+}
+
+template<> VkStructureType getStructureType<VkPipelineShaderStageCreateInfo> (void)
+{
+ return VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
+}
+
+template<> VkStructureType getStructureType<VkPipelineVertexInputStateCreateInfo> (void)
+{
+ return VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
+}
+
+template<> VkStructureType getStructureType<VkPipelineInputAssemblyStateCreateInfo> (void)
+{
+ return VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
+}
+
+template<> VkStructureType getStructureType<VkPipelineTessellationStateCreateInfo> (void)
+{
+ return VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO;
+}
+
+template<> VkStructureType getStructureType<VkPipelineViewportStateCreateInfo> (void)
+{
+ return VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO;
+}
+
+template<> VkStructureType getStructureType<VkPipelineRasterizationStateCreateInfo> (void)
+{
+ return VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO;
+}
+
+template<> VkStructureType getStructureType<VkPipelineMultisampleStateCreateInfo> (void)
+{
+ return VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;
+}
+
+template<> VkStructureType getStructureType<VkPipelineDepthStencilStateCreateInfo> (void)
+{
+ return VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO;
+}
+
+template<> VkStructureType getStructureType<VkPipelineColorBlendStateCreateInfo> (void)
+{
+ return VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
+}
+
+template<> VkStructureType getStructureType<VkPipelineDynamicStateCreateInfo> (void)
+{
+ return VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO;
+}
+
+template<> VkStructureType getStructureType<VkGraphicsPipelineCreateInfo> (void)
+{
+ return VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
+}
+
+template<> VkStructureType getStructureType<VkComputePipelineCreateInfo> (void)
+{
+ return VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO;
+}
+
+template<> VkStructureType getStructureType<VkPipelineLayoutCreateInfo> (void)
+{
+ return VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
+}
+
+template<> VkStructureType getStructureType<VkSamplerCreateInfo> (void)
+{
+ return VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO;
+}
+
+template<> VkStructureType getStructureType<VkDescriptorSetLayoutCreateInfo> (void)
+{
+ return VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
+}
+
+template<> VkStructureType getStructureType<VkDescriptorPoolCreateInfo> (void)
+{
+ return VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
+}
+
+template<> VkStructureType getStructureType<VkDescriptorSetAllocateInfo> (void)
+{
+ return VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
+}
+
+template<> VkStructureType getStructureType<VkWriteDescriptorSet> (void)
+{
+ return VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
+}
+
+template<> VkStructureType getStructureType<VkCopyDescriptorSet> (void)
+{
+ return VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET;
+}
+
+template<> VkStructureType getStructureType<VkFramebufferCreateInfo> (void)
+{
+ return VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
+}
+
+template<> VkStructureType getStructureType<VkRenderPassCreateInfo> (void)
+{
+ return VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
+}
+
+template<> VkStructureType getStructureType<VkCommandPoolCreateInfo> (void)
+{
+ return VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
+}
+
+template<> VkStructureType getStructureType<VkCommandBufferAllocateInfo> (void)
+{
+ return VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
+}
+
+template<> VkStructureType getStructureType<VkCommandBufferInheritanceInfo> (void)
+{
+ return VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO;
+}
+
+template<> VkStructureType getStructureType<VkCommandBufferBeginInfo> (void)
+{
+ return VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
+}
+
+template<> VkStructureType getStructureType<VkMemoryBarrier> (void)
+{
+ return VK_STRUCTURE_TYPE_MEMORY_BARRIER;
+}
+
+template<> VkStructureType getStructureType<VkBufferMemoryBarrier> (void)
+{
+ return VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER;
+}
+
+template<> VkStructureType getStructureType<VkImageMemoryBarrier> (void)
+{
+ return VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
+}
+
+template<> VkStructureType getStructureType<VkRenderPassBeginInfo> (void)
+{
+ return VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
+}
+
+template<> VkStructureType getStructureType<VkSwapchainCreateInfoKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
+}
+
+template<> VkStructureType getStructureType<VkPresentInfoKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
+}
+
+template<> VkStructureType getStructureType<VkDisplayModeCreateInfoKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR;
+}
+
+template<> VkStructureType getStructureType<VkDisplaySurfaceCreateInfoKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR;
+}
+
+template<> VkStructureType getStructureType<VkDisplayPresentInfoKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR;
+}
+
+template<> VkStructureType getStructureType<VkXlibSurfaceCreateInfoKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR;
+}
+
+template<> VkStructureType getStructureType<VkXcbSurfaceCreateInfoKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR;
+}
+
+template<> VkStructureType getStructureType<VkWaylandSurfaceCreateInfoKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR;
+}
+
+template<> VkStructureType getStructureType<VkMirSurfaceCreateInfoKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_MIR_SURFACE_CREATE_INFO_KHR;
+}
+
+template<> VkStructureType getStructureType<VkAndroidSurfaceCreateInfoKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR;
+}
+
+template<> VkStructureType getStructureType<VkWin32SurfaceCreateInfoKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR;
+}
+
+template<> VkStructureType getStructureType<VkPhysicalDeviceFeatures2KHR> (void)
+{
+ return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR;
+}
+
+template<> VkStructureType getStructureType<VkPhysicalDeviceProperties2KHR> (void)
+{
+ return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR;
+}
+
+template<> VkStructureType getStructureType<VkFormatProperties2KHR> (void)
+{
+ return VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR;
+}
+
+template<> VkStructureType getStructureType<VkImageFormatProperties2KHR> (void)
+{
+ return VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHR;
+}
+
+template<> VkStructureType getStructureType<VkPhysicalDeviceImageFormatInfo2KHR> (void)
+{
+ return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR;
+}
+
+template<> VkStructureType getStructureType<VkQueueFamilyProperties2KHR> (void)
+{
+ return VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2_KHR;
+}
+
+template<> VkStructureType getStructureType<VkPhysicalDeviceMemoryProperties2KHR> (void)
+{
+ return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR;
+}
+
+template<> VkStructureType getStructureType<VkSparseImageFormatProperties2KHR> (void)
+{
+ return VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2_KHR;
+}
+
+template<> VkStructureType getStructureType<VkPhysicalDeviceSparseImageFormatInfo2KHR> (void)
+{
+ return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2_KHR;
+}
+
+template<> VkStructureType getStructureType<VkPhysicalDevicePushDescriptorPropertiesKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR;
+}
+
+template<> VkStructureType getStructureType<VkPhysicalDevice16BitStorageFeaturesKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR;
+}
+
+template<> VkStructureType getStructureType<VkPresentRegionsKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR;
+}
+
+template<> VkStructureType getStructureType<VkDescriptorUpdateTemplateCreateInfoKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR;
+}
+
+template<> VkStructureType getStructureType<VkSharedPresentSurfaceCapabilitiesKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR;
+}
+
+template<> VkStructureType getStructureType<VkPhysicalDevicePointClippingPropertiesKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES_KHR;
+}
+
+template<> VkStructureType getStructureType<VkRenderPassInputAttachmentAspectCreateInfoKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO_KHR;
+}
+
+template<> VkStructureType getStructureType<VkImageViewUsageCreateInfoKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO_KHR;
+}
+
+template<> VkStructureType getStructureType<VkPipelineTessellationDomainOriginStateCreateInfoKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO_KHR;
+}
+
+template<> VkStructureType getStructureType<VkPhysicalDeviceSurfaceInfo2KHR> (void)
+{
+ return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR;
+}
+
+template<> VkStructureType getStructureType<VkSurfaceCapabilities2KHR> (void)
+{
+ return VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR;
+}
+
+template<> VkStructureType getStructureType<VkSurfaceFormat2KHR> (void)
+{
+ return VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR;
+}
+
+template<> VkStructureType getStructureType<VkPhysicalDeviceExternalFenceInfoKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO_KHR;
+}
+
+template<> VkStructureType getStructureType<VkExternalFencePropertiesKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES_KHR;
+}
+
+template<> VkStructureType getStructureType<VkExportFenceCreateInfoKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO_KHR;
+}
+
+template<> VkStructureType getStructureType<VkImportFenceWin32HandleInfoKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR;
+}
+
+template<> VkStructureType getStructureType<VkExportFenceWin32HandleInfoKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR;
+}
+
+template<> VkStructureType getStructureType<VkFenceGetWin32HandleInfoKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR;
+}
+
+template<> VkStructureType getStructureType<VkImportFenceFdInfoKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR;
+}
+
+template<> VkStructureType getStructureType<VkFenceGetFdInfoKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR;
+}
+
+template<> VkStructureType getStructureType<VkMemoryDedicatedRequirementsKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR;
+}
+
+template<> VkStructureType getStructureType<VkMemoryDedicatedAllocateInfoKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR;
+}
+
+template<> VkStructureType getStructureType<VkBufferMemoryRequirementsInfo2KHR> (void)
+{
+ return VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR;
+}
+
+template<> VkStructureType getStructureType<VkImageMemoryRequirementsInfo2KHR> (void)
+{
+ return VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR;
+}
+
+template<> VkStructureType getStructureType<VkImageSparseMemoryRequirementsInfo2KHR> (void)
+{
+ return VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2_KHR;
+}
+
+template<> VkStructureType getStructureType<VkMemoryRequirements2KHR> (void)
+{
+ return VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR;
+}
+
+template<> VkStructureType getStructureType<VkSparseImageMemoryRequirements2KHR> (void)
+{
+ return VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2_KHR;
+}
+
+template<> VkStructureType getStructureType<VkImageFormatListCreateInfoKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO_KHR;
+}
+
+template<> VkStructureType getStructureType<VkSamplerYcbcrConversionCreateInfoKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO_KHR;
+}
+
+template<> VkStructureType getStructureType<VkSamplerYcbcrConversionInfoKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO_KHR;
+}
+
+template<> VkStructureType getStructureType<VkBindImagePlaneMemoryInfoKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO_KHR;
+}
+
+template<> VkStructureType getStructureType<VkImagePlaneMemoryRequirementsInfoKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO_KHR;
+}
+
+template<> VkStructureType getStructureType<VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES_KHR;
+}
+
+template<> VkStructureType getStructureType<VkSamplerYcbcrConversionImageFormatPropertiesKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES_KHR;
+}
+
+template<> VkStructureType getStructureType<VkDebugReportCallbackCreateInfoEXT> (void)
+{
+ return VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT;
+}
+
+template<> VkStructureType getStructureType<VkRenderPassMultiviewCreateInfoKHX> (void)
+{
+ return VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO_KHX;
+}
+
+template<> VkStructureType getStructureType<VkPhysicalDeviceMultiviewFeaturesKHX> (void)
+{
+ return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHX;
+}
+
+template<> VkStructureType getStructureType<VkPhysicalDeviceMultiviewPropertiesKHX> (void)
+{
+ return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHX;
+}
+
+template<> VkStructureType getStructureType<VkPhysicalDeviceExternalImageFormatInfoKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHR;
+}
+
+template<> VkStructureType getStructureType<VkExternalImageFormatPropertiesKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHR;
+}
+
+template<> VkStructureType getStructureType<VkPhysicalDeviceExternalBufferInfoKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHR;
+}
+
+template<> VkStructureType getStructureType<VkExternalBufferPropertiesKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHR;
+}
+
+template<> VkStructureType getStructureType<VkPhysicalDeviceIDPropertiesKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHR;
+}
+
+template<> VkStructureType getStructureType<VkExternalMemoryImageCreateInfoKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHR;
+}
+
+template<> VkStructureType getStructureType<VkExternalMemoryBufferCreateInfoKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHR;
+}
+
+template<> VkStructureType getStructureType<VkExportMemoryAllocateInfoKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHR;
+}
+
+template<> VkStructureType getStructureType<VkImportMemoryWin32HandleInfoKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR;
+}
+
+template<> VkStructureType getStructureType<VkExportMemoryWin32HandleInfoKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR;
+}
+
+template<> VkStructureType getStructureType<VkMemoryWin32HandlePropertiesKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR;
+}
+
+template<> VkStructureType getStructureType<VkMemoryGetWin32HandleInfoKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR;
+}
+
+template<> VkStructureType getStructureType<VkImportMemoryFdInfoKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR;
+}
+
+template<> VkStructureType getStructureType<VkMemoryFdPropertiesKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR;
+}
+
+template<> VkStructureType getStructureType<VkMemoryGetFdInfoKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR;
+}
+
+template<> VkStructureType getStructureType<VkWin32KeyedMutexAcquireReleaseInfoKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR;
+}
+
+template<> VkStructureType getStructureType<VkPhysicalDeviceExternalSemaphoreInfoKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHR;
+}
+
+template<> VkStructureType getStructureType<VkExternalSemaphorePropertiesKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHR;
+}
+
+template<> VkStructureType getStructureType<VkExportSemaphoreCreateInfoKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHR;
+}
+
+template<> VkStructureType getStructureType<VkImportSemaphoreWin32HandleInfoKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR;
+}
+
+template<> VkStructureType getStructureType<VkExportSemaphoreWin32HandleInfoKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR;
+}
+
+template<> VkStructureType getStructureType<VkD3D12FenceSubmitInfoKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR;
+}
+
+template<> VkStructureType getStructureType<VkSemaphoreGetWin32HandleInfoKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR;
+}
+
+template<> VkStructureType getStructureType<VkImportSemaphoreFdInfoKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR;
+}
+
+template<> VkStructureType getStructureType<VkSemaphoreGetFdInfoKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR;
+}
+
+template<> VkStructureType getStructureType<VkPresentTimesInfoGOOGLE> (void)
+{
+ return VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE;
+}
+
+template<> VkStructureType getStructureType<VkPhysicalDeviceVariablePointerFeaturesKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES_KHR;
+}
+
+template<> VkStructureType getStructureType<VkBindBufferMemoryInfoKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHR;
+}
+
+template<> VkStructureType getStructureType<VkBindImageMemoryInfoKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHR;
+}
+
HANDLE_TYPE_DISPLAY_KHR,
HANDLE_TYPE_DISPLAY_MODE_KHR,
HANDLE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR,
+ HANDLE_TYPE_SAMPLER_YCBCR_CONVERSION_KHR,
HANDLE_TYPE_DEBUG_REPORT_CALLBACK_EXT,
HANDLE_TYPE_LAST
};
}
}
+bool isYCbCrFormat (VkFormat format)
+{
+ switch (format)
+ {
+ case VK_FORMAT_G8B8G8R8_422_UNORM_KHR:
+ case VK_FORMAT_B8G8R8G8_422_UNORM_KHR:
+ case VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM_KHR:
+ case VK_FORMAT_G8_B8R8_2PLANE_420_UNORM_KHR:
+ case VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM_KHR:
+ case VK_FORMAT_G8_B8R8_2PLANE_422_UNORM_KHR:
+ case VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM_KHR:
+ case VK_FORMAT_R10X6_UNORM_PACK16_KHR:
+ case VK_FORMAT_R10X6G10X6_UNORM_2PACK16_KHR:
+ case VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16_KHR:
+ case VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16_KHR:
+ case VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16_KHR:
+ case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16_KHR:
+ case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16_KHR:
+ case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16_KHR:
+ case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16_KHR:
+ case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16_KHR:
+ case VK_FORMAT_R12X4_UNORM_PACK16_KHR:
+ case VK_FORMAT_R12X4G12X4_UNORM_2PACK16_KHR:
+ case VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16_KHR:
+ case VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16_KHR:
+ case VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16_KHR:
+ case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16_KHR:
+ case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16_KHR:
+ case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16_KHR:
+ case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16_KHR:
+ case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16_KHR:
+ case VK_FORMAT_G16B16G16R16_422_UNORM_KHR:
+ case VK_FORMAT_B16G16R16G16_422_UNORM_KHR:
+ case VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM_KHR:
+ case VK_FORMAT_G16_B16R16_2PLANE_420_UNORM_KHR:
+ case VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM_KHR:
+ case VK_FORMAT_G16_B16R16_2PLANE_422_UNORM_KHR:
+ case VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM_KHR:
+ return true;
+
+ default:
+ return false;
+ }
+}
+
+const PlanarFormatDescription& getYCbCrPlanarFormatDescription (VkFormat format)
+{
+ using tcu::TextureFormat;
+
+ const deUint32 chanR = PlanarFormatDescription::CHANNEL_R;
+ const deUint32 chanG = PlanarFormatDescription::CHANNEL_G;
+ const deUint32 chanB = PlanarFormatDescription::CHANNEL_B;
+ const deUint32 chanA = PlanarFormatDescription::CHANNEL_A;
+
+ const deUint8 unorm = (deUint8)tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT;
+
+ static const PlanarFormatDescription s_formatInfo[] =
+ {
+ // VK_FORMAT_G8B8G8R8_422_UNORM_KHR
+ {
+ 1, // planes
+ chanR|chanG|chanB,
+ {
+ // Size WDiv HDiv
+ { 4, 2, 1 },
+ { 0, 0, 0 },
+ { 0, 0, 0 },
+ },
+ {
+ // Plane Type Offs Size Stride
+ { 0, unorm, 16, 8, 4 }, // R
+ { 0, unorm, 0, 8, 2 }, // G
+ { 0, unorm, 8, 8, 4 }, // B
+ { 0, 0, 0, 0, 0 }
+ }
+ },
+ // VK_FORMAT_B8G8R8G8_422_UNORM_KHR
+ {
+ 1, // planes
+ chanR|chanG|chanB,
+ {
+ // Size WDiv HDiv
+ { 4, 2, 1 },
+ { 0, 0, 0 },
+ { 0, 0, 0 },
+ },
+ {
+ // Plane Type Offs Size Stride
+ { 0, unorm, 16, 8, 4 }, // R
+ { 0, unorm, 8, 8, 2 }, // G
+ { 0, unorm, 0, 8, 4 }, // B
+ { 0, 0, 0, 0, 0 }
+ }
+ },
+ // VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM_KHR
+ {
+ 3, // planes
+ chanR|chanG|chanB,
+ {
+ // Size WDiv HDiv
+ { 1, 1, 1 },
+ { 1, 2, 2 },
+ { 1, 2, 2 },
+ },
+ {
+ // Plane Type Offs Size Stride
+ { 2, unorm, 0, 8, 1 }, // R
+ { 0, unorm, 0, 8, 1 }, // G
+ { 1, unorm, 0, 8, 1 }, // B
+ { 0, 0, 0, 0, 0 }
+ }
+ },
+ // VK_FORMAT_G8_B8R8_2PLANE_420_UNORM_KHR
+ {
+ 2, // planes
+ chanR|chanG|chanB,
+ {
+ // Size WDiv HDiv
+ { 1, 1, 1 },
+ { 2, 2, 2 },
+ { 0, 0, 0 },
+ },
+ {
+ // Plane Type Offs Size Stride
+ { 1, unorm, 8, 8, 2 }, // R
+ { 0, unorm, 0, 8, 1 }, // G
+ { 1, unorm, 0, 8, 2 }, // B
+ { 0, 0, 0, 0, 0 }
+ }
+ },
+ // VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM_KHR
+ {
+ 3, // planes
+ chanR|chanG|chanB,
+ {
+ // Size WDiv HDiv
+ { 1, 1, 1 },
+ { 1, 2, 1 },
+ { 1, 2, 1 },
+ },
+ {
+ // Plane Type Offs Size Stride
+ { 2, unorm, 0, 8, 1 }, // R
+ { 0, unorm, 0, 8, 1 }, // G
+ { 1, unorm, 0, 8, 1 }, // B
+ { 0, 0, 0, 0, 0 }
+ }
+ },
+ // VK_FORMAT_G8_B8R8_2PLANE_422_UNORM_KHR
+ {
+ 2, // planes
+ chanR|chanG|chanB,
+ {
+ // Size WDiv HDiv
+ { 1, 1, 1 },
+ { 2, 2, 1 },
+ { 0, 0, 0 },
+ },
+ {
+ // Plane Type Offs Size Stride
+ { 1, unorm, 8, 8, 2 }, // R
+ { 0, unorm, 0, 8, 1 }, // G
+ { 1, unorm, 0, 8, 2 }, // B
+ { 0, 0, 0, 0, 0 }
+ }
+ },
+ // VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM_KHR
+ {
+ 3, // planes
+ chanR|chanG|chanB,
+ {
+ // Size WDiv HDiv
+ { 1, 1, 1 },
+ { 1, 1, 1 },
+ { 1, 1, 1 },
+ },
+ {
+ // Plane Type Offs Size Stride
+ { 2, unorm, 0, 8, 1 }, // R
+ { 0, unorm, 0, 8, 1 }, // G
+ { 1, unorm, 0, 8, 1 }, // B
+ { 0, 0, 0, 0, 0 }
+ }
+ },
+ // VK_FORMAT_R10X6_UNORM_PACK16_KHR
+ {
+ 1, // planes
+ chanR,
+ {
+ // Size WDiv HDiv
+ { 2, 1, 1 },
+ { 0, 0, 0 },
+ { 0, 0, 0 },
+ },
+ {
+ // Plane Type Offs Size Stride
+ { 0, unorm, 6, 10, 2 }, // R
+ { 0, 0, 0, 0, 0 },
+ { 0, 0, 0, 0, 0 },
+ { 0, 0, 0, 0, 0 },
+ }
+ },
+ // VK_FORMAT_R10X6G10X6_UNORM_2PACK16_KHR
+ {
+ 1, // planes
+ chanR|chanG,
+ {
+ // Size WDiv HDiv
+ { 4, 1, 1 },
+ { 0, 0, 0 },
+ { 0, 0, 0 },
+ },
+ {
+ // Plane Type Offs Size Stride
+ { 0, unorm, 6, 10, 4 }, // R
+ { 0, unorm, 22, 10, 4 }, // G
+ { 0, 0, 0, 0, 0 },
+ { 0, 0, 0, 0, 0 },
+ }
+ },
+ // VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16_KHR
+ {
+ 1, // planes
+ chanR|chanG|chanB|chanA,
+ {
+ // Size WDiv HDiv
+ { 8, 1, 1 },
+ { 0, 0, 0 },
+ { 0, 0, 0 },
+ },
+ {
+ // Plane Type Offs Size Stride
+ { 0, unorm, 6, 10, 8 }, // R
+ { 0, unorm, 22, 10, 8 }, // G
+ { 0, unorm, 38, 10, 8 }, // B
+ { 0, unorm, 54, 10, 8 }, // A
+ }
+ },
+ // VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16_KHR
+ {
+ 1, // planes
+ chanR|chanG|chanB,
+ {
+ // Size WDiv HDiv
+ { 8, 2, 1 },
+ { 0, 0, 0 },
+ { 0, 0, 0 },
+ },
+ {
+ // Plane Type Offs Size Stride
+ { 0, unorm, 54, 10, 8 }, // R
+ { 0, unorm, 6, 10, 4 }, // G
+ { 0, unorm, 22, 10, 8 }, // B
+ { 0, 0, 0, 0, 0 }
+ }
+ },
+ // VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16_KHR
+ {
+ 1, // planes
+ chanR|chanG|chanB,
+ {
+ // Size WDiv HDiv
+ { 8, 2, 1 },
+ { 0, 0, 0 },
+ { 0, 0, 0 },
+ },
+ {
+ // Plane Type Offs Size Stride
+ { 0, unorm, 38, 10, 8 }, // R
+ { 0, unorm, 22, 10, 4 }, // G
+ { 0, unorm, 6, 10, 8 }, // B
+ { 0, 0, 0, 0, 0 }
+ }
+ },
+ // VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16_KHR
+ {
+ 3, // planes
+ chanR|chanG|chanB,
+ {
+ // Size WDiv HDiv
+ { 2, 1, 1 },
+ { 2, 2, 2 },
+ { 2, 2, 2 },
+ },
+ {
+ // Plane Type Offs Size Stride
+ { 2, unorm, 6, 10, 2 }, // R
+ { 0, unorm, 6, 10, 2 }, // G
+ { 1, unorm, 6, 10, 2 }, // B
+ { 0, 0, 0, 0, 0 }
+ }
+ },
+ // VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16_KHR
+ {
+ 2, // planes
+ chanR|chanG|chanB,
+ {
+ // Size WDiv HDiv
+ { 2, 1, 1 },
+ { 4, 2, 2 },
+ { 0, 0, 0 },
+ },
+ {
+ // Plane Type Offs Size Stride
+ { 1, unorm, 22, 10, 4 }, // R
+ { 0, unorm, 6, 10, 2 }, // G
+ { 1, unorm, 6, 10, 4 }, // B
+ { 0, 0, 0, 0, 0 }
+ }
+ },
+ // VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16_KHR
+ {
+ 3, // planes
+ chanR|chanG|chanB,
+ {
+ // Size WDiv HDiv
+ { 2, 1, 1 },
+ { 2, 2, 1 },
+ { 2, 2, 1 },
+ },
+ {
+ // Plane Type Offs Size Stride
+ { 2, unorm, 6, 10, 2 }, // R
+ { 0, unorm, 6, 10, 2 }, // G
+ { 1, unorm, 6, 10, 2 }, // B
+ { 0, 0, 0, 0, 0 }
+ }
+ },
+ // VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16_KHR
+ {
+ 2, // planes
+ chanR|chanG|chanB,
+ {
+ // Size WDiv HDiv
+ { 2, 1, 1 },
+ { 4, 2, 1 },
+ { 0, 0, 0 },
+ },
+ {
+ // Plane Type Offs Size Stride
+ { 1, unorm, 22, 10, 4 }, // R
+ { 0, unorm, 6, 10, 2 }, // G
+ { 1, unorm, 6, 10, 4 }, // B
+ { 0, 0, 0, 0, 0 }
+ }
+ },
+ // VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16_KHR
+ {
+ 3, // planes
+ chanR|chanG|chanB,
+ {
+ // Size WDiv HDiv
+ { 2, 1, 1 },
+ { 2, 1, 1 },
+ { 2, 1, 1 },
+ },
+ {
+ // Plane Type Offs Size Stride
+ { 2, unorm, 6, 10, 2 }, // R
+ { 0, unorm, 6, 10, 2 }, // G
+ { 1, unorm, 6, 10, 2 }, // B
+ { 0, 0, 0, 0, 0 }
+ }
+ },
+ // VK_FORMAT_R12X4_UNORM_PACK16_KHR
+ {
+ 1, // planes
+ chanR,
+ {
+ // Size WDiv HDiv
+ { 2, 1, 1 },
+ { 0, 0, 0 },
+ { 0, 0, 0 },
+ },
+ {
+ // Plane Type Offs Size Stride
+ { 0, unorm, 4, 12, 2 }, // R
+ { 0, 0, 0, 0, 0 },
+ { 0, 0, 0, 0, 0 },
+ { 0, 0, 0, 0, 0 },
+ }
+ },
+ // VK_FORMAT_R12X4G12X4_UNORM_2PACK16_KHR
+ {
+ 1, // planes
+ chanR|chanG,
+ {
+ // Size WDiv HDiv
+ { 4, 1, 1 },
+ { 0, 0, 0 },
+ { 0, 0, 0 },
+ },
+ {
+ // Plane Type Offs Size Stride
+ { 0, unorm, 4, 12, 4 }, // R
+ { 0, unorm, 20, 12, 4 }, // G
+ { 0, 0, 0, 0, 0 },
+ { 0, 0, 0, 0, 0 },
+ }
+ },
+ // VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16_KHR
+ {
+ 1, // planes
+ chanR|chanG|chanB|chanA,
+ {
+ // Size WDiv HDiv
+ { 8, 1, 1 },
+ { 0, 0, 0 },
+ { 0, 0, 0 },
+ },
+ {
+ // Plane Type Offs Size Stride
+ { 0, unorm, 4, 12, 8 }, // R
+ { 0, unorm, 20, 12, 8 }, // G
+ { 0, unorm, 36, 12, 8 }, // B
+ { 0, unorm, 52, 12, 8 }, // A
+ }
+ },
+ // VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16_KHR
+ {
+ 1, // planes
+ chanR|chanG|chanB,
+ {
+ // Size WDiv HDiv
+ { 8, 2, 1 },
+ { 0, 0, 0 },
+ { 0, 0, 0 },
+ },
+ {
+ // Plane Type Offs Size Stride
+ { 0, unorm, 52, 12, 8 }, // R
+ { 0, unorm, 4, 12, 4 }, // G
+ { 0, unorm, 20, 12, 8 }, // B
+ { 0, 0, 0, 0, 0 }
+ }
+ },
+ // VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16_KHR
+ {
+ 1, // planes
+ chanR|chanG|chanB,
+ {
+ // Size WDiv HDiv
+ { 8, 2, 1 },
+ { 0, 0, 0 },
+ { 0, 0, 0 },
+ },
+ {
+ // Plane Type Offs Size Stride
+ { 0, unorm, 36, 12, 8 }, // R
+ { 0, unorm, 20, 12, 4 }, // G
+ { 0, unorm, 4, 12, 8 }, // B
+ { 0, 0, 0, 0, 0 }
+ }
+ },
+ // VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16_KHR
+ {
+ 3, // planes
+ chanR|chanG|chanB,
+ {
+ // Size WDiv HDiv
+ { 2, 1, 1 },
+ { 2, 2, 2 },
+ { 2, 2, 2 },
+ },
+ {
+ // Plane Type Offs Size Stride
+ { 2, unorm, 4, 12, 2 }, // R
+ { 0, unorm, 4, 12, 2 }, // G
+ { 1, unorm, 4, 12, 2 }, // B
+ { 0, 0, 0, 0, 0 }
+ }
+ },
+ // VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16_KHR
+ {
+ 2, // planes
+ chanR|chanG|chanB,
+ {
+ // Size WDiv HDiv
+ { 2, 1, 1 },
+ { 4, 2, 2 },
+ { 0, 0, 0 },
+ },
+ {
+ // Plane Type Offs Size Stride
+ { 1, unorm, 20, 12, 4 }, // R
+ { 0, unorm, 4, 12, 2 }, // G
+ { 1, unorm, 4, 12, 4 }, // B
+ { 0, 0, 0, 0, 0 }
+ }
+ },
+ // VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16_KHR
+ {
+ 3, // planes
+ chanR|chanG|chanB,
+ {
+ // Size WDiv HDiv
+ { 2, 1, 1 },
+ { 2, 2, 1 },
+ { 2, 2, 1 },
+ },
+ {
+ // Plane Type Offs Size Stride
+ { 2, unorm, 4, 12, 2 }, // R
+ { 0, unorm, 4, 12, 2 }, // G
+ { 1, unorm, 4, 12, 2 }, // B
+ { 0, 0, 0, 0, 0 }
+ }
+ },
+ // VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16_KHR
+ {
+ 2, // planes
+ chanR|chanG|chanB,
+ {
+ // Size WDiv HDiv
+ { 2, 1, 1 },
+ { 4, 2, 1 },
+ { 0, 0, 0 },
+ },
+ {
+ // Plane Type Offs Size Stride
+ { 1, unorm, 20, 12, 4 }, // R
+ { 0, unorm, 4, 12, 2 }, // G
+ { 1, unorm, 4, 12, 4 }, // B
+ { 0, 0, 0, 0, 0 }
+ }
+ },
+ // VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16_KHR
+ {
+ 3, // planes
+ chanR|chanG|chanB,
+ {
+ // Size WDiv HDiv
+ { 2, 1, 1 },
+ { 2, 1, 1 },
+ { 2, 1, 1 },
+ },
+ {
+ // Plane Type Offs Size Stride
+ { 2, unorm, 4, 12, 2 }, // R
+ { 0, unorm, 4, 12, 2 }, // G
+ { 1, unorm, 4, 12, 2 }, // B
+ { 0, 0, 0, 0, 0 }
+ }
+ },
+ // VK_FORMAT_G16B16G16R16_422_UNORM_KHR
+ {
+ 1, // planes
+ chanR|chanG|chanB,
+ {
+ // Size WDiv HDiv
+ { 8, 2, 1 },
+ { 0, 0, 0 },
+ { 0, 0, 0 },
+ },
+ {
+ // Plane Type Offs Size Stride
+ { 0, unorm, 48, 16, 8 }, // R
+ { 0, unorm, 0, 16, 4 }, // G
+ { 0, unorm, 16, 16, 8 }, // B
+ { 0, 0, 0, 0, 0 }
+ }
+ },
+ // VK_FORMAT_B16G16R16G16_422_UNORM_KHR
+ {
+ 1, // planes
+ chanR|chanG|chanB,
+ {
+ // Size WDiv HDiv
+ { 8, 2, 1 },
+ { 0, 0, 0 },
+ { 0, 0, 0 },
+ },
+ {
+ // Plane Type Offs Size Stride
+ { 0, unorm, 32, 16, 8 }, // R
+ { 0, unorm, 16, 16, 4 }, // G
+ { 0, unorm, 0, 16, 8 }, // B
+ { 0, 0, 0, 0, 0 }
+ }
+ },
+ // VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM_KHR
+ {
+ 3, // planes
+ chanR|chanG|chanB,
+ {
+ // Size WDiv HDiv
+ { 2, 1, 1 },
+ { 2, 2, 2 },
+ { 2, 2, 2 },
+ },
+ {
+ // Plane Type Offs Size Stride
+ { 2, unorm, 0, 16, 2 }, // R
+ { 0, unorm, 0, 16, 2 }, // G
+ { 1, unorm, 0, 16, 2 }, // B
+ { 0, 0, 0, 0, 0 }
+ }
+ },
+ // VK_FORMAT_G16_B16R16_2PLANE_420_UNORM_KHR
+ {
+ 2, // planes
+ chanR|chanG|chanB,
+ {
+ // Size WDiv HDiv
+ { 2, 1, 1 },
+ { 4, 2, 2 },
+ { 0, 0, 0 },
+ },
+ {
+ // Plane Type Offs Size Stride
+ { 1, unorm, 16, 16, 4 }, // R
+ { 0, unorm, 0, 16, 2 }, // G
+ { 1, unorm, 0, 16, 4 }, // B
+ { 0, 0, 0, 0, 0 }
+ }
+ },
+ // VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM_KHR
+ {
+ 3, // planes
+ chanR|chanG|chanB,
+ {
+ // Size WDiv HDiv
+ { 2, 1, 1 },
+ { 2, 2, 1 },
+ { 2, 2, 1 },
+ },
+ {
+ // Plane Type Offs Size Stride
+ { 2, unorm, 0, 16, 2 }, // R
+ { 0, unorm, 0, 16, 2 }, // G
+ { 1, unorm, 0, 16, 2 }, // B
+ { 0, 0, 0, 0, 0 }
+ }
+ },
+ // VK_FORMAT_G16_B16R16_2PLANE_422_UNORM_KHR
+ {
+ 2, // planes
+ chanR|chanG|chanB,
+ {
+ // Size WDiv HDiv
+ { 2, 1, 1 },
+ { 4, 2, 1 },
+ { 0, 0, 0 },
+ },
+ {
+ // Plane Type Offs Size Stride
+ { 1, unorm, 16, 16, 4 }, // R
+ { 0, unorm, 0, 16, 2 }, // G
+ { 1, unorm, 0, 16, 4 }, // B
+ { 0, 0, 0, 0, 0 }
+ }
+ },
+ // VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM_KHR
+ {
+ 3, // planes
+ chanR|chanG|chanB,
+ {
+ // Size WDiv HDiv
+ { 2, 1, 1 },
+ { 2, 1, 1 },
+ { 2, 1, 1 },
+ },
+ {
+ // Plane Type Offs Size Stride
+ { 2, unorm, 0, 16, 2 }, // R
+ { 0, unorm, 0, 16, 2 }, // G
+ { 1, unorm, 0, 16, 2 }, // B
+ { 0, 0, 0, 0, 0 }
+ }
+ },
+ };
+
+ const size_t offset = (size_t)VK_FORMAT_G8B8G8R8_422_UNORM_KHR;
+
+ DE_ASSERT(de::inBounds<size_t>((size_t)format, offset, offset+(size_t)DE_LENGTH_OF_ARRAY(s_formatInfo)));
+
+ return s_formatInfo[(size_t)format-offset];
+}
+
+PlanarFormatDescription getCorePlanarFormatDescription (VkFormat format)
+{
+ const deUint8 unorm = (deUint8)tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT;
+
+ const deUint8 chanR = (deUint8)PlanarFormatDescription::CHANNEL_R;
+ const deUint8 chanG = (deUint8)PlanarFormatDescription::CHANNEL_G;
+ const deUint8 chanB = (deUint8)PlanarFormatDescription::CHANNEL_B;
+ const deUint8 chanA = (deUint8)PlanarFormatDescription::CHANNEL_A;
+
+ DE_ASSERT(de::inBounds<deUint32>(format, VK_FORMAT_UNDEFINED+1, VK_CORE_FORMAT_LAST));
+
+ switch (format)
+ {
+ case VK_FORMAT_R8G8B8A8_UNORM:
+ {
+ const PlanarFormatDescription desc =
+ {
+ 1, // planes
+ chanR|chanG|chanB|chanA,
+ {
+ // Size WDiv HDiv
+ { 4, 1, 1 },
+ { 0, 0, 0 },
+ { 0, 0, 0 },
+ },
+ {
+ // Plane Type Offs Size Stride
+ { 0, unorm, 0, 8, 4 }, // R
+ { 0, unorm, 8, 8, 4 }, // G
+ { 0, unorm, 16, 8, 4 }, // B
+ { 0, unorm, 24, 8, 4 } // A
+ }
+ };
+ return desc;
+ }
+
+ default:
+ TCU_THROW(InternalError, "Not implemented");
+ }
+}
+
+PlanarFormatDescription getPlanarFormatDescription (VkFormat format)
+{
+ if (isYCbCrFormat(format))
+ return getYCbCrPlanarFormatDescription(format);
+ else
+ return getCorePlanarFormatDescription(format);
+}
+
+int getPlaneCount (VkFormat format)
+{
+ switch (format)
+ {
+ case VK_FORMAT_G8B8G8R8_422_UNORM_KHR:
+ case VK_FORMAT_B8G8R8G8_422_UNORM_KHR:
+ case VK_FORMAT_R10X6_UNORM_PACK16_KHR:
+ case VK_FORMAT_R10X6G10X6_UNORM_2PACK16_KHR:
+ case VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16_KHR:
+ case VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16_KHR:
+ case VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16_KHR:
+ case VK_FORMAT_R12X4_UNORM_PACK16_KHR:
+ case VK_FORMAT_R12X4G12X4_UNORM_2PACK16_KHR:
+ case VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16_KHR:
+ case VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16_KHR:
+ case VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16_KHR:
+ case VK_FORMAT_G16B16G16R16_422_UNORM_KHR:
+ case VK_FORMAT_B16G16R16G16_422_UNORM_KHR:
+ return 1;
+
+ case VK_FORMAT_G8_B8R8_2PLANE_420_UNORM_KHR:
+ case VK_FORMAT_G8_B8R8_2PLANE_422_UNORM_KHR:
+ case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16_KHR:
+ case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16_KHR:
+ case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16_KHR:
+ case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16_KHR:
+ case VK_FORMAT_G16_B16R16_2PLANE_420_UNORM_KHR:
+ case VK_FORMAT_G16_B16R16_2PLANE_422_UNORM_KHR:
+ return 2;
+
+ case VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM_KHR:
+ case VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM_KHR:
+ case VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM_KHR:
+ case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16_KHR:
+ case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16_KHR:
+ case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16_KHR:
+ case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16_KHR:
+ case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16_KHR:
+ case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16_KHR:
+ case VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM_KHR:
+ case VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM_KHR:
+ case VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM_KHR:
+ return 3;
+
+ default:
+ DE_FATAL("Not YCbCr format");
+ return 0;
+ }
+}
+
+VkImageAspectFlagBits getPlaneAspect (deUint32 planeNdx)
+{
+ DE_ASSERT(de::inBounds(planeNdx, 0u, 3u));
+ return (VkImageAspectFlagBits)(VK_IMAGE_ASPECT_PLANE_0_BIT_KHR << planeNdx);
+}
+
+deUint32 getAspectPlaneNdx (VkImageAspectFlagBits flags)
+{
+ switch (flags)
+ {
+ case VK_IMAGE_ASPECT_PLANE_0_BIT_KHR: return 0;
+ case VK_IMAGE_ASPECT_PLANE_1_BIT_KHR: return 1;
+ case VK_IMAGE_ASPECT_PLANE_2_BIT_KHR: return 2;
+ default:
+ DE_FATAL("Invalid plane aspect");
+ return 0;
+ }
+}
+
bool isSupportedByFramework (VkFormat format)
{
if (format == VK_FORMAT_UNDEFINED || format > VK_CORE_FORMAT_LAST)
case FMT_CASE(DS, UNSIGNED_INT_24_8_REV): return VK_FORMAT_D24_UNORM_S8_UINT;
case FMT_CASE(DS, FLOAT_UNSIGNED_INT_24_8_REV): return VK_FORMAT_D32_SFLOAT_S8_UINT;
+
+ case FMT_CASE(R, UNORM_SHORT_10): return VK_FORMAT_R10X6_UNORM_PACK16_KHR;
+ case FMT_CASE(RG, UNORM_SHORT_10): return VK_FORMAT_R10X6G10X6_UNORM_2PACK16_KHR;
+ case FMT_CASE(RGBA, UNORM_SHORT_10): return VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16_KHR;
+
+ case FMT_CASE(R, UNORM_SHORT_12): return VK_FORMAT_R12X4_UNORM_PACK16_KHR;
+ case FMT_CASE(RG, UNORM_SHORT_12): return VK_FORMAT_R12X4G12X4_UNORM_2PACK16_KHR;
+ case FMT_CASE(RGBA, UNORM_SHORT_12): return VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16_KHR;
+
default:
TCU_THROW(InternalError, "Unknown texture format");
}
case VK_FORMAT_A2B10G10R10_UINT_PACK32: return TextureFormat(TextureFormat::RGBA, TextureFormat::UNSIGNED_INT_1010102_REV);
case VK_FORMAT_A2B10G10R10_SINT_PACK32: return TextureFormat(TextureFormat::RGBA, TextureFormat::SIGNED_INT_1010102_REV);
+ // YCbCr formats that can be mapped
+ case VK_FORMAT_R10X6_UNORM_PACK16_KHR: return TextureFormat(TextureFormat::R, TextureFormat::UNORM_SHORT_10);
+ case VK_FORMAT_R10X6G10X6_UNORM_2PACK16_KHR: return TextureFormat(TextureFormat::RG, TextureFormat::UNORM_SHORT_10);
+ case VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16_KHR: return TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_SHORT_10);
+
+ case VK_FORMAT_R12X4_UNORM_PACK16_KHR: return TextureFormat(TextureFormat::R, TextureFormat::UNORM_SHORT_12);
+ case VK_FORMAT_R12X4G12X4_UNORM_2PACK16_KHR: return TextureFormat(TextureFormat::RG, TextureFormat::UNORM_SHORT_12);
+ case VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16_KHR: return TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_SHORT_12);
default:
TCU_THROW(InternalError, "Unknown image format");
}
}
+tcu::TextureFormat getChannelAccessFormat (tcu::TextureChannelClass type,
+ deUint32 offsetBits,
+ deUint32 sizeBits)
+{
+ using tcu::TextureFormat;
+
+ if (offsetBits == 0)
+ {
+ static const TextureFormat::ChannelType s_size8[tcu::TEXTURECHANNELCLASS_LAST] =
+ {
+ TextureFormat::SNORM_INT8, // snorm
+ TextureFormat::UNORM_INT8, // unorm
+ TextureFormat::SIGNED_INT8, // sint
+ TextureFormat::UNSIGNED_INT8, // uint
+ TextureFormat::CHANNELTYPE_LAST, // float
+ };
+ static const TextureFormat::ChannelType s_size16[tcu::TEXTURECHANNELCLASS_LAST] =
+ {
+ TextureFormat::SNORM_INT16, // snorm
+ TextureFormat::UNORM_INT16, // unorm
+ TextureFormat::SIGNED_INT16, // sint
+ TextureFormat::UNSIGNED_INT16, // uint
+ TextureFormat::HALF_FLOAT, // float
+ };
+ static const TextureFormat::ChannelType s_size32[tcu::TEXTURECHANNELCLASS_LAST] =
+ {
+ TextureFormat::SNORM_INT32, // snorm
+ TextureFormat::UNORM_INT32, // unorm
+ TextureFormat::SIGNED_INT32, // sint
+ TextureFormat::UNSIGNED_INT32, // uint
+ TextureFormat::FLOAT, // float
+ };
+
+ TextureFormat::ChannelType chnType = TextureFormat::CHANNELTYPE_LAST;
+
+ if (sizeBits == 8)
+ chnType = s_size8[type];
+ else if (sizeBits == 16)
+ chnType = s_size16[type];
+ else if (sizeBits == 32)
+ chnType = s_size32[type];
+
+ if (chnType != TextureFormat::CHANNELTYPE_LAST)
+ return TextureFormat(TextureFormat::R, chnType);
+ }
+ else
+ {
+ if (type == tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT &&
+ offsetBits == 6 &&
+ sizeBits == 10)
+ return TextureFormat(TextureFormat::R, TextureFormat::UNORM_SHORT_10);
+ else if (type == tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT &&
+ offsetBits == 4 &&
+ sizeBits == 12)
+ return TextureFormat(TextureFormat::R, TextureFormat::UNORM_SHORT_12);
+ }
+
+ TCU_THROW(InternalError, "Channel access format is not supported");
+}
+
+tcu::PixelBufferAccess getChannelAccess (const PlanarFormatDescription& formatInfo,
+ const tcu::UVec2& size,
+ const deUint32* planeRowPitches,
+ void* const* planePtrs,
+ deUint32 channelNdx)
+{
+ DE_ASSERT(formatInfo.hasChannelNdx(channelNdx));
+
+ const deUint32 planeNdx = formatInfo.channels[channelNdx].planeNdx;
+ const deUint32 planeOffsetBytes = formatInfo.channels[channelNdx].offsetBits / 8;
+ const deUint32 valueOffsetBits = formatInfo.channels[channelNdx].offsetBits % 8;
+ const deUint32 pixelStrideBytes = formatInfo.channels[channelNdx].strideBytes;
+
+ DE_ASSERT(size.x() % formatInfo.planes[planeNdx].widthDivisor == 0);
+ DE_ASSERT(size.y() % formatInfo.planes[planeNdx].heightDivisor == 0);
+
+ deUint32 accessWidth = size.x() / formatInfo.planes[planeNdx].widthDivisor;
+ const deUint32 accessHeight = size.y() / formatInfo.planes[planeNdx].heightDivisor;
+ const deUint32 elementSizeBytes = formatInfo.planes[planeNdx].elementSizeBytes;
+
+ const deUint32 rowPitch = planeRowPitches[planeNdx];
+
+ if (pixelStrideBytes != elementSizeBytes)
+ {
+ DE_ASSERT(elementSizeBytes % pixelStrideBytes == 0);
+ accessWidth *= elementSizeBytes/pixelStrideBytes;
+ }
+
+ return tcu::PixelBufferAccess(getChannelAccessFormat((tcu::TextureChannelClass)formatInfo.channels[channelNdx].type,
+ valueOffsetBits,
+ formatInfo.channels[channelNdx].sizeBits),
+ tcu::IVec3((int)accessWidth, (int)accessHeight, 1),
+ tcu::IVec3((int)pixelStrideBytes, (int)rowPitch, 0),
+ (deUint8*)planePtrs[planeNdx] + planeOffsetBytes);
+}
+
+
+tcu::ConstPixelBufferAccess getChannelAccess (const PlanarFormatDescription& formatInfo,
+ const tcu::UVec2& size,
+ const deUint32* planeRowPitches,
+ const void* const* planePtrs,
+ deUint32 channelNdx)
+{
+ return getChannelAccess(formatInfo, size, planeRowPitches, const_cast<void* const*>(planePtrs), channelNdx);
+}
+
void imageUtilSelfTest (void)
{
for (int formatNdx = 0; formatNdx < VK_CORE_FORMAT_LAST; formatNdx++)
DE_TEST_ASSERT(format == remappedFormat);
}
}
+
+ for (int formatNdx = VK_FORMAT_G8B8G8R8_422_UNORM_KHR; formatNdx <= VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM_KHR; formatNdx++)
+ {
+ const VkFormat format = (VkFormat)formatNdx;
+ const PlanarFormatDescription& info = getPlanarFormatDescription(format);
+
+ DE_TEST_ASSERT(isYCbCrFormat(format));
+ DE_TEST_ASSERT(de::inRange<deUint8>(info.numPlanes, 1u, 3u));
+ DE_TEST_ASSERT(info.numPlanes == getPlaneCount(format));
+ }
}
VkFilter mapFilterMode (tcu::Sampler::FilterMode filterMode)
void imageUtilSelfTest (void);
+// \todo [2017-05-18 pyry] Consider moving this to tcu
+struct PlanarFormatDescription
+{
+ enum
+ {
+ MAX_CHANNELS = 4,
+ MAX_PLANES = 3
+ };
+
+ enum ChannelFlags
+ {
+ CHANNEL_R = (1u<<0), // Has "R" (0) channel
+ CHANNEL_G = (1u<<1), // Has "G" (1) channel
+ CHANNEL_B = (1u<<2), // Has "B" (2) channel
+ CHANNEL_A = (1u<<3), // Has "A" (3) channel
+ };
+
+ struct Plane
+ {
+ deUint8 elementSizeBytes;
+ deUint8 widthDivisor;
+ deUint8 heightDivisor;
+ };
+
+ struct Channel
+ {
+ deUint8 planeNdx;
+ deUint8 type; // tcu::TextureChannelClass value
+ deUint8 offsetBits; // Offset in element in bits
+ deUint8 sizeBits; // Value size in bits
+ deUint8 strideBytes; // Pixel stride (in bytes), usually plane elementSize
+ };
+
+ deUint8 numPlanes;
+ deUint8 presentChannels;
+ Plane planes[MAX_PLANES];
+ Channel channels[MAX_CHANNELS];
+
+ inline bool hasChannelNdx (deUint32 ndx) const
+ {
+ DE_ASSERT(de::inBounds(ndx, 0u, 4u));
+ return (presentChannels & (1u<<ndx)) != 0;
+ }
+};
+
+bool isYCbCrFormat (VkFormat format);
+PlanarFormatDescription getPlanarFormatDescription (VkFormat format);
+const PlanarFormatDescription& getYCbCrPlanarFormatDescription (VkFormat format);
+int getPlaneCount (VkFormat format);
+VkImageAspectFlagBits getPlaneAspect (deUint32 planeNdx);
+deUint32 getAspectPlaneNdx (VkImageAspectFlagBits planeAspect);
+
+tcu::PixelBufferAccess getChannelAccess (const PlanarFormatDescription& formatInfo,
+ const tcu::UVec2& size,
+ const deUint32* planeRowPitches,
+ void* const* planePtrs,
+ deUint32 channelNdx);
+tcu::ConstPixelBufferAccess getChannelAccess (const PlanarFormatDescription& formatInfo,
+ const tcu::UVec2& size,
+ const deUint32* planeRowPitches,
+ const void* const* planePtrs,
+ deUint32 channelNdx);
+
} // vk
#endif // _VKIMAGEUTIL_HPP
m_vk.getImageMemoryRequirements2KHR = (GetImageMemoryRequirements2KHRFunc) GET_PROC_ADDR("vkGetImageMemoryRequirements2KHR");
m_vk.getBufferMemoryRequirements2KHR = (GetBufferMemoryRequirements2KHRFunc) GET_PROC_ADDR("vkGetBufferMemoryRequirements2KHR");
m_vk.getImageSparseMemoryRequirements2KHR = (GetImageSparseMemoryRequirements2KHRFunc) GET_PROC_ADDR("vkGetImageSparseMemoryRequirements2KHR");
+m_vk.createSamplerYcbcrConversionKHR = (CreateSamplerYcbcrConversionKHRFunc) GET_PROC_ADDR("vkCreateSamplerYcbcrConversionKHR");
+m_vk.destroySamplerYcbcrConversionKHR = (DestroySamplerYcbcrConversionKHRFunc) GET_PROC_ADDR("vkDestroySamplerYcbcrConversionKHR");
m_vk.getMemoryWin32HandleKHR = (GetMemoryWin32HandleKHRFunc) GET_PROC_ADDR("vkGetMemoryWin32HandleKHR");
m_vk.getMemoryWin32HandlePropertiesKHR = (GetMemoryWin32HandlePropertiesKHRFunc) GET_PROC_ADDR("vkGetMemoryWin32HandlePropertiesKHR");
m_vk.getMemoryFdKHR = (GetMemoryFdKHRFunc) GET_PROC_ADDR("vkGetMemoryFdKHR");
return compatibleTypes;
}
+void bindImagePlaneMemory (const DeviceInterface& vkd,
+ VkDevice device,
+ VkImage image,
+ VkDeviceMemory memory,
+ VkDeviceSize memoryOffset,
+ VkImageAspectFlagBits planeAspect)
+{
+ const VkBindImagePlaneMemoryInfoKHR planeInfo =
+ {
+ VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO_KHR,
+ DE_NULL,
+ planeAspect
+ };
+ const VkBindImageMemoryInfoKHR coreInfo =
+ {
+ VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHR,
+ &planeInfo,
+ image,
+ memory,
+ memoryOffset,
+ };
+
+ VK_CHECK(vkd.bindImageMemory2KHR(device, 1u, &coreInfo));
+}
+
} // vk
void flushMappedMemoryRange (const DeviceInterface& vkd, VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size);
void invalidateMappedMemoryRange (const DeviceInterface& vkd, VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size);
deUint32 getCompatibleMemoryTypes (const VkPhysicalDeviceMemoryProperties& deviceMemProps, MemoryRequirement requirement);
+void bindImagePlaneMemory (const DeviceInterface& vkd, VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset, VkImageAspectFlagBits planeAspect);
} // vk
#include "vkNullDriver.hpp"
#include "vkPlatform.hpp"
#include "vkImageUtil.hpp"
+#include "vkQueryUtil.hpp"
#include "tcuFunctionLibrary.hpp"
#include "deMemory.h"
~SwapchainKHR (void) {}
};
+class SamplerYcbcrConversionKHR
+{
+public:
+ SamplerYcbcrConversionKHR (VkDevice, const VkSamplerYcbcrConversionCreateInfoKHR*) {}
+};
+
void* allocateHeap (const VkMemoryAllocateInfo* pAllocInfo)
{
// \todo [2015-12-03 pyry] Alignment requirements?
return VK_SUCCESS;
}
+VkResult enumerateExtensions (deUint32 numExtensions, const VkExtensionProperties* extensions, deUint32* pPropertyCount, VkExtensionProperties* pProperties)
+{
+ const deUint32 dstSize = pPropertyCount ? *pPropertyCount : 0;
+
+ if (pPropertyCount)
+ *pPropertyCount = numExtensions;
+
+ if (pProperties)
+ {
+ for (deUint32 ndx = 0; ndx < de::min(numExtensions, dstSize); ++ndx)
+ pProperties[ndx] = extensions[ndx];
+
+ if (dstSize < numExtensions)
+ return VK_INCOMPLETE;
+ }
+
+ return VK_SUCCESS;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL enumerateInstanceExtensionProperties (const char* pLayerName, deUint32* pPropertyCount, VkExtensionProperties* pProperties)
+{
+ static const VkExtensionProperties s_extensions[] =
+ {
+ { "VK_KHR_get_physical_device_properties2", 1u }
+ };
+
+ if (!pLayerName)
+ return enumerateExtensions((deUint32)DE_LENGTH_OF_ARRAY(s_extensions), s_extensions, pPropertyCount, pProperties);
+ else
+ return enumerateExtensions(0, DE_NULL, pPropertyCount, pProperties);
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL enumerateDeviceExtensionProperties (VkPhysicalDevice physicalDevice, const char* pLayerName, deUint32* pPropertyCount, VkExtensionProperties* pProperties)
+{
+ DE_UNREF(physicalDevice);
+
+ static const VkExtensionProperties s_extensions[] =
+ {
+ { "VK_KHR_get_memory_requirements2", 1u },
+ { "VK_KHR_bind_memory2", 1u },
+ { "VK_KHR_sampler_ycbcr_conversion", 1u },
+ };
+
+ if (!pLayerName)
+ return enumerateExtensions((deUint32)DE_LENGTH_OF_ARRAY(s_extensions), s_extensions, pPropertyCount, pProperties);
+ else
+ return enumerateExtensions(0, DE_NULL, pPropertyCount, pProperties);
+}
+
VKAPI_ATTR void VKAPI_CALL getPhysicalDeviceFeatures (VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures)
{
DE_UNREF(physicalDevice);
pFeatures->inheritedQueries = VK_TRUE;
}
+VKAPI_ATTR void VKAPI_CALL getPhysicalDeviceFeatures2KHR (VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2KHR* pFeatures)
+{
+ // Core features
+ getPhysicalDeviceFeatures(physicalDevice, &pFeatures->features);
+
+ // VK_KHR_sampler_ycbcr_conversion
+ {
+ VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR* extFeatures = findStructure<VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR>(pFeatures->pNext);
+
+ if (extFeatures)
+ extFeatures->samplerYcbcrConversion = VK_TRUE;
+ }
+}
+
VKAPI_ATTR void VKAPI_CALL getPhysicalDeviceProperties (VkPhysicalDevice, VkPhysicalDeviceProperties* props)
{
deMemset(props, 0, sizeof(VkPhysicalDeviceProperties));
props->limits.nonCoherentAtomSize = 128;
}
+
+VKAPI_ATTR void VKAPI_CALL getPhysicalDeviceProperties2KHR (VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2KHR* pProperties)
+{
+ getPhysicalDeviceProperties(physicalDevice, &pProperties->properties);
+}
+
VKAPI_ATTR void VKAPI_CALL getPhysicalDeviceQueueFamilyProperties (VkPhysicalDevice, deUint32* count, VkQueueFamilyProperties* props)
{
if (props && *count >= 1u)
props->memoryHeaps[0].flags = 0u;
}
-VKAPI_ATTR void VKAPI_CALL getPhysicalDeviceFormatProperties (VkPhysicalDevice, VkFormat, VkFormatProperties* pFormatProperties)
+VKAPI_ATTR void VKAPI_CALL getPhysicalDeviceFormatProperties (VkPhysicalDevice, VkFormat format, VkFormatProperties* pFormatProperties)
{
const VkFormatFeatureFlags allFeatures = VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT
| VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT
| VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT
| VK_FORMAT_FEATURE_BLIT_SRC_BIT
| VK_FORMAT_FEATURE_BLIT_DST_BIT
- | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT;
+ | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT
+ | VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT_KHR
+ | VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT_KHR
+ | VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT_KHR
+ | VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT_KHR
+ | VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT_KHR
+ | VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT_KHR;
pFormatProperties->linearTilingFeatures = allFeatures;
pFormatProperties->optimalTilingFeatures = allFeatures;
pFormatProperties->bufferFeatures = allFeatures;
+
+ if (isYCbCrFormat(format) && getPlaneCount(format) > 1)
+ pFormatProperties->optimalTilingFeatures |= VK_FORMAT_FEATURE_DISJOINT_BIT_KHR;
}
VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceImageFormatProperties (VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties)
requirements->alignment = (VkDeviceSize)1u;
}
+VKAPI_ATTR void VKAPI_CALL getBufferMemoryRequirements2KHR (VkDevice device, const VkBufferMemoryRequirementsInfo2KHR* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements)
+{
+ getBufferMemoryRequirements(device, pInfo->buffer, &pMemoryRequirements->memoryRequirements);
+}
+
VkDeviceSize getPackedImageDataSize (VkFormat format, VkExtent3D extent, VkSampleCountFlagBits samples)
{
return (VkDeviceSize)getPixelSize(mapVkFormat(format))
}
}
+VkDeviceSize getYCbCrImageDataSize (VkFormat format, VkExtent3D extent)
+{
+ const PlanarFormatDescription desc = getPlanarFormatDescription(format);
+ VkDeviceSize totalSize = 0;
+
+ DE_ASSERT(extent.depth == 1);
+
+ for (deUint32 planeNdx = 0; planeNdx < desc.numPlanes; ++planeNdx)
+ {
+ const deUint32 planeW = extent.width / desc.planes[planeNdx].widthDivisor;
+ const deUint32 planeH = extent.height / desc.planes[planeNdx].heightDivisor;
+ const deUint32 elementSize = desc.planes[planeNdx].elementSizeBytes;
+
+ totalSize = (VkDeviceSize)deAlign64((deInt64)totalSize, elementSize);
+ totalSize += planeW * planeH * elementSize;
+ }
+
+ return totalSize;
+}
+
VKAPI_ATTR void VKAPI_CALL getImageMemoryRequirements (VkDevice, VkImage imageHandle, VkMemoryRequirements* requirements)
{
const Image* image = reinterpret_cast<const Image*>(imageHandle.getInternal());
if (isCompressedFormat(image->getFormat()))
requirements->size = getCompressedImageDataSize(image->getFormat(), image->getExtent());
+ else if (isYCbCrFormat(image->getFormat()))
+ requirements->size = getYCbCrImageDataSize(image->getFormat(), image->getExtent());
else
requirements->size = getPackedImageDataSize(image->getFormat(), image->getExtent(), image->getSamples());
}
+VKAPI_ATTR void VKAPI_CALL getImageMemoryRequirements2KHR (VkDevice device, const VkImageMemoryRequirementsInfo2KHR* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements)
+{
+ const VkImagePlaneMemoryRequirementsInfoKHR* planeReqs = findStructure<VkImagePlaneMemoryRequirementsInfoKHR>(pInfo->pNext);
+
+ if (planeReqs)
+ {
+ const deUint32 planeNdx = getAspectPlaneNdx(planeReqs->planeAspect);
+ const Image* image = reinterpret_cast<const Image*>(pInfo->image.getInternal());
+ const VkFormat format = image->getFormat();
+ const PlanarFormatDescription formatDesc = getPlanarFormatDescription(format);
+
+ DE_ASSERT(de::inBounds<deUint32>(planeNdx, 0u, formatDesc.numPlanes));
+
+ const VkExtent3D extent = image->getExtent();
+ const deUint32 planeW = extent.width / formatDesc.planes[planeNdx].widthDivisor;
+ const deUint32 planeH = extent.height / formatDesc.planes[planeNdx].heightDivisor;
+ const deUint32 elementSize = formatDesc.planes[planeNdx].elementSizeBytes;
+
+ pMemoryRequirements->memoryRequirements.memoryTypeBits = 1u;
+ pMemoryRequirements->memoryRequirements.alignment = 16u;
+ pMemoryRequirements->memoryRequirements.size = planeW * planeH * elementSize;
+ }
+ else
+ getImageMemoryRequirements(device, pInfo->image, &pMemoryRequirements->memoryRequirements);
+}
+
VKAPI_ATTR VkResult VKAPI_CALL mapMemory (VkDevice, VkDeviceMemory memHandle, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData)
{
const DeviceMemory* memory = reinterpret_cast<DeviceMemory*>(memHandle.getInternal());
VK_NULL_RETURN((*pDescriptorUpdateTemplate = allocateNonDispHandle<DescriptorUpdateTemplateKHR, VkDescriptorUpdateTemplateKHR>(device, pCreateInfo, pAllocator)));
}
+VKAPI_ATTR VkResult VKAPI_CALL createSamplerYcbcrConversionKHR (VkDevice device, const VkSamplerYcbcrConversionCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversionKHR* pYcbcrConversion)
+{
+ DE_UNREF(pAllocator);
+ VK_NULL_RETURN((*pYcbcrConversion = allocateNonDispHandle<SamplerYcbcrConversionKHR, VkSamplerYcbcrConversionKHR>(device, pCreateInfo, pAllocator)));
+}
+
VKAPI_ATTR VkResult VKAPI_CALL createDebugReportCallbackEXT (VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback)
{
DE_UNREF(pAllocator);
freeNonDispHandle<DescriptorUpdateTemplateKHR, VkDescriptorUpdateTemplateKHR>(descriptorUpdateTemplate, pAllocator);
}
-VKAPI_ATTR void VKAPI_CALL destroyDebugReportCallbackEXT (VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks* pAllocator)
-{
- DE_UNREF(instance);
- freeNonDispHandle<DebugReportCallbackEXT, VkDebugReportCallbackEXT>(callback, pAllocator);
-}
-
-VKAPI_ATTR VkResult VKAPI_CALL enumerateInstanceExtensionProperties (const char* pLayerName, deUint32* pPropertyCount, VkExtensionProperties* pProperties)
+VKAPI_ATTR void VKAPI_CALL destroySamplerYcbcrConversionKHR (VkDevice device, VkSamplerYcbcrConversionKHR YcbcrConversion, const VkAllocationCallbacks* pAllocator)
{
- DE_UNREF(pLayerName);
- DE_UNREF(pPropertyCount);
- DE_UNREF(pProperties);
- return VK_SUCCESS;
+ DE_UNREF(device);
+ freeNonDispHandle<SamplerYcbcrConversionKHR, VkSamplerYcbcrConversionKHR>(YcbcrConversion, pAllocator);
}
-VKAPI_ATTR VkResult VKAPI_CALL enumerateDeviceExtensionProperties (VkPhysicalDevice physicalDevice, const char* pLayerName, deUint32* pPropertyCount, VkExtensionProperties* pProperties)
+VKAPI_ATTR void VKAPI_CALL destroyDebugReportCallbackEXT (VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks* pAllocator)
{
- DE_UNREF(physicalDevice);
- DE_UNREF(pLayerName);
- DE_UNREF(pPropertyCount);
- DE_UNREF(pProperties);
- return VK_SUCCESS;
+ DE_UNREF(instance);
+ freeNonDispHandle<DebugReportCallbackEXT, VkDebugReportCallbackEXT>(callback, pAllocator);
}
VKAPI_ATTR VkResult VKAPI_CALL enumerateInstanceLayerProperties (deUint32* pPropertyCount, VkLayerProperties* pProperties)
return VK_SUCCESS;
}
-VKAPI_ATTR void VKAPI_CALL getPhysicalDeviceFeatures2KHR (VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2KHR* pFeatures)
-{
- DE_UNREF(physicalDevice);
- DE_UNREF(pFeatures);
-}
-
-VKAPI_ATTR void VKAPI_CALL getPhysicalDeviceProperties2KHR (VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2KHR* pProperties)
-{
- DE_UNREF(physicalDevice);
- DE_UNREF(pProperties);
-}
-
VKAPI_ATTR void VKAPI_CALL getPhysicalDeviceFormatProperties2KHR (VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2KHR* pFormatProperties)
{
DE_UNREF(physicalDevice);
return VK_SUCCESS;
}
-VKAPI_ATTR void VKAPI_CALL getImageMemoryRequirements2KHR (VkDevice device, const VkImageMemoryRequirementsInfo2KHR* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements)
-{
- DE_UNREF(device);
- DE_UNREF(pInfo);
- DE_UNREF(pMemoryRequirements);
-}
-
-VKAPI_ATTR void VKAPI_CALL getBufferMemoryRequirements2KHR (VkDevice device, const VkBufferMemoryRequirementsInfo2KHR* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements)
-{
- DE_UNREF(device);
- DE_UNREF(pInfo);
- DE_UNREF(pMemoryRequirements);
-}
-
VKAPI_ATTR void VKAPI_CALL getImageSparseMemoryRequirements2KHR (VkDevice device, const VkImageSparseMemoryRequirementsInfo2KHR* pInfo, deUint32* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2KHR* pSparseMemoryRequirements)
{
DE_UNREF(device);
VK_NULL_FUNC_ENTRY(vkGetImageMemoryRequirements2KHR, getImageMemoryRequirements2KHR),
VK_NULL_FUNC_ENTRY(vkGetBufferMemoryRequirements2KHR, getBufferMemoryRequirements2KHR),
VK_NULL_FUNC_ENTRY(vkGetImageSparseMemoryRequirements2KHR, getImageSparseMemoryRequirements2KHR),
+ VK_NULL_FUNC_ENTRY(vkCreateSamplerYcbcrConversionKHR, createSamplerYcbcrConversionKHR),
+ VK_NULL_FUNC_ENTRY(vkDestroySamplerYcbcrConversionKHR, destroySamplerYcbcrConversionKHR),
VK_NULL_FUNC_ENTRY(vkGetMemoryWin32HandleKHR, getMemoryWin32HandleKHR),
VK_NULL_FUNC_ENTRY(vkGetMemoryWin32HandlePropertiesKHR, getMemoryWin32HandlePropertiesKHR),
VK_NULL_FUNC_ENTRY(vkGetMemoryFdKHR, getMemoryFdKHR),
return req;
}
+VkMemoryRequirements getImagePlaneMemoryRequirements (const DeviceInterface& vkd,
+ VkDevice device,
+ VkImage image,
+ VkImageAspectFlagBits planeAspect)
+{
+ VkImageMemoryRequirementsInfo2KHR coreInfo;
+ VkImagePlaneMemoryRequirementsInfoKHR planeInfo;
+ VkMemoryRequirements2KHR reqs;
+
+ deMemset(&coreInfo, 0, sizeof(coreInfo));
+ deMemset(&planeInfo, 0, sizeof(planeInfo));
+ deMemset(&reqs, 0, sizeof(reqs));
+
+ coreInfo.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR;
+ coreInfo.pNext = &planeInfo;
+ coreInfo.image = image;
+
+ planeInfo.sType = VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO_KHR;
+ planeInfo.planeAspect = planeAspect;
+
+ reqs.sType = VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR;
+
+ vkd.getImageMemoryRequirements2KHR(device, &coreInfo, &reqs);
+
+ return reqs.memoryRequirements;
+}
+
vector<VkLayerProperties> enumerateInstanceLayerProperties (const PlatformInterface& vkp)
{
vector<VkLayerProperties> properties;
return queue;
}
+const void* findStructureInChain (const void* first, VkStructureType type)
+{
+ struct StructureBase
+ {
+ VkStructureType sType;
+ void* pNext;
+ };
+
+ const StructureBase* cur = reinterpret_cast<const StructureBase*>(first);
+
+ while (cur)
+ {
+ if (cur->sType == type)
+ break;
+ else
+ cur = reinterpret_cast<const StructureBase*>(cur->pNext);
+ }
+
+ return cur;
+}
+
+void* findStructureInChain (void* first, VkStructureType type)
+{
+ return const_cast<void*>(findStructureInChain(const_cast<const void*>(first), type));
+}
+
+// getStructureType<T> implementations
+#include "vkGetStructureTypeImpl.inl"
+
} // vk
VkMemoryRequirements getBufferMemoryRequirements (const DeviceInterface& vk, VkDevice device, VkBuffer buffer);
VkMemoryRequirements getImageMemoryRequirements (const DeviceInterface& vk, VkDevice device, VkImage image);
+VkMemoryRequirements getImagePlaneMemoryRequirements (const DeviceInterface& vk, VkDevice device, VkImage image, VkImageAspectFlagBits planeAspect);
std::vector<VkSparseImageMemoryRequirements> getImageSparseMemoryRequirements (const DeviceInterface& vk, VkDevice device, VkImage image);
std::vector<VkLayerProperties> enumerateInstanceLayerProperties (const PlatformInterface& vkp);
bool isLayerSupported (LayerIterator begin, LayerIterator end, const RequiredLayer& required);
bool isLayerSupported (const std::vector<VkLayerProperties>& layers, const RequiredLayer& required);
+const void* findStructureInChain (const void* first, VkStructureType type);
+void* findStructureInChain (void* first, VkStructureType type);
+
+template<typename StructType>
+VkStructureType getStructureType (void);
+
+template<typename StructType>
+const StructType* findStructure (const void* first)
+{
+ return reinterpret_cast<const StructType*>(findStructureInChain(first, getStructureType<StructType>()));
+}
+
+template<typename StructType>
+StructType* findStructure (void* first)
+{
+ return reinterpret_cast<StructType*>(findStructureInChain(first, getStructureType<StructType>()));
+}
+
namespace ValidateQueryBits
{
Move<VkSurfaceKHR> createAndroidSurfaceKHR (const InstanceInterface& vk, VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
Move<VkSurfaceKHR> createWin32SurfaceKHR (const InstanceInterface& vk, VkInstance instance, const VkWin32SurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
Move<VkDescriptorUpdateTemplateKHR> createDescriptorUpdateTemplateKHR (const DeviceInterface& vk, VkDevice device, const VkDescriptorUpdateTemplateCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
+Move<VkSamplerYcbcrConversionKHR> createSamplerYcbcrConversionKHR (const DeviceInterface& vk, VkDevice device, const VkSamplerYcbcrConversionCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
Move<VkDebugReportCallbackEXT> createDebugReportCallbackEXT (const InstanceInterface& vk, VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
m_deviceIface->destroyDescriptorUpdateTemplateKHR(m_device, obj, m_allocator);
}
+template<>
+void Deleter<VkSamplerYcbcrConversionKHR>::operator() (VkSamplerYcbcrConversionKHR obj) const
+{
+ m_deviceIface->destroySamplerYcbcrConversionKHR(m_device, obj, m_allocator);
+}
+
} // refdetails
Move<VkInstance> createInstance (const PlatformInterface& vk, const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator)
return Move<VkDescriptorUpdateTemplateKHR>(check<VkDescriptorUpdateTemplateKHR>(object), Deleter<VkDescriptorUpdateTemplateKHR>(vk, device, pAllocator));
}
+Move<VkSamplerYcbcrConversionKHR> createSamplerYcbcrConversionKHR (const DeviceInterface& vk, VkDevice device, const VkSamplerYcbcrConversionCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator)
+{
+ VkSamplerYcbcrConversionKHR object = 0;
+ VK_CHECK(vk.createSamplerYcbcrConversionKHR(device, pCreateInfo, pAllocator, &object));
+ return Move<VkSamplerYcbcrConversionKHR>(check<VkSamplerYcbcrConversionKHR>(object), Deleter<VkSamplerYcbcrConversionKHR>(vk, device, pAllocator));
+}
+
Move<VkDebugReportCallbackEXT> createDebugReportCallbackEXT (const InstanceInterface& vk, VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator)
{
VkDebugReportCallbackEXT object = 0;
const char* getDescriptorUpdateTemplateTypeKHRName (VkDescriptorUpdateTemplateTypeKHR value);
const char* getPointClippingBehaviorKHRName (VkPointClippingBehaviorKHR value);
const char* getTessellationDomainOriginKHRName (VkTessellationDomainOriginKHR value);
+const char* getSamplerYcbcrModelConversionKHRName (VkSamplerYcbcrModelConversionKHR value);
+const char* getSamplerYcbcrRangeKHRName (VkSamplerYcbcrRangeKHR value);
+const char* getChromaLocationKHRName (VkChromaLocationKHR value);
const char* getDebugReportObjectTypeEXTName (VkDebugReportObjectTypeEXT value);
const char* getDebugReportErrorEXTName (VkDebugReportErrorEXT value);
inline tcu::Format::Enum<VkDescriptorUpdateTemplateTypeKHR> getDescriptorUpdateTemplateTypeKHRStr (VkDescriptorUpdateTemplateTypeKHR value) { return tcu::Format::Enum<VkDescriptorUpdateTemplateTypeKHR>(getDescriptorUpdateTemplateTypeKHRName, value); }
inline tcu::Format::Enum<VkPointClippingBehaviorKHR> getPointClippingBehaviorKHRStr (VkPointClippingBehaviorKHR value) { return tcu::Format::Enum<VkPointClippingBehaviorKHR>(getPointClippingBehaviorKHRName, value); }
inline tcu::Format::Enum<VkTessellationDomainOriginKHR> getTessellationDomainOriginKHRStr (VkTessellationDomainOriginKHR value) { return tcu::Format::Enum<VkTessellationDomainOriginKHR>(getTessellationDomainOriginKHRName, value); }
+inline tcu::Format::Enum<VkSamplerYcbcrModelConversionKHR> getSamplerYcbcrModelConversionKHRStr (VkSamplerYcbcrModelConversionKHR value) { return tcu::Format::Enum<VkSamplerYcbcrModelConversionKHR>(getSamplerYcbcrModelConversionKHRName, value); }
+inline tcu::Format::Enum<VkSamplerYcbcrRangeKHR> getSamplerYcbcrRangeKHRStr (VkSamplerYcbcrRangeKHR value) { return tcu::Format::Enum<VkSamplerYcbcrRangeKHR>(getSamplerYcbcrRangeKHRName, value); }
+inline tcu::Format::Enum<VkChromaLocationKHR> getChromaLocationKHRStr (VkChromaLocationKHR value) { return tcu::Format::Enum<VkChromaLocationKHR>(getChromaLocationKHRName, value); }
inline tcu::Format::Enum<VkDebugReportObjectTypeEXT> getDebugReportObjectTypeEXTStr (VkDebugReportObjectTypeEXT value) { return tcu::Format::Enum<VkDebugReportObjectTypeEXT>(getDebugReportObjectTypeEXTName, value); }
inline tcu::Format::Enum<VkDebugReportErrorEXT> getDebugReportErrorEXTStr (VkDebugReportErrorEXT value) { return tcu::Format::Enum<VkDebugReportErrorEXT>(getDebugReportErrorEXTName, value); }
inline std::ostream& operator<< (std::ostream& s, VkDescriptorUpdateTemplateTypeKHR value) { return s << getDescriptorUpdateTemplateTypeKHRStr(value); }
inline std::ostream& operator<< (std::ostream& s, VkPointClippingBehaviorKHR value) { return s << getPointClippingBehaviorKHRStr(value); }
inline std::ostream& operator<< (std::ostream& s, VkTessellationDomainOriginKHR value) { return s << getTessellationDomainOriginKHRStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkSamplerYcbcrModelConversionKHR value) { return s << getSamplerYcbcrModelConversionKHRStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkSamplerYcbcrRangeKHR value) { return s << getSamplerYcbcrRangeKHRStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkChromaLocationKHR value) { return s << getChromaLocationKHRStr(value); }
inline std::ostream& operator<< (std::ostream& s, VkDebugReportObjectTypeEXT value) { return s << getDebugReportObjectTypeEXTStr(value); }
inline std::ostream& operator<< (std::ostream& s, VkDebugReportErrorEXT value) { return s << getDebugReportErrorEXTStr(value); }
std::ostream& operator<< (std::ostream& s, const VkMemoryRequirements2KHR& value);
std::ostream& operator<< (std::ostream& s, const VkSparseImageMemoryRequirements2KHR& value);
std::ostream& operator<< (std::ostream& s, const VkImageFormatListCreateInfoKHR& value);
+std::ostream& operator<< (std::ostream& s, const VkSamplerYcbcrConversionCreateInfoKHR& value);
+std::ostream& operator<< (std::ostream& s, const VkSamplerYcbcrConversionInfoKHR& value);
+std::ostream& operator<< (std::ostream& s, const VkBindImagePlaneMemoryInfoKHR& value);
+std::ostream& operator<< (std::ostream& s, const VkImagePlaneMemoryRequirementsInfoKHR& value);
+std::ostream& operator<< (std::ostream& s, const VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR& value);
+std::ostream& operator<< (std::ostream& s, const VkSamplerYcbcrConversionImageFormatPropertiesKHR& value);
std::ostream& operator<< (std::ostream& s, const VkDebugReportCallbackCreateInfoEXT& value);
std::ostream& operator<< (std::ostream& s, const VkRenderPassMultiviewCreateInfoKHX& value);
std::ostream& operator<< (std::ostream& s, const VkPhysicalDeviceMultiviewFeaturesKHX& value);
template<> const char* getTypeName<VkDisplayKHR> (void) { return "VkDisplayKHR"; }
template<> const char* getTypeName<VkDisplayModeKHR> (void) { return "VkDisplayModeKHR"; }
template<> const char* getTypeName<VkDescriptorUpdateTemplateKHR> (void) { return "VkDescriptorUpdateTemplateKHR"; }
+template<> const char* getTypeName<VkSamplerYcbcrConversionKHR> (void) { return "VkSamplerYcbcrConversionKHR"; }
template<> const char* getTypeName<VkDebugReportCallbackEXT> (void) { return "VkDebugReportCallbackEXT"; }
namespace pt
case VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2_KHR: return "VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2_KHR";
case VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR: return "VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR";
case VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2_KHR: return "VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2_KHR";
+ case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO_KHR: return "VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO_KHR";
+ case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO_KHR: return "VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO_KHR";
+ case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO_KHR: return "VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO_KHR";
+ case VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO_KHR: return "VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO_KHR";
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES_KHR: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES_KHR";
+ case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES_KHR: return "VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES_KHR";
case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHR: return "VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHR";
case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHR: return "VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHR";
default: return DE_NULL;
{
switch (value)
{
- case VK_FORMAT_UNDEFINED: return "VK_FORMAT_UNDEFINED";
- case VK_FORMAT_R4G4_UNORM_PACK8: return "VK_FORMAT_R4G4_UNORM_PACK8";
- case VK_FORMAT_R4G4B4A4_UNORM_PACK16: return "VK_FORMAT_R4G4B4A4_UNORM_PACK16";
- case VK_FORMAT_B4G4R4A4_UNORM_PACK16: return "VK_FORMAT_B4G4R4A4_UNORM_PACK16";
- case VK_FORMAT_R5G6B5_UNORM_PACK16: return "VK_FORMAT_R5G6B5_UNORM_PACK16";
- case VK_FORMAT_B5G6R5_UNORM_PACK16: return "VK_FORMAT_B5G6R5_UNORM_PACK16";
- case VK_FORMAT_R5G5B5A1_UNORM_PACK16: return "VK_FORMAT_R5G5B5A1_UNORM_PACK16";
- case VK_FORMAT_B5G5R5A1_UNORM_PACK16: return "VK_FORMAT_B5G5R5A1_UNORM_PACK16";
- case VK_FORMAT_A1R5G5B5_UNORM_PACK16: return "VK_FORMAT_A1R5G5B5_UNORM_PACK16";
- case VK_FORMAT_R8_UNORM: return "VK_FORMAT_R8_UNORM";
- case VK_FORMAT_R8_SNORM: return "VK_FORMAT_R8_SNORM";
- case VK_FORMAT_R8_USCALED: return "VK_FORMAT_R8_USCALED";
- case VK_FORMAT_R8_SSCALED: return "VK_FORMAT_R8_SSCALED";
- case VK_FORMAT_R8_UINT: return "VK_FORMAT_R8_UINT";
- case VK_FORMAT_R8_SINT: return "VK_FORMAT_R8_SINT";
- case VK_FORMAT_R8_SRGB: return "VK_FORMAT_R8_SRGB";
- case VK_FORMAT_R8G8_UNORM: return "VK_FORMAT_R8G8_UNORM";
- case VK_FORMAT_R8G8_SNORM: return "VK_FORMAT_R8G8_SNORM";
- case VK_FORMAT_R8G8_USCALED: return "VK_FORMAT_R8G8_USCALED";
- case VK_FORMAT_R8G8_SSCALED: return "VK_FORMAT_R8G8_SSCALED";
- case VK_FORMAT_R8G8_UINT: return "VK_FORMAT_R8G8_UINT";
- case VK_FORMAT_R8G8_SINT: return "VK_FORMAT_R8G8_SINT";
- case VK_FORMAT_R8G8_SRGB: return "VK_FORMAT_R8G8_SRGB";
- case VK_FORMAT_R8G8B8_UNORM: return "VK_FORMAT_R8G8B8_UNORM";
- case VK_FORMAT_R8G8B8_SNORM: return "VK_FORMAT_R8G8B8_SNORM";
- case VK_FORMAT_R8G8B8_USCALED: return "VK_FORMAT_R8G8B8_USCALED";
- case VK_FORMAT_R8G8B8_SSCALED: return "VK_FORMAT_R8G8B8_SSCALED";
- case VK_FORMAT_R8G8B8_UINT: return "VK_FORMAT_R8G8B8_UINT";
- case VK_FORMAT_R8G8B8_SINT: return "VK_FORMAT_R8G8B8_SINT";
- case VK_FORMAT_R8G8B8_SRGB: return "VK_FORMAT_R8G8B8_SRGB";
- case VK_FORMAT_B8G8R8_UNORM: return "VK_FORMAT_B8G8R8_UNORM";
- case VK_FORMAT_B8G8R8_SNORM: return "VK_FORMAT_B8G8R8_SNORM";
- case VK_FORMAT_B8G8R8_USCALED: return "VK_FORMAT_B8G8R8_USCALED";
- case VK_FORMAT_B8G8R8_SSCALED: return "VK_FORMAT_B8G8R8_SSCALED";
- case VK_FORMAT_B8G8R8_UINT: return "VK_FORMAT_B8G8R8_UINT";
- case VK_FORMAT_B8G8R8_SINT: return "VK_FORMAT_B8G8R8_SINT";
- case VK_FORMAT_B8G8R8_SRGB: return "VK_FORMAT_B8G8R8_SRGB";
- case VK_FORMAT_R8G8B8A8_UNORM: return "VK_FORMAT_R8G8B8A8_UNORM";
- case VK_FORMAT_R8G8B8A8_SNORM: return "VK_FORMAT_R8G8B8A8_SNORM";
- case VK_FORMAT_R8G8B8A8_USCALED: return "VK_FORMAT_R8G8B8A8_USCALED";
- case VK_FORMAT_R8G8B8A8_SSCALED: return "VK_FORMAT_R8G8B8A8_SSCALED";
- case VK_FORMAT_R8G8B8A8_UINT: return "VK_FORMAT_R8G8B8A8_UINT";
- case VK_FORMAT_R8G8B8A8_SINT: return "VK_FORMAT_R8G8B8A8_SINT";
- case VK_FORMAT_R8G8B8A8_SRGB: return "VK_FORMAT_R8G8B8A8_SRGB";
- case VK_FORMAT_B8G8R8A8_UNORM: return "VK_FORMAT_B8G8R8A8_UNORM";
- case VK_FORMAT_B8G8R8A8_SNORM: return "VK_FORMAT_B8G8R8A8_SNORM";
- case VK_FORMAT_B8G8R8A8_USCALED: return "VK_FORMAT_B8G8R8A8_USCALED";
- case VK_FORMAT_B8G8R8A8_SSCALED: return "VK_FORMAT_B8G8R8A8_SSCALED";
- case VK_FORMAT_B8G8R8A8_UINT: return "VK_FORMAT_B8G8R8A8_UINT";
- case VK_FORMAT_B8G8R8A8_SINT: return "VK_FORMAT_B8G8R8A8_SINT";
- case VK_FORMAT_B8G8R8A8_SRGB: return "VK_FORMAT_B8G8R8A8_SRGB";
- case VK_FORMAT_A8B8G8R8_UNORM_PACK32: return "VK_FORMAT_A8B8G8R8_UNORM_PACK32";
- case VK_FORMAT_A8B8G8R8_SNORM_PACK32: return "VK_FORMAT_A8B8G8R8_SNORM_PACK32";
- case VK_FORMAT_A8B8G8R8_USCALED_PACK32: return "VK_FORMAT_A8B8G8R8_USCALED_PACK32";
- case VK_FORMAT_A8B8G8R8_SSCALED_PACK32: return "VK_FORMAT_A8B8G8R8_SSCALED_PACK32";
- case VK_FORMAT_A8B8G8R8_UINT_PACK32: return "VK_FORMAT_A8B8G8R8_UINT_PACK32";
- case VK_FORMAT_A8B8G8R8_SINT_PACK32: return "VK_FORMAT_A8B8G8R8_SINT_PACK32";
- case VK_FORMAT_A8B8G8R8_SRGB_PACK32: return "VK_FORMAT_A8B8G8R8_SRGB_PACK32";
- case VK_FORMAT_A2R10G10B10_UNORM_PACK32: return "VK_FORMAT_A2R10G10B10_UNORM_PACK32";
- case VK_FORMAT_A2R10G10B10_SNORM_PACK32: return "VK_FORMAT_A2R10G10B10_SNORM_PACK32";
- case VK_FORMAT_A2R10G10B10_USCALED_PACK32: return "VK_FORMAT_A2R10G10B10_USCALED_PACK32";
- case VK_FORMAT_A2R10G10B10_SSCALED_PACK32: return "VK_FORMAT_A2R10G10B10_SSCALED_PACK32";
- case VK_FORMAT_A2R10G10B10_UINT_PACK32: return "VK_FORMAT_A2R10G10B10_UINT_PACK32";
- case VK_FORMAT_A2R10G10B10_SINT_PACK32: return "VK_FORMAT_A2R10G10B10_SINT_PACK32";
- case VK_FORMAT_A2B10G10R10_UNORM_PACK32: return "VK_FORMAT_A2B10G10R10_UNORM_PACK32";
- case VK_FORMAT_A2B10G10R10_SNORM_PACK32: return "VK_FORMAT_A2B10G10R10_SNORM_PACK32";
- case VK_FORMAT_A2B10G10R10_USCALED_PACK32: return "VK_FORMAT_A2B10G10R10_USCALED_PACK32";
- case VK_FORMAT_A2B10G10R10_SSCALED_PACK32: return "VK_FORMAT_A2B10G10R10_SSCALED_PACK32";
- case VK_FORMAT_A2B10G10R10_UINT_PACK32: return "VK_FORMAT_A2B10G10R10_UINT_PACK32";
- case VK_FORMAT_A2B10G10R10_SINT_PACK32: return "VK_FORMAT_A2B10G10R10_SINT_PACK32";
- case VK_FORMAT_R16_UNORM: return "VK_FORMAT_R16_UNORM";
- case VK_FORMAT_R16_SNORM: return "VK_FORMAT_R16_SNORM";
- case VK_FORMAT_R16_USCALED: return "VK_FORMAT_R16_USCALED";
- case VK_FORMAT_R16_SSCALED: return "VK_FORMAT_R16_SSCALED";
- case VK_FORMAT_R16_UINT: return "VK_FORMAT_R16_UINT";
- case VK_FORMAT_R16_SINT: return "VK_FORMAT_R16_SINT";
- case VK_FORMAT_R16_SFLOAT: return "VK_FORMAT_R16_SFLOAT";
- case VK_FORMAT_R16G16_UNORM: return "VK_FORMAT_R16G16_UNORM";
- case VK_FORMAT_R16G16_SNORM: return "VK_FORMAT_R16G16_SNORM";
- case VK_FORMAT_R16G16_USCALED: return "VK_FORMAT_R16G16_USCALED";
- case VK_FORMAT_R16G16_SSCALED: return "VK_FORMAT_R16G16_SSCALED";
- case VK_FORMAT_R16G16_UINT: return "VK_FORMAT_R16G16_UINT";
- case VK_FORMAT_R16G16_SINT: return "VK_FORMAT_R16G16_SINT";
- case VK_FORMAT_R16G16_SFLOAT: return "VK_FORMAT_R16G16_SFLOAT";
- case VK_FORMAT_R16G16B16_UNORM: return "VK_FORMAT_R16G16B16_UNORM";
- case VK_FORMAT_R16G16B16_SNORM: return "VK_FORMAT_R16G16B16_SNORM";
- case VK_FORMAT_R16G16B16_USCALED: return "VK_FORMAT_R16G16B16_USCALED";
- case VK_FORMAT_R16G16B16_SSCALED: return "VK_FORMAT_R16G16B16_SSCALED";
- case VK_FORMAT_R16G16B16_UINT: return "VK_FORMAT_R16G16B16_UINT";
- case VK_FORMAT_R16G16B16_SINT: return "VK_FORMAT_R16G16B16_SINT";
- case VK_FORMAT_R16G16B16_SFLOAT: return "VK_FORMAT_R16G16B16_SFLOAT";
- case VK_FORMAT_R16G16B16A16_UNORM: return "VK_FORMAT_R16G16B16A16_UNORM";
- case VK_FORMAT_R16G16B16A16_SNORM: return "VK_FORMAT_R16G16B16A16_SNORM";
- case VK_FORMAT_R16G16B16A16_USCALED: return "VK_FORMAT_R16G16B16A16_USCALED";
- case VK_FORMAT_R16G16B16A16_SSCALED: return "VK_FORMAT_R16G16B16A16_SSCALED";
- case VK_FORMAT_R16G16B16A16_UINT: return "VK_FORMAT_R16G16B16A16_UINT";
- case VK_FORMAT_R16G16B16A16_SINT: return "VK_FORMAT_R16G16B16A16_SINT";
- case VK_FORMAT_R16G16B16A16_SFLOAT: return "VK_FORMAT_R16G16B16A16_SFLOAT";
- case VK_FORMAT_R32_UINT: return "VK_FORMAT_R32_UINT";
- case VK_FORMAT_R32_SINT: return "VK_FORMAT_R32_SINT";
- case VK_FORMAT_R32_SFLOAT: return "VK_FORMAT_R32_SFLOAT";
- case VK_FORMAT_R32G32_UINT: return "VK_FORMAT_R32G32_UINT";
- case VK_FORMAT_R32G32_SINT: return "VK_FORMAT_R32G32_SINT";
- case VK_FORMAT_R32G32_SFLOAT: return "VK_FORMAT_R32G32_SFLOAT";
- case VK_FORMAT_R32G32B32_UINT: return "VK_FORMAT_R32G32B32_UINT";
- case VK_FORMAT_R32G32B32_SINT: return "VK_FORMAT_R32G32B32_SINT";
- case VK_FORMAT_R32G32B32_SFLOAT: return "VK_FORMAT_R32G32B32_SFLOAT";
- case VK_FORMAT_R32G32B32A32_UINT: return "VK_FORMAT_R32G32B32A32_UINT";
- case VK_FORMAT_R32G32B32A32_SINT: return "VK_FORMAT_R32G32B32A32_SINT";
- case VK_FORMAT_R32G32B32A32_SFLOAT: return "VK_FORMAT_R32G32B32A32_SFLOAT";
- case VK_FORMAT_R64_UINT: return "VK_FORMAT_R64_UINT";
- case VK_FORMAT_R64_SINT: return "VK_FORMAT_R64_SINT";
- case VK_FORMAT_R64_SFLOAT: return "VK_FORMAT_R64_SFLOAT";
- case VK_FORMAT_R64G64_UINT: return "VK_FORMAT_R64G64_UINT";
- case VK_FORMAT_R64G64_SINT: return "VK_FORMAT_R64G64_SINT";
- case VK_FORMAT_R64G64_SFLOAT: return "VK_FORMAT_R64G64_SFLOAT";
- case VK_FORMAT_R64G64B64_UINT: return "VK_FORMAT_R64G64B64_UINT";
- case VK_FORMAT_R64G64B64_SINT: return "VK_FORMAT_R64G64B64_SINT";
- case VK_FORMAT_R64G64B64_SFLOAT: return "VK_FORMAT_R64G64B64_SFLOAT";
- case VK_FORMAT_R64G64B64A64_UINT: return "VK_FORMAT_R64G64B64A64_UINT";
- case VK_FORMAT_R64G64B64A64_SINT: return "VK_FORMAT_R64G64B64A64_SINT";
- case VK_FORMAT_R64G64B64A64_SFLOAT: return "VK_FORMAT_R64G64B64A64_SFLOAT";
- case VK_FORMAT_B10G11R11_UFLOAT_PACK32: return "VK_FORMAT_B10G11R11_UFLOAT_PACK32";
- case VK_FORMAT_E5B9G9R9_UFLOAT_PACK32: return "VK_FORMAT_E5B9G9R9_UFLOAT_PACK32";
- case VK_FORMAT_D16_UNORM: return "VK_FORMAT_D16_UNORM";
- case VK_FORMAT_X8_D24_UNORM_PACK32: return "VK_FORMAT_X8_D24_UNORM_PACK32";
- case VK_FORMAT_D32_SFLOAT: return "VK_FORMAT_D32_SFLOAT";
- case VK_FORMAT_S8_UINT: return "VK_FORMAT_S8_UINT";
- case VK_FORMAT_D16_UNORM_S8_UINT: return "VK_FORMAT_D16_UNORM_S8_UINT";
- case VK_FORMAT_D24_UNORM_S8_UINT: return "VK_FORMAT_D24_UNORM_S8_UINT";
- case VK_FORMAT_D32_SFLOAT_S8_UINT: return "VK_FORMAT_D32_SFLOAT_S8_UINT";
- case VK_FORMAT_BC1_RGB_UNORM_BLOCK: return "VK_FORMAT_BC1_RGB_UNORM_BLOCK";
- case VK_FORMAT_BC1_RGB_SRGB_BLOCK: return "VK_FORMAT_BC1_RGB_SRGB_BLOCK";
- case VK_FORMAT_BC1_RGBA_UNORM_BLOCK: return "VK_FORMAT_BC1_RGBA_UNORM_BLOCK";
- case VK_FORMAT_BC1_RGBA_SRGB_BLOCK: return "VK_FORMAT_BC1_RGBA_SRGB_BLOCK";
- case VK_FORMAT_BC2_UNORM_BLOCK: return "VK_FORMAT_BC2_UNORM_BLOCK";
- case VK_FORMAT_BC2_SRGB_BLOCK: return "VK_FORMAT_BC2_SRGB_BLOCK";
- case VK_FORMAT_BC3_UNORM_BLOCK: return "VK_FORMAT_BC3_UNORM_BLOCK";
- case VK_FORMAT_BC3_SRGB_BLOCK: return "VK_FORMAT_BC3_SRGB_BLOCK";
- case VK_FORMAT_BC4_UNORM_BLOCK: return "VK_FORMAT_BC4_UNORM_BLOCK";
- case VK_FORMAT_BC4_SNORM_BLOCK: return "VK_FORMAT_BC4_SNORM_BLOCK";
- case VK_FORMAT_BC5_UNORM_BLOCK: return "VK_FORMAT_BC5_UNORM_BLOCK";
- case VK_FORMAT_BC5_SNORM_BLOCK: return "VK_FORMAT_BC5_SNORM_BLOCK";
- case VK_FORMAT_BC6H_UFLOAT_BLOCK: return "VK_FORMAT_BC6H_UFLOAT_BLOCK";
- case VK_FORMAT_BC6H_SFLOAT_BLOCK: return "VK_FORMAT_BC6H_SFLOAT_BLOCK";
- case VK_FORMAT_BC7_UNORM_BLOCK: return "VK_FORMAT_BC7_UNORM_BLOCK";
- case VK_FORMAT_BC7_SRGB_BLOCK: return "VK_FORMAT_BC7_SRGB_BLOCK";
- case VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK: return "VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK";
- case VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK: return "VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK";
- case VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK: return "VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK";
- case VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK: return "VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK";
- case VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK: return "VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK";
- case VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK: return "VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK";
- case VK_FORMAT_EAC_R11_UNORM_BLOCK: return "VK_FORMAT_EAC_R11_UNORM_BLOCK";
- case VK_FORMAT_EAC_R11_SNORM_BLOCK: return "VK_FORMAT_EAC_R11_SNORM_BLOCK";
- case VK_FORMAT_EAC_R11G11_UNORM_BLOCK: return "VK_FORMAT_EAC_R11G11_UNORM_BLOCK";
- case VK_FORMAT_EAC_R11G11_SNORM_BLOCK: return "VK_FORMAT_EAC_R11G11_SNORM_BLOCK";
- case VK_FORMAT_ASTC_4x4_UNORM_BLOCK: return "VK_FORMAT_ASTC_4x4_UNORM_BLOCK";
- case VK_FORMAT_ASTC_4x4_SRGB_BLOCK: return "VK_FORMAT_ASTC_4x4_SRGB_BLOCK";
- case VK_FORMAT_ASTC_5x4_UNORM_BLOCK: return "VK_FORMAT_ASTC_5x4_UNORM_BLOCK";
- case VK_FORMAT_ASTC_5x4_SRGB_BLOCK: return "VK_FORMAT_ASTC_5x4_SRGB_BLOCK";
- case VK_FORMAT_ASTC_5x5_UNORM_BLOCK: return "VK_FORMAT_ASTC_5x5_UNORM_BLOCK";
- case VK_FORMAT_ASTC_5x5_SRGB_BLOCK: return "VK_FORMAT_ASTC_5x5_SRGB_BLOCK";
- case VK_FORMAT_ASTC_6x5_UNORM_BLOCK: return "VK_FORMAT_ASTC_6x5_UNORM_BLOCK";
- case VK_FORMAT_ASTC_6x5_SRGB_BLOCK: return "VK_FORMAT_ASTC_6x5_SRGB_BLOCK";
- case VK_FORMAT_ASTC_6x6_UNORM_BLOCK: return "VK_FORMAT_ASTC_6x6_UNORM_BLOCK";
- case VK_FORMAT_ASTC_6x6_SRGB_BLOCK: return "VK_FORMAT_ASTC_6x6_SRGB_BLOCK";
- case VK_FORMAT_ASTC_8x5_UNORM_BLOCK: return "VK_FORMAT_ASTC_8x5_UNORM_BLOCK";
- case VK_FORMAT_ASTC_8x5_SRGB_BLOCK: return "VK_FORMAT_ASTC_8x5_SRGB_BLOCK";
- case VK_FORMAT_ASTC_8x6_UNORM_BLOCK: return "VK_FORMAT_ASTC_8x6_UNORM_BLOCK";
- case VK_FORMAT_ASTC_8x6_SRGB_BLOCK: return "VK_FORMAT_ASTC_8x6_SRGB_BLOCK";
- case VK_FORMAT_ASTC_8x8_UNORM_BLOCK: return "VK_FORMAT_ASTC_8x8_UNORM_BLOCK";
- case VK_FORMAT_ASTC_8x8_SRGB_BLOCK: return "VK_FORMAT_ASTC_8x8_SRGB_BLOCK";
- case VK_FORMAT_ASTC_10x5_UNORM_BLOCK: return "VK_FORMAT_ASTC_10x5_UNORM_BLOCK";
- case VK_FORMAT_ASTC_10x5_SRGB_BLOCK: return "VK_FORMAT_ASTC_10x5_SRGB_BLOCK";
- case VK_FORMAT_ASTC_10x6_UNORM_BLOCK: return "VK_FORMAT_ASTC_10x6_UNORM_BLOCK";
- case VK_FORMAT_ASTC_10x6_SRGB_BLOCK: return "VK_FORMAT_ASTC_10x6_SRGB_BLOCK";
- case VK_FORMAT_ASTC_10x8_UNORM_BLOCK: return "VK_FORMAT_ASTC_10x8_UNORM_BLOCK";
- case VK_FORMAT_ASTC_10x8_SRGB_BLOCK: return "VK_FORMAT_ASTC_10x8_SRGB_BLOCK";
- case VK_FORMAT_ASTC_10x10_UNORM_BLOCK: return "VK_FORMAT_ASTC_10x10_UNORM_BLOCK";
- case VK_FORMAT_ASTC_10x10_SRGB_BLOCK: return "VK_FORMAT_ASTC_10x10_SRGB_BLOCK";
- case VK_FORMAT_ASTC_12x10_UNORM_BLOCK: return "VK_FORMAT_ASTC_12x10_UNORM_BLOCK";
- case VK_FORMAT_ASTC_12x10_SRGB_BLOCK: return "VK_FORMAT_ASTC_12x10_SRGB_BLOCK";
- case VK_FORMAT_ASTC_12x12_UNORM_BLOCK: return "VK_FORMAT_ASTC_12x12_UNORM_BLOCK";
- case VK_FORMAT_ASTC_12x12_SRGB_BLOCK: return "VK_FORMAT_ASTC_12x12_SRGB_BLOCK";
- default: return DE_NULL;
+ case VK_FORMAT_UNDEFINED: return "VK_FORMAT_UNDEFINED";
+ case VK_FORMAT_R4G4_UNORM_PACK8: return "VK_FORMAT_R4G4_UNORM_PACK8";
+ case VK_FORMAT_R4G4B4A4_UNORM_PACK16: return "VK_FORMAT_R4G4B4A4_UNORM_PACK16";
+ case VK_FORMAT_B4G4R4A4_UNORM_PACK16: return "VK_FORMAT_B4G4R4A4_UNORM_PACK16";
+ case VK_FORMAT_R5G6B5_UNORM_PACK16: return "VK_FORMAT_R5G6B5_UNORM_PACK16";
+ case VK_FORMAT_B5G6R5_UNORM_PACK16: return "VK_FORMAT_B5G6R5_UNORM_PACK16";
+ case VK_FORMAT_R5G5B5A1_UNORM_PACK16: return "VK_FORMAT_R5G5B5A1_UNORM_PACK16";
+ case VK_FORMAT_B5G5R5A1_UNORM_PACK16: return "VK_FORMAT_B5G5R5A1_UNORM_PACK16";
+ case VK_FORMAT_A1R5G5B5_UNORM_PACK16: return "VK_FORMAT_A1R5G5B5_UNORM_PACK16";
+ case VK_FORMAT_R8_UNORM: return "VK_FORMAT_R8_UNORM";
+ case VK_FORMAT_R8_SNORM: return "VK_FORMAT_R8_SNORM";
+ case VK_FORMAT_R8_USCALED: return "VK_FORMAT_R8_USCALED";
+ case VK_FORMAT_R8_SSCALED: return "VK_FORMAT_R8_SSCALED";
+ case VK_FORMAT_R8_UINT: return "VK_FORMAT_R8_UINT";
+ case VK_FORMAT_R8_SINT: return "VK_FORMAT_R8_SINT";
+ case VK_FORMAT_R8_SRGB: return "VK_FORMAT_R8_SRGB";
+ case VK_FORMAT_R8G8_UNORM: return "VK_FORMAT_R8G8_UNORM";
+ case VK_FORMAT_R8G8_SNORM: return "VK_FORMAT_R8G8_SNORM";
+ case VK_FORMAT_R8G8_USCALED: return "VK_FORMAT_R8G8_USCALED";
+ case VK_FORMAT_R8G8_SSCALED: return "VK_FORMAT_R8G8_SSCALED";
+ case VK_FORMAT_R8G8_UINT: return "VK_FORMAT_R8G8_UINT";
+ case VK_FORMAT_R8G8_SINT: return "VK_FORMAT_R8G8_SINT";
+ case VK_FORMAT_R8G8_SRGB: return "VK_FORMAT_R8G8_SRGB";
+ case VK_FORMAT_R8G8B8_UNORM: return "VK_FORMAT_R8G8B8_UNORM";
+ case VK_FORMAT_R8G8B8_SNORM: return "VK_FORMAT_R8G8B8_SNORM";
+ case VK_FORMAT_R8G8B8_USCALED: return "VK_FORMAT_R8G8B8_USCALED";
+ case VK_FORMAT_R8G8B8_SSCALED: return "VK_FORMAT_R8G8B8_SSCALED";
+ case VK_FORMAT_R8G8B8_UINT: return "VK_FORMAT_R8G8B8_UINT";
+ case VK_FORMAT_R8G8B8_SINT: return "VK_FORMAT_R8G8B8_SINT";
+ case VK_FORMAT_R8G8B8_SRGB: return "VK_FORMAT_R8G8B8_SRGB";
+ case VK_FORMAT_B8G8R8_UNORM: return "VK_FORMAT_B8G8R8_UNORM";
+ case VK_FORMAT_B8G8R8_SNORM: return "VK_FORMAT_B8G8R8_SNORM";
+ case VK_FORMAT_B8G8R8_USCALED: return "VK_FORMAT_B8G8R8_USCALED";
+ case VK_FORMAT_B8G8R8_SSCALED: return "VK_FORMAT_B8G8R8_SSCALED";
+ case VK_FORMAT_B8G8R8_UINT: return "VK_FORMAT_B8G8R8_UINT";
+ case VK_FORMAT_B8G8R8_SINT: return "VK_FORMAT_B8G8R8_SINT";
+ case VK_FORMAT_B8G8R8_SRGB: return "VK_FORMAT_B8G8R8_SRGB";
+ case VK_FORMAT_R8G8B8A8_UNORM: return "VK_FORMAT_R8G8B8A8_UNORM";
+ case VK_FORMAT_R8G8B8A8_SNORM: return "VK_FORMAT_R8G8B8A8_SNORM";
+ case VK_FORMAT_R8G8B8A8_USCALED: return "VK_FORMAT_R8G8B8A8_USCALED";
+ case VK_FORMAT_R8G8B8A8_SSCALED: return "VK_FORMAT_R8G8B8A8_SSCALED";
+ case VK_FORMAT_R8G8B8A8_UINT: return "VK_FORMAT_R8G8B8A8_UINT";
+ case VK_FORMAT_R8G8B8A8_SINT: return "VK_FORMAT_R8G8B8A8_SINT";
+ case VK_FORMAT_R8G8B8A8_SRGB: return "VK_FORMAT_R8G8B8A8_SRGB";
+ case VK_FORMAT_B8G8R8A8_UNORM: return "VK_FORMAT_B8G8R8A8_UNORM";
+ case VK_FORMAT_B8G8R8A8_SNORM: return "VK_FORMAT_B8G8R8A8_SNORM";
+ case VK_FORMAT_B8G8R8A8_USCALED: return "VK_FORMAT_B8G8R8A8_USCALED";
+ case VK_FORMAT_B8G8R8A8_SSCALED: return "VK_FORMAT_B8G8R8A8_SSCALED";
+ case VK_FORMAT_B8G8R8A8_UINT: return "VK_FORMAT_B8G8R8A8_UINT";
+ case VK_FORMAT_B8G8R8A8_SINT: return "VK_FORMAT_B8G8R8A8_SINT";
+ case VK_FORMAT_B8G8R8A8_SRGB: return "VK_FORMAT_B8G8R8A8_SRGB";
+ case VK_FORMAT_A8B8G8R8_UNORM_PACK32: return "VK_FORMAT_A8B8G8R8_UNORM_PACK32";
+ case VK_FORMAT_A8B8G8R8_SNORM_PACK32: return "VK_FORMAT_A8B8G8R8_SNORM_PACK32";
+ case VK_FORMAT_A8B8G8R8_USCALED_PACK32: return "VK_FORMAT_A8B8G8R8_USCALED_PACK32";
+ case VK_FORMAT_A8B8G8R8_SSCALED_PACK32: return "VK_FORMAT_A8B8G8R8_SSCALED_PACK32";
+ case VK_FORMAT_A8B8G8R8_UINT_PACK32: return "VK_FORMAT_A8B8G8R8_UINT_PACK32";
+ case VK_FORMAT_A8B8G8R8_SINT_PACK32: return "VK_FORMAT_A8B8G8R8_SINT_PACK32";
+ case VK_FORMAT_A8B8G8R8_SRGB_PACK32: return "VK_FORMAT_A8B8G8R8_SRGB_PACK32";
+ case VK_FORMAT_A2R10G10B10_UNORM_PACK32: return "VK_FORMAT_A2R10G10B10_UNORM_PACK32";
+ case VK_FORMAT_A2R10G10B10_SNORM_PACK32: return "VK_FORMAT_A2R10G10B10_SNORM_PACK32";
+ case VK_FORMAT_A2R10G10B10_USCALED_PACK32: return "VK_FORMAT_A2R10G10B10_USCALED_PACK32";
+ case VK_FORMAT_A2R10G10B10_SSCALED_PACK32: return "VK_FORMAT_A2R10G10B10_SSCALED_PACK32";
+ case VK_FORMAT_A2R10G10B10_UINT_PACK32: return "VK_FORMAT_A2R10G10B10_UINT_PACK32";
+ case VK_FORMAT_A2R10G10B10_SINT_PACK32: return "VK_FORMAT_A2R10G10B10_SINT_PACK32";
+ case VK_FORMAT_A2B10G10R10_UNORM_PACK32: return "VK_FORMAT_A2B10G10R10_UNORM_PACK32";
+ case VK_FORMAT_A2B10G10R10_SNORM_PACK32: return "VK_FORMAT_A2B10G10R10_SNORM_PACK32";
+ case VK_FORMAT_A2B10G10R10_USCALED_PACK32: return "VK_FORMAT_A2B10G10R10_USCALED_PACK32";
+ case VK_FORMAT_A2B10G10R10_SSCALED_PACK32: return "VK_FORMAT_A2B10G10R10_SSCALED_PACK32";
+ case VK_FORMAT_A2B10G10R10_UINT_PACK32: return "VK_FORMAT_A2B10G10R10_UINT_PACK32";
+ case VK_FORMAT_A2B10G10R10_SINT_PACK32: return "VK_FORMAT_A2B10G10R10_SINT_PACK32";
+ case VK_FORMAT_R16_UNORM: return "VK_FORMAT_R16_UNORM";
+ case VK_FORMAT_R16_SNORM: return "VK_FORMAT_R16_SNORM";
+ case VK_FORMAT_R16_USCALED: return "VK_FORMAT_R16_USCALED";
+ case VK_FORMAT_R16_SSCALED: return "VK_FORMAT_R16_SSCALED";
+ case VK_FORMAT_R16_UINT: return "VK_FORMAT_R16_UINT";
+ case VK_FORMAT_R16_SINT: return "VK_FORMAT_R16_SINT";
+ case VK_FORMAT_R16_SFLOAT: return "VK_FORMAT_R16_SFLOAT";
+ case VK_FORMAT_R16G16_UNORM: return "VK_FORMAT_R16G16_UNORM";
+ case VK_FORMAT_R16G16_SNORM: return "VK_FORMAT_R16G16_SNORM";
+ case VK_FORMAT_R16G16_USCALED: return "VK_FORMAT_R16G16_USCALED";
+ case VK_FORMAT_R16G16_SSCALED: return "VK_FORMAT_R16G16_SSCALED";
+ case VK_FORMAT_R16G16_UINT: return "VK_FORMAT_R16G16_UINT";
+ case VK_FORMAT_R16G16_SINT: return "VK_FORMAT_R16G16_SINT";
+ case VK_FORMAT_R16G16_SFLOAT: return "VK_FORMAT_R16G16_SFLOAT";
+ case VK_FORMAT_R16G16B16_UNORM: return "VK_FORMAT_R16G16B16_UNORM";
+ case VK_FORMAT_R16G16B16_SNORM: return "VK_FORMAT_R16G16B16_SNORM";
+ case VK_FORMAT_R16G16B16_USCALED: return "VK_FORMAT_R16G16B16_USCALED";
+ case VK_FORMAT_R16G16B16_SSCALED: return "VK_FORMAT_R16G16B16_SSCALED";
+ case VK_FORMAT_R16G16B16_UINT: return "VK_FORMAT_R16G16B16_UINT";
+ case VK_FORMAT_R16G16B16_SINT: return "VK_FORMAT_R16G16B16_SINT";
+ case VK_FORMAT_R16G16B16_SFLOAT: return "VK_FORMAT_R16G16B16_SFLOAT";
+ case VK_FORMAT_R16G16B16A16_UNORM: return "VK_FORMAT_R16G16B16A16_UNORM";
+ case VK_FORMAT_R16G16B16A16_SNORM: return "VK_FORMAT_R16G16B16A16_SNORM";
+ case VK_FORMAT_R16G16B16A16_USCALED: return "VK_FORMAT_R16G16B16A16_USCALED";
+ case VK_FORMAT_R16G16B16A16_SSCALED: return "VK_FORMAT_R16G16B16A16_SSCALED";
+ case VK_FORMAT_R16G16B16A16_UINT: return "VK_FORMAT_R16G16B16A16_UINT";
+ case VK_FORMAT_R16G16B16A16_SINT: return "VK_FORMAT_R16G16B16A16_SINT";
+ case VK_FORMAT_R16G16B16A16_SFLOAT: return "VK_FORMAT_R16G16B16A16_SFLOAT";
+ case VK_FORMAT_R32_UINT: return "VK_FORMAT_R32_UINT";
+ case VK_FORMAT_R32_SINT: return "VK_FORMAT_R32_SINT";
+ case VK_FORMAT_R32_SFLOAT: return "VK_FORMAT_R32_SFLOAT";
+ case VK_FORMAT_R32G32_UINT: return "VK_FORMAT_R32G32_UINT";
+ case VK_FORMAT_R32G32_SINT: return "VK_FORMAT_R32G32_SINT";
+ case VK_FORMAT_R32G32_SFLOAT: return "VK_FORMAT_R32G32_SFLOAT";
+ case VK_FORMAT_R32G32B32_UINT: return "VK_FORMAT_R32G32B32_UINT";
+ case VK_FORMAT_R32G32B32_SINT: return "VK_FORMAT_R32G32B32_SINT";
+ case VK_FORMAT_R32G32B32_SFLOAT: return "VK_FORMAT_R32G32B32_SFLOAT";
+ case VK_FORMAT_R32G32B32A32_UINT: return "VK_FORMAT_R32G32B32A32_UINT";
+ case VK_FORMAT_R32G32B32A32_SINT: return "VK_FORMAT_R32G32B32A32_SINT";
+ case VK_FORMAT_R32G32B32A32_SFLOAT: return "VK_FORMAT_R32G32B32A32_SFLOAT";
+ case VK_FORMAT_R64_UINT: return "VK_FORMAT_R64_UINT";
+ case VK_FORMAT_R64_SINT: return "VK_FORMAT_R64_SINT";
+ case VK_FORMAT_R64_SFLOAT: return "VK_FORMAT_R64_SFLOAT";
+ case VK_FORMAT_R64G64_UINT: return "VK_FORMAT_R64G64_UINT";
+ case VK_FORMAT_R64G64_SINT: return "VK_FORMAT_R64G64_SINT";
+ case VK_FORMAT_R64G64_SFLOAT: return "VK_FORMAT_R64G64_SFLOAT";
+ case VK_FORMAT_R64G64B64_UINT: return "VK_FORMAT_R64G64B64_UINT";
+ case VK_FORMAT_R64G64B64_SINT: return "VK_FORMAT_R64G64B64_SINT";
+ case VK_FORMAT_R64G64B64_SFLOAT: return "VK_FORMAT_R64G64B64_SFLOAT";
+ case VK_FORMAT_R64G64B64A64_UINT: return "VK_FORMAT_R64G64B64A64_UINT";
+ case VK_FORMAT_R64G64B64A64_SINT: return "VK_FORMAT_R64G64B64A64_SINT";
+ case VK_FORMAT_R64G64B64A64_SFLOAT: return "VK_FORMAT_R64G64B64A64_SFLOAT";
+ case VK_FORMAT_B10G11R11_UFLOAT_PACK32: return "VK_FORMAT_B10G11R11_UFLOAT_PACK32";
+ case VK_FORMAT_E5B9G9R9_UFLOAT_PACK32: return "VK_FORMAT_E5B9G9R9_UFLOAT_PACK32";
+ case VK_FORMAT_D16_UNORM: return "VK_FORMAT_D16_UNORM";
+ case VK_FORMAT_X8_D24_UNORM_PACK32: return "VK_FORMAT_X8_D24_UNORM_PACK32";
+ case VK_FORMAT_D32_SFLOAT: return "VK_FORMAT_D32_SFLOAT";
+ case VK_FORMAT_S8_UINT: return "VK_FORMAT_S8_UINT";
+ case VK_FORMAT_D16_UNORM_S8_UINT: return "VK_FORMAT_D16_UNORM_S8_UINT";
+ case VK_FORMAT_D24_UNORM_S8_UINT: return "VK_FORMAT_D24_UNORM_S8_UINT";
+ case VK_FORMAT_D32_SFLOAT_S8_UINT: return "VK_FORMAT_D32_SFLOAT_S8_UINT";
+ case VK_FORMAT_BC1_RGB_UNORM_BLOCK: return "VK_FORMAT_BC1_RGB_UNORM_BLOCK";
+ case VK_FORMAT_BC1_RGB_SRGB_BLOCK: return "VK_FORMAT_BC1_RGB_SRGB_BLOCK";
+ case VK_FORMAT_BC1_RGBA_UNORM_BLOCK: return "VK_FORMAT_BC1_RGBA_UNORM_BLOCK";
+ case VK_FORMAT_BC1_RGBA_SRGB_BLOCK: return "VK_FORMAT_BC1_RGBA_SRGB_BLOCK";
+ case VK_FORMAT_BC2_UNORM_BLOCK: return "VK_FORMAT_BC2_UNORM_BLOCK";
+ case VK_FORMAT_BC2_SRGB_BLOCK: return "VK_FORMAT_BC2_SRGB_BLOCK";
+ case VK_FORMAT_BC3_UNORM_BLOCK: return "VK_FORMAT_BC3_UNORM_BLOCK";
+ case VK_FORMAT_BC3_SRGB_BLOCK: return "VK_FORMAT_BC3_SRGB_BLOCK";
+ case VK_FORMAT_BC4_UNORM_BLOCK: return "VK_FORMAT_BC4_UNORM_BLOCK";
+ case VK_FORMAT_BC4_SNORM_BLOCK: return "VK_FORMAT_BC4_SNORM_BLOCK";
+ case VK_FORMAT_BC5_UNORM_BLOCK: return "VK_FORMAT_BC5_UNORM_BLOCK";
+ case VK_FORMAT_BC5_SNORM_BLOCK: return "VK_FORMAT_BC5_SNORM_BLOCK";
+ case VK_FORMAT_BC6H_UFLOAT_BLOCK: return "VK_FORMAT_BC6H_UFLOAT_BLOCK";
+ case VK_FORMAT_BC6H_SFLOAT_BLOCK: return "VK_FORMAT_BC6H_SFLOAT_BLOCK";
+ case VK_FORMAT_BC7_UNORM_BLOCK: return "VK_FORMAT_BC7_UNORM_BLOCK";
+ case VK_FORMAT_BC7_SRGB_BLOCK: return "VK_FORMAT_BC7_SRGB_BLOCK";
+ case VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK: return "VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK";
+ case VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK: return "VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK";
+ case VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK: return "VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK";
+ case VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK: return "VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK";
+ case VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK: return "VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK";
+ case VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK: return "VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK";
+ case VK_FORMAT_EAC_R11_UNORM_BLOCK: return "VK_FORMAT_EAC_R11_UNORM_BLOCK";
+ case VK_FORMAT_EAC_R11_SNORM_BLOCK: return "VK_FORMAT_EAC_R11_SNORM_BLOCK";
+ case VK_FORMAT_EAC_R11G11_UNORM_BLOCK: return "VK_FORMAT_EAC_R11G11_UNORM_BLOCK";
+ case VK_FORMAT_EAC_R11G11_SNORM_BLOCK: return "VK_FORMAT_EAC_R11G11_SNORM_BLOCK";
+ case VK_FORMAT_ASTC_4x4_UNORM_BLOCK: return "VK_FORMAT_ASTC_4x4_UNORM_BLOCK";
+ case VK_FORMAT_ASTC_4x4_SRGB_BLOCK: return "VK_FORMAT_ASTC_4x4_SRGB_BLOCK";
+ case VK_FORMAT_ASTC_5x4_UNORM_BLOCK: return "VK_FORMAT_ASTC_5x4_UNORM_BLOCK";
+ case VK_FORMAT_ASTC_5x4_SRGB_BLOCK: return "VK_FORMAT_ASTC_5x4_SRGB_BLOCK";
+ case VK_FORMAT_ASTC_5x5_UNORM_BLOCK: return "VK_FORMAT_ASTC_5x5_UNORM_BLOCK";
+ case VK_FORMAT_ASTC_5x5_SRGB_BLOCK: return "VK_FORMAT_ASTC_5x5_SRGB_BLOCK";
+ case VK_FORMAT_ASTC_6x5_UNORM_BLOCK: return "VK_FORMAT_ASTC_6x5_UNORM_BLOCK";
+ case VK_FORMAT_ASTC_6x5_SRGB_BLOCK: return "VK_FORMAT_ASTC_6x5_SRGB_BLOCK";
+ case VK_FORMAT_ASTC_6x6_UNORM_BLOCK: return "VK_FORMAT_ASTC_6x6_UNORM_BLOCK";
+ case VK_FORMAT_ASTC_6x6_SRGB_BLOCK: return "VK_FORMAT_ASTC_6x6_SRGB_BLOCK";
+ case VK_FORMAT_ASTC_8x5_UNORM_BLOCK: return "VK_FORMAT_ASTC_8x5_UNORM_BLOCK";
+ case VK_FORMAT_ASTC_8x5_SRGB_BLOCK: return "VK_FORMAT_ASTC_8x5_SRGB_BLOCK";
+ case VK_FORMAT_ASTC_8x6_UNORM_BLOCK: return "VK_FORMAT_ASTC_8x6_UNORM_BLOCK";
+ case VK_FORMAT_ASTC_8x6_SRGB_BLOCK: return "VK_FORMAT_ASTC_8x6_SRGB_BLOCK";
+ case VK_FORMAT_ASTC_8x8_UNORM_BLOCK: return "VK_FORMAT_ASTC_8x8_UNORM_BLOCK";
+ case VK_FORMAT_ASTC_8x8_SRGB_BLOCK: return "VK_FORMAT_ASTC_8x8_SRGB_BLOCK";
+ case VK_FORMAT_ASTC_10x5_UNORM_BLOCK: return "VK_FORMAT_ASTC_10x5_UNORM_BLOCK";
+ case VK_FORMAT_ASTC_10x5_SRGB_BLOCK: return "VK_FORMAT_ASTC_10x5_SRGB_BLOCK";
+ case VK_FORMAT_ASTC_10x6_UNORM_BLOCK: return "VK_FORMAT_ASTC_10x6_UNORM_BLOCK";
+ case VK_FORMAT_ASTC_10x6_SRGB_BLOCK: return "VK_FORMAT_ASTC_10x6_SRGB_BLOCK";
+ case VK_FORMAT_ASTC_10x8_UNORM_BLOCK: return "VK_FORMAT_ASTC_10x8_UNORM_BLOCK";
+ case VK_FORMAT_ASTC_10x8_SRGB_BLOCK: return "VK_FORMAT_ASTC_10x8_SRGB_BLOCK";
+ case VK_FORMAT_ASTC_10x10_UNORM_BLOCK: return "VK_FORMAT_ASTC_10x10_UNORM_BLOCK";
+ case VK_FORMAT_ASTC_10x10_SRGB_BLOCK: return "VK_FORMAT_ASTC_10x10_SRGB_BLOCK";
+ case VK_FORMAT_ASTC_12x10_UNORM_BLOCK: return "VK_FORMAT_ASTC_12x10_UNORM_BLOCK";
+ case VK_FORMAT_ASTC_12x10_SRGB_BLOCK: return "VK_FORMAT_ASTC_12x10_SRGB_BLOCK";
+ case VK_FORMAT_ASTC_12x12_UNORM_BLOCK: return "VK_FORMAT_ASTC_12x12_UNORM_BLOCK";
+ case VK_FORMAT_ASTC_12x12_SRGB_BLOCK: return "VK_FORMAT_ASTC_12x12_SRGB_BLOCK";
+ case VK_FORMAT_G8B8G8R8_422_UNORM_KHR: return "VK_FORMAT_G8B8G8R8_422_UNORM_KHR";
+ case VK_FORMAT_B8G8R8G8_422_UNORM_KHR: return "VK_FORMAT_B8G8R8G8_422_UNORM_KHR";
+ case VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM_KHR: return "VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM_KHR";
+ case VK_FORMAT_G8_B8R8_2PLANE_420_UNORM_KHR: return "VK_FORMAT_G8_B8R8_2PLANE_420_UNORM_KHR";
+ case VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM_KHR: return "VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM_KHR";
+ case VK_FORMAT_G8_B8R8_2PLANE_422_UNORM_KHR: return "VK_FORMAT_G8_B8R8_2PLANE_422_UNORM_KHR";
+ case VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM_KHR: return "VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM_KHR";
+ case VK_FORMAT_R10X6_UNORM_PACK16_KHR: return "VK_FORMAT_R10X6_UNORM_PACK16_KHR";
+ case VK_FORMAT_R10X6G10X6_UNORM_2PACK16_KHR: return "VK_FORMAT_R10X6G10X6_UNORM_2PACK16_KHR";
+ case VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16_KHR: return "VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16_KHR";
+ case VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16_KHR: return "VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16_KHR";
+ case VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16_KHR: return "VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16_KHR";
+ case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16_KHR: return "VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16_KHR";
+ case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16_KHR: return "VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16_KHR";
+ case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16_KHR: return "VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16_KHR";
+ case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16_KHR: return "VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16_KHR";
+ case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16_KHR: return "VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16_KHR";
+ case VK_FORMAT_R12X4_UNORM_PACK16_KHR: return "VK_FORMAT_R12X4_UNORM_PACK16_KHR";
+ case VK_FORMAT_R12X4G12X4_UNORM_2PACK16_KHR: return "VK_FORMAT_R12X4G12X4_UNORM_2PACK16_KHR";
+ case VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16_KHR: return "VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16_KHR";
+ case VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16_KHR: return "VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16_KHR";
+ case VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16_KHR: return "VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16_KHR";
+ case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16_KHR: return "VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16_KHR";
+ case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16_KHR: return "VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16_KHR";
+ case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16_KHR: return "VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16_KHR";
+ case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16_KHR: return "VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16_KHR";
+ case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16_KHR: return "VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16_KHR";
+ case VK_FORMAT_G16B16G16R16_422_UNORM_KHR: return "VK_FORMAT_G16B16G16R16_422_UNORM_KHR";
+ case VK_FORMAT_B16G16R16G16_422_UNORM_KHR: return "VK_FORMAT_B16G16R16G16_422_UNORM_KHR";
+ case VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM_KHR: return "VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM_KHR";
+ case VK_FORMAT_G16_B16R16_2PLANE_420_UNORM_KHR: return "VK_FORMAT_G16_B16R16_2PLANE_420_UNORM_KHR";
+ case VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM_KHR: return "VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM_KHR";
+ case VK_FORMAT_G16_B16R16_2PLANE_422_UNORM_KHR: return "VK_FORMAT_G16_B16R16_2PLANE_422_UNORM_KHR";
+ case VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM_KHR: return "VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM_KHR";
+ default: return DE_NULL;
}
}
}
}
+const char* getSamplerYcbcrModelConversionKHRName (VkSamplerYcbcrModelConversionKHR value)
+{
+ switch (value)
+ {
+ case VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY_KHR: return "VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY_KHR";
+ case VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY_KHR: return "VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY_KHR";
+ case VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709_KHR: return "VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709_KHR";
+ case VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601_KHR: return "VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601_KHR";
+ case VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020_KHR: return "VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020_KHR";
+ default: return DE_NULL;
+ }
+}
+
+const char* getSamplerYcbcrRangeKHRName (VkSamplerYcbcrRangeKHR value)
+{
+ switch (value)
+ {
+ case VK_SAMPLER_YCBCR_RANGE_ITU_FULL_KHR: return "VK_SAMPLER_YCBCR_RANGE_ITU_FULL_KHR";
+ case VK_SAMPLER_YCBCR_RANGE_ITU_NARROW_KHR: return "VK_SAMPLER_YCBCR_RANGE_ITU_NARROW_KHR";
+ default: return DE_NULL;
+ }
+}
+
+const char* getChromaLocationKHRName (VkChromaLocationKHR value)
+{
+ switch (value)
+ {
+ case VK_CHROMA_LOCATION_COSITED_EVEN_KHR: return "VK_CHROMA_LOCATION_COSITED_EVEN_KHR";
+ case VK_CHROMA_LOCATION_MIDPOINT_KHR: return "VK_CHROMA_LOCATION_MIDPOINT_KHR";
+ default: return DE_NULL;
+ }
+}
+
const char* getDebugReportObjectTypeEXTName (VkDebugReportObjectTypeEXT value)
{
switch (value)
case VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT: return "VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT";
case VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT: return "VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT";
case VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR_EXT: return "VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR_EXT";
+ case VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR_EXT: return "VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR_EXT";
default: return DE_NULL;
}
}
{
static const tcu::Format::BitDesc s_desc[] =
{
- tcu::Format::BitDesc(VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT, "VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT"),
- tcu::Format::BitDesc(VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT, "VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT"),
- tcu::Format::BitDesc(VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT, "VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT"),
- tcu::Format::BitDesc(VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT, "VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT"),
- tcu::Format::BitDesc(VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT, "VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT"),
- tcu::Format::BitDesc(VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT, "VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT"),
- tcu::Format::BitDesc(VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT, "VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT"),
- tcu::Format::BitDesc(VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT, "VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT"),
- tcu::Format::BitDesc(VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT, "VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT"),
- tcu::Format::BitDesc(VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT, "VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT"),
- tcu::Format::BitDesc(VK_FORMAT_FEATURE_BLIT_SRC_BIT, "VK_FORMAT_FEATURE_BLIT_SRC_BIT"),
- tcu::Format::BitDesc(VK_FORMAT_FEATURE_BLIT_DST_BIT, "VK_FORMAT_FEATURE_BLIT_DST_BIT"),
- tcu::Format::BitDesc(VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT, "VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT"),
- tcu::Format::BitDesc(VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR, "VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR"),
- tcu::Format::BitDesc(VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR, "VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR"),
+ tcu::Format::BitDesc(VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT, "VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT"),
+ tcu::Format::BitDesc(VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT, "VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT"),
+ tcu::Format::BitDesc(VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT, "VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT"),
+ tcu::Format::BitDesc(VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT, "VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT"),
+ tcu::Format::BitDesc(VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT, "VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT"),
+ tcu::Format::BitDesc(VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT, "VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT"),
+ tcu::Format::BitDesc(VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT, "VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT"),
+ tcu::Format::BitDesc(VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT, "VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT"),
+ tcu::Format::BitDesc(VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT, "VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT"),
+ tcu::Format::BitDesc(VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT, "VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT"),
+ tcu::Format::BitDesc(VK_FORMAT_FEATURE_BLIT_SRC_BIT, "VK_FORMAT_FEATURE_BLIT_SRC_BIT"),
+ tcu::Format::BitDesc(VK_FORMAT_FEATURE_BLIT_DST_BIT, "VK_FORMAT_FEATURE_BLIT_DST_BIT"),
+ tcu::Format::BitDesc(VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT, "VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT"),
+ tcu::Format::BitDesc(VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR, "VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR"),
+ tcu::Format::BitDesc(VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR, "VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR"),
+ tcu::Format::BitDesc(VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT_KHR, "VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT_KHR"),
+ tcu::Format::BitDesc(VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT_KHR, "VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT_KHR"),
+ tcu::Format::BitDesc(VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT_KHR, "VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT_KHR"),
+ tcu::Format::BitDesc(VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT_KHR, "VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT_KHR"),
+ tcu::Format::BitDesc(VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT_KHR, "VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT_KHR"),
+ tcu::Format::BitDesc(VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT_KHR, "VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT_KHR"),
+ tcu::Format::BitDesc(VK_FORMAT_FEATURE_DISJOINT_BIT_KHR, "VK_FORMAT_FEATURE_DISJOINT_BIT_KHR"),
+ tcu::Format::BitDesc(VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT_KHR, "VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT_KHR"),
};
return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
}
tcu::Format::BitDesc(VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_KHR, "VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_KHR"),
tcu::Format::BitDesc(VK_IMAGE_CREATE_EXTENDED_USAGE_BIT_KHR, "VK_IMAGE_CREATE_EXTENDED_USAGE_BIT_KHR"),
tcu::Format::BitDesc(VK_IMAGE_CREATE_ALIAS_BIT_KHR, "VK_IMAGE_CREATE_ALIAS_BIT_KHR"),
+ tcu::Format::BitDesc(VK_IMAGE_CREATE_DISJOINT_BIT_KHR, "VK_IMAGE_CREATE_DISJOINT_BIT_KHR"),
};
return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
}
{
static const tcu::Format::BitDesc s_desc[] =
{
- tcu::Format::BitDesc(VK_IMAGE_ASPECT_COLOR_BIT, "VK_IMAGE_ASPECT_COLOR_BIT"),
- tcu::Format::BitDesc(VK_IMAGE_ASPECT_DEPTH_BIT, "VK_IMAGE_ASPECT_DEPTH_BIT"),
- tcu::Format::BitDesc(VK_IMAGE_ASPECT_STENCIL_BIT, "VK_IMAGE_ASPECT_STENCIL_BIT"),
- tcu::Format::BitDesc(VK_IMAGE_ASPECT_METADATA_BIT, "VK_IMAGE_ASPECT_METADATA_BIT"),
+ tcu::Format::BitDesc(VK_IMAGE_ASPECT_COLOR_BIT, "VK_IMAGE_ASPECT_COLOR_BIT"),
+ tcu::Format::BitDesc(VK_IMAGE_ASPECT_DEPTH_BIT, "VK_IMAGE_ASPECT_DEPTH_BIT"),
+ tcu::Format::BitDesc(VK_IMAGE_ASPECT_STENCIL_BIT, "VK_IMAGE_ASPECT_STENCIL_BIT"),
+ tcu::Format::BitDesc(VK_IMAGE_ASPECT_METADATA_BIT, "VK_IMAGE_ASPECT_METADATA_BIT"),
+ tcu::Format::BitDesc(VK_IMAGE_ASPECT_PLANE_0_BIT_KHR, "VK_IMAGE_ASPECT_PLANE_0_BIT_KHR"),
+ tcu::Format::BitDesc(VK_IMAGE_ASPECT_PLANE_1_BIT_KHR, "VK_IMAGE_ASPECT_PLANE_1_BIT_KHR"),
+ tcu::Format::BitDesc(VK_IMAGE_ASPECT_PLANE_2_BIT_KHR, "VK_IMAGE_ASPECT_PLANE_2_BIT_KHR"),
};
return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
}
return s;
}
+std::ostream& operator<< (std::ostream& s, const VkSamplerYcbcrConversionCreateInfoKHR& value)
+{
+ s << "VkSamplerYcbcrConversionCreateInfoKHR = {\n";
+ s << "\tsType = " << value.sType << '\n';
+ s << "\tpNext = " << value.pNext << '\n';
+ s << "\tformat = " << value.format << '\n';
+ s << "\tYcbcrModel = " << value.YcbcrModel << '\n';
+ s << "\tYcbcrRange = " << value.YcbcrRange << '\n';
+ s << "\tcomponents = " << value.components << '\n';
+ s << "\txChromaOffset = " << value.xChromaOffset << '\n';
+ s << "\tyChromaOffset = " << value.yChromaOffset << '\n';
+ s << "\tchromaFilter = " << value.chromaFilter << '\n';
+ s << "\tforceExplicitReconstruction = " << value.forceExplicitReconstruction << '\n';
+ s << '}';
+ return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkSamplerYcbcrConversionInfoKHR& value)
+{
+ s << "VkSamplerYcbcrConversionInfoKHR = {\n";
+ s << "\tsType = " << value.sType << '\n';
+ s << "\tpNext = " << value.pNext << '\n';
+ s << "\tconversion = " << value.conversion << '\n';
+ s << '}';
+ return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkBindImagePlaneMemoryInfoKHR& value)
+{
+ s << "VkBindImagePlaneMemoryInfoKHR = {\n";
+ s << "\tsType = " << value.sType << '\n';
+ s << "\tpNext = " << value.pNext << '\n';
+ s << "\tplaneAspect = " << value.planeAspect << '\n';
+ s << '}';
+ return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkImagePlaneMemoryRequirementsInfoKHR& value)
+{
+ s << "VkImagePlaneMemoryRequirementsInfoKHR = {\n";
+ s << "\tsType = " << value.sType << '\n';
+ s << "\tpNext = " << value.pNext << '\n';
+ s << "\tplaneAspect = " << value.planeAspect << '\n';
+ s << '}';
+ return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR& value)
+{
+ s << "VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR = {\n";
+ s << "\tsType = " << value.sType << '\n';
+ s << "\tpNext = " << value.pNext << '\n';
+ s << "\tsamplerYcbcrConversion = " << value.samplerYcbcrConversion << '\n';
+ s << '}';
+ return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkSamplerYcbcrConversionImageFormatPropertiesKHR& value)
+{
+ s << "VkSamplerYcbcrConversionImageFormatPropertiesKHR = {\n";
+ s << "\tsType = " << value.sType << '\n';
+ s << "\tpNext = " << value.pNext << '\n';
+ s << "\tcombinedImageSamplerDescriptorCount = " << value.combinedImageSamplerDescriptorCount << '\n';
+ s << '}';
+ return s;
+}
+
std::ostream& operator<< (std::ostream& s, const VkDebugReportCallbackCreateInfoEXT& value)
{
s << "VkDebugReportCallbackCreateInfoEXT = {\n";
const VkFormat* pViewFormats;
};
+struct VkSamplerYcbcrConversionCreateInfoKHR
+{
+ VkStructureType sType;
+ const void* pNext;
+ VkFormat format;
+ VkSamplerYcbcrModelConversionKHR YcbcrModel;
+ VkSamplerYcbcrRangeKHR YcbcrRange;
+ VkComponentMapping components;
+ VkChromaLocationKHR xChromaOffset;
+ VkChromaLocationKHR yChromaOffset;
+ VkFilter chromaFilter;
+ VkBool32 forceExplicitReconstruction;
+};
+
+struct VkSamplerYcbcrConversionInfoKHR
+{
+ VkStructureType sType;
+ const void* pNext;
+ VkSamplerYcbcrConversionKHR conversion;
+};
+
+struct VkBindImagePlaneMemoryInfoKHR
+{
+ VkStructureType sType;
+ const void* pNext;
+ VkImageAspectFlagBits planeAspect;
+};
+
+struct VkImagePlaneMemoryRequirementsInfoKHR
+{
+ VkStructureType sType;
+ const void* pNext;
+ VkImageAspectFlagBits planeAspect;
+};
+
+struct VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR
+{
+ VkStructureType sType;
+ void* pNext;
+ VkBool32 samplerYcbcrConversion;
+};
+
+struct VkSamplerYcbcrConversionImageFormatPropertiesKHR
+{
+ VkStructureType sType;
+ void* pNext;
+ deUint32 combinedImageSamplerDescriptorCount;
+};
+
struct VkDebugReportCallbackCreateInfoEXT
{
VkStructureType sType;
virtual void getImageMemoryRequirements2KHR (VkDevice device, const VkImageMemoryRequirementsInfo2KHR* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements) const = 0;
virtual void getBufferMemoryRequirements2KHR (VkDevice device, const VkBufferMemoryRequirementsInfo2KHR* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements) const = 0;
virtual void getImageSparseMemoryRequirements2KHR (VkDevice device, const VkImageSparseMemoryRequirementsInfo2KHR* pInfo, deUint32* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2KHR* pSparseMemoryRequirements) const = 0;
+virtual VkResult createSamplerYcbcrConversionKHR (VkDevice device, const VkSamplerYcbcrConversionCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversionKHR* pYcbcrConversion) const = 0;
+virtual void destroySamplerYcbcrConversionKHR (VkDevice device, VkSamplerYcbcrConversionKHR YcbcrConversion, const VkAllocationCallbacks* pAllocator) const = 0;
virtual VkResult getMemoryWin32HandleKHR (VkDevice device, const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, pt::Win32Handle* pHandle) const = 0;
virtual VkResult getMemoryWin32HandlePropertiesKHR (VkDevice device, VkExternalMemoryHandleTypeFlagBitsKHR handleType, pt::Win32Handle handle, VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties) const = 0;
virtual VkResult getMemoryFdKHR (VkDevice device, const VkMemoryGetFdInfoKHR* pGetFdInfo, int* pFd) const = 0;
#include "tcuCommandLine.hpp"
+#include "deSTLUtil.hpp"
#include "deMemory.h"
namespace vkt
using std::string;
using namespace vk;
+namespace
+{
+
vector<string> getValidationLayers (const vector<VkLayerProperties>& supportedLayers)
{
static const char* s_magicLayer = "VK_LAYER_LUNARG_standard_validation";
TCU_THROW(NotSupportedError, "No matching queue found");
}
-Move<VkDevice> createDefaultDevice (const InstanceInterface& vki,
- VkPhysicalDevice physicalDevice,
- deUint32 queueIndex,
- const VkPhysicalDeviceFeatures& enabledFeatures,
- const vector<string>& enabledExtensions,
- const tcu::CommandLine& cmdLine)
+Move<VkDevice> createDefaultDevice (const InstanceInterface& vki,
+ VkPhysicalDevice physicalDevice,
+ deUint32 queueIndex,
+ const VkPhysicalDeviceFeatures2KHR& enabledFeatures,
+ const vector<string>& enabledExtensions,
+ const tcu::CommandLine& cmdLine)
{
VkDeviceQueueCreateInfo queueInfo;
VkDeviceCreateInfo deviceInfo;
for (size_t ndx = 0; ndx < enabledExtensions.size(); ++ndx)
extensionPtrs[ndx] = enabledExtensions[ndx].c_str();
+ // VK_KHR_get_physical_device_propeties2 is used if enabledFeatures.pNext != 0
+
queueInfo.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
- queueInfo.pNext = DE_NULL;
+ queueInfo.pNext = enabledFeatures.pNext ? &enabledFeatures : DE_NULL;
queueInfo.flags = (VkDeviceQueueCreateFlags)0u;
queueInfo.queueFamilyIndex = queueIndex;
queueInfo.queueCount = 1u;
deviceInfo.ppEnabledExtensionNames = (extensionPtrs.empty() ? DE_NULL : &extensionPtrs[0]);
deviceInfo.enabledLayerCount = (deUint32)layerPtrs.size();
deviceInfo.ppEnabledLayerNames = (layerPtrs.empty() ? DE_NULL : &layerPtrs[0]);
- deviceInfo.pEnabledFeatures = &enabledFeatures;
+ deviceInfo.pEnabledFeatures = enabledFeatures.pNext ? DE_NULL : &enabledFeatures.features;
return createDevice(vki, physicalDevice, &deviceInfo);
};
+bool isPhysicalDeviceFeatures2Supported (const vector<string>& instanceExtensions)
+{
+ return de::contains(instanceExtensions.begin(), instanceExtensions.end(), "VK_KHR_get_physical_device_properties2");
+}
+
+struct DeviceFeatures
+{
+ VkPhysicalDeviceFeatures2KHR coreFeatures;
+ VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR samplerYCbCrConversionFeatures;
+
+ DeviceFeatures (const InstanceInterface& vki,
+ VkPhysicalDevice physicalDevice,
+ const vector<string>& instanceExtensions,
+ const vector<string>& deviceExtensions)
+ {
+ void** curExtPoint = &coreFeatures.pNext;
+
+ deMemset(&coreFeatures, 0, sizeof(coreFeatures));
+ deMemset(&samplerYCbCrConversionFeatures, 0, sizeof(samplerYCbCrConversionFeatures));
+
+ coreFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR;
+ samplerYCbCrConversionFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES_KHR;
+
+ if (isPhysicalDeviceFeatures2Supported(instanceExtensions))
+ {
+ if (de::contains(deviceExtensions.begin(), deviceExtensions.end(), "VK_KHR_sampler_ycbcr_conversion"))
+ {
+ *curExtPoint = &samplerYCbCrConversionFeatures;
+ curExtPoint = &samplerYCbCrConversionFeatures.pNext;
+ }
+
+ vki.getPhysicalDeviceFeatures2KHR(physicalDevice, &coreFeatures);
+ }
+ else
+ coreFeatures.features = getPhysicalDeviceFeatures(vki, physicalDevice);
+
+ // Disable robustness by default, as it has an impact on performance on some HW.
+ coreFeatures.features.robustBufferAccess = false;
+ }
+};
+
+} // anonymous
+
class DefaultDevice
{
public:
DefaultDevice (const PlatformInterface& vkPlatform, const tcu::CommandLine& cmdLine);
~DefaultDevice (void);
- VkInstance getInstance (void) const { return *m_instance; }
- const InstanceInterface& getInstanceInterface (void) const { return m_instanceInterface; }
- const vector<string>& getInstanceExtensions (void) const { return m_instanceExtensions; }
+ VkInstance getInstance (void) const { return *m_instance; }
+ const InstanceInterface& getInstanceInterface (void) const { return m_instanceInterface; }
+ const vector<string>& getInstanceExtensions (void) const { return m_instanceExtensions; }
- VkPhysicalDevice getPhysicalDevice (void) const { return m_physicalDevice; }
- const VkPhysicalDeviceFeatures& getDeviceFeatures (void) const { return m_deviceFeatures; }
- VkDevice getDevice (void) const { return *m_device; }
- const DeviceInterface& getDeviceInterface (void) const { return m_deviceInterface; }
- const VkPhysicalDeviceProperties& getDeviceProperties (void) const { return m_deviceProperties; }
- const vector<string>& getDeviceExtensions (void) const { return m_deviceExtensions; }
+ VkPhysicalDevice getPhysicalDevice (void) const { return m_physicalDevice; }
+ const VkPhysicalDeviceFeatures& getDeviceFeatures (void) const { return m_deviceFeatures.coreFeatures.features; }
+ const VkPhysicalDeviceFeatures2KHR& getDeviceFeatures2 (void) const { return m_deviceFeatures.coreFeatures; }
+ VkDevice getDevice (void) const { return *m_device; }
+ const DeviceInterface& getDeviceInterface (void) const { return m_deviceInterface; }
+ const VkPhysicalDeviceProperties& getDeviceProperties (void) const { return m_deviceProperties; }
+ const vector<string>& getDeviceExtensions (void) const { return m_deviceExtensions; }
- deUint32 getUniversalQueueFamilyIndex (void) const { return m_universalQueueFamilyIndex; }
+ deUint32 getUniversalQueueFamilyIndex (void) const { return m_universalQueueFamilyIndex; }
VkQueue getUniversalQueue (void) const;
private:
const VkPhysicalDevice m_physicalDevice;
const deUint32 m_universalQueueFamilyIndex;
- const VkPhysicalDeviceFeatures m_deviceFeatures;
- const VkPhysicalDeviceProperties m_deviceProperties;
const vector<string> m_deviceExtensions;
+ const DeviceFeatures m_deviceFeatures;
+ const VkPhysicalDeviceProperties m_deviceProperties;
const Unique<VkDevice> m_device;
const DeviceDriver m_deviceInterface;
, m_instanceInterface (vkPlatform, *m_instance)
, m_physicalDevice (chooseDevice(m_instanceInterface, *m_instance, cmdLine))
, m_universalQueueFamilyIndex (findQueueFamilyIndexWithCaps(m_instanceInterface, m_physicalDevice, VK_QUEUE_GRAPHICS_BIT|VK_QUEUE_COMPUTE_BIT))
- , m_deviceFeatures (filterDefaultDeviceFeatures(getPhysicalDeviceFeatures(m_instanceInterface, m_physicalDevice)))
- , m_deviceProperties (getPhysicalDeviceProperties(m_instanceInterface, m_physicalDevice))
, m_deviceExtensions (filterExtensions(enumerateDeviceExtensionProperties(m_instanceInterface, m_physicalDevice, DE_NULL)))
- , m_device (createDefaultDevice(m_instanceInterface, m_physicalDevice, m_universalQueueFamilyIndex, m_deviceFeatures, m_deviceExtensions, cmdLine))
+ , m_deviceFeatures (m_instanceInterface, m_physicalDevice, m_instanceExtensions, m_deviceExtensions)
+ , m_deviceProperties (getPhysicalDeviceProperties(m_instanceInterface, m_physicalDevice))
+ , m_device (createDefaultDevice(m_instanceInterface,
+ m_physicalDevice,
+ m_universalQueueFamilyIndex,
+ m_deviceFeatures.coreFeatures,
+ m_deviceExtensions,
+ cmdLine))
, m_deviceInterface (m_instanceInterface, *m_device)
{
}
return getDeviceQueue(m_deviceInterface, *m_device, m_universalQueueFamilyIndex, 0);
}
-VkPhysicalDeviceFeatures DefaultDevice::filterDefaultDeviceFeatures (const VkPhysicalDeviceFeatures& deviceFeatures)
+namespace
{
- VkPhysicalDeviceFeatures enabledDeviceFeatures = deviceFeatures;
-
- // Disable robustness by default, as it has an impact on performance on some HW.
- enabledDeviceFeatures.robustBufferAccess = false;
-
- return enabledDeviceFeatures;
-}
// Allocator utilities
return new SimpleAllocator(device->getDeviceInterface(), device->getDevice(), memoryProperties);
}
+} // anonymous
+
// Context
Context::Context (tcu::TestContext& testCtx,
const vk::InstanceInterface& Context::getInstanceInterface (void) const { return m_device->getInstanceInterface(); }
vk::VkPhysicalDevice Context::getPhysicalDevice (void) const { return m_device->getPhysicalDevice(); }
const vk::VkPhysicalDeviceFeatures& Context::getDeviceFeatures (void) const { return m_device->getDeviceFeatures(); }
+const vk::VkPhysicalDeviceFeatures2KHR& Context::getDeviceFeatures2 (void) const { return m_device->getDeviceFeatures2(); }
const vk::VkPhysicalDeviceProperties& Context::getDeviceProperties (void) const { return m_device->getDeviceProperties(); }
const vector<string>& Context::getDeviceExtensions (void) const { return m_device->getDeviceExtensions(); }
vk::VkDevice Context::getDevice (void) const { return m_device->getDevice(); }
const vk::InstanceInterface& getInstanceInterface (void) const;
vk::VkPhysicalDevice getPhysicalDevice (void) const;
const vk::VkPhysicalDeviceFeatures& getDeviceFeatures (void) const;
+ const vk::VkPhysicalDeviceFeatures2KHR& getDeviceFeatures2 (void) const;
const vk::VkPhysicalDeviceProperties& getDeviceProperties (void) const;
const std::vector<std::string>& getDeviceExtensions (void) const;
vk::VkDevice getDevice (void) const;
EXTENSION_POSTFIXES = ["KHR", "EXT", "NV", "NVX", "KHX"]
+def typeNameToEnumValue (name):
+ name = re.sub(r'([a-z0-9])([A-Z])', r'\1_\2', name[2:])
+ name = re.sub(r'([a-zA-Z])([0-9])', r'\1_\2', name)
+ name = name.upper()
+
+ # Patch irregularities
+ name = name.replace("YCB_CR_", "YCBCR_")
+ name = name.replace("WIN_32_", "WIN32_")
+ name = name.replace("16_BIT_", "16BIT_")
+ name = name.replace("D_3_D_12_", "D3D12_")
+ name = name.replace("_IDPROPERTIES_", "_ID_PROPERTIES_")
+
+ return name
+
class Handle:
TYPE_DISP = 0
TYPE_NONDISP = 1
self.name = name
def getHandleType (self):
- name = re.sub(r'([a-z])([A-Z])', r'\1_\2', self.name)
- return "HANDLE_TYPE_" + name[3:].upper()
+ return "HANDLE_TYPE_" + typeNameToEnumValue(self.name)
class Enum:
def __init__ (self, name, values):
writeInlFile(filename, INL_HEADER, makeRefUtilImpl())
+def writeStructTraitsImpl (api, filename):
+ def gen ():
+ for type in api.compositeTypes:
+ if type.getClassName() == "struct" and type.members[0].name == "sType":
+ yield "template<> VkStructureType getStructureType<%s> (void)" % type.name
+ yield "{"
+ yield "\treturn VK_STRUCTURE_TYPE_%s;" % typeNameToEnumValue(type.name)
+ yield "}"
+ yield ""
+
+ writeInlFile(filename, INL_HEADER, gen())
+
def writeNullDriverImpl (api, filename):
def genNullDriverImpl ():
specialFuncNames = [
"vkGetInstanceProcAddr",
"vkGetDeviceProcAddr",
"vkEnumeratePhysicalDevices",
+ "vkEnumerateInstanceExtensionProperties",
+ "vkEnumerateDeviceExtensionProperties",
"vkGetPhysicalDeviceFeatures",
+ "vkGetPhysicalDeviceFeatures2KHR",
"vkGetPhysicalDeviceProperties",
+ "vkGetPhysicalDeviceProperties2KHR",
"vkGetPhysicalDeviceQueueFamilyProperties",
"vkGetPhysicalDeviceMemoryProperties",
"vkGetPhysicalDeviceFormatProperties",
"vkGetPhysicalDeviceImageFormatProperties",
"vkGetDeviceQueue",
"vkGetBufferMemoryRequirements",
+ "vkGetBufferMemoryRequirements2KHR",
"vkGetImageMemoryRequirements",
+ "vkGetImageMemoryRequirements2KHR",
"vkMapMemory",
"vkAllocateDescriptorSets",
"vkFreeDescriptorSets",
writeStrUtilImpl (api, os.path.join(VULKAN_DIR, "vkStrUtilImpl.inl"))
writeRefUtilProto (api, os.path.join(VULKAN_DIR, "vkRefUtil.inl"))
writeRefUtilImpl (api, os.path.join(VULKAN_DIR, "vkRefUtilImpl.inl"))
+ writeStructTraitsImpl (api, os.path.join(VULKAN_DIR, "vkGetStructureTypeImpl.inl"))
writeNullDriverImpl (api, os.path.join(VULKAN_DIR, "vkNullDriverImpl.inl"))
writeTypeUtil (api, os.path.join(VULKAN_DIR, "vkTypeUtil.inl"))
VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2_KHR = 1000146002,
VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR = 1000146003,
VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2_KHR = 1000146004,
- VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHR = 1000157000,
+ VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO_KHR = 1000156000,
+ VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO_KHR = 1000156001,
+ VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO_KHR = 1000156002,
+ VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO_KHR = 1000156003,
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES_KHR = 1000156004,
+ VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES_KHR = 1000156005,
+ VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHR = 1000157000,
VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHR = 1000157001,
VK_STRUCTURE_TYPE_BEGIN_RANGE = VK_STRUCTURE_TYPE_APPLICATION_INFO,
VK_STRUCTURE_TYPE_END_RANGE = VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO,
VK_FORMAT_ASTC_12x10_SRGB_BLOCK = 182,
VK_FORMAT_ASTC_12x12_UNORM_BLOCK = 183,
VK_FORMAT_ASTC_12x12_SRGB_BLOCK = 184,
+ VK_FORMAT_G8B8G8R8_422_UNORM_KHR = 1000156000,
+ VK_FORMAT_B8G8R8G8_422_UNORM_KHR = 1000156001,
+ VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM_KHR = 1000156002,
+ VK_FORMAT_G8_B8R8_2PLANE_420_UNORM_KHR = 1000156003,
+ VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM_KHR = 1000156004,
+ VK_FORMAT_G8_B8R8_2PLANE_422_UNORM_KHR = 1000156005,
+ VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM_KHR = 1000156006,
+ VK_FORMAT_R10X6_UNORM_PACK16_KHR = 1000156007,
+ VK_FORMAT_R10X6G10X6_UNORM_2PACK16_KHR = 1000156008,
+ VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16_KHR = 1000156009,
+ VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16_KHR = 1000156010,
+ VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16_KHR = 1000156011,
+ VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16_KHR = 1000156012,
+ VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16_KHR = 1000156013,
+ VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16_KHR = 1000156014,
+ VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16_KHR = 1000156015,
+ VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16_KHR = 1000156016,
+ VK_FORMAT_R12X4_UNORM_PACK16_KHR = 1000156017,
+ VK_FORMAT_R12X4G12X4_UNORM_2PACK16_KHR = 1000156018,
+ VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16_KHR = 1000156019,
+ VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16_KHR = 1000156020,
+ VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16_KHR = 1000156021,
+ VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16_KHR = 1000156022,
+ VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16_KHR = 1000156023,
+ VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16_KHR = 1000156024,
+ VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16_KHR = 1000156025,
+ VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16_KHR = 1000156026,
+ VK_FORMAT_G16B16G16R16_422_UNORM_KHR = 1000156027,
+ VK_FORMAT_B16G16R16G16_422_UNORM_KHR = 1000156028,
+ VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM_KHR = 1000156029,
+ VK_FORMAT_G16_B16R16_2PLANE_420_UNORM_KHR = 1000156030,
+ VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM_KHR = 1000156031,
+ VK_FORMAT_G16_B16R16_2PLANE_422_UNORM_KHR = 1000156032,
+ VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM_KHR = 1000156033,
VK_FORMAT_BEGIN_RANGE = VK_FORMAT_UNDEFINED,
VK_FORMAT_END_RANGE = VK_FORMAT_ASTC_12x12_SRGB_BLOCK,
VK_FORMAT_RANGE_SIZE = (VK_FORMAT_ASTC_12x12_SRGB_BLOCK - VK_FORMAT_UNDEFINED + 1),
VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT = 0x00001000,
VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR = 0x00004000,
VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR = 0x00008000,
+ VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT_KHR = 0x00010000,
+ VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT_KHR = 0x00020000,
+ VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT_KHR = 0x00040000,
+ VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT_KHR = 0x00080000,
+ VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT_KHR = 0x00100000,
+ VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT_KHR = 0x00200000,
+ VK_FORMAT_FEATURE_DISJOINT_BIT_KHR = 0x00400000,
+ VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT_KHR = 0x00800000,
VK_FORMAT_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
} VkFormatFeatureFlagBits;
typedef VkFlags VkFormatFeatureFlags;
VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR = 0x00000020,
VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_KHR = 0x00000080,
VK_IMAGE_CREATE_EXTENDED_USAGE_BIT_KHR = 0x00000100,
- VK_IMAGE_CREATE_ALIAS_BIT_KHR = 0x00000400,
+ VK_IMAGE_CREATE_ALIAS_BIT_KHR = 0x00000400,
+ VK_IMAGE_CREATE_DISJOINT_BIT_KHR = 0x00000200,
VK_IMAGE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
} VkImageCreateFlagBits;
typedef VkFlags VkImageCreateFlags;
VK_IMAGE_ASPECT_DEPTH_BIT = 0x00000002,
VK_IMAGE_ASPECT_STENCIL_BIT = 0x00000004,
VK_IMAGE_ASPECT_METADATA_BIT = 0x00000008,
+ VK_IMAGE_ASPECT_PLANE_0_BIT_KHR = 0x00000010,
+ VK_IMAGE_ASPECT_PLANE_1_BIT_KHR = 0x00000020,
+ VK_IMAGE_ASPECT_PLANE_2_BIT_KHR = 0x00000040,
VK_IMAGE_ASPECT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
} VkImageAspectFlagBits;
typedef VkFlags VkImageAspectFlags;
const VkFormat* pViewFormats;
} VkImageFormatListCreateInfoKHR;
+#define VK_KHR_sampler_ycbcr_conversion 1
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSamplerYcbcrConversionKHR)
+
+#define VK_KHR_SAMPLER_YCBCR_CONVERSION_SPEC_VERSION 1
+#define VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME "VK_KHR_sampler_ycbcr_conversion"
+
+
+typedef enum VkSamplerYcbcrModelConversionKHR {
+ VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY_KHR = 0,
+ VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY_KHR = 1,
+ VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709_KHR = 2,
+ VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601_KHR = 3,
+ VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020_KHR = 4,
+ VK_SAMPLER_YCBCR_MODEL_CONVERSION_BEGIN_RANGE_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY_KHR,
+ VK_SAMPLER_YCBCR_MODEL_CONVERSION_END_RANGE_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020_KHR,
+ VK_SAMPLER_YCBCR_MODEL_CONVERSION_RANGE_SIZE_KHR = (VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020_KHR - VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY_KHR + 1),
+ VK_SAMPLER_YCBCR_MODEL_CONVERSION_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkSamplerYcbcrModelConversionKHR;
+
+typedef enum VkSamplerYcbcrRangeKHR {
+ VK_SAMPLER_YCBCR_RANGE_ITU_FULL_KHR = 0,
+ VK_SAMPLER_YCBCR_RANGE_ITU_NARROW_KHR = 1,
+ VK_SAMPLER_YCBCR_RANGE_BEGIN_RANGE_KHR = VK_SAMPLER_YCBCR_RANGE_KHRONOS_KHR,
+ VK_SAMPLER_YCBCR_RANGE_END_RANGE_KHR = VK_SAMPLER_YCBCR_RANGE_ITU_NARROW_KHR,
+ VK_SAMPLER_YCBCR_RANGE_RANGE_SIZE_KHR = (VK_SAMPLER_YCBCR_RANGE_ITU_NARROW_KHR - VK_SAMPLER_YCBCR_RANGE_KHRONOS_KHR + 1),
+ VK_SAMPLER_YCBCR_RANGE_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkSamplerYcbcrRangeKHR;
+
+typedef enum VkChromaLocationKHR {
+ VK_CHROMA_LOCATION_COSITED_EVEN_KHR = 0,
+ VK_CHROMA_LOCATION_MIDPOINT_KHR = 1,
+ VK_CHROMA_LOCATION_BEGIN_RANGE_KHR = VK_CHROMA_LOCATION_COSITED_EVEN_KHR,
+ VK_CHROMA_LOCATION_END_RANGE_KHR = VK_CHROMA_LOCATION_MIDPOINT_KHR,
+ VK_CHROMA_LOCATION_RANGE_SIZE_KHR = (VK_CHROMA_LOCATION_MIDPOINT_KHR - VK_CHROMA_LOCATION_COSITED_EVEN_KHR + 1),
+ VK_CHROMA_LOCATION_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkChromaLocationKHR;
+
+typedef struct VkSamplerYcbcrConversionCreateInfoKHR {
+ VkStructureType sType;
+ const void* pNext;
+ VkFormat format;
+ VkSamplerYcbcrModelConversionKHR YcbcrModel;
+ VkSamplerYcbcrRangeKHR YcbcrRange;
+ VkComponentMapping components;
+ VkChromaLocationKHR xChromaOffset;
+ VkChromaLocationKHR yChromaOffset;
+ VkFilter chromaFilter;
+ VkBool32 forceExplicitReconstruction;
+} VkSamplerYcbcrConversionCreateInfoKHR;
+
+typedef struct VkSamplerYcbcrConversionInfoKHR {
+ VkStructureType sType;
+ const void* pNext;
+ VkSamplerYcbcrConversionKHR conversion;
+} VkSamplerYcbcrConversionInfoKHR;
+
+typedef struct VkBindImagePlaneMemoryInfoKHR {
+ VkStructureType sType;
+ const void* pNext;
+ VkImageAspectFlagBits planeAspect;
+} VkBindImagePlaneMemoryInfoKHR;
+
+typedef struct VkImagePlaneMemoryRequirementsInfoKHR {
+ VkStructureType sType;
+ const void* pNext;
+ VkImageAspectFlagBits planeAspect;
+} VkImagePlaneMemoryRequirementsInfoKHR;
+
+typedef struct VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR {
+ VkStructureType sType;
+ void* pNext;
+ VkBool32 samplerYcbcrConversion;
+} VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR;
+
+typedef struct VkSamplerYcbcrConversionImageFormatPropertiesKHR {
+ VkStructureType sType;
+ void* pNext;
+ uint32_t combinedImageSamplerDescriptorCount;
+} VkSamplerYcbcrConversionImageFormatPropertiesKHR;
+
+
+typedef VkResult (VKAPI_PTR *PFN_vkCreateSamplerYcbcrConversionKHR)(VkDevice device, const VkSamplerYcbcrConversionCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversionKHR* pYcbcrConversion);
+typedef void (VKAPI_PTR *PFN_vkDestroySamplerYcbcrConversionKHR)(VkDevice device, VkSamplerYcbcrConversionKHR YcbcrConversion, const VkAllocationCallbacks* pAllocator);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateSamplerYcbcrConversionKHR(
+ VkDevice device,
+ const VkSamplerYcbcrConversionCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSamplerYcbcrConversionKHR* pYcbcrConversion);
+
+VKAPI_ATTR void VKAPI_CALL vkDestroySamplerYcbcrConversionKHR(
+ VkDevice device,
+ VkSamplerYcbcrConversionKHR YcbcrConversion,
+ const VkAllocationCallbacks* pAllocator);
+#endif
+
#define VK_EXT_debug_report 1
VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDebugReportCallbackEXT)
VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT = 29,
VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT = 30,
VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR_EXT = 1000085000,
+ VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR_EXT = 1000156000,
VK_DEBUG_REPORT_OBJECT_TYPE_BEGIN_RANGE_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT,
VK_DEBUG_REPORT_OBJECT_TYPE_END_RANGE_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT,
VK_DEBUG_REPORT_OBJECT_TYPE_RANGE_SIZE_EXT = (VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT - VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT + 1),
projects / platform / upstream / VK-GL-CTS.git / commitdiff