external/vulkancts/modules/vulkan/geometry/vktGeometryTests.cpp \
external/vulkancts/modules/vulkan/geometry/vktGeometryTestsUtil.cpp \
external/vulkancts/modules/vulkan/geometry/vktGeometryVaryingGeometryShaderTests.cpp \
+ external/vulkancts/modules/vulkan/image/vktImageAstcDecodeModeTests.cpp \
external/vulkancts/modules/vulkan/image/vktImageAtomicOperationTests.cpp \
external/vulkancts/modules/vulkan/image/vktImageCompressionTranscodingSupport.cpp \
external/vulkancts/modules/vulkan/image/vktImageLoadStoreTests.cpp \
dEQP-VK.image.extend_operands_spirv1p4.r8_sint_force_sign_extend
dEQP-VK.image.extend_operands_spirv1p4.r8_sint_relaxed_matching_extend
dEQP-VK.image.extend_operands_spirv1p4.r8_sint_relaxed_force_sign_extend
+dEQP-VK.image.astc_decode_mode.4x4_unorm_to_r16g16b16a16_sfloat
+dEQP-VK.image.astc_decode_mode.4x4_unorm_to_r8g8b8a8_unorm
+dEQP-VK.image.astc_decode_mode.4x4_unorm_to_e5b9g9r9_ufloat_pack32
+dEQP-VK.image.astc_decode_mode.4x4_srgb_to_r16g16b16a16_sfloat
+dEQP-VK.image.astc_decode_mode.4x4_srgb_to_r8g8b8a8_unorm
+dEQP-VK.image.astc_decode_mode.4x4_srgb_to_e5b9g9r9_ufloat_pack32
+dEQP-VK.image.astc_decode_mode.5x4_unorm_to_r16g16b16a16_sfloat
+dEQP-VK.image.astc_decode_mode.5x4_unorm_to_r8g8b8a8_unorm
+dEQP-VK.image.astc_decode_mode.5x4_unorm_to_e5b9g9r9_ufloat_pack32
+dEQP-VK.image.astc_decode_mode.5x4_srgb_to_r16g16b16a16_sfloat
+dEQP-VK.image.astc_decode_mode.5x4_srgb_to_r8g8b8a8_unorm
+dEQP-VK.image.astc_decode_mode.5x4_srgb_to_e5b9g9r9_ufloat_pack32
+dEQP-VK.image.astc_decode_mode.5x5_unorm_to_r16g16b16a16_sfloat
+dEQP-VK.image.astc_decode_mode.5x5_unorm_to_r8g8b8a8_unorm
+dEQP-VK.image.astc_decode_mode.5x5_unorm_to_e5b9g9r9_ufloat_pack32
+dEQP-VK.image.astc_decode_mode.5x5_srgb_to_r16g16b16a16_sfloat
+dEQP-VK.image.astc_decode_mode.5x5_srgb_to_r8g8b8a8_unorm
+dEQP-VK.image.astc_decode_mode.5x5_srgb_to_e5b9g9r9_ufloat_pack32
+dEQP-VK.image.astc_decode_mode.6x5_unorm_to_r16g16b16a16_sfloat
+dEQP-VK.image.astc_decode_mode.6x5_unorm_to_r8g8b8a8_unorm
+dEQP-VK.image.astc_decode_mode.6x5_unorm_to_e5b9g9r9_ufloat_pack32
+dEQP-VK.image.astc_decode_mode.6x5_srgb_to_r16g16b16a16_sfloat
+dEQP-VK.image.astc_decode_mode.6x5_srgb_to_r8g8b8a8_unorm
+dEQP-VK.image.astc_decode_mode.6x5_srgb_to_e5b9g9r9_ufloat_pack32
+dEQP-VK.image.astc_decode_mode.6x6_unorm_to_r16g16b16a16_sfloat
+dEQP-VK.image.astc_decode_mode.6x6_unorm_to_r8g8b8a8_unorm
+dEQP-VK.image.astc_decode_mode.6x6_unorm_to_e5b9g9r9_ufloat_pack32
+dEQP-VK.image.astc_decode_mode.6x6_srgb_to_r16g16b16a16_sfloat
+dEQP-VK.image.astc_decode_mode.6x6_srgb_to_r8g8b8a8_unorm
+dEQP-VK.image.astc_decode_mode.6x6_srgb_to_e5b9g9r9_ufloat_pack32
+dEQP-VK.image.astc_decode_mode.8x5_unorm_to_r16g16b16a16_sfloat
+dEQP-VK.image.astc_decode_mode.8x5_unorm_to_r8g8b8a8_unorm
+dEQP-VK.image.astc_decode_mode.8x5_unorm_to_e5b9g9r9_ufloat_pack32
+dEQP-VK.image.astc_decode_mode.8x5_srgb_to_r16g16b16a16_sfloat
+dEQP-VK.image.astc_decode_mode.8x5_srgb_to_r8g8b8a8_unorm
+dEQP-VK.image.astc_decode_mode.8x5_srgb_to_e5b9g9r9_ufloat_pack32
+dEQP-VK.image.astc_decode_mode.8x6_unorm_to_r16g16b16a16_sfloat
+dEQP-VK.image.astc_decode_mode.8x6_unorm_to_r8g8b8a8_unorm
+dEQP-VK.image.astc_decode_mode.8x6_unorm_to_e5b9g9r9_ufloat_pack32
+dEQP-VK.image.astc_decode_mode.8x6_srgb_to_r16g16b16a16_sfloat
+dEQP-VK.image.astc_decode_mode.8x6_srgb_to_r8g8b8a8_unorm
+dEQP-VK.image.astc_decode_mode.8x6_srgb_to_e5b9g9r9_ufloat_pack32
+dEQP-VK.image.astc_decode_mode.8x8_unorm_to_r16g16b16a16_sfloat
+dEQP-VK.image.astc_decode_mode.8x8_unorm_to_r8g8b8a8_unorm
+dEQP-VK.image.astc_decode_mode.8x8_unorm_to_e5b9g9r9_ufloat_pack32
+dEQP-VK.image.astc_decode_mode.8x8_srgb_to_r16g16b16a16_sfloat
+dEQP-VK.image.astc_decode_mode.8x8_srgb_to_r8g8b8a8_unorm
+dEQP-VK.image.astc_decode_mode.8x8_srgb_to_e5b9g9r9_ufloat_pack32
+dEQP-VK.image.astc_decode_mode.10x5_unorm_to_r16g16b16a16_sfloat
+dEQP-VK.image.astc_decode_mode.10x5_unorm_to_r8g8b8a8_unorm
+dEQP-VK.image.astc_decode_mode.10x5_unorm_to_e5b9g9r9_ufloat_pack32
+dEQP-VK.image.astc_decode_mode.10x5_srgb_to_r16g16b16a16_sfloat
+dEQP-VK.image.astc_decode_mode.10x5_srgb_to_r8g8b8a8_unorm
+dEQP-VK.image.astc_decode_mode.10x5_srgb_to_e5b9g9r9_ufloat_pack32
+dEQP-VK.image.astc_decode_mode.10x6_unorm_to_r16g16b16a16_sfloat
+dEQP-VK.image.astc_decode_mode.10x6_unorm_to_r8g8b8a8_unorm
+dEQP-VK.image.astc_decode_mode.10x6_unorm_to_e5b9g9r9_ufloat_pack32
+dEQP-VK.image.astc_decode_mode.10x6_srgb_to_r16g16b16a16_sfloat
+dEQP-VK.image.astc_decode_mode.10x6_srgb_to_r8g8b8a8_unorm
+dEQP-VK.image.astc_decode_mode.10x6_srgb_to_e5b9g9r9_ufloat_pack32
+dEQP-VK.image.astc_decode_mode.10x8_unorm_to_r16g16b16a16_sfloat
+dEQP-VK.image.astc_decode_mode.10x8_unorm_to_r8g8b8a8_unorm
+dEQP-VK.image.astc_decode_mode.10x8_unorm_to_e5b9g9r9_ufloat_pack32
+dEQP-VK.image.astc_decode_mode.10x8_srgb_to_r16g16b16a16_sfloat
+dEQP-VK.image.astc_decode_mode.10x8_srgb_to_r8g8b8a8_unorm
+dEQP-VK.image.astc_decode_mode.10x8_srgb_to_e5b9g9r9_ufloat_pack32
+dEQP-VK.image.astc_decode_mode.10x10_unorm_to_r16g16b16a16_sfloat
+dEQP-VK.image.astc_decode_mode.10x10_unorm_to_r8g8b8a8_unorm
+dEQP-VK.image.astc_decode_mode.10x10_unorm_to_e5b9g9r9_ufloat_pack32
+dEQP-VK.image.astc_decode_mode.10x10_srgb_to_r16g16b16a16_sfloat
+dEQP-VK.image.astc_decode_mode.10x10_srgb_to_r8g8b8a8_unorm
+dEQP-VK.image.astc_decode_mode.10x10_srgb_to_e5b9g9r9_ufloat_pack32
+dEQP-VK.image.astc_decode_mode.12x10_unorm_to_r16g16b16a16_sfloat
+dEQP-VK.image.astc_decode_mode.12x10_unorm_to_r8g8b8a8_unorm
+dEQP-VK.image.astc_decode_mode.12x10_unorm_to_e5b9g9r9_ufloat_pack32
+dEQP-VK.image.astc_decode_mode.12x10_srgb_to_r16g16b16a16_sfloat
+dEQP-VK.image.astc_decode_mode.12x10_srgb_to_r8g8b8a8_unorm
+dEQP-VK.image.astc_decode_mode.12x10_srgb_to_e5b9g9r9_ufloat_pack32
+dEQP-VK.image.astc_decode_mode.12x12_unorm_to_r16g16b16a16_sfloat
+dEQP-VK.image.astc_decode_mode.12x12_unorm_to_r8g8b8a8_unorm
+dEQP-VK.image.astc_decode_mode.12x12_unorm_to_e5b9g9r9_ufloat_pack32
+dEQP-VK.image.astc_decode_mode.12x12_srgb_to_r16g16b16a16_sfloat
+dEQP-VK.image.astc_decode_mode.12x12_srgb_to_r8g8b8a8_unorm
+dEQP-VK.image.astc_decode_mode.12x12_srgb_to_e5b9g9r9_ufloat_pack32
dEQP-VK.image.misaligned_cube.7
dEQP-VK.image.misaligned_cube.8
dEQP-VK.image.misaligned_cube.9
{
#define VK_KHR_16BIT_STORAGE_EXTENSION_NAME "VK_KHR_16bit_storage"
#define VK_KHR_8BIT_STORAGE_EXTENSION_NAME "VK_KHR_8bit_storage"
+#define VK_EXT_ASTC_DECODE_MODE_EXTENSION_NAME "VK_EXT_astc_decode_mode"
#define VK_EXT_BLEND_OPERATION_ADVANCED_EXTENSION_NAME "VK_EXT_blend_operation_advanced"
#define VK_EXT_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME "VK_EXT_buffer_device_address"
#define DECL_AMD_COHERENT_MEMORY_EXTENSION_NAME "not_existent_feature"
#define VK_KHR_SHADER_FLOAT16_INT8_EXTENSION_NAME "VK_KHR_shader_float16_int8"
#define VK_NV_SHADER_IMAGE_FOOTPRINT_EXTENSION_NAME "VK_NV_shader_image_footprint"
#define VK_INTEL_SHADER_INTEGER_FUNCTIONS_2_EXTENSION_NAME "VK_INTEL_shader_integer_functions2"
+#define VK_NV_SHADER_SM_BUILTINS_EXTENSION_NAME "VK_NV_shader_sm_builtins"
#define VK_KHR_SHADER_SUBGROUP_EXTENDED_TYPES_EXTENSION_NAME "VK_KHR_shader_subgroup_extended_types"
#define VK_NV_SHADING_RATE_IMAGE_EXTENSION_NAME "VK_NV_shading_rate_image"
#define VK_EXT_SUBGROUP_SIZE_CONTROL_EXTENSION_NAME "VK_EXT_subgroup_size_control"
#define VK_EXT_YCBCR_IMAGE_ARRAYS_EXTENSION_NAME "VK_EXT_ycbcr_image_arrays"
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDevice16BitStorageFeatures>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES, VK_KHR_16BIT_STORAGE_EXTENSION_NAME, VK_KHR_16BIT_STORAGE_SPEC_VERSION, 50); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDevice8BitStorageFeaturesKHR>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR, VK_KHR_8BIT_STORAGE_EXTENSION_NAME, VK_KHR_8BIT_STORAGE_SPEC_VERSION, 49); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT, VK_EXT_BLEND_OPERATION_ADVANCED_EXTENSION_NAME, VK_EXT_BLEND_OPERATION_ADVANCED_SPEC_VERSION, 48); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceBufferDeviceAddressFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT, VK_EXT_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME, VK_EXT_BUFFER_DEVICE_ADDRESS_SPEC_VERSION, 47); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceCoherentMemoryFeaturesAMD>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD, DECL_AMD_COHERENT_MEMORY_EXTENSION_NAME, 0, 46); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceComputeShaderDerivativesFeaturesNV>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV, VK_NV_COMPUTE_SHADER_DERIVATIVES_EXTENSION_NAME, VK_NV_COMPUTE_SHADER_DERIVATIVES_SPEC_VERSION, 45); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceConditionalRenderingFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT, VK_EXT_CONDITIONAL_RENDERING_EXTENSION_NAME, VK_EXT_CONDITIONAL_RENDERING_SPEC_VERSION, 44); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceCooperativeMatrixFeaturesNV>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV, VK_NV_COOPERATIVE_MATRIX_EXTENSION_NAME, VK_NV_COOPERATIVE_MATRIX_SPEC_VERSION, 43); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceCornerSampledImageFeaturesNV>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV, VK_NV_CORNER_SAMPLED_IMAGE_EXTENSION_NAME, VK_NV_CORNER_SAMPLED_IMAGE_SPEC_VERSION, 42); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceCoverageReductionModeFeaturesNV>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV, VK_NV_COVERAGE_REDUCTION_MODE_EXTENSION_NAME, VK_NV_COVERAGE_REDUCTION_MODE_SPEC_VERSION, 41); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV, VK_NV_DEDICATED_ALLOCATION_IMAGE_ALIASING_EXTENSION_NAME, VK_NV_DEDICATED_ALLOCATION_IMAGE_ALIASING_SPEC_VERSION, 40); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceDepthClipEnableFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT, VK_EXT_DEPTH_CLIP_ENABLE_EXTENSION_NAME, VK_EXT_DEPTH_CLIP_ENABLE_SPEC_VERSION, 39); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceDescriptorIndexingFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT, VK_EXT_DESCRIPTOR_INDEXING_EXTENSION_NAME, VK_EXT_DESCRIPTOR_INDEXING_SPEC_VERSION, 38); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceExclusiveScissorFeaturesNV>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV, VK_NV_SCISSOR_EXCLUSIVE_EXTENSION_NAME, VK_NV_SCISSOR_EXCLUSIVE_SPEC_VERSION, 37); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceFragmentDensityMapFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT, VK_EXT_FRAGMENT_DENSITY_MAP_EXTENSION_NAME, VK_EXT_FRAGMENT_DENSITY_MAP_SPEC_VERSION, 36); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV, VK_NV_FRAGMENT_SHADER_BARYCENTRIC_EXTENSION_NAME, VK_NV_FRAGMENT_SHADER_BARYCENTRIC_SPEC_VERSION, 35); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT, VK_EXT_FRAGMENT_SHADER_INTERLOCK_EXTENSION_NAME, VK_EXT_FRAGMENT_SHADER_INTERLOCK_SPEC_VERSION, 34); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceHostQueryResetFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES_EXT, VK_EXT_HOST_QUERY_RESET_EXTENSION_NAME, VK_EXT_HOST_QUERY_RESET_SPEC_VERSION, 33); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceImagelessFramebufferFeaturesKHR>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES_KHR, VK_KHR_IMAGELESS_FRAMEBUFFER_EXTENSION_NAME, VK_KHR_IMAGELESS_FRAMEBUFFER_SPEC_VERSION, 32); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceIndexTypeUint8FeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT, VK_EXT_INDEX_TYPE_UINT8_EXTENSION_NAME, VK_EXT_INDEX_TYPE_UINT8_SPEC_VERSION, 31); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceInlineUniformBlockFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT, VK_EXT_INLINE_UNIFORM_BLOCK_EXTENSION_NAME, VK_EXT_INLINE_UNIFORM_BLOCK_SPEC_VERSION, 30); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceLineRasterizationFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT, VK_EXT_LINE_RASTERIZATION_EXTENSION_NAME, VK_EXT_LINE_RASTERIZATION_SPEC_VERSION, 29); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceMemoryPriorityFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT, VK_EXT_MEMORY_PRIORITY_EXTENSION_NAME, VK_EXT_MEMORY_PRIORITY_SPEC_VERSION, 28); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceMeshShaderFeaturesNV>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV, VK_NV_MESH_SHADER_EXTENSION_NAME, VK_NV_MESH_SHADER_SPEC_VERSION, 27); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceMultiviewFeatures>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES, VK_KHR_MULTIVIEW_EXTENSION_NAME, VK_KHR_MULTIVIEW_SPEC_VERSION, 26); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDevicePerformanceQueryFeaturesKHR>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR, VK_KHR_PERFORMANCE_QUERY_EXTENSION_NAME, VK_KHR_PERFORMANCE_QUERY_SPEC_VERSION, 25); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR, VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_EXTENSION_NAME, VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_SPEC_VERSION, 24); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceProtectedMemoryFeatures>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES, DECL_PROTECTED_MEMORY_EXTENSION_NAME, 0, 23); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV, VK_NV_REPRESENTATIVE_FRAGMENT_TEST_EXTENSION_NAME, VK_NV_REPRESENTATIVE_FRAGMENT_TEST_SPEC_VERSION, 22); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceSamplerYcbcrConversionFeatures>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES, VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME, VK_KHR_SAMPLER_YCBCR_CONVERSION_SPEC_VERSION, 21); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceScalarBlockLayoutFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES_EXT, VK_EXT_SCALAR_BLOCK_LAYOUT_EXTENSION_NAME, VK_EXT_SCALAR_BLOCK_LAYOUT_SPEC_VERSION, 20); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES_KHR, VK_KHR_SEPARATE_DEPTH_STENCIL_LAYOUTS_EXTENSION_NAME, VK_KHR_SEPARATE_DEPTH_STENCIL_LAYOUTS_SPEC_VERSION, 19); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceShaderAtomicInt64FeaturesKHR>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES_KHR, VK_KHR_SHADER_ATOMIC_INT64_EXTENSION_NAME, VK_KHR_SHADER_ATOMIC_INT64_SPEC_VERSION, 18); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceShaderClockFeaturesKHR>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR, VK_KHR_SHADER_CLOCK_EXTENSION_NAME, VK_KHR_SHADER_CLOCK_SPEC_VERSION, 17); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT, VK_EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_EXTENSION_NAME, VK_EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_SPEC_VERSION, 16); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceShaderDrawParametersFeatures>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES, VK_KHR_SHADER_DRAW_PARAMETERS_EXTENSION_NAME, VK_KHR_SHADER_DRAW_PARAMETERS_SPEC_VERSION, 15); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceShaderFloat16Int8FeaturesKHR>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES_KHR, VK_KHR_SHADER_FLOAT16_INT8_EXTENSION_NAME, VK_KHR_SHADER_FLOAT16_INT8_SPEC_VERSION, 14); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceShaderImageFootprintFeaturesNV>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV, VK_NV_SHADER_IMAGE_FOOTPRINT_EXTENSION_NAME, VK_NV_SHADER_IMAGE_FOOTPRINT_SPEC_VERSION, 13); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL, VK_INTEL_SHADER_INTEGER_FUNCTIONS_2_EXTENSION_NAME, VK_INTEL_SHADER_INTEGER_FUNCTIONS_2_SPEC_VERSION, 12); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDevice16BitStorageFeatures>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES, VK_KHR_16BIT_STORAGE_EXTENSION_NAME, VK_KHR_16BIT_STORAGE_SPEC_VERSION, 52); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDevice8BitStorageFeaturesKHR>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR, VK_KHR_8BIT_STORAGE_EXTENSION_NAME, VK_KHR_8BIT_STORAGE_SPEC_VERSION, 51); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceASTCDecodeFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT, VK_EXT_ASTC_DECODE_MODE_EXTENSION_NAME, VK_EXT_ASTC_DECODE_MODE_SPEC_VERSION, 50); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT, VK_EXT_BLEND_OPERATION_ADVANCED_EXTENSION_NAME, VK_EXT_BLEND_OPERATION_ADVANCED_SPEC_VERSION, 49); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceBufferDeviceAddressFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT, VK_EXT_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME, VK_EXT_BUFFER_DEVICE_ADDRESS_SPEC_VERSION, 48); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceCoherentMemoryFeaturesAMD>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD, DECL_AMD_COHERENT_MEMORY_EXTENSION_NAME, 0, 47); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceComputeShaderDerivativesFeaturesNV>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV, VK_NV_COMPUTE_SHADER_DERIVATIVES_EXTENSION_NAME, VK_NV_COMPUTE_SHADER_DERIVATIVES_SPEC_VERSION, 46); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceConditionalRenderingFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT, VK_EXT_CONDITIONAL_RENDERING_EXTENSION_NAME, VK_EXT_CONDITIONAL_RENDERING_SPEC_VERSION, 45); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceCooperativeMatrixFeaturesNV>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV, VK_NV_COOPERATIVE_MATRIX_EXTENSION_NAME, VK_NV_COOPERATIVE_MATRIX_SPEC_VERSION, 44); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceCornerSampledImageFeaturesNV>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV, VK_NV_CORNER_SAMPLED_IMAGE_EXTENSION_NAME, VK_NV_CORNER_SAMPLED_IMAGE_SPEC_VERSION, 43); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceCoverageReductionModeFeaturesNV>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV, VK_NV_COVERAGE_REDUCTION_MODE_EXTENSION_NAME, VK_NV_COVERAGE_REDUCTION_MODE_SPEC_VERSION, 42); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV, VK_NV_DEDICATED_ALLOCATION_IMAGE_ALIASING_EXTENSION_NAME, VK_NV_DEDICATED_ALLOCATION_IMAGE_ALIASING_SPEC_VERSION, 41); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceDepthClipEnableFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT, VK_EXT_DEPTH_CLIP_ENABLE_EXTENSION_NAME, VK_EXT_DEPTH_CLIP_ENABLE_SPEC_VERSION, 40); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceDescriptorIndexingFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT, VK_EXT_DESCRIPTOR_INDEXING_EXTENSION_NAME, VK_EXT_DESCRIPTOR_INDEXING_SPEC_VERSION, 39); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceExclusiveScissorFeaturesNV>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV, VK_NV_SCISSOR_EXCLUSIVE_EXTENSION_NAME, VK_NV_SCISSOR_EXCLUSIVE_SPEC_VERSION, 38); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceFragmentDensityMapFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT, VK_EXT_FRAGMENT_DENSITY_MAP_EXTENSION_NAME, VK_EXT_FRAGMENT_DENSITY_MAP_SPEC_VERSION, 37); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV, VK_NV_FRAGMENT_SHADER_BARYCENTRIC_EXTENSION_NAME, VK_NV_FRAGMENT_SHADER_BARYCENTRIC_SPEC_VERSION, 36); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT, VK_EXT_FRAGMENT_SHADER_INTERLOCK_EXTENSION_NAME, VK_EXT_FRAGMENT_SHADER_INTERLOCK_SPEC_VERSION, 35); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceHostQueryResetFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES_EXT, VK_EXT_HOST_QUERY_RESET_EXTENSION_NAME, VK_EXT_HOST_QUERY_RESET_SPEC_VERSION, 34); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceImagelessFramebufferFeaturesKHR>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES_KHR, VK_KHR_IMAGELESS_FRAMEBUFFER_EXTENSION_NAME, VK_KHR_IMAGELESS_FRAMEBUFFER_SPEC_VERSION, 33); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceIndexTypeUint8FeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT, VK_EXT_INDEX_TYPE_UINT8_EXTENSION_NAME, VK_EXT_INDEX_TYPE_UINT8_SPEC_VERSION, 32); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceInlineUniformBlockFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT, VK_EXT_INLINE_UNIFORM_BLOCK_EXTENSION_NAME, VK_EXT_INLINE_UNIFORM_BLOCK_SPEC_VERSION, 31); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceLineRasterizationFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT, VK_EXT_LINE_RASTERIZATION_EXTENSION_NAME, VK_EXT_LINE_RASTERIZATION_SPEC_VERSION, 30); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceMemoryPriorityFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT, VK_EXT_MEMORY_PRIORITY_EXTENSION_NAME, VK_EXT_MEMORY_PRIORITY_SPEC_VERSION, 29); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceMeshShaderFeaturesNV>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV, VK_NV_MESH_SHADER_EXTENSION_NAME, VK_NV_MESH_SHADER_SPEC_VERSION, 28); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceMultiviewFeatures>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES, VK_KHR_MULTIVIEW_EXTENSION_NAME, VK_KHR_MULTIVIEW_SPEC_VERSION, 27); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDevicePerformanceQueryFeaturesKHR>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR, VK_KHR_PERFORMANCE_QUERY_EXTENSION_NAME, VK_KHR_PERFORMANCE_QUERY_SPEC_VERSION, 26); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR, VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_EXTENSION_NAME, VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_SPEC_VERSION, 25); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceProtectedMemoryFeatures>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES, DECL_PROTECTED_MEMORY_EXTENSION_NAME, 0, 24); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV, VK_NV_REPRESENTATIVE_FRAGMENT_TEST_EXTENSION_NAME, VK_NV_REPRESENTATIVE_FRAGMENT_TEST_SPEC_VERSION, 23); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceSamplerYcbcrConversionFeatures>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES, VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME, VK_KHR_SAMPLER_YCBCR_CONVERSION_SPEC_VERSION, 22); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceScalarBlockLayoutFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES_EXT, VK_EXT_SCALAR_BLOCK_LAYOUT_EXTENSION_NAME, VK_EXT_SCALAR_BLOCK_LAYOUT_SPEC_VERSION, 21); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES_KHR, VK_KHR_SEPARATE_DEPTH_STENCIL_LAYOUTS_EXTENSION_NAME, VK_KHR_SEPARATE_DEPTH_STENCIL_LAYOUTS_SPEC_VERSION, 20); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceShaderAtomicInt64FeaturesKHR>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES_KHR, VK_KHR_SHADER_ATOMIC_INT64_EXTENSION_NAME, VK_KHR_SHADER_ATOMIC_INT64_SPEC_VERSION, 19); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceShaderClockFeaturesKHR>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR, VK_KHR_SHADER_CLOCK_EXTENSION_NAME, VK_KHR_SHADER_CLOCK_SPEC_VERSION, 18); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT, VK_EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_EXTENSION_NAME, VK_EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_SPEC_VERSION, 17); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceShaderDrawParametersFeatures>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES, VK_KHR_SHADER_DRAW_PARAMETERS_EXTENSION_NAME, VK_KHR_SHADER_DRAW_PARAMETERS_SPEC_VERSION, 16); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceShaderFloat16Int8FeaturesKHR>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES_KHR, VK_KHR_SHADER_FLOAT16_INT8_EXTENSION_NAME, VK_KHR_SHADER_FLOAT16_INT8_SPEC_VERSION, 15); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceShaderImageFootprintFeaturesNV>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV, VK_NV_SHADER_IMAGE_FOOTPRINT_EXTENSION_NAME, VK_NV_SHADER_IMAGE_FOOTPRINT_SPEC_VERSION, 14); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL, VK_INTEL_SHADER_INTEGER_FUNCTIONS_2_EXTENSION_NAME, VK_INTEL_SHADER_INTEGER_FUNCTIONS_2_SPEC_VERSION, 13); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceShaderSMBuiltinsFeaturesNV>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV, VK_NV_SHADER_SM_BUILTINS_EXTENSION_NAME, VK_NV_SHADER_SM_BUILTINS_SPEC_VERSION, 12); }
template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES_KHR, VK_KHR_SHADER_SUBGROUP_EXTENDED_TYPES_EXTENSION_NAME, VK_KHR_SHADER_SUBGROUP_EXTENDED_TYPES_SPEC_VERSION, 11); }
template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceShadingRateImageFeaturesNV>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV, VK_NV_SHADING_RATE_IMAGE_EXTENSION_NAME, VK_NV_SHADING_RATE_IMAGE_SPEC_VERSION, 10); }
template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceSubgroupSizeControlFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT, VK_EXT_SUBGROUP_SIZE_CONTROL_EXTENSION_NAME, VK_EXT_SUBGROUP_SIZE_CONTROL_SPEC_VERSION, 9); }
{
{ createFeatureStructWrapper<VkPhysicalDevice16BitStorageFeatures>, VK_KHR_16BIT_STORAGE_EXTENSION_NAME, VK_KHR_16BIT_STORAGE_SPEC_VERSION },
{ createFeatureStructWrapper<VkPhysicalDevice8BitStorageFeaturesKHR>, VK_KHR_8BIT_STORAGE_EXTENSION_NAME, VK_KHR_8BIT_STORAGE_SPEC_VERSION },
+ { createFeatureStructWrapper<VkPhysicalDeviceASTCDecodeFeaturesEXT>, VK_EXT_ASTC_DECODE_MODE_EXTENSION_NAME, VK_EXT_ASTC_DECODE_MODE_SPEC_VERSION },
{ createFeatureStructWrapper<VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT>, VK_EXT_BLEND_OPERATION_ADVANCED_EXTENSION_NAME, VK_EXT_BLEND_OPERATION_ADVANCED_SPEC_VERSION },
{ createFeatureStructWrapper<VkPhysicalDeviceBufferDeviceAddressFeaturesEXT>, VK_EXT_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME, VK_EXT_BUFFER_DEVICE_ADDRESS_SPEC_VERSION },
{ createFeatureStructWrapper<VkPhysicalDeviceCoherentMemoryFeaturesAMD>, DECL_AMD_COHERENT_MEMORY_EXTENSION_NAME, 0 },
{ createFeatureStructWrapper<VkPhysicalDeviceShaderFloat16Int8FeaturesKHR>, VK_KHR_SHADER_FLOAT16_INT8_EXTENSION_NAME, VK_KHR_SHADER_FLOAT16_INT8_SPEC_VERSION },
{ createFeatureStructWrapper<VkPhysicalDeviceShaderImageFootprintFeaturesNV>, VK_NV_SHADER_IMAGE_FOOTPRINT_EXTENSION_NAME, VK_NV_SHADER_IMAGE_FOOTPRINT_SPEC_VERSION },
{ createFeatureStructWrapper<VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL>, VK_INTEL_SHADER_INTEGER_FUNCTIONS_2_EXTENSION_NAME, VK_INTEL_SHADER_INTEGER_FUNCTIONS_2_SPEC_VERSION },
+ { createFeatureStructWrapper<VkPhysicalDeviceShaderSMBuiltinsFeaturesNV>, VK_NV_SHADER_SM_BUILTINS_EXTENSION_NAME, VK_NV_SHADER_SM_BUILTINS_SPEC_VERSION },
{ createFeatureStructWrapper<VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR>, VK_KHR_SHADER_SUBGROUP_EXTENDED_TYPES_EXTENSION_NAME, VK_KHR_SHADER_SUBGROUP_EXTENDED_TYPES_SPEC_VERSION },
{ createFeatureStructWrapper<VkPhysicalDeviceShadingRateImageFeaturesNV>, VK_NV_SHADING_RATE_IMAGE_EXTENSION_NAME, VK_NV_SHADING_RATE_IMAGE_SPEC_VERSION },
{ createFeatureStructWrapper<VkPhysicalDeviceSubgroupSizeControlFeaturesEXT>, VK_EXT_SUBGROUP_SIZE_CONTROL_EXTENSION_NAME, VK_EXT_SUBGROUP_SIZE_CONTROL_SPEC_VERSION },
*/
const vk::VkPhysicalDevice16BitStorageFeatures& get16BitStorageFeatures (void) const;
const vk::VkPhysicalDevice8BitStorageFeaturesKHR& get8BitStorageFeatures (void) const;
+const vk::VkPhysicalDeviceASTCDecodeFeaturesEXT& getASTCDecodeFeatures (void) const;
const vk::VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT& getBlendOperationAdvancedFeatures (void) const;
const vk::VkPhysicalDeviceBufferDeviceAddressFeaturesEXT& getBufferDeviceAddressFeatures (void) const;
const vk::VkPhysicalDeviceCoherentMemoryFeaturesAMD& getCoherentMemoryFeaturesAMD (void) const;
const vk::VkPhysicalDeviceShaderFloat16Int8FeaturesKHR& getShaderFloat16Int8Features (void) const;
const vk::VkPhysicalDeviceShaderImageFootprintFeaturesNV& getShaderImageFootprintFeatures (void) const;
const vk::VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL& getShaderIntegerFunctions2FeaturesINTEL (void) const;
+const vk::VkPhysicalDeviceShaderSMBuiltinsFeaturesNV& getShaderSMBuiltinsFeatures (void) const;
const vk::VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR& getShaderSubgroupExtendedTypesFeatures (void) const;
const vk::VkPhysicalDeviceShadingRateImageFeaturesNV& getShadingRateImageFeatures (void) const;
const vk::VkPhysicalDeviceSubgroupSizeControlFeaturesEXT& getSubgroupSizeControlFeatures (void) const;
*/
const vk::VkPhysicalDevice16BitStorageFeatures& Context::get16BitStorageFeatures (void) const { return m_device->get16BitStorageFeatures(); }
const vk::VkPhysicalDevice8BitStorageFeaturesKHR& Context::get8BitStorageFeatures (void) const { return m_device->get8BitStorageFeatures(); }
+const vk::VkPhysicalDeviceASTCDecodeFeaturesEXT& Context::getASTCDecodeFeatures (void) const { return m_device->getASTCDecodeFeatures(); }
const vk::VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT& Context::getBlendOperationAdvancedFeatures (void) const { return m_device->getBlendOperationAdvancedFeatures(); }
const vk::VkPhysicalDeviceBufferDeviceAddressFeaturesEXT& Context::getBufferDeviceAddressFeatures (void) const { return m_device->getBufferDeviceAddressFeatures(); }
const vk::VkPhysicalDeviceCoherentMemoryFeaturesAMD& Context::getCoherentMemoryFeaturesAMD (void) const { return m_device->getCoherentMemoryFeaturesAMD(); }
const vk::VkPhysicalDeviceShaderFloat16Int8FeaturesKHR& Context::getShaderFloat16Int8Features (void) const { return m_device->getShaderFloat16Int8Features(); }
const vk::VkPhysicalDeviceShaderImageFootprintFeaturesNV& Context::getShaderImageFootprintFeatures (void) const { return m_device->getShaderImageFootprintFeatures(); }
const vk::VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL& Context::getShaderIntegerFunctions2FeaturesINTEL (void) const { return m_device->getShaderIntegerFunctions2FeaturesINTEL(); }
+const vk::VkPhysicalDeviceShaderSMBuiltinsFeaturesNV& Context::getShaderSMBuiltinsFeatures (void) const { return m_device->getShaderSMBuiltinsFeatures(); }
const vk::VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR& Context::getShaderSubgroupExtendedTypesFeatures (void) const { return m_device->getShaderSubgroupExtendedTypesFeatures(); }
const vk::VkPhysicalDeviceShadingRateImageFeaturesNV& Context::getShadingRateImageFeatures (void) const { return m_device->getShadingRateImageFeatures(); }
const vk::VkPhysicalDeviceSubgroupSizeControlFeaturesEXT& Context::getSubgroupSizeControlFeatures (void) const { return m_device->getSubgroupSizeControlFeatures(); }
*/
const VkPhysicalDevice16BitStorageFeatures& get16BitStorageFeatures (void) const { return m_deviceFeatures.getFeatureType<VkPhysicalDevice16BitStorageFeatures>(); }
const VkPhysicalDevice8BitStorageFeaturesKHR& get8BitStorageFeatures (void) const { return m_deviceFeatures.getFeatureType<VkPhysicalDevice8BitStorageFeaturesKHR>(); }
+const VkPhysicalDeviceASTCDecodeFeaturesEXT& getASTCDecodeFeatures (void) const { return m_deviceFeatures.getFeatureType<VkPhysicalDeviceASTCDecodeFeaturesEXT>(); }
const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT& getBlendOperationAdvancedFeatures (void) const { return m_deviceFeatures.getFeatureType<VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT>(); }
const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT& getBufferDeviceAddressFeatures (void) const { return m_deviceFeatures.getFeatureType<VkPhysicalDeviceBufferDeviceAddressFeaturesEXT>(); }
const VkPhysicalDeviceCoherentMemoryFeaturesAMD& getCoherentMemoryFeaturesAMD (void) const { return m_deviceFeatures.getFeatureType<VkPhysicalDeviceCoherentMemoryFeaturesAMD>(); }
const VkPhysicalDeviceShaderFloat16Int8FeaturesKHR& getShaderFloat16Int8Features (void) const { return m_deviceFeatures.getFeatureType<VkPhysicalDeviceShaderFloat16Int8FeaturesKHR>(); }
const VkPhysicalDeviceShaderImageFootprintFeaturesNV& getShaderImageFootprintFeatures (void) const { return m_deviceFeatures.getFeatureType<VkPhysicalDeviceShaderImageFootprintFeaturesNV>(); }
const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL& getShaderIntegerFunctions2FeaturesINTEL (void) const { return m_deviceFeatures.getFeatureType<VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL>(); }
+const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV& getShaderSMBuiltinsFeatures (void) const { return m_deviceFeatures.getFeatureType<VkPhysicalDeviceShaderSMBuiltinsFeaturesNV>(); }
const VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR& getShaderSubgroupExtendedTypesFeatures (void) const { return m_deviceFeatures.getFeatureType<VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR>(); }
const VkPhysicalDeviceShadingRateImageFeaturesNV& getShadingRateImageFeatures (void) const { return m_deviceFeatures.getFeatureType<VkPhysicalDeviceShadingRateImageFeaturesNV>(); }
const VkPhysicalDeviceSubgroupSizeControlFeaturesEXT& getSubgroupSizeControlFeatures (void) const { return m_deviceFeatures.getFeatureType<VkPhysicalDeviceSubgroupSizeControlFeaturesEXT>(); }
vktImageTests.hpp
vktImageTestsUtil.cpp
vktImageTestsUtil.hpp
+ vktImageAstcDecodeModeTests.cpp
+ vktImageAstcDecodeModeTests.hpp
vktImageAtomicOperationTests.cpp
vktImageAtomicOperationTests.hpp
vktImageLoadStoreTests.cpp
--- /dev/null
+/*------------------------------------------------------------------------
+ * Vulkan Conformance Tests
+ * ------------------------
+ *
+ * Copyright (c) 2019 The Khronos Group Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ *//*!
+ * \file vktImageAstcDecodeModeTests.cpp
+ * \brief Astc decode mode tests
+ *//*--------------------------------------------------------------------*/
+
+#include "vktImageAstcDecodeModeTests.hpp"
+#include "vktImageLoadStoreUtil.hpp"
+
+#include "vktTestCaseUtil.hpp"
+#include "vkBarrierUtil.hpp"
+#include "vkBuilderUtil.hpp"
+#include "vkQueryUtil.hpp"
+#include "vkCmdUtil.hpp"
+#include "vkObjUtil.hpp"
+
+#include "tcuTextureUtil.hpp"
+#include "tcuTexture.hpp"
+#include "tcuCompressedTexture.hpp"
+#include "tcuImageCompare.hpp"
+
+#include "deRandom.hpp"
+#include <vector>
+
+using namespace vk;
+namespace vkt
+{
+namespace image
+{
+namespace
+{
+using std::string;
+using std::vector;
+using tcu::TestContext;
+using tcu::TestStatus;
+using tcu::UVec3;
+using tcu::IVec3;
+using tcu::CompressedTexFormat;
+using tcu::CompressedTexture;
+using de::MovePtr;
+using de::SharedPtr;
+using de::Random;
+
+struct TestParameters
+{
+ ImageType imageType;
+ UVec3 imageSize;
+
+ VkFormat testedFormat;
+ deBool testedIsUnorm;
+ VkFormat testedDecodeMode;
+ VkImageUsageFlags testedImageUsage;
+
+ VkFormat resultFormat;
+ VkImageUsageFlags resultImageUsage;
+};
+
+class BasicComputeTestInstance : public TestInstance
+{
+public:
+ BasicComputeTestInstance (Context& context,
+ const TestParameters& parameters);
+
+ TestStatus iterate (void);
+
+protected:
+
+ void generateData (deUint8* toFill,
+ const size_t size,
+ const VkFormat format,
+ const deUint32 layer,
+ const deUint32 level);
+
+protected:
+
+ const TestParameters m_parameters;
+};
+
+BasicComputeTestInstance::BasicComputeTestInstance (Context& context, const TestParameters& parameters)
+ : TestInstance (context)
+ , m_parameters (parameters)
+{
+}
+
+TestStatus BasicComputeTestInstance::iterate (void)
+{
+ Allocator& allocator = m_context.getDefaultAllocator();
+ const DeviceInterface& vk = m_context.getDeviceInterface();
+ const VkDevice device = m_context.getDevice();
+ const VkQueue queue = m_context.getUniversalQueue();
+ const deUint32 queueFamilyIndex = m_context.getUniversalQueueFamilyIndex();
+ const VkImageType imageType = mapImageType(m_parameters.imageType);
+ const VkExtent3D extentCompressed = makeExtent3D(getCompressedImageResolutionInBlocks(m_parameters.testedFormat, m_parameters.imageSize));
+ const Unique<VkCommandPool> cmdPool (createCommandPool(vk, device, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT, queueFamilyIndex));
+ const Unique<VkCommandBuffer> cmdBuffer (allocateCommandBuffer(vk, device, *cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY));
+ const Unique<VkShaderModule> shaderModule (createShaderModule(vk, device, m_context.getBinaryCollection().get("comp"), 0));
+
+ const VkImageCreateInfo compressedImageInfo =
+ {
+ VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT |
+ VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT, // VkImageCreateFlags flags;
+ imageType, // VkImageType imageType;
+ m_parameters.testedFormat, // VkFormat format;
+ extentCompressed, // VkExtent3D extent;
+ 1u, // deUint32 mipLevels;
+ 1u, // deUint32 arrayLayers;
+ VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples;
+ VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling;
+ VK_IMAGE_USAGE_SAMPLED_BIT |
+ VK_IMAGE_USAGE_TRANSFER_DST_BIT, // VkImageUsageFlags usage;
+ VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
+ 0u, // deUint32 queueFamilyIndexCount;
+ DE_NULL, // const deUint32* pQueueFamilyIndices;
+ VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout initialLayout;
+ };
+
+ const VkImageCreateInfo resultImageInfo =
+ {
+ VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ 0u, // VkImageCreateFlags flags;
+ imageType, // VkImageType imageType;
+ m_parameters.resultFormat, // VkFormat format;
+ extentCompressed, // VkExtent3D extent;
+ 1u, // deUint32 mipLevels;
+ 1u, // deUint32 arrayLayers;
+ VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples;
+ VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling;
+ VK_IMAGE_USAGE_SAMPLED_BIT |
+ VK_IMAGE_USAGE_STORAGE_BIT |
+ VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
+ VK_IMAGE_USAGE_TRANSFER_DST_BIT, // VkImageUsageFlags usage;
+ VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
+ 0u, // deUint32 queueFamilyIndexCount;
+ DE_NULL, // const deUint32* pQueueFamilyIndices;
+ VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout initialLayout;
+ };
+
+ // create images
+ Image testedImage (vk, device, allocator, compressedImageInfo, MemoryRequirement::Any);
+ Image referenceImage (vk, device, allocator, compressedImageInfo, MemoryRequirement::Any);
+ Image resultImage (vk, device, allocator, resultImageInfo, MemoryRequirement::Any);
+
+ // create image views
+ const VkImageViewType imageViewType (mapImageViewType(m_parameters.imageType));
+ VkImageSubresourceRange subresourceRange = makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 1u);
+ VkFormat viewFormat = m_parameters.testedIsUnorm ? VK_FORMAT_R32G32B32A32_UINT : VK_FORMAT_R32G32B32A32_SINT;
+
+ VkImageViewASTCDecodeModeEXT decodeMode =
+ {
+ VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT,
+ DE_NULL,
+ m_parameters.testedDecodeMode
+ };
+
+ const VkImageViewCreateInfo imageViewParams =
+ {
+ VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, // VkStructureType sType;
+ &decodeMode, // const void* pNext;
+ 0u, // VkImageViewCreateFlags flags;
+ testedImage.get(), // VkImage image;
+ imageViewType, // VkImageViewType viewType;
+ viewFormat, // VkFormat format;
+ makeComponentMappingRGBA(), // VkComponentMapping components;
+ subresourceRange, // VkImageSubresourceRange subresourceRange;
+ };
+
+ Move<VkImageView> testedView = createImageView(vk, device, &imageViewParams);
+ Move<VkImageView> referenceView = makeImageView(vk, device, referenceImage.get(), imageViewType, viewFormat, subresourceRange);
+ Move<VkImageView> resultView = makeImageView(vk, device, resultImage.get(), imageViewType, m_parameters.resultFormat,
+ makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, resultImageInfo.extent.depth, 0u, resultImageInfo.arrayLayers));
+
+ Move<VkDescriptorSetLayout> descriptorSetLayout = DescriptorSetLayoutBuilder()
+ .addSingleBinding(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_SHADER_STAGE_COMPUTE_BIT)
+ .addSingleBinding(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_SHADER_STAGE_COMPUTE_BIT)
+ .addSingleBinding(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, VK_SHADER_STAGE_COMPUTE_BIT)
+ .build(vk, device);
+ Move<VkDescriptorPool> descriptorPool = DescriptorPoolBuilder()
+ .addType(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, compressedImageInfo.arrayLayers)
+ .addType(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, compressedImageInfo.arrayLayers)
+ .addType(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, resultImageInfo.arrayLayers)
+ .build(vk, device, VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, resultImageInfo.arrayLayers);
+
+ Move<VkDescriptorSet> descriptorSet = makeDescriptorSet(vk, device, *descriptorPool, *descriptorSetLayout);
+ const Unique<VkPipelineLayout> pipelineLayout (makePipelineLayout(vk, device, *descriptorSetLayout));
+ const Unique<VkPipeline> pipeline (makeComputePipeline(vk, device, *pipelineLayout, *shaderModule));
+
+ const VkDeviceSize bufferSizeCompresed = getCompressedImageSizeInBytes(m_parameters.testedFormat, m_parameters.imageSize);
+ const VkDeviceSize bufferSizeUncompressed = getImageSizeBytes(IVec3((int)extentCompressed.width, (int)extentCompressed.height, (int)extentCompressed.depth), m_parameters.resultFormat);
+ VkBufferCreateInfo compressedBufferCI = makeBufferCreateInfo(bufferSizeCompresed, VK_BUFFER_USAGE_TRANSFER_SRC_BIT);
+ VkBufferCreateInfo uncompressedBufferCI = makeBufferCreateInfo(bufferSizeUncompressed, VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT);
+ Buffer inBuffer (vk, device, allocator, compressedBufferCI, MemoryRequirement::HostVisible);
+ Buffer resultBuffer (vk, device, allocator, uncompressedBufferCI, MemoryRequirement::HostVisible);
+ Move<VkSampler> sampler;
+
+ // generate data for compressed image and copy it to in buffer
+ {
+ vector<deUint8> generatedData;
+ generatedData.resize(static_cast<size_t>(bufferSizeCompresed));
+ generateData(generatedData.data(), generatedData.size(), m_parameters.testedFormat, 0u, 0u);
+
+ const Allocation& alloc = inBuffer.getAllocation();
+ deMemcpy(alloc.getHostPtr(), generatedData.data(), generatedData.size());
+ flushAlloc(vk, device, alloc);
+ }
+
+ {
+ const VkSamplerCreateInfo createInfo =
+ {
+ VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO, //VkStructureType sType;
+ DE_NULL, //const void* pNext;
+ 0u, //VkSamplerCreateFlags flags;
+ VK_FILTER_NEAREST, //VkFilter magFilter;
+ VK_FILTER_NEAREST, //VkFilter minFilter;
+ VK_SAMPLER_MIPMAP_MODE_NEAREST, //VkSamplerMipmapMode mipmapMode;
+ VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, //VkSamplerAddressMode addressModeU;
+ VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, //VkSamplerAddressMode addressModeV;
+ VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, //VkSamplerAddressMode addressModeW;
+ 0.0f, //float mipLodBias;
+ VK_FALSE, //VkBool32 anisotropyEnable;
+ 1.0f, //float maxAnisotropy;
+ VK_FALSE, //VkBool32 compareEnable;
+ VK_COMPARE_OP_EQUAL, //VkCompareOp compareOp;
+ 0.0f, //float minLod;
+ 1.0f, //float maxLod;
+ VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK, //VkBorderColor borderColor;
+ VK_FALSE, //VkBool32 unnormalizedCoordinates;
+ };
+ sampler = createSampler(vk, device, &createInfo);
+ }
+
+ VkDescriptorImageInfo descriptorImageInfos[] =
+ {
+ makeDescriptorImageInfo(*sampler, *testedView, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL),
+ makeDescriptorImageInfo(*sampler, *referenceView, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL),
+ makeDescriptorImageInfo(DE_NULL, *resultView, VK_IMAGE_LAYOUT_GENERAL),
+ };
+ DescriptorSetUpdateBuilder()
+ .writeSingle(descriptorSet.get(), DescriptorSetUpdateBuilder::Location::binding(0u), VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, &descriptorImageInfos[0])
+ .writeSingle(descriptorSet.get(), DescriptorSetUpdateBuilder::Location::binding(1u), VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, &descriptorImageInfos[1])
+ .writeSingle(descriptorSet.get(), DescriptorSetUpdateBuilder::Location::binding(2u), VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, &descriptorImageInfos[2])
+ .update(vk, device);
+
+ beginCommandBuffer(vk, *cmdBuffer);
+ {
+ // copy input buffer to tested and reference images
+ {
+ Image* inImages[] = { &testedImage, &referenceImage };
+ for (Image* image : inImages)
+ {
+ const VkImageMemoryBarrier preCopyImageBarrier = makeImageMemoryBarrier(
+ 0u, VK_ACCESS_TRANSFER_WRITE_BIT,
+ VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
+ image->get(), subresourceRange);
+
+ const VkBufferMemoryBarrier flushHostCopyBarrier = makeBufferMemoryBarrier(
+ VK_ACCESS_HOST_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT,
+ inBuffer.get(), 0ull, bufferSizeCompresed);
+
+ vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_HOST_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
+ (VkDependencyFlags)0, 0u, (const VkMemoryBarrier*)DE_NULL, 1u, &flushHostCopyBarrier, 1u, &preCopyImageBarrier);
+
+ const VkBufferImageCopy copyRegion =
+ {
+ 0ull, //VkDeviceSize bufferOffset;
+ 0u, //deUint32 bufferRowLength;
+ 0u, //deUint32 bufferImageHeight;
+ makeImageSubresourceLayers(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 0u, 1u), //VkImageSubresourceLayers imageSubresource;
+ makeOffset3D(0, 0, 0), //VkOffset3D imageOffset;
+ extentCompressed, //VkExtent3D imageExtent;
+ };
+
+ vk.cmdCopyBufferToImage(*cmdBuffer, inBuffer.get(), image->get(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1u, ©Region);
+ }
+ }
+
+ // bind pipeline and descriptors
+ vk.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, *pipeline);
+ vk.cmdBindDescriptorSets(*cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, *pipelineLayout, 0u, 1u, &descriptorSet.get(), 0u, DE_NULL);
+
+ {
+ const VkImageMemoryBarrier preShaderImageBarriers[] =
+ {
+ makeImageMemoryBarrier(VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_SHADER_READ_BIT,
+ VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
+ testedImage.get(), subresourceRange),
+
+ makeImageMemoryBarrier(VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_SHADER_READ_BIT,
+ VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
+ referenceImage.get(), subresourceRange),
+
+ makeImageMemoryBarrier(0u, VK_ACCESS_SHADER_WRITE_BIT,
+ VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_GENERAL,
+ resultImage.get(), subresourceRange)
+ };
+
+ vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
+ (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0u, (const VkBufferMemoryBarrier*)DE_NULL,
+ DE_LENGTH_OF_ARRAY(preShaderImageBarriers), preShaderImageBarriers);
+ }
+
+ vk.cmdDispatch(*cmdBuffer, extentCompressed.width, extentCompressed.height, extentCompressed.depth);
+
+ {
+ const VkImageMemoryBarrier postShaderImageBarriers[] =
+ {
+ makeImageMemoryBarrier(VK_ACCESS_SHADER_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT,
+ VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
+ resultImage.get(), subresourceRange)
+ };
+
+ vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
+ (VkDependencyFlags)0, 0u, (const VkMemoryBarrier*)DE_NULL, 0u, (const VkBufferMemoryBarrier*)DE_NULL,
+ DE_LENGTH_OF_ARRAY(postShaderImageBarriers), postShaderImageBarriers);
+ }
+
+ const VkBufferImageCopy copyRegion =
+ {
+ 0ull, // VkDeviceSize bufferOffset;
+ 0u, // deUint32 bufferRowLength;
+ 0u, // deUint32 bufferImageHeight;
+ makeImageSubresourceLayers(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 0u, 1u), // VkImageSubresourceLayers imageSubresource;
+ makeOffset3D(0, 0, 0), // VkOffset3D imageOffset;
+ resultImageInfo.extent, // VkExtent3D imageExtent;
+ };
+ vk.cmdCopyImageToBuffer(*cmdBuffer, resultImage.get(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, resultBuffer.get(), 1u, ©Region);
+
+ {
+ const VkBufferMemoryBarrier postCopyBufferBarrier[] =
+ {
+ makeBufferMemoryBarrier(VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_HOST_READ_BIT,
+ resultBuffer.get(), 0ull, bufferSizeUncompressed),
+ };
+
+ vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT,
+ (VkDependencyFlags)0, 0u, (const VkMemoryBarrier*)DE_NULL, DE_LENGTH_OF_ARRAY(postCopyBufferBarrier), postCopyBufferBarrier,
+ 0u, (const VkImageMemoryBarrier*)DE_NULL);
+ }
+ }
+ endCommandBuffer(vk, *cmdBuffer);
+ submitCommandsAndWait(vk, device, queue, *cmdBuffer);
+
+ const Allocation& resultAlloc = resultBuffer.getAllocation();
+ invalidateAlloc(vk, device, resultAlloc);
+
+ // verification is done in shader - here we just check if one of pixels has wrong value
+ const size_t numBytes = static_cast<size_t>(bufferSizeUncompressed);
+ deUint8* result = static_cast<deUint8*>(resultAlloc.getHostPtr());
+ for (size_t i = 0 ; i < numBytes ; i += 4)
+ {
+ // expected result should be around 128 (if reference is same as tested mode then we return 0.5)
+ if ((result[i] < 100) || (result[i] > 150))
+ return TestStatus::fail("Fail");
+ }
+
+ return TestStatus::pass("Pass");
+}
+
+void BasicComputeTestInstance::generateData (deUint8* toFill,
+ const size_t size,
+ const VkFormat format,
+ const deUint32 layer,
+ const deUint32 level)
+{
+ // Random data
+ deUint32* start32 = reinterpret_cast<deUint32*>(toFill);
+ size_t sizeToRnd32 = size / sizeof(deUint32);
+ deUint32 seed = (layer << 24) ^ (level << 16) ^ static_cast<deUint32>(format);
+ Random rnd (seed);
+
+ for (size_t i = 0; i < sizeToRnd32; i++)
+ start32[i] = rnd.getUint32();
+}
+
+class AstcDecodeModeCase : public TestCase
+{
+public:
+ AstcDecodeModeCase (TestContext& testCtx,
+ const std::string& name,
+ const std::string& desc,
+ const TestParameters& parameters);
+ virtual void checkSupport (Context& context) const;
+ void initPrograms (SourceCollections& programCollection) const;
+ TestInstance* createInstance (Context& context) const;
+
+protected:
+
+ const TestParameters m_parameters;
+};
+
+AstcDecodeModeCase::AstcDecodeModeCase (TestContext& testCtx,
+ const std::string& name,
+ const std::string& desc,
+ const TestParameters& parameters)
+ : TestCase (testCtx, name, desc)
+ , m_parameters (parameters)
+{
+}
+
+void AstcDecodeModeCase::checkSupport (Context& context) const
+{
+ const VkPhysicalDevice physicalDevice = context.getPhysicalDevice();
+ const InstanceInterface& vk = context.getInstanceInterface();
+
+ context.requireDeviceFunctionality("VK_EXT_astc_decode_mode");
+ if (!getPhysicalDeviceFeatures(vk, physicalDevice).textureCompressionASTC_LDR)
+ TCU_THROW(NotSupportedError, "textureCompressionASTC_LDR not supported");
+
+ VkImageFormatProperties imageFormatProperties;
+ if (VK_ERROR_FORMAT_NOT_SUPPORTED == vk.getPhysicalDeviceImageFormatProperties(physicalDevice, m_parameters.testedFormat,
+ mapImageType(m_parameters.imageType), VK_IMAGE_TILING_OPTIMAL,
+ m_parameters.testedImageUsage, 0u, &imageFormatProperties))
+ TCU_THROW(NotSupportedError, "Operation not supported with this image format");
+
+ if (VK_ERROR_FORMAT_NOT_SUPPORTED == vk.getPhysicalDeviceImageFormatProperties(physicalDevice, m_parameters.resultFormat,
+ mapImageType(m_parameters.imageType), VK_IMAGE_TILING_OPTIMAL,
+ m_parameters.resultImageUsage, 0u, &imageFormatProperties))
+ TCU_THROW(NotSupportedError, "Operation not supported with this image format");
+
+ if ((m_parameters.testedDecodeMode == VK_FORMAT_E5B9G9R9_UFLOAT_PACK32) &&
+ !context.getASTCDecodeFeatures().decodeModeSharedExponent)
+ TCU_THROW(NotSupportedError, "decodeModeSharedExponent not supported");
+
+ VkFormatProperties properties;
+ context.getInstanceInterface().getPhysicalDeviceFormatProperties(context.getPhysicalDevice(), m_parameters.resultFormat, &properties);
+ if (!(properties.optimalTilingFeatures & VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT))
+ TCU_THROW(NotSupportedError, "Format storage feature not supported");
+}
+
+void AstcDecodeModeCase::initPrograms (vk::SourceCollections& programCollection) const
+{
+ DE_ASSERT(m_parameters.imageSize.x() > 0);
+ DE_ASSERT(m_parameters.imageSize.y() > 0);
+
+ VkFormat compatibileFormat = m_parameters.testedIsUnorm ? VK_FORMAT_R32G32B32A32_UINT : VK_FORMAT_R32G32B32A32_SINT;
+ tcu::TextureFormat testedTextureFormat = mapVkFormat(compatibileFormat);
+ VkImageViewType imageViewType = mapImageViewType(m_parameters.imageType);
+ string samplerType = getGlslSamplerType(testedTextureFormat, imageViewType);
+ const string formatQualifierStr = getShaderImageFormatQualifier(mapVkFormat(m_parameters.resultFormat));
+ const string imageTypeStr = getShaderImageType(mapVkFormat(m_parameters.resultFormat), m_parameters.imageType);
+
+ std::ostringstream src;
+ src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_450) << "\n"
+ << "layout (local_size_x = 1, local_size_y = 1, local_size_z = 1) in;\n\n"
+ << "layout (binding = 0) uniform " << samplerType << " compressed_tested;\n"
+ << "layout (binding = 1) uniform " << samplerType << " compressed_reference;\n"
+ << "layout (binding = 2, " << formatQualifierStr << ") writeonly uniform " << imageTypeStr << " result;\n"
+ << "void main (void)\n"
+ << "{\n"
+ << " const vec2 pixels_resolution = vec2(gl_NumWorkGroups.xy);\n"
+ << " const vec2 cord = vec2(gl_GlobalInvocationID.xy) / vec2(pixels_resolution);\n"
+ << " const ivec2 pos = ivec2(gl_GlobalInvocationID.xy); \n"
+ << " vec4 tested = texture(compressed_tested, cord);\n"
+ << " vec4 reference = texture(compressed_reference, cord);\n";
+
+ // special case for e5b9g9r9 decode mode that was set on unorm astc formats
+ // here negative values are clamped to zero and alpha is set to 1
+ if (m_parameters.testedIsUnorm && (m_parameters.testedDecodeMode == VK_FORMAT_E5B9G9R9_UFLOAT_PACK32))
+ src << " reference = max(vec4(0,0,0,1), reference);\n"
+ " float result_color = 0.5 * float(distance(tested, reference) < 0.01);\n";
+ else
+ src << " float result_color = 0.5 * float(distance(tested, reference) < 0.01);\n";
+
+ src << " imageStore(result, pos, vec4(result_color));\n"
+ << "}\n";
+
+ programCollection.glslSources.add("comp") << glu::ComputeSource(src.str());
+}
+
+TestInstance* AstcDecodeModeCase::createInstance (Context& context) const
+{
+ return new BasicComputeTestInstance(context, m_parameters);
+}
+
+} // anonymous ns
+
+tcu::TestCaseGroup* createImageAstcDecodeModeTests (tcu::TestContext& testCtx)
+{
+ struct FormatData
+ {
+ VkFormat format;
+ std::string name;
+ deBool isUnorm;
+ };
+ const FormatData astcFormats[] =
+ {
+ { VK_FORMAT_ASTC_4x4_UNORM_BLOCK, "4x4_unorm", DE_TRUE },
+ { VK_FORMAT_ASTC_4x4_SRGB_BLOCK, "4x4_srgb", DE_FALSE },
+ { VK_FORMAT_ASTC_5x4_UNORM_BLOCK, "5x4_unorm", DE_TRUE },
+ { VK_FORMAT_ASTC_5x4_SRGB_BLOCK, "5x4_srgb", DE_FALSE },
+ { VK_FORMAT_ASTC_5x5_UNORM_BLOCK, "5x5_unorm", DE_TRUE },
+ { VK_FORMAT_ASTC_5x5_SRGB_BLOCK, "5x5_srgb", DE_FALSE },
+ { VK_FORMAT_ASTC_6x5_UNORM_BLOCK, "6x5_unorm", DE_TRUE },
+ { VK_FORMAT_ASTC_6x5_SRGB_BLOCK, "6x5_srgb", DE_FALSE },
+ { VK_FORMAT_ASTC_6x6_UNORM_BLOCK, "6x6_unorm", DE_TRUE },
+ { VK_FORMAT_ASTC_6x6_SRGB_BLOCK, "6x6_srgb", DE_FALSE },
+ { VK_FORMAT_ASTC_8x5_UNORM_BLOCK, "8x5_unorm", DE_TRUE },
+ { VK_FORMAT_ASTC_8x5_SRGB_BLOCK, "8x5_srgb", DE_FALSE },
+ { VK_FORMAT_ASTC_8x6_UNORM_BLOCK, "8x6_unorm", DE_TRUE },
+ { VK_FORMAT_ASTC_8x6_SRGB_BLOCK, "8x6_srgb", DE_FALSE },
+ { VK_FORMAT_ASTC_8x8_UNORM_BLOCK, "8x8_unorm", DE_TRUE },
+ { VK_FORMAT_ASTC_8x8_SRGB_BLOCK, "8x8_srgb", DE_FALSE },
+ { VK_FORMAT_ASTC_10x5_UNORM_BLOCK, "10x5_unorm", DE_TRUE },
+ { VK_FORMAT_ASTC_10x5_SRGB_BLOCK, "10x5_srgb", DE_FALSE },
+ { VK_FORMAT_ASTC_10x6_UNORM_BLOCK, "10x6_unorm", DE_TRUE },
+ { VK_FORMAT_ASTC_10x6_SRGB_BLOCK, "10x6_srgb", DE_FALSE },
+ { VK_FORMAT_ASTC_10x8_UNORM_BLOCK, "10x8_unorm", DE_TRUE },
+ { VK_FORMAT_ASTC_10x8_SRGB_BLOCK, "10x8_srgb", DE_FALSE },
+ { VK_FORMAT_ASTC_10x10_UNORM_BLOCK, "10x10_unorm", DE_TRUE },
+ { VK_FORMAT_ASTC_10x10_SRGB_BLOCK, "10x10_srgb", DE_FALSE },
+ { VK_FORMAT_ASTC_12x10_UNORM_BLOCK, "12x10_unorm", DE_TRUE },
+ { VK_FORMAT_ASTC_12x10_SRGB_BLOCK, "12x10_srgb", DE_FALSE },
+ { VK_FORMAT_ASTC_12x12_UNORM_BLOCK, "12x12_unorm", DE_TRUE },
+ { VK_FORMAT_ASTC_12x12_SRGB_BLOCK, "12x12_srgb", DE_FALSE },
+ };
+
+ struct DecodeModeData
+ {
+ VkFormat mode;
+ std::string name;
+ };
+ const DecodeModeData decodeModes[] =
+ {
+ { VK_FORMAT_R16G16B16A16_SFLOAT, "r16g16b16a16_sfloat" },
+ { VK_FORMAT_R8G8B8A8_UNORM, "r8g8b8a8_unorm" },
+ { VK_FORMAT_E5B9G9R9_UFLOAT_PACK32, "e5b9g9r9_ufloat_pack32" }
+ };
+
+ MovePtr<tcu::TestCaseGroup> astcDecodeModeTests(new tcu::TestCaseGroup(testCtx, "astc_decode_mode", "Intermediate decoding precision cases"));
+ for (const FormatData& format : astcFormats)
+ {
+ for (const DecodeModeData& mode : decodeModes)
+ {
+ const TestParameters parameters =
+ {
+ IMAGE_TYPE_2D,
+ UVec3(64u, 64u, 1u),
+ format.format,
+ format.isUnorm,
+ mode.mode,
+ VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT,
+ VK_FORMAT_R8G8B8A8_UNORM,
+ VK_IMAGE_USAGE_STORAGE_BIT
+ };
+
+ std::string name = format.name + "_to_" + mode.name;
+ astcDecodeModeTests->addChild(new AstcDecodeModeCase(testCtx, name, "", parameters));
+ }
+ }
+
+ return astcDecodeModeTests.release();
+}
+
+} // image
+} // vkt
--- /dev/null
+#ifndef _VKTIMAGEASTCDECODEMODETESTS_HPP
+#define _VKTIMAGEASTCDECODEMODETESTS_HPP
+/*------------------------------------------------------------------------
+ * Vulkan Conformance Tests
+ * ------------------------
+ *
+ * Copyright (c) 2019 The Khronos Group Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ *//*!
+ * \file vktImageAstcDecodeModeTests.hpp
+ * \brief Astc decode mode tests
+ *//*--------------------------------------------------------------------*/
+
+#include "tcuDefs.hpp"
+#include "tcuTestCase.hpp"
+
+namespace vkt
+{
+namespace image
+{
+
+tcu::TestCaseGroup* createImageAstcDecodeModeTests (tcu::TestContext& testCtx);
+
+} // image
+} // vkt
+
+#endif // _VKTIMAGEASTCDECODEMODETESTS_HPP
#include "vktImageAtomicOperationTests.hpp"
#include "vktImageCompressionTranscodingSupport.hpp"
#include "vktImageTranscodingSupportTests.hpp"
+#include "vktImageAstcDecodeModeTests.hpp"
#include "vktImageMisalignedCubeTests.hpp"
namespace vkt
imageTests->addChild(createImageCompressionTranscodingTests(testCtx));
imageTests->addChild(createImageTranscodingSupportTests(testCtx));
imageTests->addChild(createImageExtendOperandsTests(testCtx));
+ imageTests->addChild(createImageAstcDecodeModeTests(testCtx));
imageTests->addChild(createMisalignedCubeTests(testCtx));
}
dEQP-VK.image.extend_operands_spirv1p4.r8_sint_force_sign_extend
dEQP-VK.image.extend_operands_spirv1p4.r8_sint_relaxed_matching_extend
dEQP-VK.image.extend_operands_spirv1p4.r8_sint_relaxed_force_sign_extend
+dEQP-VK.image.astc_decode_mode.4x4_unorm_to_r16g16b16a16_sfloat
+dEQP-VK.image.astc_decode_mode.4x4_unorm_to_r8g8b8a8_unorm
+dEQP-VK.image.astc_decode_mode.4x4_unorm_to_e5b9g9r9_ufloat_pack32
+dEQP-VK.image.astc_decode_mode.4x4_srgb_to_r16g16b16a16_sfloat
+dEQP-VK.image.astc_decode_mode.4x4_srgb_to_r8g8b8a8_unorm
+dEQP-VK.image.astc_decode_mode.4x4_srgb_to_e5b9g9r9_ufloat_pack32
+dEQP-VK.image.astc_decode_mode.5x4_unorm_to_r16g16b16a16_sfloat
+dEQP-VK.image.astc_decode_mode.5x4_unorm_to_r8g8b8a8_unorm
+dEQP-VK.image.astc_decode_mode.5x4_unorm_to_e5b9g9r9_ufloat_pack32
+dEQP-VK.image.astc_decode_mode.5x4_srgb_to_r16g16b16a16_sfloat
+dEQP-VK.image.astc_decode_mode.5x4_srgb_to_r8g8b8a8_unorm
+dEQP-VK.image.astc_decode_mode.5x4_srgb_to_e5b9g9r9_ufloat_pack32
+dEQP-VK.image.astc_decode_mode.5x5_unorm_to_r16g16b16a16_sfloat
+dEQP-VK.image.astc_decode_mode.5x5_unorm_to_r8g8b8a8_unorm
+dEQP-VK.image.astc_decode_mode.5x5_unorm_to_e5b9g9r9_ufloat_pack32
+dEQP-VK.image.astc_decode_mode.5x5_srgb_to_r16g16b16a16_sfloat
+dEQP-VK.image.astc_decode_mode.5x5_srgb_to_r8g8b8a8_unorm
+dEQP-VK.image.astc_decode_mode.5x5_srgb_to_e5b9g9r9_ufloat_pack32
+dEQP-VK.image.astc_decode_mode.6x5_unorm_to_r16g16b16a16_sfloat
+dEQP-VK.image.astc_decode_mode.6x5_unorm_to_r8g8b8a8_unorm
+dEQP-VK.image.astc_decode_mode.6x5_unorm_to_e5b9g9r9_ufloat_pack32
+dEQP-VK.image.astc_decode_mode.6x5_srgb_to_r16g16b16a16_sfloat
+dEQP-VK.image.astc_decode_mode.6x5_srgb_to_r8g8b8a8_unorm
+dEQP-VK.image.astc_decode_mode.6x5_srgb_to_e5b9g9r9_ufloat_pack32
+dEQP-VK.image.astc_decode_mode.6x6_unorm_to_r16g16b16a16_sfloat
+dEQP-VK.image.astc_decode_mode.6x6_unorm_to_r8g8b8a8_unorm
+dEQP-VK.image.astc_decode_mode.6x6_unorm_to_e5b9g9r9_ufloat_pack32
+dEQP-VK.image.astc_decode_mode.6x6_srgb_to_r16g16b16a16_sfloat
+dEQP-VK.image.astc_decode_mode.6x6_srgb_to_r8g8b8a8_unorm
+dEQP-VK.image.astc_decode_mode.6x6_srgb_to_e5b9g9r9_ufloat_pack32
+dEQP-VK.image.astc_decode_mode.8x5_unorm_to_r16g16b16a16_sfloat
+dEQP-VK.image.astc_decode_mode.8x5_unorm_to_r8g8b8a8_unorm
+dEQP-VK.image.astc_decode_mode.8x5_unorm_to_e5b9g9r9_ufloat_pack32
+dEQP-VK.image.astc_decode_mode.8x5_srgb_to_r16g16b16a16_sfloat
+dEQP-VK.image.astc_decode_mode.8x5_srgb_to_r8g8b8a8_unorm
+dEQP-VK.image.astc_decode_mode.8x5_srgb_to_e5b9g9r9_ufloat_pack32
+dEQP-VK.image.astc_decode_mode.8x6_unorm_to_r16g16b16a16_sfloat
+dEQP-VK.image.astc_decode_mode.8x6_unorm_to_r8g8b8a8_unorm
+dEQP-VK.image.astc_decode_mode.8x6_unorm_to_e5b9g9r9_ufloat_pack32
+dEQP-VK.image.astc_decode_mode.8x6_srgb_to_r16g16b16a16_sfloat
+dEQP-VK.image.astc_decode_mode.8x6_srgb_to_r8g8b8a8_unorm
+dEQP-VK.image.astc_decode_mode.8x6_srgb_to_e5b9g9r9_ufloat_pack32
+dEQP-VK.image.astc_decode_mode.8x8_unorm_to_r16g16b16a16_sfloat
+dEQP-VK.image.astc_decode_mode.8x8_unorm_to_r8g8b8a8_unorm
+dEQP-VK.image.astc_decode_mode.8x8_unorm_to_e5b9g9r9_ufloat_pack32
+dEQP-VK.image.astc_decode_mode.8x8_srgb_to_r16g16b16a16_sfloat
+dEQP-VK.image.astc_decode_mode.8x8_srgb_to_r8g8b8a8_unorm
+dEQP-VK.image.astc_decode_mode.8x8_srgb_to_e5b9g9r9_ufloat_pack32
+dEQP-VK.image.astc_decode_mode.10x5_unorm_to_r16g16b16a16_sfloat
+dEQP-VK.image.astc_decode_mode.10x5_unorm_to_r8g8b8a8_unorm
+dEQP-VK.image.astc_decode_mode.10x5_unorm_to_e5b9g9r9_ufloat_pack32
+dEQP-VK.image.astc_decode_mode.10x5_srgb_to_r16g16b16a16_sfloat
+dEQP-VK.image.astc_decode_mode.10x5_srgb_to_r8g8b8a8_unorm
+dEQP-VK.image.astc_decode_mode.10x5_srgb_to_e5b9g9r9_ufloat_pack32
+dEQP-VK.image.astc_decode_mode.10x6_unorm_to_r16g16b16a16_sfloat
+dEQP-VK.image.astc_decode_mode.10x6_unorm_to_r8g8b8a8_unorm
+dEQP-VK.image.astc_decode_mode.10x6_unorm_to_e5b9g9r9_ufloat_pack32
+dEQP-VK.image.astc_decode_mode.10x6_srgb_to_r16g16b16a16_sfloat
+dEQP-VK.image.astc_decode_mode.10x6_srgb_to_r8g8b8a8_unorm
+dEQP-VK.image.astc_decode_mode.10x6_srgb_to_e5b9g9r9_ufloat_pack32
+dEQP-VK.image.astc_decode_mode.10x8_unorm_to_r16g16b16a16_sfloat
+dEQP-VK.image.astc_decode_mode.10x8_unorm_to_r8g8b8a8_unorm
+dEQP-VK.image.astc_decode_mode.10x8_unorm_to_e5b9g9r9_ufloat_pack32
+dEQP-VK.image.astc_decode_mode.10x8_srgb_to_r16g16b16a16_sfloat
+dEQP-VK.image.astc_decode_mode.10x8_srgb_to_r8g8b8a8_unorm
+dEQP-VK.image.astc_decode_mode.10x8_srgb_to_e5b9g9r9_ufloat_pack32
+dEQP-VK.image.astc_decode_mode.10x10_unorm_to_r16g16b16a16_sfloat
+dEQP-VK.image.astc_decode_mode.10x10_unorm_to_r8g8b8a8_unorm
+dEQP-VK.image.astc_decode_mode.10x10_unorm_to_e5b9g9r9_ufloat_pack32
+dEQP-VK.image.astc_decode_mode.10x10_srgb_to_r16g16b16a16_sfloat
+dEQP-VK.image.astc_decode_mode.10x10_srgb_to_r8g8b8a8_unorm
+dEQP-VK.image.astc_decode_mode.10x10_srgb_to_e5b9g9r9_ufloat_pack32
+dEQP-VK.image.astc_decode_mode.12x10_unorm_to_r16g16b16a16_sfloat
+dEQP-VK.image.astc_decode_mode.12x10_unorm_to_r8g8b8a8_unorm
+dEQP-VK.image.astc_decode_mode.12x10_unorm_to_e5b9g9r9_ufloat_pack32
+dEQP-VK.image.astc_decode_mode.12x10_srgb_to_r16g16b16a16_sfloat
+dEQP-VK.image.astc_decode_mode.12x10_srgb_to_r8g8b8a8_unorm
+dEQP-VK.image.astc_decode_mode.12x10_srgb_to_e5b9g9r9_ufloat_pack32
+dEQP-VK.image.astc_decode_mode.12x12_unorm_to_r16g16b16a16_sfloat
+dEQP-VK.image.astc_decode_mode.12x12_unorm_to_r8g8b8a8_unorm
+dEQP-VK.image.astc_decode_mode.12x12_unorm_to_e5b9g9r9_ufloat_pack32
+dEQP-VK.image.astc_decode_mode.12x12_srgb_to_r16g16b16a16_sfloat
+dEQP-VK.image.astc_decode_mode.12x12_srgb_to_r8g8b8a8_unorm
+dEQP-VK.image.astc_decode_mode.12x12_srgb_to_e5b9g9r9_ufloat_pack32
dEQP-VK.image.misaligned_cube.7
dEQP-VK.image.misaligned_cube.8
dEQP-VK.image.misaligned_cube.9
dEQP-VK.image.extend_operands_spirv1p4.r8_sint_force_sign_extend
dEQP-VK.image.extend_operands_spirv1p4.r8_sint_relaxed_matching_extend
dEQP-VK.image.extend_operands_spirv1p4.r8_sint_relaxed_force_sign_extend
+dEQP-VK.image.astc_decode_mode.4x4_unorm_to_r16g16b16a16_sfloat
+dEQP-VK.image.astc_decode_mode.4x4_unorm_to_r8g8b8a8_unorm
+dEQP-VK.image.astc_decode_mode.4x4_unorm_to_e5b9g9r9_ufloat_pack32
+dEQP-VK.image.astc_decode_mode.4x4_srgb_to_r16g16b16a16_sfloat
+dEQP-VK.image.astc_decode_mode.4x4_srgb_to_r8g8b8a8_unorm
+dEQP-VK.image.astc_decode_mode.4x4_srgb_to_e5b9g9r9_ufloat_pack32
+dEQP-VK.image.astc_decode_mode.5x4_unorm_to_r16g16b16a16_sfloat
+dEQP-VK.image.astc_decode_mode.5x4_unorm_to_r8g8b8a8_unorm
+dEQP-VK.image.astc_decode_mode.5x4_unorm_to_e5b9g9r9_ufloat_pack32
+dEQP-VK.image.astc_decode_mode.5x4_srgb_to_r16g16b16a16_sfloat
+dEQP-VK.image.astc_decode_mode.5x4_srgb_to_r8g8b8a8_unorm
+dEQP-VK.image.astc_decode_mode.5x4_srgb_to_e5b9g9r9_ufloat_pack32
+dEQP-VK.image.astc_decode_mode.5x5_unorm_to_r16g16b16a16_sfloat
+dEQP-VK.image.astc_decode_mode.5x5_unorm_to_r8g8b8a8_unorm
+dEQP-VK.image.astc_decode_mode.5x5_unorm_to_e5b9g9r9_ufloat_pack32
+dEQP-VK.image.astc_decode_mode.5x5_srgb_to_r16g16b16a16_sfloat
+dEQP-VK.image.astc_decode_mode.5x5_srgb_to_r8g8b8a8_unorm
+dEQP-VK.image.astc_decode_mode.5x5_srgb_to_e5b9g9r9_ufloat_pack32
+dEQP-VK.image.astc_decode_mode.6x5_unorm_to_r16g16b16a16_sfloat
+dEQP-VK.image.astc_decode_mode.6x5_unorm_to_r8g8b8a8_unorm
+dEQP-VK.image.astc_decode_mode.6x5_unorm_to_e5b9g9r9_ufloat_pack32
+dEQP-VK.image.astc_decode_mode.6x5_srgb_to_r16g16b16a16_sfloat
+dEQP-VK.image.astc_decode_mode.6x5_srgb_to_r8g8b8a8_unorm
+dEQP-VK.image.astc_decode_mode.6x5_srgb_to_e5b9g9r9_ufloat_pack32
+dEQP-VK.image.astc_decode_mode.6x6_unorm_to_r16g16b16a16_sfloat
+dEQP-VK.image.astc_decode_mode.6x6_unorm_to_r8g8b8a8_unorm
+dEQP-VK.image.astc_decode_mode.6x6_unorm_to_e5b9g9r9_ufloat_pack32
+dEQP-VK.image.astc_decode_mode.6x6_srgb_to_r16g16b16a16_sfloat
+dEQP-VK.image.astc_decode_mode.6x6_srgb_to_r8g8b8a8_unorm
+dEQP-VK.image.astc_decode_mode.6x6_srgb_to_e5b9g9r9_ufloat_pack32
+dEQP-VK.image.astc_decode_mode.8x5_unorm_to_r16g16b16a16_sfloat
+dEQP-VK.image.astc_decode_mode.8x5_unorm_to_r8g8b8a8_unorm
+dEQP-VK.image.astc_decode_mode.8x5_unorm_to_e5b9g9r9_ufloat_pack32
+dEQP-VK.image.astc_decode_mode.8x5_srgb_to_r16g16b16a16_sfloat
+dEQP-VK.image.astc_decode_mode.8x5_srgb_to_r8g8b8a8_unorm
+dEQP-VK.image.astc_decode_mode.8x5_srgb_to_e5b9g9r9_ufloat_pack32
+dEQP-VK.image.astc_decode_mode.8x6_unorm_to_r16g16b16a16_sfloat
+dEQP-VK.image.astc_decode_mode.8x6_unorm_to_r8g8b8a8_unorm
+dEQP-VK.image.astc_decode_mode.8x6_unorm_to_e5b9g9r9_ufloat_pack32
+dEQP-VK.image.astc_decode_mode.8x6_srgb_to_r16g16b16a16_sfloat
+dEQP-VK.image.astc_decode_mode.8x6_srgb_to_r8g8b8a8_unorm
+dEQP-VK.image.astc_decode_mode.8x6_srgb_to_e5b9g9r9_ufloat_pack32
+dEQP-VK.image.astc_decode_mode.8x8_unorm_to_r16g16b16a16_sfloat
+dEQP-VK.image.astc_decode_mode.8x8_unorm_to_r8g8b8a8_unorm
+dEQP-VK.image.astc_decode_mode.8x8_unorm_to_e5b9g9r9_ufloat_pack32
+dEQP-VK.image.astc_decode_mode.8x8_srgb_to_r16g16b16a16_sfloat
+dEQP-VK.image.astc_decode_mode.8x8_srgb_to_r8g8b8a8_unorm
+dEQP-VK.image.astc_decode_mode.8x8_srgb_to_e5b9g9r9_ufloat_pack32
+dEQP-VK.image.astc_decode_mode.10x5_unorm_to_r16g16b16a16_sfloat
+dEQP-VK.image.astc_decode_mode.10x5_unorm_to_r8g8b8a8_unorm
+dEQP-VK.image.astc_decode_mode.10x5_unorm_to_e5b9g9r9_ufloat_pack32
+dEQP-VK.image.astc_decode_mode.10x5_srgb_to_r16g16b16a16_sfloat
+dEQP-VK.image.astc_decode_mode.10x5_srgb_to_r8g8b8a8_unorm
+dEQP-VK.image.astc_decode_mode.10x5_srgb_to_e5b9g9r9_ufloat_pack32
+dEQP-VK.image.astc_decode_mode.10x6_unorm_to_r16g16b16a16_sfloat
+dEQP-VK.image.astc_decode_mode.10x6_unorm_to_r8g8b8a8_unorm
+dEQP-VK.image.astc_decode_mode.10x6_unorm_to_e5b9g9r9_ufloat_pack32
+dEQP-VK.image.astc_decode_mode.10x6_srgb_to_r16g16b16a16_sfloat
+dEQP-VK.image.astc_decode_mode.10x6_srgb_to_r8g8b8a8_unorm
+dEQP-VK.image.astc_decode_mode.10x6_srgb_to_e5b9g9r9_ufloat_pack32
+dEQP-VK.image.astc_decode_mode.10x8_unorm_to_r16g16b16a16_sfloat
+dEQP-VK.image.astc_decode_mode.10x8_unorm_to_r8g8b8a8_unorm
+dEQP-VK.image.astc_decode_mode.10x8_unorm_to_e5b9g9r9_ufloat_pack32
+dEQP-VK.image.astc_decode_mode.10x8_srgb_to_r16g16b16a16_sfloat
+dEQP-VK.image.astc_decode_mode.10x8_srgb_to_r8g8b8a8_unorm
+dEQP-VK.image.astc_decode_mode.10x8_srgb_to_e5b9g9r9_ufloat_pack32
+dEQP-VK.image.astc_decode_mode.10x10_unorm_to_r16g16b16a16_sfloat
+dEQP-VK.image.astc_decode_mode.10x10_unorm_to_r8g8b8a8_unorm
+dEQP-VK.image.astc_decode_mode.10x10_unorm_to_e5b9g9r9_ufloat_pack32
+dEQP-VK.image.astc_decode_mode.10x10_srgb_to_r16g16b16a16_sfloat
+dEQP-VK.image.astc_decode_mode.10x10_srgb_to_r8g8b8a8_unorm
+dEQP-VK.image.astc_decode_mode.10x10_srgb_to_e5b9g9r9_ufloat_pack32
+dEQP-VK.image.astc_decode_mode.12x10_unorm_to_r16g16b16a16_sfloat
+dEQP-VK.image.astc_decode_mode.12x10_unorm_to_r8g8b8a8_unorm
+dEQP-VK.image.astc_decode_mode.12x10_unorm_to_e5b9g9r9_ufloat_pack32
+dEQP-VK.image.astc_decode_mode.12x10_srgb_to_r16g16b16a16_sfloat
+dEQP-VK.image.astc_decode_mode.12x10_srgb_to_r8g8b8a8_unorm
+dEQP-VK.image.astc_decode_mode.12x10_srgb_to_e5b9g9r9_ufloat_pack32
+dEQP-VK.image.astc_decode_mode.12x12_unorm_to_r16g16b16a16_sfloat
+dEQP-VK.image.astc_decode_mode.12x12_unorm_to_r8g8b8a8_unorm
+dEQP-VK.image.astc_decode_mode.12x12_unorm_to_e5b9g9r9_ufloat_pack32
+dEQP-VK.image.astc_decode_mode.12x12_srgb_to_r16g16b16a16_sfloat
+dEQP-VK.image.astc_decode_mode.12x12_srgb_to_r8g8b8a8_unorm
+dEQP-VK.image.astc_decode_mode.12x12_srgb_to_e5b9g9r9_ufloat_pack32
dEQP-VK.image.misaligned_cube.7
dEQP-VK.image.misaligned_cube.8
dEQP-VK.image.misaligned_cube.9
for sType, sSuffix in matches:
structName = re.sub("[_0-9][a-z]", lambda match: match.group(0).upper(), sType.capitalize()).replace('_', '')
ptrnStructName = r'\s*typedef\s+struct\s+(VkPhysicalDevice' + structName + 'Features' + sSuffix[1:] + ')'
- matchStructName = re.search(ptrnStructName, src, re.M)
+ matchStructName = re.search(ptrnStructName, src, re.IGNORECASE)
if matchStructName:
# handle special cases
if sType == "EXCLUSIVE_SCISSOR":
sType = "SCISSOR_EXCLUSIVE"
+ elif sType == "ASTC_DECODE":
+ sType = "ASTC_DECODE_MODE"
+ elif sType == "TEXTURE_COMPRESSION_ASTC_HDR":
+ continue # skip due to const pNext
# end handling special cases
ptrnExtensionName = r'^\s*#define\s+(\w+' + sSuffix + '_' + sType + '_EXTENSION_NAME).+$'
matchExtensionName = re.search(ptrnExtensionName, src, re.M)
# handle special cases
if sType == "SCISSOR_EXCLUSIVE":
sType = "EXCLUSIVE_SCISSOR"
+ elif sType == "ASTC_DECODE_MODE":
+ sType = "ASTC_DECODE"
# end handling special cases
# construct makeFeatureDesc template function definitions
sTypeName = "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_{0}_FEATURES{1}".format(sType, sSuffix)
projects / platform / upstream / VK-GL-CTS.git / commitdiff