From 605dc6d3e789630d24310435121cd0c7d51b6483 Mon Sep 17 00:00:00 2001 From: Jon Leech Date: Fri, 2 Jun 2023 06:19:12 -0700 Subject: [PATCH] Update for Vulkan-Docs 1.3.252 --- include/vulkan/vulkan.hpp | 36 +- include/vulkan/vulkan_core.h | 14 +- include/vulkan/vulkan_enums.hpp | 1 + .../vulkan/vulkan_extension_inspection.hpp | 9 +- include/vulkan/vulkan_handles.hpp | 3 + include/vulkan/vulkan_hash.hpp | 13 + include/vulkan/vulkan_static_assertions.hpp | 9 + include/vulkan/vulkan_structs.hpp | 98 + include/vulkan/vulkan_to_string.hpp | 1 + registry/apiconventions.py | 12 +- registry/genvk.py | 244 +++ registry/parse_dependency.py | 11 +- registry/reg.py | 26 + registry/validusage.json | 1916 +++++++++++++---- registry/vk.xml | 24 +- registry/vkconventions.py | 19 + 16 files changed, 2007 insertions(+), 429 deletions(-) mode change 100644 => 100755 registry/vkconventions.py diff --git a/include/vulkan/vulkan.hpp b/include/vulkan/vulkan.hpp index 95c6513..16867fd 100644 --- a/include/vulkan/vulkan.hpp +++ b/include/vulkan/vulkan.hpp @@ -114,7 +114,7 @@ extern "C" __declspec( dllimport ) FARPROC __stdcall GetProcAddress( HINSTANCE h # include #endif -static_assert( VK_HEADER_VERSION == 251, "Wrong VK_HEADER_VERSION!" ); +static_assert( VK_HEADER_VERSION == 252, "Wrong VK_HEADER_VERSION!" ); // 32-bit vulkan is not typesafe for non-dispatchable handles, so don't allow copy constructors on this platform by default. // To enable this feature on 32-bit platforms please define VULKAN_HPP_TYPESAFE_CONVERSION @@ -12259,6 +12259,40 @@ namespace VULKAN_HPP_NAMESPACE }; }; + //=== VK_EXT_external_memory_acquire_unmodified === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + //=== VK_EXT_extended_dynamic_state3 === template <> struct StructExtends diff --git a/include/vulkan/vulkan_core.h b/include/vulkan/vulkan_core.h index 24cbeb3..0db6741 100644 --- a/include/vulkan/vulkan_core.h +++ b/include/vulkan/vulkan_core.h @@ -68,7 +68,7 @@ extern "C" { #define VK_API_VERSION_1_0 VK_MAKE_API_VERSION(0, 1, 0, 0)// Patch version should always be set to 0 // Version of this file -#define VK_HEADER_VERSION 251 +#define VK_HEADER_VERSION 252 // Complete version of this file #define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 3, VK_HEADER_VERSION) @@ -980,6 +980,7 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM = 1000440000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM = 1000440001, VK_STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM = 1000440002, + VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT = 1000453000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT = 1000455000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT = 1000455001, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT = 1000458000, @@ -15903,6 +15904,17 @@ typedef struct VkPhysicalDeviceImageProcessingPropertiesQCOM { +#define VK_EXT_external_memory_acquire_unmodified 1 +#define VK_EXT_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_SPEC_VERSION 1 +#define VK_EXT_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXTENSION_NAME "VK_EXT_external_memory_acquire_unmodified" +typedef struct VkExternalMemoryAcquireUnmodifiedEXT { + VkStructureType sType; + const void* pNext; + VkBool32 acquireUnmodifiedMemory; +} VkExternalMemoryAcquireUnmodifiedEXT; + + + #define VK_EXT_extended_dynamic_state3 1 #define VK_EXT_EXTENDED_DYNAMIC_STATE_3_SPEC_VERSION 2 #define VK_EXT_EXTENDED_DYNAMIC_STATE_3_EXTENSION_NAME "VK_EXT_extended_dynamic_state3" diff --git a/include/vulkan/vulkan_enums.hpp b/include/vulkan/vulkan_enums.hpp index ca09d80..7061515 100644 --- a/include/vulkan/vulkan_enums.hpp +++ b/include/vulkan/vulkan_enums.hpp @@ -1036,6 +1036,7 @@ namespace VULKAN_HPP_NAMESPACE ePhysicalDeviceImageProcessingFeaturesQCOM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM, ePhysicalDeviceImageProcessingPropertiesQCOM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM, eImageViewSampleWeightCreateInfoQCOM = VK_STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM, + eExternalMemoryAcquireUnmodifiedEXT = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT, ePhysicalDeviceExtendedDynamicState3FeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT, ePhysicalDeviceExtendedDynamicState3PropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT, ePhysicalDeviceSubpassMergeFeedbackFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT, diff --git a/include/vulkan/vulkan_extension_inspection.hpp b/include/vulkan/vulkan_extension_inspection.hpp index 5ffa5f2..c4a56e9 100644 --- a/include/vulkan/vulkan_extension_inspection.hpp +++ b/include/vulkan/vulkan_extension_inspection.hpp @@ -368,6 +368,7 @@ namespace VULKAN_HPP_NAMESPACE "VK_NV_linear_color_attachment", "VK_EXT_image_compression_control_swapchain", "VK_QCOM_image_processing", +"VK_EXT_external_memory_acquire_unmodified", "VK_EXT_extended_dynamic_state3", "VK_EXT_subpass_merge_feedback", "VK_EXT_shader_module_identifier", @@ -754,6 +755,7 @@ namespace VULKAN_HPP_NAMESPACE { "VK_GOOGLE_surfaceless_query", { { "VK_VERSION_1_0", { { "VK_KHR_surface", } } } } }, { "VK_EXT_image_compression_control_swapchain", { { "VK_VERSION_1_0", { { "VK_EXT_image_compression_control", } } } } }, { "VK_QCOM_image_processing", { { "VK_VERSION_1_0", { { "VK_KHR_format_feature_flags2", } } } } }, +{ "VK_EXT_external_memory_acquire_unmodified", { { "VK_VERSION_1_0", { { "VK_KHR_external_memory", } } } } }, { "VK_EXT_extended_dynamic_state3", { { "VK_VERSION_1_0", { { "VK_KHR_get_physical_device_properties2", } } } } }, { "VK_EXT_subpass_merge_feedback", { { "VK_VERSION_1_0", { { "VK_KHR_get_physical_device_properties2", } } } } }, { "VK_EXT_shader_module_identifier", { { "VK_VERSION_1_0", { { "VK_KHR_get_physical_device_properties2", "VK_EXT_pipeline_creation_cache_control", } } } } }, @@ -1470,9 +1472,10 @@ namespace VULKAN_HPP_NAMESPACE ( extension == "VK_EXT_non_seamless_cube_map" ) || ( extension == "VK_QCOM_fragment_density_map_offset" ) || ( extension == "VK_NV_copy_memory_indirect" ) || ( extension == "VK_NV_memory_decompression" ) || ( extension == "VK_NV_linear_color_attachment" ) || ( extension == "VK_EXT_image_compression_control_swapchain" ) || ( extension == "VK_QCOM_image_processing" ) || - ( extension == "VK_EXT_extended_dynamic_state3" ) || ( extension == "VK_EXT_subpass_merge_feedback" ) || - ( extension == "VK_EXT_shader_module_identifier" ) || ( extension == "VK_EXT_rasterization_order_attachment_access" ) || - ( extension == "VK_NV_optical_flow" ) || ( extension == "VK_EXT_legacy_dithering" ) || ( extension == "VK_EXT_pipeline_protected_access" ) || + ( extension == "VK_EXT_external_memory_acquire_unmodified" ) || ( extension == "VK_EXT_extended_dynamic_state3" ) || + ( extension == "VK_EXT_subpass_merge_feedback" ) || ( extension == "VK_EXT_shader_module_identifier" ) || + ( extension == "VK_EXT_rasterization_order_attachment_access" ) || ( extension == "VK_NV_optical_flow" ) || + ( extension == "VK_EXT_legacy_dithering" ) || ( extension == "VK_EXT_pipeline_protected_access" ) || ( extension == "VK_KHR_ray_tracing_position_fetch" ) || ( extension == "VK_EXT_shader_object" ) || ( extension == "VK_QCOM_tile_properties" ) || ( extension == "VK_SEC_amigo_profiling" ) || ( extension == "VK_QCOM_multiview_per_view_viewports" ) || ( extension == "VK_NV_ray_tracing_invocation_reorder" ) || ( extension == "VK_EXT_mutable_descriptor_type" ) || diff --git a/include/vulkan/vulkan_handles.hpp b/include/vulkan/vulkan_handles.hpp index 9df2227..3630ac9 100644 --- a/include/vulkan/vulkan_handles.hpp +++ b/include/vulkan/vulkan_handles.hpp @@ -1514,6 +1514,9 @@ namespace VULKAN_HPP_NAMESPACE struct PhysicalDeviceImageProcessingFeaturesQCOM; struct PhysicalDeviceImageProcessingPropertiesQCOM; + //=== VK_EXT_external_memory_acquire_unmodified === + struct ExternalMemoryAcquireUnmodifiedEXT; + //=== VK_EXT_extended_dynamic_state3 === struct PhysicalDeviceExtendedDynamicState3FeaturesEXT; struct PhysicalDeviceExtendedDynamicState3PropertiesEXT; diff --git a/include/vulkan/vulkan_hash.hpp b/include/vulkan/vulkan_hash.hpp index 59c8044..1c2795f 100644 --- a/include/vulkan/vulkan_hash.hpp +++ b/include/vulkan/vulkan_hash.hpp @@ -4436,6 +4436,19 @@ namespace std } }; + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalMemoryAcquireUnmodifiedEXT const & externalMemoryAcquireUnmodifiedEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, externalMemoryAcquireUnmodifiedEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, externalMemoryAcquireUnmodifiedEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, externalMemoryAcquireUnmodifiedEXT.acquireUnmodifiedMemory ); + return seed; + } + }; + template <> struct hash { diff --git a/include/vulkan/vulkan_static_assertions.hpp b/include/vulkan/vulkan_static_assertions.hpp index 9991c52..e366864 100644 --- a/include/vulkan/vulkan_static_assertions.hpp +++ b/include/vulkan/vulkan_static_assertions.hpp @@ -6138,6 +6138,15 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "PhysicalDeviceImageProcessingPropertiesQCOM is not nothrow_move_constructible!" ); +//=== VK_EXT_external_memory_acquire_unmodified === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ExternalMemoryAcquireUnmodifiedEXT ) == sizeof( VkExternalMemoryAcquireUnmodifiedEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ExternalMemoryAcquireUnmodifiedEXT is not nothrow_move_constructible!" ); + //=== VK_EXT_extended_dynamic_state3 === VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicState3FeaturesEXT ) == diff --git a/include/vulkan/vulkan_structs.hpp b/include/vulkan/vulkan_structs.hpp index 69a1c04..8e39452 100644 --- a/include/vulkan/vulkan_structs.hpp +++ b/include/vulkan/vulkan_structs.hpp @@ -32884,6 +32884,104 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV compatibleHandleTypes = {}; }; + struct ExternalMemoryAcquireUnmodifiedEXT + { + using NativeType = VkExternalMemoryAcquireUnmodifiedEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExternalMemoryAcquireUnmodifiedEXT; + +#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ExternalMemoryAcquireUnmodifiedEXT( VULKAN_HPP_NAMESPACE::Bool32 acquireUnmodifiedMemory_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext( pNext_ ) + , acquireUnmodifiedMemory( acquireUnmodifiedMemory_ ) + { + } + + VULKAN_HPP_CONSTEXPR ExternalMemoryAcquireUnmodifiedEXT( ExternalMemoryAcquireUnmodifiedEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ExternalMemoryAcquireUnmodifiedEXT( VkExternalMemoryAcquireUnmodifiedEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : ExternalMemoryAcquireUnmodifiedEXT( *reinterpret_cast( &rhs ) ) + { + } + + ExternalMemoryAcquireUnmodifiedEXT & operator=( ExternalMemoryAcquireUnmodifiedEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/ + + ExternalMemoryAcquireUnmodifiedEXT & operator=( VkExternalMemoryAcquireUnmodifiedEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ExternalMemoryAcquireUnmodifiedEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ExternalMemoryAcquireUnmodifiedEXT & + setAcquireUnmodifiedMemory( VULKAN_HPP_NAMESPACE::Bool32 acquireUnmodifiedMemory_ ) VULKAN_HPP_NOEXCEPT + { + acquireUnmodifiedMemory = acquireUnmodifiedMemory_; + return *this; + } +#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ + + operator VkExternalMemoryAcquireUnmodifiedEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkExternalMemoryAcquireUnmodifiedEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, acquireUnmodifiedMemory ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ExternalMemoryAcquireUnmodifiedEXT const & ) const = default; +#else + bool operator==( ExternalMemoryAcquireUnmodifiedEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( acquireUnmodifiedMemory == rhs.acquireUnmodifiedMemory ); +# endif + } + + bool operator!=( ExternalMemoryAcquireUnmodifiedEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eExternalMemoryAcquireUnmodifiedEXT; + const void * pNext = {}; + VULKAN_HPP_NAMESPACE::Bool32 acquireUnmodifiedMemory = {}; + }; + + template <> + struct CppType + { + using Type = ExternalMemoryAcquireUnmodifiedEXT; + }; + struct ExternalMemoryBufferCreateInfo { using NativeType = VkExternalMemoryBufferCreateInfo; diff --git a/include/vulkan/vulkan_to_string.hpp b/include/vulkan/vulkan_to_string.hpp index 656d9b4..c9fc846 100644 --- a/include/vulkan/vulkan_to_string.hpp +++ b/include/vulkan/vulkan_to_string.hpp @@ -4089,6 +4089,7 @@ namespace VULKAN_HPP_NAMESPACE case StructureType::ePhysicalDeviceImageProcessingFeaturesQCOM: return "PhysicalDeviceImageProcessingFeaturesQCOM"; case StructureType::ePhysicalDeviceImageProcessingPropertiesQCOM: return "PhysicalDeviceImageProcessingPropertiesQCOM"; case StructureType::eImageViewSampleWeightCreateInfoQCOM: return "ImageViewSampleWeightCreateInfoQCOM"; + case StructureType::eExternalMemoryAcquireUnmodifiedEXT: return "ExternalMemoryAcquireUnmodifiedEXT"; case StructureType::ePhysicalDeviceExtendedDynamicState3FeaturesEXT: return "PhysicalDeviceExtendedDynamicState3FeaturesEXT"; case StructureType::ePhysicalDeviceExtendedDynamicState3PropertiesEXT: return "PhysicalDeviceExtendedDynamicState3PropertiesEXT"; case StructureType::ePhysicalDeviceSubpassMergeFeedbackFeaturesEXT: return "PhysicalDeviceSubpassMergeFeedbackFeaturesEXT"; diff --git a/registry/apiconventions.py b/registry/apiconventions.py index 5d9eee4..d170dd4 100644 --- a/registry/apiconventions.py +++ b/registry/apiconventions.py @@ -8,4 +8,14 @@ # This import should be changed at the repository / working group level to # specify the correct API's conventions. -from vkconventions import VulkanConventions as APIConventions + +import os + +defaultAPI = 'vulkan' + +VulkanAPI = os.getenv('VULKAN_API', default=defaultAPI) + +if VulkanAPI == 'vulkansc': + from vkconventions import VulkanSCConventions as APIConventions +else: + from vkconventions import VulkanConventions as APIConventions diff --git a/registry/genvk.py b/registry/genvk.py index b31f167..98618c1 100755 --- a/registry/genvk.py +++ b/registry/genvk.py @@ -16,6 +16,12 @@ import xml.etree.ElementTree as etree sys.path.append(os.path.abspath(os.path.dirname(__file__))) from cgenerator import CGeneratorOptions, COutputGenerator +# Vulkan SC modules +from json_parser import JSONParserGenerator, JSONParserOptions +from schema_generator import SchemaGeneratorOptions, SchemaOutputGenerator +from json_generator import JSONGeneratorOptions, JSONOutputGenerator +from json_h_generator import JSONHeaderOutputGenerator, JSONHeaderGeneratorOptions +from json_c_generator import JSONCOutputGenerator, JSONCGeneratorOptions from docgenerator import DocGeneratorOptions, DocOutputGenerator from extensionmetadocgenerator import (ExtensionMetaDocGeneratorOptions, @@ -137,6 +143,8 @@ def makeGenOpts(args): '' ] + vulkanLayer = args.vulkanLayer + # Defaults for generating re-inclusion protection wrappers (or not) protectFile = protect @@ -151,6 +159,8 @@ def makeGenOpts(args): # APIs to merge mergeApiNames = args.mergeApiNames + isCTS = args.isCTS + # API include files for spec and ref pages # Overwrites include subdirectories in spec source tree # The generated include files do not include the calling convention @@ -426,6 +436,9 @@ def makeGenOpts(args): [ 'vulkan_metal.h', [ 'VK_EXT_metal_surface', 'VK_EXT_metal_objects' ], commonSuppressExtensions ], [ 'vulkan_screen.h', [ 'VK_QNX_screen_surface' ], commonSuppressExtensions ], + [ 'vulkan_sci.h', [ 'VK_NV_external_sci_sync', + 'VK_NV_external_sci_sync2', + 'VK_NV_external_memory_sci_buf'], commonSuppressExtensions ], [ 'vulkan_beta.h', betaRequireExtensions, betaSuppressExtensions ], ] @@ -509,6 +522,233 @@ def makeGenOpts(args): misracppstyle = misracppstyle) ] + # Vulkan versions to include for SC header - SC *removes* features from 1.0/1.1/1.2 + scVersions = makeREstring(['VK_VERSION_1_0', 'VK_VERSION_1_1', 'VK_VERSION_1_2', 'VKSC_VERSION_1_0']) + + genOpts['vulkan_sc_core.h'] = [ + COutputGenerator, + CGeneratorOptions( + conventions = conventions, + filename = 'vulkan_sc_core.h', + directory = directory, + apiname = 'vulkansc', + profile = None, + versions = scVersions, + emitversions = scVersions, + defaultExtensions = 'vulkansc', + addExtensions = addExtensionsPat, + removeExtensions = removeExtensionsPat, + emitExtensions = emitExtensionsPat, + prefixText = prefixStrings + vkPrefixStrings, + genFuncPointers = True, + protectFile = protectFile, + protectFeature = False, + protectProto = '#ifndef', + protectProtoStr = 'VK_NO_PROTOTYPES', + apicall = 'VKAPI_ATTR ', + apientry = 'VKAPI_CALL ', + apientryp = 'VKAPI_PTR *', + alignFuncParam = 48, + misracstyle = misracstyle, + misracppstyle = misracppstyle) + ] + + genOpts['vulkan_sc_core.hpp'] = [ + COutputGenerator, + CGeneratorOptions( + conventions = conventions, + filename = 'vulkan_sc_core.hpp', + directory = directory, + apiname = 'vulkansc', + profile = None, + versions = scVersions, + emitversions = scVersions, + defaultExtensions = 'vulkansc', + addExtensions = addExtensionsPat, + removeExtensions = removeExtensionsPat, + emitExtensions = emitExtensionsPat, + prefixText = prefixStrings + vkPrefixStrings, + genFuncPointers = True, + protectFile = protectFile, + protectFeature = False, + protectProto = '#ifndef', + protectProtoStr = 'VK_NO_PROTOTYPES', + apicall = 'VKAPI_ATTR ', + apientry = 'VKAPI_CALL ', + apientryp = 'VKAPI_PTR *', + alignFuncParam = 48, + misracstyle = misracstyle, + misracppstyle = misracppstyle) + ] + + genOpts['vk.json'] = [ + SchemaOutputGenerator, + SchemaGeneratorOptions( + conventions = conventions, + filename = 'vk.json', + directory = directory, + apiname = 'vulkansc', + profile = None, + versions = scVersions, + emitversions = scVersions, + defaultExtensions = 'vulkansc', + addExtensions = addExtensionsPat, + removeExtensions = removeExtensionsPat, + emitExtensions = emitExtensionsPat, + prefixText = prefixStrings + vkPrefixStrings, + genFuncPointers = True, + protectFile = protectFile, + protectFeature = False, + protectProto = '#ifndef', + protectProtoStr = 'VK_NO_PROTOTYPES', + apicall = 'VKAPI_ATTR ', + apientry = 'VKAPI_CALL ', + apientryp = 'VKAPI_PTR *', + alignFuncParam = 48) + ] + + if vulkanLayer: + genOpts['vulkan_json_data.hpp'] = [ + JSONOutputGenerator, + JSONGeneratorOptions( + conventions = conventions, + filename = 'vulkan_json_data.hpp', + directory = directory, + apiname = 'vulkan', + profile = None, + versions = featuresPat, + emitversions = featuresPat, + defaultExtensions = None, + addExtensions = addExtensionsPat, + removeExtensions = None, + emitExtensions = None, + vulkanLayer = vulkanLayer, + prefixText = prefixStrings + vkPrefixStrings, + genFuncPointers = True, + protectFile = protectFile, + protectFeature = False, + protectProto = '#ifndef', + protectProtoStr = 'VK_NO_PROTOTYPES', + apicall = 'VKAPI_ATTR ', + apientry = 'VKAPI_CALL ', + apientryp = 'VKAPI_PTR *', + alignFuncParam = 48) + ] + else: + genOpts['vulkan_json_data.hpp'] = [ + JSONOutputGenerator, + JSONGeneratorOptions( + conventions = conventions, + filename = 'vulkan_json_data.hpp', + directory = directory, + apiname = 'vulkansc', + profile = None, + versions = scVersions, + emitversions = scVersions, + defaultExtensions = 'vulkansc', + addExtensions = addExtensionsPat, + removeExtensions = removeExtensionsPat, + emitExtensions = emitExtensionsPat, + vulkanLayer = vulkanLayer, + prefixText = prefixStrings + vkPrefixStrings, + genFuncPointers = True, + protectFile = protectFile, + protectFeature = False, + protectProto = '#ifndef', + protectProtoStr = 'VK_NO_PROTOTYPES', + apicall = 'VKAPI_ATTR ', + apientry = 'VKAPI_CALL ', + apientryp = 'VKAPI_PTR *', + isCTS = isCTS, + alignFuncParam = 48) + ] + + # keep any relevant platform extensions for the following generators + # (needed for e.g. the vulkan_sci extensions) + explicitRemoveExtensionsPat = makeREstring( + removeExtensions, None, strings_are_regex=True) + + # Raw C header file generator. + genOpts['vulkan_json_gen.h'] = [ + JSONHeaderOutputGenerator, + JSONHeaderGeneratorOptions( + conventions = conventions, + filename = 'vulkan_json_gen.h', + directory = directory, + apiname = 'vulkansc', + profile = None, + versions = scVersions, + emitversions = scVersions, + defaultExtensions = 'vulkansc', + addExtensions = addExtensionsPat, + removeExtensions = explicitRemoveExtensionsPat, + emitExtensions = emitExtensionsPat, + prefixText = prefixStrings + vkPrefixStrings, + genFuncPointers = True, + protectFile = protectFile, + protectFeature = False, + protectProto = '#ifndef', + protectProtoStr = 'VK_NO_PROTOTYPES', + apicall = 'VKAPI_ATTR ', + apientry = 'VKAPI_CALL ', + apientryp = 'VKAPI_PTR *', + alignFuncParam = 48) + ] + + # Raw C source file generator. + genOpts['vulkan_json_gen.c'] = [ + JSONCOutputGenerator, + JSONCGeneratorOptions( + conventions = conventions, + filename = 'vulkan_json_gen.c', + directory = directory, + apiname = 'vulkansc', + profile = None, + versions = scVersions, + emitversions = scVersions, + defaultExtensions = 'vulkansc', + addExtensions = addExtensionsPat, + removeExtensions = explicitRemoveExtensionsPat, + emitExtensions = emitExtensionsPat, + prefixText = prefixStrings + vkPrefixStrings, + genFuncPointers = True, + protectFile = protectFile, + protectFeature = False, + protectProto = '#ifndef', + protectProtoStr = 'VK_NO_PROTOTYPES', + apicall = 'VKAPI_ATTR ', + apientry = 'VKAPI_CALL ', + apientryp = 'VKAPI_PTR *', + alignFuncParam = 48) + ] + + genOpts['vulkan_json_parser.hpp'] = [ + JSONParserGenerator, + JSONParserOptions( + conventions = conventions, + filename = 'vulkan_json_parser.hpp', + directory = directory, + apiname = 'vulkansc', + profile = None, + versions = scVersions, + emitversions = scVersions, + defaultExtensions = 'vulkansc', + addExtensions = addExtensionsPat, + removeExtensions = explicitRemoveExtensionsPat, + emitExtensions = emitExtensionsPat, + prefixText = prefixStrings + vkPrefixStrings, + genFuncPointers = True, + protectFile = protectFile, + protectFeature = False, + protectProto = '#ifndef', + protectProtoStr = 'VK_NO_PROTOTYPES', + apicall = 'VKAPI_ATTR ', + apientry = 'VKAPI_CALL ', + apientryp = 'VKAPI_PTR *', + isCTS = isCTS, + alignFuncParam = 48) + ] + # Unused - vulkan10.h target. # It is possible to generate a header with just the Vulkan 1.0 + # extension interfaces defined, but since the promoted KHR extensions @@ -787,10 +1027,14 @@ if __name__ == '__main__': help='Suppress script output during normal execution.') parser.add_argument('-verbose', action='store_false', dest='quiet', default=True, help='Enable script output during normal execution.') + parser.add_argument('--vulkanLayer', action='store_true', dest='vulkanLayer', + help='Enable scripts to generate VK specific vulkan_json_data.hpp for json_gen_layer.') parser.add_argument('-misracstyle', dest='misracstyle', action='store_true', help='generate MISRA C-friendly headers') parser.add_argument('-misracppstyle', dest='misracppstyle', action='store_true', help='generate MISRA C++-friendly headers') + parser.add_argument('--iscts', action='store_true', dest='isCTS', + help='Specify if this should generate CTS compatible code') args = parser.parse_args() diff --git a/registry/parse_dependency.py b/registry/parse_dependency.py index 433c2e3..63eeabc 100755 --- a/registry/parse_dependency.py +++ b/registry/parse_dependency.py @@ -65,7 +65,16 @@ def nameMarkup(name): major = match.group(1) minor = match.group(2) version = major + '.' + minor - return f'<>' + + # Vulkan SC has a different anchor pattern for version appendices + scMatch = re.search("[A-Z]+SC_VERSION_([0-9]+)_([0-9]+)", name) + if scMatch is not None: + if version == '1.0': + return 'Vulkan SC 1.0' + else: + return f'<>' + else: + return f'<>' else: return 'apiext:' + name diff --git a/registry/reg.py b/registry/reg.py index 9c2b11c..3ff580d 100644 --- a/registry/reg.py +++ b/registry/reg.py @@ -974,6 +974,7 @@ class Registry: self.markTypeRequired(typeElem.get('name'), required) for enumElem in feature.findall('enum'): self.markEnumRequired(enumElem.get('name'), required) + for cmdElem in feature.findall('command'): self.markCmdRequired(cmdElem.get('name'), required) @@ -1402,6 +1403,30 @@ class Registry: if stripped: eleminfo.elem.set(attribute, ','.join(apis)) + def stripUnsupportedAPIsFromList(self, dictionary, supportedDictionary): + """Strip unsupported APIs from attributes of APIs. + dictionary - dictionary of list of structure name strings + supportedDictionary - dictionary in which to look for supported + API elements in the attribute""" + + for key in dictionary: + attribstring = dictionary[key] + if attribstring is not None: + apis = [] + stripped = False + for api in attribstring: + ##print('Checking API {} referenced by {}'.format(api, key)) + if supportedDictionary[api].required: + apis.append(api) + else: + stripped = True + ##print('\t**STRIPPING API {} from {}'.format(api, key)) + + # Update the attribute after stripping stuff. + # Could sort apis before joining, but it is not a clear win + if stripped: + dictionary[key] = apis + def generateFormat(self, format, dictionary): if format is None: self.gen.logMsg('diag', 'No entry found for format element', @@ -1603,6 +1628,7 @@ class Registry: self.stripUnsupportedAPIs(self.typedict, 'structextends', self.typedict) self.stripUnsupportedAPIs(self.cmddict, 'successcodes', self.enumdict) self.stripUnsupportedAPIs(self.cmddict, 'errorcodes', self.enumdict) + self.stripUnsupportedAPIsFromList(self.validextensionstructs, self.typedict) # Construct lists of valid extension structures self.tagValidExtensionStructs() diff --git a/registry/validusage.json b/registry/validusage.json index 4b0aa1b..a8c619a 100644 --- a/registry/validusage.json +++ b/registry/validusage.json @@ -1,9 +1,9 @@ { "version info": { "schema version": 2, - "api version": "1.3.251", - "comment": "from git branch: github-main commit: 45b5ba66f8128be493745da2d45f0bb407d9296a", - "date": "2023-05-28 12:06:34Z" + "api version": "1.3.252", + "comment": "from git branch: github-main commit: 5718db0a370b5bd91e6cf2268a3dc2af9cfc15d1", + "date": "2023-06-02 12:04:26Z" }, "validation": { "vkGetInstanceProcAddr": { @@ -193,11 +193,25 @@ ] }, "VkApplicationInfo": { - "core": [ + "!(VKSC_VERSION_1_0)": [ { "vuid": "VUID-VkApplicationInfo-apiVersion-04010", "text": " If apiVersion is not 0, then it must be greater than or equal to VK_API_VERSION_1_0" - }, + } + ], + "(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkApplicationInfo-apiVersion-05021", + "text": " If apiVersion is not 0 and its variant is VKSC_API_VARIANT, then it must be greater than or equal to VKSC_API_VERSION_1_0" + } + ], + "(VK_EXT_application_parameters)": [ + { + "vuid": "VUID-VkApplicationInfo-key-05093", + "text": " The key value of each VkApplicationParametersEXT structure in the VkApplicationInfo::pNext chain must be unique for each vendorID and deviceID pairing" + } + ], + "core": [ { "vuid": "VUID-VkApplicationInfo-sType-sType", "text": " sType must be VK_STRUCTURE_TYPE_APPLICATION_INFO" @@ -222,14 +236,6 @@ "vuid": "VUID-vkDestroyInstance-instance-00629", "text": " All child objects created using instance must have been destroyed prior to destroying instance" }, - { - "vuid": "VUID-vkDestroyInstance-instance-00630", - "text": " If VkAllocationCallbacks were provided when instance was created, a compatible set of callbacks must be provided here" - }, - { - "vuid": "VUID-vkDestroyInstance-instance-00631", - "text": " If no VkAllocationCallbacks were provided when instance was created, pAllocator must be NULL" - }, { "vuid": "VUID-vkDestroyInstance-instance-parameter", "text": " If instance is not NULL, instance must be a valid VkInstance handle" @@ -238,6 +244,16 @@ "vuid": "VUID-vkDestroyInstance-pAllocator-parameter", "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" } + ], + "!(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkDestroyInstance-instance-00630", + "text": " If VkAllocationCallbacks were provided when instance was created, a compatible set of callbacks must be provided here" + }, + { + "vuid": "VUID-vkDestroyInstance-instance-00631", + "text": " If no VkAllocationCallbacks were provided when instance was created, pAllocator must be NULL" + } ] }, "vkEnumeratePhysicalDevices": { @@ -562,6 +578,22 @@ "vuid": "VUID-vkCreateDevice-pDevice-parameter", "text": " pDevice must be a valid pointer to a VkDevice handle" } + ], + "(VK_EXT_application_parameters)": [ + { + "vuid": "VUID-vkCreateDevice-key-05092", + "text": " The key value of each VkApplicationParametersEXT structure in the VkDeviceCreateInfo::pNext chain must be unique" + } + ], + "(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkCreateDevice-deviceMemoryRequestCount-05095", + "text": " The sum of deviceMemoryRequestCount over all VkDeviceObjectReservationCreateInfo structures must be less than or equal to VkPhysicalDeviceLimits::maxMemoryAllocationCount" + }, + { + "vuid": "VUID-vkCreateDevice-samplerRequestCount-05096", + "text": " The sum of samplerRequestCount over all VkDeviceObjectReservationCreateInfo structures must be less than or equal to VkPhysicalDeviceLimits::maxSamplerAllocationCount" + } ] }, "VkDeviceCreateInfo": { @@ -858,8 +890,38 @@ } ] }, + "VkDeviceObjectReservationCreateInfo": { + "(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkDeviceObjectReservationCreateInfo-maxImageViewArrayLayers-05014", + "text": " maxImageViewArrayLayers must be less than or equal to VkPhysicalDeviceLimits::maxImageArrayLayers" + }, + { + "vuid": "VUID-VkDeviceObjectReservationCreateInfo-maxImageViewMipLevels-05015", + "text": " maxImageViewMipLevels must be less than or equal to the number of levels in the complete mipmap chain based on the maximum of VkPhysicalDeviceLimits::maxImageDimension1D, maxImageDimension2D, maxImageDimension3D, and maxImageDimensionCube" + }, + { + "vuid": "VUID-VkDeviceObjectReservationCreateInfo-maxLayeredImageViewMipLevels-05016", + "text": " maxLayeredImageViewMipLevels must be less than or equal to the number of levels in the complete mipmap chain based on VkPhysicalDeviceLimits::maxImageDimension1D, maxImageDimension2D, maxImageDimension3D, and maxImageDimensionCube" + }, + { + "vuid": "VUID-VkDeviceObjectReservationCreateInfo-subpassDescriptionRequestCount-05017", + "text": " subpassDescriptionRequestCount must be less than or equal to renderPassRequestCount multiplied by VkPhysicalDeviceVulkanSC10Properties::maxRenderPassSubpasses" + }, + { + "vuid": "VUID-VkDeviceObjectReservationCreateInfo-attachmentDescriptionRequestCount-05018", + "text": " attachmentDescriptionRequestCount must be less than or equal to renderPassRequestCount multiplied by VkPhysicalDeviceVulkanSC10Properties::maxFramebufferAttachments" + } + ] + }, "vkDestroyDevice": { - "core": [ + "(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkDestroyDevice-device-05137", + "text": " All child objects created on device, except those with no explicit free or destroy command, must have been destroyed prior to destroying device" + } + ], + "!(VKSC_VERSION_1_0)": [ { "vuid": "VUID-vkDestroyDevice-device-00378", "text": " All child objects created on device must have been destroyed prior to destroying device" @@ -871,7 +933,9 @@ { "vuid": "VUID-vkDestroyDevice-device-00380", "text": " If no VkAllocationCallbacks were provided when device was created, pAllocator must be NULL" - }, + } + ], + "core": [ { "vuid": "VUID-vkDestroyDevice-device-parameter", "text": " If device is not NULL, device must be a valid VkDevice handle" @@ -1034,6 +1098,12 @@ "vuid": "VUID-vkCreateCommandPool-pCommandPool-parameter", "text": " pCommandPool must be a valid pointer to a VkCommandPool handle" } + ], + "(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkCreateCommandPool-device-05068", + "text": " The number of {objectnameplural} currently allocated from device plus {objectcount} must be less than or equal to the total number of {objectnameplural} requested via VkDeviceObjectReservationCreateInfo::pname:{objectnamecamelcase}RequestCount specified when device was created" + } ] }, "VkCommandPoolCreateInfo": { @@ -1043,6 +1113,12 @@ "text": " If the protectedMemory feature is not enabled, the VK_COMMAND_POOL_CREATE_PROTECTED_BIT bit of flags must not be set" } ], + "(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkCommandPoolCreateInfo-pNext-05002", + "text": " The pNext chain must include a VkCommandPoolMemoryReservationCreateInfo structure" + } + ], "core": [ { "vuid": "VUID-VkCommandPoolCreateInfo-sType-sType", @@ -1058,8 +1134,28 @@ } ] }, + "VkCommandPoolMemoryReservationCreateInfo": { + "(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkCommandPoolMemoryReservationCreateInfo-commandPoolReservedSize-05003", + "text": " commandPoolReservedSize must be greater than 0" + }, + { + "vuid": "VUID-VkCommandPoolMemoryReservationCreateInfo-commandPoolMaxCommandBuffers-05004", + "text": " commandPoolMaxCommandBuffers must be greater than 0" + }, + { + "vuid": "VUID-VkCommandPoolMemoryReservationCreateInfo-commandPoolMaxCommandBuffers-05090", + "text": " commandPoolMaxCommandBuffers must be less than or equal to VkPhysicalDeviceVulkanSC10Properties::maxCommandPoolCommandBuffers" + }, + { + "vuid": "VUID-VkCommandPoolMemoryReservationCreateInfo-commandPoolMaxCommandBuffers-05074", + "text": " The number of command buffers reserved by all command pools plus commandPoolMaxCommandBuffers must be less than or equal to the total number of command buffers requested via VkDeviceObjectReservationCreateInfo::commandBufferRequestCount" + } + ] + }, "vkTrimCommandPool": { - "(VK_VERSION_1_1,VK_KHR_maintenance1)": [ + "!(VKSC_VERSION_1_0)+(VK_VERSION_1_1,VK_KHR_maintenance1)": [ { "vuid": "VUID-vkTrimCommandPool-device-parameter", "text": " device must be a valid VkDevice handle" @@ -1100,10 +1196,16 @@ "vuid": "VUID-vkResetCommandPool-commandPool-parent", "text": " commandPool must have been created, allocated, or retrieved from device" } + ], + "(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkResetCommandPool-flags-05005", + "text": " flags must not contain VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT" + } ] }, "vkDestroyCommandPool": { - "core": [ + "!(VKSC_VERSION_1_0)": [ { "vuid": "VUID-vkDestroyCommandPool-commandPool-00041", "text": " All VkCommandBuffer objects allocated from commandPool must not be in the pending state" @@ -1155,6 +1257,12 @@ ] }, "VkCommandBufferAllocateInfo": { + "(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkCommandBufferAllocateInfo-commandPool-05006", + "text": " The number of command buffers currently allocated from commandPool plus commandBufferCount must be less than or equal to the value of VkCommandPoolMemoryReservationCreateInfo::commandPoolMaxCommandBuffers specified when commandPool was created" + } + ], "core": [ { "vuid": "VUID-VkCommandBufferAllocateInfo-sType-sType", @@ -1192,6 +1300,12 @@ "vuid": "VUID-vkResetCommandBuffer-flags-parameter", "text": " flags must be a valid combination of VkCommandBufferResetFlagBits values" } + ], + "(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkResetCommandBuffer-commandPoolResetCommandBuffer-05135", + "text": " commandPoolResetCommandBuffer must be supported" + } ] }, "vkFreeCommandBuffers": { @@ -1256,6 +1370,20 @@ "vuid": "VUID-vkBeginCommandBuffer-pBeginInfo-parameter", "text": " pBeginInfo must be a valid pointer to a valid VkCommandBufferBeginInfo structure" } + ], + "(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkBeginCommandBuffer-commandPoolResetCommandBuffer-05136", + "text": " If commandPoolResetCommandBuffer is not supported, commandBuffer must be in the initial state" + }, + { + "vuid": "VUID-vkBeginCommandBuffer-commandPoolMultipleCommandBuffersRecording-05007", + "text": " If commandPoolMultipleCommandBuffersRecording is VK_FALSE, then the command pool that commandBuffer was created from must have no other command buffers in the recording state" + }, + { + "vuid": "VUID-vkBeginCommandBuffer-commandBufferSimultaneousUse-05008", + "text": " If commandBufferSimultaneousUse is VK_FALSE, then pBeginInfo->flags must not include VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT" + } ] }, "VkCommandBufferBeginInfo": { @@ -1269,26 +1397,20 @@ "text": " If flags contains VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT, the subpass member of pInheritanceInfo must be a valid subpass index within the renderPass member of pInheritanceInfo" } ], - "core": [ + "!(VKSC_VERSION_1_0)": [ { "vuid": "VUID-VkCommandBufferBeginInfo-flags-00055", "text": " If flags contains VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT, the framebuffer member of pInheritanceInfo must be either VK_NULL_HANDLE, or a valid VkFramebuffer that is compatible with the renderPass member of pInheritanceInfo" + } + ], + "(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkCommandBufferBeginInfo-flags-05009", + "text": " If flags contains VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT and secondaryCommandBufferNullOrImagelessFramebuffer is VK_TRUE, the framebuffer member of pInheritanceInfo must be either VK_NULL_HANDLE, or a valid VkFramebuffer that is compatible with the renderPass member of pInheritanceInfo" }, { - "vuid": "VUID-VkCommandBufferBeginInfo-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO" - }, - { - "vuid": "VUID-VkCommandBufferBeginInfo-pNext-pNext", - "text": " pNext must be NULL or a pointer to a valid instance of VkDeviceGroupCommandBufferBeginInfo" - }, - { - "vuid": "VUID-VkCommandBufferBeginInfo-sType-unique", - "text": " The sType value of each struct in the pNext chain must be unique" - }, - { - "vuid": "VUID-VkCommandBufferBeginInfo-flags-parameter", - "text": " flags must be a valid combination of VkCommandBufferUsageFlagBits values" + "vuid": "VUID-VkCommandBufferBeginInfo-flags-05010", + "text": " If flags contains VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT and secondaryCommandBufferNullOrImagelessFramebuffer is VK_FALSE, the framebuffer member of pInheritanceInfo must be a valid VkFramebuffer that is compatible with the renderPass member of pInheritanceInfo and must not have been created with a VkFramebufferCreateInfo::flags value that includes VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT" } ], "(VK_VERSION_1_3,VK_KHR_dynamic_rendering)": [ @@ -1310,6 +1432,24 @@ "vuid": "VUID-VkCommandBufferBeginInfo-flags-06003", "text": " If flags contains VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT, the renderPass member of pInheritanceInfo is VK_NULL_HANDLE, and the pNext chain of pInheritanceInfo includes a VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV structure, the colorAttachmentCount member of that structure must be equal to the value of VkCommandBufferInheritanceRenderingInfo::colorAttachmentCount" } + ], + "core": [ + { + "vuid": "VUID-VkCommandBufferBeginInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO" + }, + { + "vuid": "VUID-VkCommandBufferBeginInfo-pNext-pNext", + "text": " pNext must be NULL or a pointer to a valid instance of VkDeviceGroupCommandBufferBeginInfo" + }, + { + "vuid": "VUID-VkCommandBufferBeginInfo-sType-unique", + "text": " The sType value of each struct in the pNext chain must be unique" + }, + { + "vuid": "VUID-VkCommandBufferBeginInfo-flags-parameter", + "text": " flags must be a valid combination of VkCommandBufferUsageFlagBits values" + } ] }, "VkCommandBufferInheritanceInfo": { @@ -1828,6 +1968,12 @@ "vuid": "VUID-VkSemaphoreSubmitInfo-device-03889", "text": " If the device that semaphore was created on is a device group, deviceIndex must be a valid device index" } + ], + "(VK_VERSION_1_3,VK_KHR_synchronization2)+(VK_NV_external_sci_sync,VK_NV_external_sci_sync2)": [ + { + "vuid": "VUID-VkSemaphoreSubmitInfoKHR-semaphore-05094", + "text": " If semaphore has a payload of NvSciSyncObj, value must be calculated by application via NvSciSync APIs." + } ] }, "VkCommandBufferSubmitInfo": { @@ -2603,6 +2749,18 @@ ] }, "vkCreateFence": { + "(VKSC_VERSION_1_0,VK_NV_external_sci_sync,VK_NV_external_sci_sync2)+(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkCreateFence-device-05068", + "text": " The number of {objectnameplural} currently allocated from device plus {objectcount} must be less than or equal to the total number of {objectnameplural} requested via VkDeviceObjectReservationCreateInfo::pname:{objectnamecamelcase}RequestCount specified when device was created" + } + ], + "(VKSC_VERSION_1_0,VK_NV_external_sci_sync,VK_NV_external_sci_sync2)+(VK_NV_external_sci_sync,VK_NV_external_sci_sync2)": [ + { + "vuid": "VUID-vkCreateFence-pNext-05106", + "text": " If the pNext chain of VkFenceCreateInfo includes VkExportFenceSciSyncInfoNV, then VkFenceCreateInfo::flags must not include VK_FENCE_CREATE_SIGNALED_BIT" + } + ], "core": [ { "vuid": "VUID-vkCreateFence-device-parameter", @@ -2656,6 +2814,12 @@ "vuid": "VUID-VkExportFenceCreateInfo-handleTypes-parameter", "text": " handleTypes must be a valid combination of VkExternalFenceHandleTypeFlagBits values" } + ], + "(VK_VERSION_1_1,VK_KHR_external_fence)+(VK_NV_external_sci_sync,VK_NV_external_sci_sync2)": [ + { + "vuid": "VUID-VkExportFenceCreateInfo-pNext-05107", + "text": " If the pNext chain includes a VkExportFenceSciSyncInfoNV structure, VkPhysicalDeviceExternalSciSyncFeaturesNV::sciSyncFence and VkPhysicalDeviceExternalSciSyncFeaturesNV::sciSyncExport, or VkPhysicalDeviceExternalSciSync2FeaturesNV::sciSyncFence and VkPhysicalDeviceExternalSciSync2FeaturesNV::sciSyncExport must be enabled" + } ] }, "VkExportFenceWin32HandleInfoKHR": { @@ -2782,20 +2946,60 @@ } ] }, + "VkExportFenceSciSyncInfoNV": { + "(VK_NV_external_sci_sync,VK_NV_external_sci_sync2)": [ + { + "vuid": "VUID-VkExportFenceSciSyncInfoNV-pAttributes-05108", + "text": " pAttributes must be a reconciled NvSciSyncAttrList" + } + ] + }, + "vkGetPhysicalDeviceSciSyncAttributesNV": { + "(VK_NV_external_sci_sync,VK_NV_external_sci_sync2)": [ + { + "vuid": "VUID-vkGetPhysicalDeviceSciSyncAttributesNV-pSciSyncAttributesInfo-05109", + "text": " If pSciSyncAttributesInfo->primitiveType is VK_SCI_SYNC_PRIMITIVE_TYPE_FENCE_NV then VkPhysicalDeviceExternalSciSyncFeaturesNV::sciSyncFence or VkPhysicalDeviceExternalSciSync2FeaturesNV::sciSyncFence must be enabled" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceSciSyncAttributesNV-pSciSyncAttributesInfo-05110", + "text": " If pSciSyncAttributesInfo->primitiveType is VK_SCI_SYNC_PRIMITIVE_TYPE_SEMAPHORE_NV then VkPhysicalDeviceExternalSciSyncFeaturesNV::sciSyncSemaphore or VkPhysicalDeviceExternalSciSync2FeaturesNV::sciSyncSemaphore2 must be enabled" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceSciSyncAttributesNV-pAttributes-05111", + "text": " pAttributes must be a valid NvSciSyncAttrList and must not be NULL" + } + ] + }, + "vkGetFenceSciSyncFenceNV": { + "(VK_NV_external_sci_sync,VK_NV_external_sci_sync2)": [ + { + "vuid": "VUID-vkGetFenceSciSyncFenceNV-pGetSciSyncHandleInfo-05112", + "text": " pGetSciSyncHandleInfo->handleType must be VK_EXTERNAL_FENCE_HANDLE_TYPE_SCI_SYNC_FENCE_BIT_NV" + }, + { + "vuid": "VUID-vkGetFenceSciSyncFenceNV-sciSyncFence-05113", + "text": " VkPhysicalDeviceExternalSciSyncFeaturesNV::sciSyncFence or VkPhysicalDeviceExternalSciSync2FeaturesNV::sciSyncFence must be enabled" + } + ] + }, + "vkGetFenceSciSyncObjNV": { + "(VK_NV_external_sci_sync,VK_NV_external_sci_sync2)": [ + { + "vuid": "VUID-vkGetFenceSciSyncObjNV-pGetSciSyncHandleInfo-05114", + "text": " pGetSciSyncHandleInfo->handleType must be VK_EXTERNAL_FENCE_HANDLE_TYPE_SCI_SYNC_OBJ_BIT_NV" + }, + { + "vuid": "VUID-vkGetFenceSciSyncObjNV-sciSyncFence-05115", + "text": " VkPhysicalDeviceExternalSciSyncFeaturesNV::sciSyncFence or VkPhysicalDeviceExternalSciSync2FeaturesNV::sciSyncFence must be enabled" + } + ] + }, "vkDestroyFence": { "core": [ { "vuid": "VUID-vkDestroyFence-fence-01120", "text": " All queue submission commands that refer to fence must have completed execution" }, - { - "vuid": "VUID-vkDestroyFence-fence-01121", - "text": " If VkAllocationCallbacks were provided when fence was created, a compatible set of callbacks must be provided here" - }, - { - "vuid": "VUID-vkDestroyFence-fence-01122", - "text": " If no VkAllocationCallbacks were provided when fence was created, pAllocator must be NULL" - }, { "vuid": "VUID-vkDestroyFence-device-parameter", "text": " device must be a valid VkDevice handle" @@ -2812,6 +3016,16 @@ "vuid": "VUID-vkDestroyFence-fence-parent", "text": " If fence is a valid handle, it must have been created, allocated, or retrieved from device" } + ], + "!(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkDestroyFence-fence-01121", + "text": " If VkAllocationCallbacks were provided when fence was created, a compatible set of callbacks must be provided here" + }, + { + "vuid": "VUID-vkDestroyFence-fence-01122", + "text": " If no VkAllocationCallbacks were provided when fence was created, pAllocator must be NULL" + } ] }, "vkGetFenceStatus": { @@ -3070,7 +3284,45 @@ } ] }, + "vkImportFenceSciSyncFenceNV": { + "(VK_NV_external_sci_sync,VK_NV_external_sci_sync2)": [ + { + "vuid": "VUID-vkImportFenceSciSyncFenceNV-sciSyncImport-05140", + "text": " VkPhysicalDeviceExternalSciSyncFeaturesNV::sciSyncImport and VkPhysicalDeviceExternalSciSyncFeaturesNV::sciSyncFence, or VkPhysicalDeviceExternalSciSync2FeaturesNV::sciSyncImport and VkPhysicalDeviceExternalSciSync2FeaturesNV::sciSyncFence must be enabled" + }, + { + "vuid": "VUID-vkImportFenceSciSyncFenceNV-fence-05141", + "text": " fence must not be associated with any queue command that has not yet completed execution on that queue" + }, + { + "vuid": "VUID-vkImportFenceSciSyncFenceNV-pImportFenceSciSyncInfo-05142", + "text": " pImportFenceSciSyncInfo->handleType must be VK_EXTERNAL_FENCE_HANDLE_TYPE_SCI_SYNC_FENCE_BIT_NV" + } + ] + }, + "vkImportFenceSciSyncObjNV": { + "(VK_NV_external_sci_sync,VK_NV_external_sci_sync2)": [ + { + "vuid": "VUID-vkImportFenceSciSyncObjNV-sciSyncImport-05143", + "text": " VkPhysicalDeviceExternalSciSyncFeaturesNV::sciSyncImport and VkPhysicalDeviceExternalSciSyncFeaturesNV::sciSyncFence, or VkPhysicalDeviceExternalSciSync2FeaturesNV::sciSyncImport and VkPhysicalDeviceExternalSciSync2FeaturesNV::sciSyncFence must be enabled" + }, + { + "vuid": "VUID-vkImportFenceSciSyncObjNV-fence-05144", + "text": " fence must not be associated with any queue command that has not yet completed execution on that queue" + }, + { + "vuid": "VUID-vkImportFenceSciSyncObjNV-pImportFenceSciSyncInfo-05145", + "text": " pImportFenceSciSyncInfo->handleType must be VK_EXTERNAL_FENCE_HANDLE_TYPE_SCI_SYNC_OBJ_BIT_NV" + } + ] + }, "vkCreateSemaphore": { + "(VKSC_VERSION_1_0)+(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkCreateSemaphore-device-05068", + "text": " The number of {objectnameplural} currently allocated from device plus {objectcount} must be less than or equal to the total number of {objectnameplural} requested via VkDeviceObjectReservationCreateInfo::pname:{objectnamecamelcase}RequestCount specified when device was created" + } + ], "core": [ { "vuid": "VUID-vkCreateSemaphore-device-parameter", @@ -3091,12 +3343,24 @@ ] }, "VkSemaphoreCreateInfo": { - "(VK_EXT_metal_objects)": [ + "(VK_EXT_metal_objects,VK_NV_external_sci_sync,VK_NV_external_sci_sync2)+(VK_EXT_metal_objects)": [ { "vuid": "VUID-VkSemaphoreCreateInfo-pNext-06789", "text": " If the pNext chain includes a VkExportMetalObjectCreateInfoEXT structure, its exportObjectType member must be VK_EXPORT_METAL_OBJECT_TYPE_METAL_SHARED_EVENT_BIT_EXT" } ], + "(VK_EXT_metal_objects,VK_NV_external_sci_sync,VK_NV_external_sci_sync2)+(VK_NV_external_sci_sync)": [ + { + "vuid": "VUID-VkSemaphoreCreateInfo-pNext-05118", + "text": " If the pNext chain includes VkExportSemaphoreSciSyncInfoNV, it must also include VkSemaphoreTypeCreateInfo with a VkSemaphoreTypeCreateInfo::semaphoreType of VK_SEMAPHORE_TYPE_TIMELINE" + } + ], + "(VK_EXT_metal_objects,VK_NV_external_sci_sync,VK_NV_external_sci_sync2)+(VK_NV_external_sci_sync2)": [ + { + "vuid": "VUID-VkSemaphoreCreateInfo-pNext-05146", + "text": " If the pNext chain includes VkSemaphoreSciSyncCreateInfoNV, it must also include VkSemaphoreTypeCreateInfo with a VkSemaphoreTypeCreateInfo::semaphoreType of VK_SEMAPHORE_TYPE_TIMELINE" + } + ], "core": [ { "vuid": "VUID-VkSemaphoreCreateInfo-sType-sType", @@ -3134,6 +3398,12 @@ "vuid": "VUID-VkSemaphoreTypeCreateInfo-semaphoreType-parameter", "text": " semaphoreType must be a valid VkSemaphoreType value" } + ], + "(VK_VERSION_1_2,VK_KHR_timeline_semaphore)+(VK_NV_external_sci_sync)": [ + { + "vuid": "VUID-VkSemaphoreTypeCreateInfo-pNext-05119", + "text": " If the pNext chain includes VkExportSemaphoreSciSyncInfoNV, initialValue must be zero." + } ] }, "VkExportSemaphoreCreateInfo": { @@ -3150,6 +3420,12 @@ "vuid": "VUID-VkExportSemaphoreCreateInfo-handleTypes-parameter", "text": " handleTypes must be a valid combination of VkExternalSemaphoreHandleTypeFlagBits values" } + ], + "(VK_VERSION_1_1,VK_KHR_external_semaphore)+(VK_NV_external_sci_sync)": [ + { + "vuid": "VUID-VkExportSemaphoreCreateInfo-pNext-05120", + "text": " If the pNext chain includes a VkExportSemaphoreSciSyncInfoNV structure, VkPhysicalDeviceExternalSciSyncFeaturesNV::sciSyncSemapore and VkPhysicalDeviceExternalSciSyncFeaturesNV::sciSyncExport must be enabled" + } ] }, "VkExportSemaphoreWin32HandleInfoKHR": { @@ -3366,12 +3642,60 @@ } ] }, + "VkExportSemaphoreSciSyncInfoNV": { + "(VK_NV_external_sci_sync)": [ + { + "vuid": "VUID-VkExportSemaphoreSciSyncInfoNV-pAttributes-05121", + "text": " pAttributes must be a reconciled NvSciSyncAttrList" + } + ] + }, + "vkGetSemaphoreSciSyncObjNV": { + "(VK_NV_external_sci_sync)": [ + { + "vuid": "VUID-vkGetSemaphoreSciSyncObjNV-sciSyncSemaphore-05147", + "text": " VkPhysicalDeviceExternalSciSyncFeaturesNV::sciSyncSemaphore must be enabled" + } + ] + }, + "VkSemaphoreGetSciSyncInfoNV": { + "(VK_NV_external_sci_sync)": [ + { + "vuid": "VUID-VkSemaphoreGetSciSyncInfoNV-handleType-05122", + "text": " handleType must be VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SCI_SYNC_OBJ_BIT_NV" + }, + { + "vuid": "VUID-VkSemaphoreGetSciSyncInfoNV-semaphore-05123", + "text": " semaphore must have been created with a VkSemaphoreType of VK_SEMAPHORE_TYPE_TIMELINE" + }, + { + "vuid": "VUID-VkSemaphoreGetSciSyncInfoNV-semaphore-05129", + "text": " semaphore must have been created with VkExportSemaphoreSciSyncInfoNV included pNext chain of VkSemaphoreCreateInfo, or previously imported by vkImportSemaphoreSciSyncObjNV" + } + ] + }, + "VkSemaphoreSciSyncCreateInfoNV": { + "(VK_NV_external_sci_sync2)": [ + { + "vuid": "VUID-VkSemaphoreSciSyncCreateInfoNV-sciSyncSemaphore2-05148", + "text": " The VkPhysicalDeviceExternalSciSync2FeaturesNV::sciSyncSemaphore2 feature must be enabled" + } + ] + }, "vkDestroySemaphore": { - "core": [ + "!(VK_NV_external_sci_sync2)": [ { "vuid": "VUID-vkDestroySemaphore-semaphore-01137", "text": " All submitted batches that refer to semaphore must have completed execution" - }, + } + ], + "(VK_NV_external_sci_sync2)": [ + { + "vuid": "VUID-vkDestroySemaphore-semaphore-05149", + "text": " If semaphore was not created with VkSemaphoreSciSyncCreateInfoNV present in the VkSemaphoreCreateInfo::pNext chain when it was created, all submitted batches that refer to semaphore must have completed execution" + } + ], + "!(VKSC_VERSION_1_0)": [ { "vuid": "VUID-vkDestroySemaphore-semaphore-01138", "text": " If VkAllocationCallbacks were provided when semaphore was created, a compatible set of callbacks must be provided here" @@ -3379,7 +3703,9 @@ { "vuid": "VUID-vkDestroySemaphore-semaphore-01139", "text": " If no VkAllocationCallbacks were provided when semaphore was created, pAllocator must be NULL" - }, + } + ], + "core": [ { "vuid": "VUID-vkDestroySemaphore-device-parameter", "text": " device must be a valid VkDevice handle" @@ -3398,6 +3724,40 @@ } ] }, + "vkCreateSemaphoreSciSyncPoolNV": { + "(VK_NV_external_sci_sync2)+(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkCreateSemaphoreSciSyncPoolNV-device-05150", + "text": " The number of semaphore pools currently allocated from device plus 1 must be less than or equal to the total number of semaphore pools requested via VkDeviceSemaphoreSciSyncPoolReservationCreateInfoNV::semaphoreSciSyncPoolRequestCount specified when device was created" + } + ], + "(VK_NV_external_sci_sync2)": [ + { + "vuid": "VUID-vkCreateSemaphoreSciSyncPoolNV-sciSyncSemaphore2-05151", + "text": " The VkPhysicalDeviceExternalSciSync2FeaturesNV::sciSyncSemaphore2 feature must be enabled" + } + ] + }, + "VkSemaphoreSciSyncPoolCreateInfoNV": { + "(VK_NV_external_sci_sync2)": [ + { + "vuid": "VUID-VkSemaphoreSciSyncPoolCreateInfoNV-handle-05152", + "text": " handle must be a valid NvSciSyncObj" + } + ] + }, + "vkDestroySemaphoreSciSyncPoolNV": { + "(VK_NV_external_sci_sync2)+!(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkDestroySemaphoreSciSyncPoolNV-semaphorePool-05153", + "text": " All submitted batches that refer to a semaphore created from semaphorePool must have completed execution" + }, + { + "vuid": "VUID-vkDestroySemaphoreSciSyncPoolNV-sciSyncSemaphore2-05154", + "text": " The VkPhysicalDeviceExternalSciSync2FeaturesNV::sciSyncSemaphore2 feature must be enabled" + } + ] + }, "vkGetSemaphoreCounterValue": { "(VK_VERSION_1_2,VK_KHR_timeline_semaphore)": [ { @@ -3464,6 +3824,12 @@ "vuid": "VUID-VkSemaphoreWaitInfo-semaphoreCount-arraylength", "text": " semaphoreCount must be greater than 0" } + ], + "(VK_VERSION_1_2,VK_KHR_timeline_semaphore)+(VK_NV_external_sci_sync,VK_NV_external_sci_sync2)": [ + { + "vuid": "VUID-VkSemaphoreWaitInfo-pSemaphores-05124", + "text": " If any of the semaphores in pSemaphores have NvSciSyncObj as payload, application must calculate the corresponding timeline semaphore values in pValues by calling NvSciSync APIs." + } ] }, "vkSignalSemaphore": { @@ -3508,6 +3874,12 @@ "vuid": "VUID-VkSemaphoreSignalInfo-semaphore-parameter", "text": " semaphore must be a valid VkSemaphore handle" } + ], + "(VK_VERSION_1_2,VK_KHR_timeline_semaphore)+(VK_NV_external_sci_sync,VK_NV_external_sci_sync2)": [ + { + "vuid": "VUID-VkSemaphoreSignalInfo-semaphores-05125", + "text": " If semaphores has NvSciSyncObj as payload, application must calculate the corresponding timeline semaphore value in value by calling NvSciSync APIs." + } ] }, "vkImportSemaphoreWin32HandleKHR": { @@ -3708,6 +4080,30 @@ } ] }, + "vkImportSemaphoreSciSyncObjNV": { + "(VK_NV_external_sci_sync)": [ + { + "vuid": "VUID-vkImportSemaphoreSciSyncObjNV-sciSyncImport-05155", + "text": " VkPhysicalDeviceExternalSciSyncFeaturesNV::sciSyncImport and VkPhysicalDeviceExternalSciSyncFeaturesNV::sciSyncSemaphore must be enabled" + } + ] + }, + "VkImportSemaphoreSciSyncInfoNV": { + "(VK_NV_external_sci_sync)": [ + { + "vuid": "VUID-VkImportSemaphoreSciSyncInfoNV-handleType-05126", + "text": " handleType must be a value included in the Handle Types Supported by VkImportSemaphoreSciSyncInfoNV table" + }, + { + "vuid": "VUID-VkImportSemaphoreSciSyncInfoNV-semaphore-05127", + "text": " semaphore must have been created with a VkSemaphoreType of VK_SEMAPHORE_TYPE_TIMELINE" + }, + { + "vuid": "VUID-VkImportSemaphoreSciSyncInfoNV-semaphore-05128", + "text": " semaphore must not be associated with any queue command that has not yet completed execution on that queue" + } + ] + }, "vkCreateEvent": { "(VK_KHR_portability_subset)": [ { @@ -3715,6 +4111,12 @@ "text": " If the VK_KHR_portability_subset extension is enabled, and VkPhysicalDevicePortabilitySubsetFeaturesKHR::events is VK_FALSE, then the implementation does not support events, and vkCreateEvent must not be used" } ], + "(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkCreateEvent-device-05068", + "text": " The number of {objectnameplural} currently allocated from device plus {objectcount} must be less than or equal to the total number of {objectnameplural} requested via VkDeviceObjectReservationCreateInfo::pname:{objectnamecamelcase}RequestCount specified when device was created" + } + ], "core": [ { "vuid": "VUID-vkCreateEvent-device-parameter", @@ -3766,14 +4168,6 @@ "vuid": "VUID-vkDestroyEvent-event-01145", "text": " All submitted commands that refer to event must have completed execution" }, - { - "vuid": "VUID-vkDestroyEvent-event-01146", - "text": " If VkAllocationCallbacks were provided when event was created, a compatible set of callbacks must be provided here" - }, - { - "vuid": "VUID-vkDestroyEvent-event-01147", - "text": " If no VkAllocationCallbacks were provided when event was created, pAllocator must be NULL" - }, { "vuid": "VUID-vkDestroyEvent-device-parameter", "text": " device must be a valid VkDevice handle" @@ -3790,6 +4184,16 @@ "vuid": "VUID-vkDestroyEvent-event-parent", "text": " If event is a valid handle, it must have been created, allocated, or retrieved from device" } + ], + "!(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkDestroyEvent-event-01146", + "text": " If VkAllocationCallbacks were provided when event was created, a compatible set of callbacks must be provided here" + }, + { + "vuid": "VUID-vkDestroyEvent-event-01147", + "text": " If no VkAllocationCallbacks were provided when event was created, pAllocator must be NULL" + } ] }, "vkGetEventStatus": { @@ -5810,7 +6214,11 @@ }, { "vuid": "VUID-VkBufferMemoryBarrier2-pNext-pNext", - "text": " pNext must be NULL" + "text": " pNext must be NULL or a pointer to a valid instance of VkExternalMemoryAcquireUnmodifiedEXT" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier2-sType-unique", + "text": " The sType value of each struct in the pNext chain must be unique" }, { "vuid": "VUID-VkBufferMemoryBarrier2-srcStageMask-parameter", @@ -6260,7 +6668,11 @@ }, { "vuid": "VUID-VkBufferMemoryBarrier-pNext-pNext", - "text": " pNext must be NULL" + "text": " pNext must be NULL or a pointer to a valid instance of VkExternalMemoryAcquireUnmodifiedEXT" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier-sType-unique", + "text": " The sType value of each struct in the pNext chain must be unique" }, { "vuid": "VUID-VkBufferMemoryBarrier-buffer-parameter", @@ -6532,7 +6944,7 @@ }, { "vuid": "VUID-VkImageMemoryBarrier2-pNext-pNext", - "text": " pNext must be NULL or a pointer to a valid instance of VkSampleLocationsInfoEXT" + "text": " Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkExternalMemoryAcquireUnmodifiedEXT or VkSampleLocationsInfoEXT" }, { "vuid": "VUID-VkImageMemoryBarrier2-sType-unique", @@ -7160,7 +7572,7 @@ }, { "vuid": "VUID-VkImageMemoryBarrier-pNext-pNext", - "text": " pNext must be NULL or a pointer to a valid instance of VkSampleLocationsInfoEXT" + "text": " Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkExternalMemoryAcquireUnmodifiedEXT or VkSampleLocationsInfoEXT" }, { "vuid": "VUID-VkImageMemoryBarrier-sType-unique", @@ -7358,6 +7770,18 @@ } ] }, + "VkExternalMemoryAcquireUnmodifiedEXT": { + "(VK_EXT_external_memory_acquire_unmodified)": [ + { + "vuid": "VUID-VkExternalMemoryAcquireUnmodifiedEXT-acquireUnmodifiedMemory-08922", + "text": " If acquireUnmodifiedMemory is VK_TRUE, and the memory barrier’s srcQueueFamilyIndex is a special queue family reserved for external memory ownership transfers (as described in Queue Family Ownership Transfer), then each range of VkDeviceMemory bound to the resource must have remained unmodified during all time since the resource’s most recent release of ownership to the queue family." + }, + { + "vuid": "VUID-VkExternalMemoryAcquireUnmodifiedEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT" + } + ] + }, "vkQueueWaitIdle": { "core": [ { @@ -8037,7 +8461,7 @@ "text": " If imageView is not VK_NULL_HANDLE, it must have a layerCount equal to 1" } ], - "(VK_VERSION_1_3,VK_KHR_dynamic_rendering)+(VK_EXT_fragment_density_map)+(VK_VERSION_1_1,VK_KHR_multiview)": [ + "(VK_VERSION_1_3,VK_KHR_dynamic_rendering)+(VK_EXT_fragment_density_map)+(VK_VERSION_1_1,VK_KHR_multiview)+!(VKSC_VERSION_1_0)": [ { "vuid": "VUID-VkRenderingFragmentDensityMapAttachmentInfoEXT-apiVersion-07908", "text": " If VK_KHR_multiview is not enabled, VkPhysicalDeviceProperties::apiVersion is less than Vulkan 1.1, and imageView is not VK_NULL_HANDLE, it must have a layerCount equal to 1" @@ -8115,6 +8539,20 @@ ] }, "vkCreateRenderPass": { + "(VKSC_VERSION_1_0)+(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkCreateRenderPass-device-05068", + "text": " The number of {objectnameplural} currently allocated from device plus {objectcount} must be less than or equal to the total number of {objectnameplural} requested via VkDeviceObjectReservationCreateInfo::pname:{objectnamecamelcase}RequestCount specified when device was created" + }, + { + "vuid": "VUID-vkCreateRenderPass-subpasses-device-05089", + "text": " The number of subpasses currently allocated from device across all slink:VkRenderPass objects plus pname:pCreateInfo->subpassCount must be less than or equal to the total number of subpasses requested via VkDeviceObjectReservationCreateInfo::pname:subpassDescriptionRequestCount specified when device was created" + }, + { + "vuid": "VUID-vkCreateRenderPass-attachments-device-05089", + "text": " The number of attachments currently allocated from device across all slink:VkRenderPass objects plus pname:pCreateInfo->attachmentCount must be less than or equal to the total number of attachments requested via VkDeviceObjectReservationCreateInfo::pname:attachmentDescriptionRequestCount specified when device was created" + } + ], "core": [ { "vuid": "VUID-vkCreateRenderPass-device-parameter", @@ -8254,6 +8692,20 @@ "vuid": "VUID-VkRenderPassCreateInfo-pNext-02515", "text": " If the pNext chain includes a VkRenderPassMultiviewCreateInfo structure, and each element of its pViewMasks member is 0, its correlationMaskCount member must be 0" } + ], + "(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkRenderPassCreateInfo-subpassCount-05050", + "text": " subpassCount must be less than or equal to maxRenderPassSubpasses" + }, + { + "vuid": "VUID-VkRenderPassCreateInfo-dependencyCount-05051", + "text": " dependencyCount must be less than or equal to maxRenderPassDependencies" + }, + { + "vuid": "VUID-VkRenderPassCreateInfo-attachmentCount-05052", + "text": " attachmentCount must be less than or equal to maxFramebufferAttachments" + } ] }, "VkRenderPassMultiviewCreateInfo": { @@ -8720,6 +9172,16 @@ "vuid": "VUID-VkSubpassDescription-pInputAttachments-02868", "text": " If the render pass is created with VK_RENDER_PASS_CREATE_TRANSFORM_BIT_QCOM each of the elements of pInputAttachments must be VK_ATTACHMENT_UNUSED" } + ], + "(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkSubpassDescription-inputAttachmentCount-05053", + "text": " inputAttachmentCount must be less than or equal to maxSubpassInputAttachments" + }, + { + "vuid": "VUID-VkSubpassDescription-preserveAttachmentCount-05054", + "text": " preserveAttachmentCount must be less than or equal to maxSubpassPreserveAttachments" + } ] }, "VkAttachmentReference": { @@ -8995,6 +9457,20 @@ ] }, "vkCreateRenderPass2": { + "(VK_VERSION_1_2,VK_KHR_create_renderpass2)+(VKSC_VERSION_1_0)+(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkCreateRenderPass2-device-05068", + "text": " The number of {objectnameplural} currently allocated from device plus {objectcount} must be less than or equal to the total number of {objectnameplural} requested via VkDeviceObjectReservationCreateInfo::pname:{objectnamecamelcase}RequestCount specified when device was created" + }, + { + "vuid": "VUID-vkCreateRenderPass2-subpasses-device-05089", + "text": " The number of subpasses currently allocated from device across all slink:VkRenderPass objects plus pname:pCreateInfo->subpassCount must be less than or equal to the total number of subpasses requested via VkDeviceObjectReservationCreateInfo::pname:subpassDescriptionRequestCount specified when device was created" + }, + { + "vuid": "VUID-vkCreateRenderPass2-attachments-device-05089", + "text": " The number of attachments currently allocated from device across all slink:VkRenderPass objects plus pname:pCreateInfo->attachmentCount must be less than or equal to the total number of attachments requested via VkDeviceObjectReservationCreateInfo::pname:attachmentDescriptionRequestCount specified when device was created" + } + ], "(VK_VERSION_1_2,VK_KHR_create_renderpass2)": [ { "vuid": "VUID-vkCreateRenderPass2-device-parameter", @@ -9163,6 +9639,20 @@ "text": " If flags includes VK_SUBPASS_DESCRIPTION_SHADER_RESOLVE_BIT_QCOM, then the subpass must be the last subpass in a subpass dependency chain" } ], + "(VK_VERSION_1_2,VK_KHR_create_renderpass2)+(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkRenderPassCreateInfo2-subpassCount-05055", + "text": " subpassCount must be less than or equal to maxRenderPassSubpasses" + }, + { + "vuid": "VUID-VkRenderPassCreateInfo2-dependencyCount-05056", + "text": " dependencyCount must be less than or equal to maxRenderPassDependencies" + }, + { + "vuid": "VUID-VkRenderPassCreateInfo2-attachmentCount-05057", + "text": " attachmentCount must be less than or equal to maxFramebufferAttachments" + } + ], "(VK_VERSION_1_2,VK_KHR_create_renderpass2)+(VK_VERSION_1_2,VK_KHR_separate_depth_stencil_layouts)": [ { "vuid": "VUID-VkRenderPassCreateInfo2-attachment-06244", @@ -9615,6 +10105,16 @@ "text": " If the attachment member of any element of pInputAttachments is not VK_ATTACHMENT_UNUSED, then the aspectMask member must not include VK_IMAGE_ASPECT_MEMORY_PLANE{ibit}BIT_EXT for any index i" } ], + "(VK_VERSION_1_2,VK_KHR_create_renderpass2)+(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkSubpassDescription2-inputAttachmentCount-05058", + "text": " inputAttachmentCount must be less than or equal to maxSubpassInputAttachments" + }, + { + "vuid": "VUID-VkSubpassDescription2-preserveAttachmentCount-05059", + "text": " preserveAttachmentCount must be less than or equal to maxSubpassPreserveAttachments" + } + ], "(VK_VERSION_1_2,VK_KHR_create_renderpass2)+(VK_VERSION_1_1,VK_KHR_multiview)": [ { "vuid": "VUID-VkSubpassDescription2-multiview-06558", @@ -10058,14 +10558,6 @@ "vuid": "VUID-vkDestroyRenderPass-renderPass-00873", "text": " All submitted commands that refer to renderPass must have completed execution" }, - { - "vuid": "VUID-vkDestroyRenderPass-renderPass-00874", - "text": " If VkAllocationCallbacks were provided when renderPass was created, a compatible set of callbacks must be provided here" - }, - { - "vuid": "VUID-vkDestroyRenderPass-renderPass-00875", - "text": " If no VkAllocationCallbacks were provided when renderPass was created, pAllocator must be NULL" - }, { "vuid": "VUID-vkDestroyRenderPass-device-parameter", "text": " device must be a valid VkDevice handle" @@ -10082,6 +10574,16 @@ "vuid": "VUID-vkDestroyRenderPass-renderPass-parent", "text": " If renderPass is a valid handle, it must have been created, allocated, or retrieved from device" } + ], + "!(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkDestroyRenderPass-renderPass-00874", + "text": " If VkAllocationCallbacks were provided when renderPass was created, a compatible set of callbacks must be provided here" + }, + { + "vuid": "VUID-vkDestroyRenderPass-renderPass-00875", + "text": " If no VkAllocationCallbacks were provided when renderPass was created, pAllocator must be NULL" + } ] }, "vkCreateFramebuffer": { @@ -10106,6 +10608,12 @@ "vuid": "VUID-vkCreateFramebuffer-pFramebuffer-parameter", "text": " pFramebuffer must be a valid pointer to a VkFramebuffer handle" } + ], + "(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkCreateFramebuffer-device-05068", + "text": " The number of {objectnameplural} currently allocated from device plus {objectcount} must be less than or equal to the total number of {objectnameplural} requested via VkDeviceObjectReservationCreateInfo::pname:{objectnamecamelcase}RequestCount specified when device was created" + } ] }, "VkFramebufferCreateInfo": { @@ -10275,6 +10783,10 @@ { "vuid": "VUID-VkFramebufferCreateInfo-flags-04538", "text": " If flags does not include VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, and renderPass was not specified with non-zero view masks, each element of pAttachments that is used as a fragment shading rate attachment by renderPass must have a layerCount that is either 1, or greater than layers" + }, + { + "vuid": "VUID-VkFramebufferCreateInfo-renderPass-08921", + "text": " If renderPass was specified with non-zero view masks, each element of pAttachments that is used as a fragment shading rate attachment must have a layerCount equal to 1 or greater than the index of the most significant bit set in any of those view masks" } ], "(VK_KHR_fragment_shading_rate)": [ @@ -10391,6 +10903,12 @@ "text": " If flags includes VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, the usage member of any element of the pAttachmentImageInfos member of a VkFramebufferAttachmentsCreateInfo structure included in the pNext chain that refers to an attachment used as a fragment shading rate attachment by renderPass must include VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR" } ], + "(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkFramebufferCreateInfo-attachmentCount-05060", + "text": " attachmentCount must be less than or equal to maxFramebufferAttachments" + } + ], "(VK_EXT_multisampled_render_to_single_sampled)": [ { "vuid": "VUID-VkFramebufferCreateInfo-samples-06881", @@ -10448,14 +10966,6 @@ "vuid": "VUID-vkDestroyFramebuffer-framebuffer-00892", "text": " All submitted commands that refer to framebuffer must have completed execution" }, - { - "vuid": "VUID-vkDestroyFramebuffer-framebuffer-00893", - "text": " If VkAllocationCallbacks were provided when framebuffer was created, a compatible set of callbacks must be provided here" - }, - { - "vuid": "VUID-vkDestroyFramebuffer-framebuffer-00894", - "text": " If no VkAllocationCallbacks were provided when framebuffer was created, pAllocator must be NULL" - }, { "vuid": "VUID-vkDestroyFramebuffer-device-parameter", "text": " device must be a valid VkDevice handle" @@ -10472,6 +10982,16 @@ "vuid": "VUID-vkDestroyFramebuffer-framebuffer-parent", "text": " If framebuffer is a valid handle, it must have been created, allocated, or retrieved from device" } + ], + "!(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkDestroyFramebuffer-framebuffer-00893", + "text": " If VkAllocationCallbacks were provided when framebuffer was created, a compatible set of callbacks must be provided here" + }, + { + "vuid": "VUID-vkDestroyFramebuffer-framebuffer-00894", + "text": " If no VkAllocationCallbacks were provided when framebuffer was created, pAllocator must be NULL" + } ] }, "vkCmdBeginRenderPass": { @@ -11921,19 +12441,19 @@ ] }, "vkCreateShaderModule": { - "(VK_EXT_validation_cache)": [ + "!(VKSC_VERSION_1_0)+(VK_EXT_validation_cache)": [ { "vuid": "VUID-vkCreateShaderModule-pCreateInfo-06904", "text": " If pCreateInfo is not NULL, pCreateInfo->pNext must be NULL or a pointer to a VkShaderModuleValidationCacheCreateInfoEXT structure" } ], - "!(VK_EXT_validation_cache)": [ + "!(VKSC_VERSION_1_0)+!(VK_EXT_validation_cache)": [ { "vuid": "VUID-vkCreateShaderModule-pCreateInfo-06905", "text": " If pCreateInfo is not NULL, pCreateInfo->pNext must be NULL" } ], - "core": [ + "!(VKSC_VERSION_1_0)": [ { "vuid": "VUID-vkCreateShaderModule-device-parameter", "text": " device must be a valid VkDevice handle" @@ -11953,7 +12473,7 @@ ] }, "VkShaderModuleCreateInfo": { - "!(VK_NV_glsl_shader[]\n:prefixConditio)": [ + "!(VKSC_VERSION_1_0)+!(VK_NV_glsl_shader[]\n:prefixConditio)": [ { "vuid": "VUID-VkShaderModuleCreateInfo-codeSize-08735", "text": " If pname:codeType is ename:VK_SHADER_CODE_TYPE_SPIRV_EXT, codeSize must be a multiple of 4" @@ -11987,7 +12507,7 @@ "text": " If pname:codeType is ename:VK_SHADER_CODE_TYPE_SPIRV_EXT, and pCode declares any of the SPIR-V extensions listed in the SPIR-V Environment appendix, one of the corresponding requirements must be satisfied" } ], - "(VK_NV_glsl_shader[]\n:prefixCondition: If pCode is a pointer to SPIR-V cod)": [ + "!(VKSC_VERSION_1_0)+(VK_NV_glsl_shader[]\n:prefixCondition: If pCode is a pointer to SPIR-V cod)": [ { "vuid": "VUID-VkShaderModuleCreateInfo-codeSize-08735", "text": " If pname:codeType is ename:VK_SHADER_CODE_TYPE_SPIRV_EXT, codeSize must be a multiple of 4" @@ -12029,7 +12549,7 @@ "text": " If pCode is a pointer to GLSL code, it must be valid GLSL code written to the GL_KHR_vulkan_glsl GLSL extension specification" } ], - "core": [ + "!(VKSC_VERSION_1_0)": [ { "vuid": "VUID-VkShaderModuleCreateInfo-codeSize-01085", "text": " codeSize must be greater than 0" @@ -12049,7 +12569,7 @@ ] }, "VkShaderModuleValidationCacheCreateInfoEXT": { - "(VK_EXT_validation_cache)": [ + "!(VKSC_VERSION_1_0)+(VK_EXT_validation_cache)": [ { "vuid": "VUID-VkShaderModuleValidationCacheCreateInfoEXT-sType-sType", "text": " sType must be VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT" @@ -12061,7 +12581,7 @@ ] }, "vkDestroyShaderModule": { - "core": [ + "!(VKSC_VERSION_1_0)": [ { "vuid": "VUID-vkDestroyShaderModule-shaderModule-01092", "text": " If VkAllocationCallbacks were provided when shaderModule was created, a compatible set of callbacks must be provided here" @@ -12367,7 +12887,7 @@ ] }, "vkCreateComputePipelines": { - "core": [ + "!(VKSC_VERSION_1_0)": [ { "vuid": "VUID-vkCreateComputePipelines-flags-00695", "text": " If the flags member of any element of pCreateInfos contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and the basePipelineIndex member of that same element is not -1, basePipelineIndex must be less than the index into pCreateInfos that corresponds to that element" @@ -12375,7 +12895,25 @@ { "vuid": "VUID-vkCreateComputePipelines-flags-00696", "text": " If the flags member of any element of pCreateInfos contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, the base pipeline must have been created with the VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT flag set" + } + ], + "(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkCreateComputePipelines-pipelineCache-05022", + "text": " pipelineCache must not be VK_NULL_HANDLE" }, + { + "vuid": "VUID-vkCreateComputePipelines-device-05068", + "text": " The number of {objectnameplural} currently allocated from device plus {objectcount} must be less than or equal to the total number of {objectnameplural} requested via VkDeviceObjectReservationCreateInfo::pname:{objectnamecamelcase}RequestCount specified when device was created" + } + ], + "(VK_VERSION_1_3,VK_EXT_pipeline_creation_cache_control)": [ + { + "vuid": "VUID-vkCreateComputePipelines-pipelineCache-02873", + "text": " If pipelineCache was created with VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT, host access to pipelineCache must be externally synchronized" + } + ], + "core": [ { "vuid": "VUID-vkCreateComputePipelines-device-parameter", "text": " device must be a valid VkDevice handle" @@ -12404,16 +12942,10 @@ "vuid": "VUID-vkCreateComputePipelines-pipelineCache-parent", "text": " If pipelineCache is a valid handle, it must have been created, allocated, or retrieved from device" } - ], - "(VK_VERSION_1_3,VK_EXT_pipeline_creation_cache_control)": [ - { - "vuid": "VUID-vkCreateComputePipelines-pipelineCache-02873", - "text": " If pipelineCache was created with VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT, host access to pipelineCache must be externally synchronized" - } ] }, "VkComputePipelineCreateInfo": { - "core": [ + "!(VKSC_VERSION_1_0)": [ { "vuid": "VUID-VkComputePipelineCreateInfo-flags-07984", "text": " If flags contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and basePipelineIndex is -1, basePipelineHandle must be a valid handle to a compute VkPipeline" @@ -12425,7 +12957,19 @@ { "vuid": "VUID-VkComputePipelineCreateInfo-flags-07986", "text": " If flags contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, basePipelineIndex must be -1 or basePipelineHandle must be VK_NULL_HANDLE" + } + ], + "(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkComputePipelineCreateInfo-basePipelineHandle-05024", + "text": " basePipelineHandle must be VK_NULL_HANDLE" }, + { + "vuid": "VUID-VkComputePipelineCreateInfo-basePipelineIndex-05025", + "text": " basePipelineIndex must be zero" + } + ], + "core": [ { "vuid": "VUID-VkComputePipelineCreateInfo-layout-07987", "text": " If a push constant block is declared in a shader, a push constant range in layout must match both the shader stage and range" @@ -12578,10 +13122,6 @@ "vuid": "VUID-VkPipelineShaderStageCreateInfo-stage-00706", "text": " stage must not be VK_SHADER_STAGE_ALL_GRAPHICS, or VK_SHADER_STAGE_ALL" }, - { - "vuid": "VUID-VkPipelineShaderStageCreateInfo-pName-00707", - "text": " pName must be the name of an OpEntryPoint in module with an execution model that matches stage" - }, { "vuid": "VUID-VkPipelineShaderStageCreateInfo-maxClipDistances-00708", "text": " If the identified entry point includes any variable in its interface that is declared with the ClipDistance BuiltIn decoration, that variable must not have an array size greater than VkPhysicalDeviceLimits::maxClipDistances" @@ -12679,6 +13219,22 @@ "text": " If the clustercullingShader feature is not enabled, stage must not be VK_SHADER_STAGE_CLUSTER_CULLING_BIT_HUAWEI" } ], + "(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkPipelineShaderStageCreateInfo-module-05026", + "text": " module must be VK_NULL_HANDLE." + }, + { + "vuid": "VUID-VkPipelineShaderStageCreateInfo-pName-05027", + "text": " If pName is not NULL, it must be the name of an OpEntryPoint in the SPIR-V shader module used for offline compilation of this pipeline with an execution model that matches stage" + } + ], + "!(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkPipelineShaderStageCreateInfo-pName-00707", + "text": " pName must be the name of an OpEntryPoint in module with an execution model that matches stage" + } + ], "(VK_EXT_shader_stencil_export)": [ { "vuid": "VUID-VkPipelineShaderStageCreateInfo-stage-06686", @@ -12909,7 +13465,7 @@ ] }, "vkCreateGraphicsPipelines": { - "core": [ + "!(VKSC_VERSION_1_0)": [ { "vuid": "VUID-vkCreateGraphicsPipelines-flags-00720", "text": " If the flags member of any element of pCreateInfos contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and the basePipelineIndex member of that same element is not -1, basePipelineIndex must be less than the index into pCreateInfos that corresponds to that element" @@ -12917,7 +13473,25 @@ { "vuid": "VUID-vkCreateGraphicsPipelines-flags-00721", "text": " If the flags member of any element of pCreateInfos contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, the base pipeline must have been created with the VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT flag set" + } + ], + "(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkCreateGraphicsPipelines-pipelineCache-05031", + "text": " pipelineCache must not be VK_NULL_HANDLE" }, + { + "vuid": "VUID-vkCreateGraphicsPipelines-device-05068", + "text": " The number of {objectnameplural} currently allocated from device plus {objectcount} must be less than or equal to the total number of {objectnameplural} requested via VkDeviceObjectReservationCreateInfo::pname:{objectnamecamelcase}RequestCount specified when device was created" + } + ], + "(VK_VERSION_1_3,VK_EXT_pipeline_creation_cache_control)": [ + { + "vuid": "VUID-vkCreateGraphicsPipelines-pipelineCache-02876", + "text": " If pipelineCache was created with VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT, host access to pipelineCache must be externally synchronized" + } + ], + "core": [ { "vuid": "VUID-vkCreateGraphicsPipelines-device-parameter", "text": " device must be a valid VkDevice handle" @@ -12946,16 +13520,10 @@ "vuid": "VUID-vkCreateGraphicsPipelines-pipelineCache-parent", "text": " If pipelineCache is a valid handle, it must have been created, allocated, or retrieved from device" } - ], - "(VK_VERSION_1_3,VK_EXT_pipeline_creation_cache_control)": [ - { - "vuid": "VUID-vkCreateGraphicsPipelines-pipelineCache-02876", - "text": " If pipelineCache was created with VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT, host access to pipelineCache must be externally synchronized" - } ] }, "VkGraphicsPipelineCreateInfo": { - "core": [ + "!(VKSC_VERSION_1_0)": [ { "vuid": "VUID-VkGraphicsPipelineCreateInfo-flags-07984", "text": " If flags contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and basePipelineIndex is -1, basePipelineHandle must be a valid handle to a graphics VkPipeline" @@ -12967,7 +13535,19 @@ { "vuid": "VUID-VkGraphicsPipelineCreateInfo-flags-07986", "text": " If flags contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, basePipelineIndex must be -1 or basePipelineHandle must be VK_NULL_HANDLE" + } + ], + "(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-basePipelineHandle-05024", + "text": " basePipelineHandle must be VK_NULL_HANDLE" }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-basePipelineIndex-05025", + "text": " basePipelineIndex must be zero" + } + ], + "core": [ { "vuid": "VUID-VkGraphicsPipelineCreateInfo-layout-07987", "text": " If a push constant block is declared in a shader, a push constant range in layout must match both the shader stage and range" @@ -14547,7 +15127,7 @@ ] }, "vkCreateRayTracingPipelinesNV": { - "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_NV_ray_tracing)": [ + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_NV_ray_tracing)+!(VKSC_VERSION_1_0)": [ { "vuid": "VUID-vkCreateRayTracingPipelinesNV-flags-03415", "text": " If the flags member of any element of pCreateInfos contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and the basePipelineIndex member of that same element is not -1, basePipelineIndex must be less than the index into pCreateInfos that corresponds to that element" @@ -14555,7 +15135,27 @@ { "vuid": "VUID-vkCreateRayTracingPipelinesNV-flags-03416", "text": " If the flags member of any element of pCreateInfos contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, the base pipeline must have been created with the VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT flag set" - }, + } + ], + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_NV_ray_tracing)+!(VKSC_VERSION_1_0)+(VK_VERSION_1_1,VK_KHR_device_group)": [ + { + "vuid": "VUID-vkCreateRayTracingPipelinesNV-flags-03816", + "text": " flags must not contain the VK_PIPELINE_CREATE_DISPATCH_BASE flag" + } + ], + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_NV_ray_tracing)+(VK_VERSION_1_3,VK_EXT_pipeline_creation_cache_control)": [ + { + "vuid": "VUID-vkCreateRayTracingPipelinesNV-pipelineCache-02903", + "text": " If pipelineCache was created with VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT, host access to pipelineCache must be externally synchronized" + } + ], + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_NV_ray_tracing)+(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkCreateRayTracingPipelinesNV-pipelineCache-05035", + "text": " pipelineCache must not be VK_NULL_HANDLE" + } + ], + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_NV_ray_tracing)": [ { "vuid": "VUID-vkCreateRayTracingPipelinesNV-device-parameter", "text": " device must be a valid VkDevice handle" @@ -14584,22 +15184,10 @@ "vuid": "VUID-vkCreateRayTracingPipelinesNV-pipelineCache-parent", "text": " If pipelineCache is a valid handle, it must have been created, allocated, or retrieved from device" } - ], - "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_NV_ray_tracing)+(VK_VERSION_1_1,VK_KHR_device_group)": [ - { - "vuid": "VUID-vkCreateRayTracingPipelinesNV-flags-03816", - "text": " flags must not contain the VK_PIPELINE_CREATE_DISPATCH_BASE flag" - } - ], - "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_NV_ray_tracing)+(VK_VERSION_1_3,VK_EXT_pipeline_creation_cache_control)": [ - { - "vuid": "VUID-vkCreateRayTracingPipelinesNV-pipelineCache-02903", - "text": " If pipelineCache was created with VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT, host access to pipelineCache must be externally synchronized" - } ] }, "vkCreateRayTracingPipelinesKHR": { - "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)": [ + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+!(VKSC_VERSION_1_0)": [ { "vuid": "VUID-vkCreateRayTracingPipelinesKHR-flags-03415", "text": " If the flags member of any element of pCreateInfos contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and the basePipelineIndex member of that same element is not -1, basePipelineIndex must be less than the index into pCreateInfos that corresponds to that element" @@ -14607,7 +15195,21 @@ { "vuid": "VUID-vkCreateRayTracingPipelinesKHR-flags-03416", "text": " If the flags member of any element of pCreateInfos contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, the base pipeline must have been created with the VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT flag set" - }, + } + ], + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+!(VKSC_VERSION_1_0)+(VK_VERSION_1_1,VK_KHR_device_group)": [ + { + "vuid": "VUID-vkCreateRayTracingPipelinesKHR-flags-03816", + "text": " flags must not contain the VK_PIPELINE_CREATE_DISPATCH_BASE flag" + } + ], + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+(VK_VERSION_1_3,VK_EXT_pipeline_creation_cache_control)": [ + { + "vuid": "VUID-vkCreateRayTracingPipelinesKHR-pipelineCache-02903", + "text": " If pipelineCache was created with VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT, host access to pipelineCache must be externally synchronized" + } + ], + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)": [ { "vuid": "VUID-vkCreateRayTracingPipelinesKHR-deferredOperation-03677", "text": " If deferredOperation is not VK_NULL_HANDLE, it must be a valid VkDeferredOperationKHR object" @@ -14657,16 +15259,10 @@ "text": " If pipelineCache is a valid handle, it must have been created, allocated, or retrieved from device" } ], - "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+(VK_VERSION_1_1,VK_KHR_device_group)": [ + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+(VKSC_VERSION_1_0)": [ { - "vuid": "VUID-vkCreateRayTracingPipelinesKHR-flags-03816", - "text": " flags must not contain the VK_PIPELINE_CREATE_DISPATCH_BASE flag" - } - ], - "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+(VK_VERSION_1_3,VK_EXT_pipeline_creation_cache_control)": [ - { - "vuid": "VUID-vkCreateRayTracingPipelinesKHR-pipelineCache-02903", - "text": " If pipelineCache was created with VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT, host access to pipelineCache must be externally synchronized" + "vuid": "VUID-vkCreateRayTracingPipelinesKHR-pipelineCache-05036", + "text": " pipelineCache must not be VK_NULL_HANDLE" } ], "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+(VK_VERSION_1_3,VK_EXT_pipeline_creation_cache_control)+(VK_KHR_deferred_host_operations)": [ @@ -14677,7 +15273,7 @@ ] }, "VkRayTracingPipelineCreateInfoNV": { - "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_NV_ray_tracing)": [ + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_NV_ray_tracing)+!(VKSC_VERSION_1_0)": [ { "vuid": "VUID-VkRayTracingPipelineCreateInfoNV-flags-07984", "text": " If flags contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and basePipelineIndex is -1, basePipelineHandle must be a valid handle to a ray tracing VkPipeline" @@ -14689,7 +15285,27 @@ { "vuid": "VUID-VkRayTracingPipelineCreateInfoNV-flags-07986", "text": " If flags contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, basePipelineIndex must be -1 or basePipelineHandle must be VK_NULL_HANDLE" + } + ], + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_NV_ray_tracing)+(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkRayTracingPipelineCreateInfoNV-basePipelineHandle-05024", + "text": " basePipelineHandle must be VK_NULL_HANDLE" }, + { + "vuid": "VUID-VkRayTracingPipelineCreateInfoNV-basePipelineIndex-05025", + "text": " basePipelineIndex must be zero" + }, + { + "vuid": "VUID-VkRayTracingPipelineCreateInfoNV-basePipelineHandle-05038", + "text": " basePipelineHandle must be VK_NULL_HANDLE" + }, + { + "vuid": "VUID-VkRayTracingPipelineCreateInfoNV-basePipelineIndex-05039", + "text": " basePipelineIndex must be zero" + } + ], + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_NV_ray_tracing)": [ { "vuid": "VUID-VkRayTracingPipelineCreateInfoNV-layout-07987", "text": " If a push constant block is declared in a shader, a push constant range in layout must match both the shader stage and range" @@ -14853,7 +15469,7 @@ ] }, "VkRayTracingPipelineCreateInfoKHR": { - "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)": [ + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+!(VKSC_VERSION_1_0)": [ { "vuid": "VUID-VkRayTracingPipelineCreateInfoKHR-flags-07984", "text": " If flags contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and basePipelineIndex is -1, basePipelineHandle must be a valid handle to a ray tracing VkPipeline" @@ -14865,7 +15481,27 @@ { "vuid": "VUID-VkRayTracingPipelineCreateInfoKHR-flags-07986", "text": " If flags contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, basePipelineIndex must be -1 or basePipelineHandle must be VK_NULL_HANDLE" + } + ], + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkRayTracingPipelineCreateInfoKHR-basePipelineHandle-05024", + "text": " basePipelineHandle must be VK_NULL_HANDLE" }, + { + "vuid": "VUID-VkRayTracingPipelineCreateInfoKHR-basePipelineIndex-05025", + "text": " basePipelineIndex must be zero" + }, + { + "vuid": "VUID-VkRayTracingPipelineCreateInfoKHR-basePipelineHandle-05041", + "text": " basePipelineHandle must be VK_NULL_HANDLE" + }, + { + "vuid": "VUID-VkRayTracingPipelineCreateInfoKHR-basePipelineIndex-05042", + "text": " basePipelineIndex must be zero" + } + ], + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)": [ { "vuid": "VUID-VkRayTracingPipelineCreateInfoKHR-layout-07987", "text": " If a push constant block is declared in a shader, a push constant range in layout must match both the shader stage and range" @@ -15390,14 +16026,6 @@ "vuid": "VUID-vkDestroyPipeline-pipeline-00765", "text": " All submitted commands that refer to pipeline must have completed execution" }, - { - "vuid": "VUID-vkDestroyPipeline-pipeline-00766", - "text": " If VkAllocationCallbacks were provided when pipeline was created, a compatible set of callbacks must be provided here" - }, - { - "vuid": "VUID-vkDestroyPipeline-pipeline-00767", - "text": " If no VkAllocationCallbacks were provided when pipeline was created, pAllocator must be NULL" - }, { "vuid": "VUID-vkDestroyPipeline-device-parameter", "text": " device must be a valid VkDevice handle" @@ -15414,9 +16042,25 @@ "vuid": "VUID-vkDestroyPipeline-pipeline-parent", "text": " If pipeline is a valid handle, it must have been created, allocated, or retrieved from device" } + ], + "!(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkDestroyPipeline-pipeline-00766", + "text": " If VkAllocationCallbacks were provided when pipeline was created, a compatible set of callbacks must be provided here" + }, + { + "vuid": "VUID-vkDestroyPipeline-pipeline-00767", + "text": " If no VkAllocationCallbacks were provided when pipeline was created, pAllocator must be NULL" + } ] }, "vkCreatePipelineCache": { + "(VKSC_VERSION_1_0)+(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkCreatePipelineCache-device-05068", + "text": " The number of {objectnameplural} currently allocated from device plus {objectcount} must be less than or equal to the total number of {objectnameplural} requested via VkDeviceObjectReservationCreateInfo::pname:{objectnamecamelcase}RequestCount specified when device was created" + } + ], "core": [ { "vuid": "VUID-vkCreatePipelineCache-device-parameter", @@ -15437,7 +16081,7 @@ ] }, "VkPipelineCacheCreateInfo": { - "core": [ + "!(VKSC_VERSION_1_0)": [ { "vuid": "VUID-VkPipelineCacheCreateInfo-initialDataSize-00768", "text": " If initialDataSize is not 0, it must be equal to the size of pInitialData, as returned by vkGetPipelineCacheData when pInitialData was originally retrieved" @@ -15445,7 +16089,33 @@ { "vuid": "VUID-VkPipelineCacheCreateInfo-initialDataSize-00769", "text": " If initialDataSize is not 0, pInitialData must have been retrieved from a previous call to vkGetPipelineCacheData" + } + ], + "(VK_VERSION_1_3,VK_EXT_pipeline_creation_cache_control)": [ + { + "vuid": "VUID-VkPipelineCacheCreateInfo-pipelineCreationCacheControl-02892", + "text": " If the pipelineCreationCacheControl feature is not enabled, flags must not include VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT" + } + ], + "(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkPipelineCacheCreateInfo-flags-05043", + "text": " flags must include VK_PIPELINE_CACHE_CREATE_READ_ONLY_BIT" }, + { + "vuid": "VUID-VkPipelineCacheCreateInfo-flags-05044", + "text": " flags must include VK_PIPELINE_CACHE_CREATE_USE_APPLICATION_STORAGE_BIT" + }, + { + "vuid": "VUID-VkPipelineCacheCreateInfo-pInitialData-05045", + "text": " The contents of this structure and data pointed to by pInitialData must be the same as specified in one of the VkDeviceObjectReservationCreateInfo::pPipelineCacheCreateInfos structures when the device was created" + }, + { + "vuid": "VUID-VkPipelineCacheCreateInfo-pInitialData-05139", + "text": " The pipeline cache data pointed to by pInitialData must not contain any pipelines with duplicate pipeline identifiers." + } + ], + "core": [ { "vuid": "VUID-VkPipelineCacheCreateInfo-sType-sType", "text": " sType must be VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO" @@ -15462,16 +16132,10 @@ "vuid": "VUID-VkPipelineCacheCreateInfo-pInitialData-parameter", "text": " If initialDataSize is not 0, pInitialData must be a valid pointer to an array of initialDataSize bytes" } - ], - "(VK_VERSION_1_3,VK_EXT_pipeline_creation_cache_control)": [ - { - "vuid": "VUID-VkPipelineCacheCreateInfo-pipelineCreationCacheControl-02892", - "text": " If the pipelineCreationCacheControl feature is not enabled, flags must not include VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT" - } ] }, "vkMergePipelineCaches": { - "core": [ + "!(VKSC_VERSION_1_0)": [ { "vuid": "VUID-vkMergePipelineCaches-dstCache-00770", "text": " dstCache must not appear in the list of source caches" @@ -15503,7 +16167,7 @@ ] }, "vkGetPipelineCacheData": { - "core": [ + "!(VKSC_VERSION_1_0)": [ { "vuid": "VUID-vkGetPipelineCacheData-device-parameter", "text": " device must be a valid VkDevice handle" @@ -15527,7 +16191,7 @@ ] }, "VkPipelineCacheHeaderVersionOne": { - "core": [ + "!(VKSC_VERSION_1_0)": [ { "vuid": "VUID-VkPipelineCacheHeaderVersionOne-headerSize-04967", "text": " headerSize must be 32" @@ -15535,15 +16199,83 @@ { "vuid": "VUID-VkPipelineCacheHeaderVersionOne-headerVersion-04968", "text": " headerVersion must be VK_PIPELINE_CACHE_HEADER_VERSION_ONE" + } + ], + "(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkPipelineCacheHeaderVersionOne-headerSize-05075", + "text": " headerSize must be 56" }, + { + "vuid": "VUID-VkPipelineCacheHeaderVersionOne-headerVersion-05076", + "text": " headerVersion must be VK_PIPELINE_CACHE_HEADER_VERSION_SAFETY_CRITICAL_ONE" + } + ], + "core": [ { "vuid": "VUID-VkPipelineCacheHeaderVersionOne-headerVersion-parameter", "text": " headerVersion must be a valid VkPipelineCacheHeaderVersion value" } ] }, + "VkPipelineCacheHeaderVersionSafetyCriticalOne": { + "(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkPipelineCacheHeaderVersionSafetyCriticalOne-validationVersion-05077", + "text": " validationVersion must be VK_PIPELINE_CACHE_VALIDATION_VERSION_SAFETY_CRITICAL_ONE" + }, + { + "vuid": "VUID-VkPipelineCacheHeaderVersionSafetyCriticalOne-pipelineIndexStride-05078", + "text": " pipelineIndexStride must be greater than or equal to 56 (the size of the VkPipelineCacheSafetyCriticalIndexEntry structure)" + }, + { + "vuid": "VUID-VkPipelineCacheHeaderVersionSafetyCriticalOne-pipelineIndexOffset-05079", + "text": " pipelineIndexOffset + pipelineIndexCount {times} pipelineIndexStride must not exceed the size of the pipeline cache" + } + ] + }, + "VkPipelineCacheSafetyCriticalIndexEntry": { + "(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkPipelineCacheSafetyCriticalIndexEntry-jsonSize-05080", + "text": " if jsonSize is 0, jsonOffset must be 0" + }, + { + "vuid": "VUID-VkPipelineCacheSafetyCriticalIndexEntry-jsonSize-05081", + "text": " if jsonSize is 0, stageIndexCount must be 0" + }, + { + "vuid": "VUID-VkPipelineCacheSafetyCriticalIndexEntry-stageIndexCount-05082", + "text": " if stageIndexCount is 0, stageIndexOffset and stageIndexStride must be 0" + }, + { + "vuid": "VUID-VkPipelineCacheSafetyCriticalIndexEntry-stageIndexCount-05083", + "text": " if stageIndexCount is not 0, stageIndexStride must be greater than or equal to 16 (the size of the VkPipelineCacheStageValidationIndexEntry structure)" + }, + { + "vuid": "VUID-VkPipelineCacheSafetyCriticalIndexEntry-stageIndexCount-05084", + "text": " if stageIndexCount is not 0, stageIndexOffset + stageIndexCount {times} stageIndexStride must not exceed the size of the pipeline cache" + } + ] + }, + "VkPipelineCacheStageValidationIndexEntry": { + "(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkPipelineCacheStageValidationIndexEntry-codeSize-05085", + "text": " codeSize must be greater than 0" + }, + { + "vuid": "VUID-VkPipelineCacheStageValidationIndexEntry-codeSize-05086", + "text": " codeSize must be a multiple of 4" + }, + { + "vuid": "VUID-VkPipelineCacheStageValidationIndexEntry-codeOffset-05087", + "text": " codeOffset + codeSize must not exceed the size of the pipeline cache" + } + ] + }, "vkDestroyPipelineCache": { - "core": [ + "!(VKSC_VERSION_1_0)": [ { "vuid": "VUID-vkDestroyPipelineCache-pipelineCache-00771", "text": " If VkAllocationCallbacks were provided when pipelineCache was created, a compatible set of callbacks must be provided here" @@ -15551,7 +16283,9 @@ { "vuid": "VUID-vkDestroyPipelineCache-pipelineCache-00772", "text": " If no VkAllocationCallbacks were provided when pipelineCache was created, pAllocator must be NULL" - }, + } + ], + "core": [ { "vuid": "VUID-vkDestroyPipelineCache-device-parameter", "text": " device must be a valid VkDevice handle" @@ -15570,6 +16304,22 @@ } ] }, + "VkPipelineOfflineCreateInfo": { + "(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkPipelineOfflineCreateInfo-poolEntrySize-05028", + "text": " poolEntrySize must be one of the sizes requested via VkPipelinePoolSize when the device was created" + }, + { + "vuid": "VUID-VkPipelineOfflineCreateInfo-recyclePipelineMemory-05029", + "text": " If VkPhysicalDeviceVulkanSC10Properties::recyclePipelineMemory is VK_TRUE, the number of currently existing pipelines created with this same value of poolEntrySize plus 1 must be less than or equal to the sum of the VkPipelinePoolSize::poolEntryCount values with the same value of poolEntrySize" + }, + { + "vuid": "VUID-VkPipelineOfflineCreateInfo-recyclePipelineMemory-05030", + "text": " If VkPhysicalDeviceVulkanSC10Properties::recyclePipelineMemory is VK_FALSE, the total number of pipelines ever created with this same value of poolEntrySize plus 1 must be less than or equal to the sum of the VkPipelinePoolSize::poolEntryCount values with the same value of poolEntrySize" + } + ] + }, "VkSpecializationInfo": { "core": [ { @@ -16085,7 +16835,7 @@ ] }, "VkAllocationCallbacks": { - "core": [ + "!(VKSC_VERSION_1_0)": [ { "vuid": "VUID-VkAllocationCallbacks-pfnAllocation-00632", "text": " pfnAllocation must be a valid pointer to a valid user-defined PFN_vkAllocationFunction" @@ -16188,16 +16938,22 @@ "vuid": "VUID-vkAllocateMemory-deviceCoherentMemory-02790", "text": " If the deviceCoherentMemory feature is not enabled, pAllocateInfo->memoryTypeIndex must not identify a memory type supporting VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD" } + ], + "(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkAllocateMemory-device-05068", + "text": " The number of {objectnameplural} currently allocated from device plus {objectcount} must be less than or equal to the total number of {objectnameplural} requested via VkDeviceObjectReservationCreateInfo::pname:{objectnamecamelcase}RequestCount specified when device was created" + } ] }, "VkMemoryAllocateInfo": { - "!(VK_KHR_external_memory_win32,VK_KHR_external_memory_fd,VK_EXT_external_memory_host,VK_ANDROID_external_memory_android_hardware_buffer,VK_FUCHSIA_external_memory)": [ + "!(VK_KHR_external_memory_win32,VK_KHR_external_memory_fd,VK_EXT_external_memory_host,VK_ANDROID_external_memory_android_hardware_buffer,VK_FUCHSIA_external_memory,VK_NV_external_memory_sci_buf)": [ { "vuid": "VUID-VkMemoryAllocateInfo-allocationSize-00638", "text": " allocationSize must be greater than 0" } ], - "(VK_KHR_external_memory_win32,VK_KHR_external_memory_fd,VK_EXT_external_memory_host,VK_ANDROID_external_memory_android_hardware_buffer,VK_FUCHSIA_external_memory)": [ + "(VK_KHR_external_memory_win32,VK_KHR_external_memory_fd,VK_EXT_external_memory_host,VK_ANDROID_external_memory_android_hardware_buffer,VK_FUCHSIA_external_memory,VK_NV_external_memory_sci_buf)": [ { "vuid": "VUID-VkMemoryAllocateInfo-None-06657", "text": " The parameters must not define more than one import operation" @@ -16207,13 +16963,13 @@ "text": " If the parameters do not define an import or export operation, allocationSize must be greater than 0" } ], - "(VK_KHR_external_memory_win32,VK_KHR_external_memory_fd,VK_EXT_external_memory_host,VK_ANDROID_external_memory_android_hardware_buffer,VK_FUCHSIA_external_memory)+!(VK_ANDROID_external_memory_android_hardware_buffer)": [ + "(VK_KHR_external_memory_win32,VK_KHR_external_memory_fd,VK_EXT_external_memory_host,VK_ANDROID_external_memory_android_hardware_buffer,VK_FUCHSIA_external_memory,VK_NV_external_memory_sci_buf)+!(VK_ANDROID_external_memory_android_hardware_buffer)": [ { "vuid": "VUID-VkMemoryAllocateInfo-allocationSize-07898", "text": " If the parameters define an export operation, allocationSize must be greater than 0" } ], - "(VK_KHR_external_memory_win32,VK_KHR_external_memory_fd,VK_EXT_external_memory_host,VK_ANDROID_external_memory_android_hardware_buffer,VK_FUCHSIA_external_memory)+(VK_ANDROID_external_memory_android_hardware_buffer)": [ + "(VK_KHR_external_memory_win32,VK_KHR_external_memory_fd,VK_EXT_external_memory_host,VK_ANDROID_external_memory_android_hardware_buffer,VK_FUCHSIA_external_memory,VK_NV_external_memory_sci_buf)+(VK_ANDROID_external_memory_android_hardware_buffer)": [ { "vuid": "VUID-VkMemoryAllocateInfo-allocationSize-07899", "text": " If the parameters define an export operation and the handle type is not VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID, allocationSize must be greater than 0" @@ -16417,6 +17173,20 @@ "text": " If the parameters define an import operation and the external handle type is VK_EXTERNAL_MEMORY_HANDLE_TYPE_ZIRCON_VMO_BIT_FUCHSIA, the value of allocationSize must be less than or equal to the size of the VMO as determined by zx_vmo_get_size(handle) where handle is the VMO handle to the imported external memory" } ], + "(VK_NV_external_memory_sci_buf)": [ + { + "vuid": "VUID-VkMemoryAllocateInfo-pNext-05097", + "text": " If the pNext chain includes a VkExportMemorySciBufInfoNV structure, VkPhysicalDeviceExternalMemorySciBufFeaturesNV::sciBufExport must be enabled" + }, + { + "vuid": "VUID-VkMemoryAllocateInfo-pNext-05098", + "text": " If the pNext chain includes a VkImportMemorySciBufInfoNV structure, VkPhysicalDeviceExternalMemorySciBufFeaturesNV::sciBufImport must be enabled" + }, + { + "vuid": "VUID-VkMemoryAllocateInfo-memoryTypeIndex-05099", + "text": " If the parameters define an import operation and the external handle is a NvSciBufObj, the value of memoryTypeIndex must be one of those returned by vkGetPhysicalDeviceExternalMemorySciBufPropertiesNV" + } + ], "(VK_EXT_metal_objects)": [ { "vuid": "VUID-VkMemoryAllocateInfo-pNext-06780", @@ -17524,6 +18294,50 @@ } ] }, + "VkExportMemorySciBufInfoNV": { + "(VK_NV_external_memory_sci_buf)": [ + { + "vuid": "VUID-VkExportMemorySciBufInfoNV-pAttributes-05100", + "text": " pAttributes must be a reconciled NvSciBufAttrList" + } + ] + }, + "vkGetPhysicalDeviceSciBufAttributesNV": { + "(VK_NV_external_memory_sci_buf)": [ + { + "vuid": "VUID-vkGetPhysicalDeviceSciBufAttributesNV-pAttributes-05101", + "text": " pAttributes must be a valid NvSciBufAttrList and must not be NULL" + } + ] + }, + "VkImportMemorySciBufInfoNV": { + "(VK_NV_external_memory_sci_buf)": [ + { + "vuid": "VUID-VkImportMemorySciBufInfoNV-handleType-05102", + "text": " handleType must be VK_EXTERNAL_MEMORY_HANDLE_TYPE_SCI_BUF_BIT_NV" + } + ] + }, + "VkMemoryGetSciBufInfoNV": { + "(VK_NV_external_memory_sci_buf)": [ + { + "vuid": "VUID-VkMemoryGetSciBufInfoNV-handleType-05103", + "text": " handleType must be VK_EXTERNAL_MEMORY_HANDLE_TYPE_SCI_BUF_BIT_NV" + } + ] + }, + "vkGetPhysicalDeviceExternalMemorySciBufPropertiesNV": { + "(VK_NV_external_memory_sci_buf)": [ + { + "vuid": "VUID-vkGetPhysicalDeviceExternalMemorySciBufPropertiesNV-handleType-05104", + "text": " handleType must be VK_EXTERNAL_MEMORY_HANDLE_TYPE_SCI_BUF_BIT_NV" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceExternalMemorySciBufPropertiesNV-sciBufImport-05105", + "text": " VkPhysicalDeviceExternalMemorySciBufFeaturesNV::sciBufImport must be enabled" + } + ] + }, "VkMemoryAllocateFlagsInfo": { "(VK_VERSION_1_1,VK_KHR_device_group)": [ { @@ -17553,7 +18367,7 @@ ] }, "vkFreeMemory": { - "core": [ + "!(VKSC_VERSION_1_0)": [ { "vuid": "VUID-vkFreeMemory-memory-00677", "text": " All submitted commands that refer to memory (via images or buffers) must have completed execution" @@ -17909,11 +18723,25 @@ ] }, "vkCreateBuffer": { - "core": [ + "!(VKSC_VERSION_1_0)": [ { "vuid": "VUID-vkCreateBuffer-flags-00911", "text": " If the flags member of pCreateInfo includes VK_BUFFER_CREATE_SPARSE_BINDING_BIT, creating this VkBuffer must not cause the total required sparse memory for all currently valid sparse resources on the device to exceed VkPhysicalDeviceLimits::sparseAddressSpaceSize" - }, + } + ], + "(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkCreateBuffer-device-05068", + "text": " The number of {objectnameplural} currently allocated from device plus {objectcount} must be less than or equal to the total number of {objectnameplural} requested via VkDeviceObjectReservationCreateInfo::pname:{objectnamecamelcase}RequestCount specified when device was created" + } + ], + "(VK_FUCHSIA_buffer_collection)": [ + { + "vuid": "VUID-vkCreateBuffer-pNext-06387", + "text": " If using the VkBuffer for an import operation from a VkBufferCollectionFUCHSIA where a VkBufferCollectionBufferCreateInfoFUCHSIA has been chained to pNext, pCreateInfo must match the VkBufferConstraintsInfoFUCHSIA::createInfo used when setting the constraints on the buffer collection with vkSetBufferCollectionBufferConstraintsFUCHSIA" + } + ], + "core": [ { "vuid": "VUID-vkCreateBuffer-device-parameter", "text": " device must be a valid VkDevice handle" @@ -17930,12 +18758,6 @@ "vuid": "VUID-vkCreateBuffer-pBuffer-parameter", "text": " pBuffer must be a valid pointer to a VkBuffer handle" } - ], - "(VK_FUCHSIA_buffer_collection)": [ - { - "vuid": "VUID-vkCreateBuffer-pNext-06387", - "text": " If using the VkBuffer for an import operation from a VkBufferCollectionFUCHSIA where a VkBufferCollectionBufferCreateInfoFUCHSIA has been chained to pNext, pCreateInfo must match the VkBufferConstraintsInfoFUCHSIA::createInfo used when setting the constraints on the buffer collection with vkSetBufferCollectionBufferConstraintsFUCHSIA" - } ] }, "VkBufferCreateInfo": { @@ -17952,22 +18774,6 @@ "vuid": "VUID-VkBufferCreateInfo-sharingMode-00914", "text": " If sharingMode is VK_SHARING_MODE_CONCURRENT, queueFamilyIndexCount must be greater than 1" }, - { - "vuid": "VUID-VkBufferCreateInfo-flags-00915", - "text": " If the sparseBinding feature is not enabled, flags must not contain VK_BUFFER_CREATE_SPARSE_BINDING_BIT" - }, - { - "vuid": "VUID-VkBufferCreateInfo-flags-00916", - "text": " If the sparseResidencyBuffer feature is not enabled, flags must not contain VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT" - }, - { - "vuid": "VUID-VkBufferCreateInfo-flags-00917", - "text": " If the sparseResidencyAliased feature is not enabled, flags must not contain VK_BUFFER_CREATE_SPARSE_ALIASED_BIT" - }, - { - "vuid": "VUID-VkBufferCreateInfo-flags-00918", - "text": " If flags contains VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT or VK_BUFFER_CREATE_SPARSE_ALIASED_BIT, it must also contain VK_BUFFER_CREATE_SPARSE_BINDING_BIT" - }, { "vuid": "VUID-VkBufferCreateInfo-sType-sType", "text": " sType must be VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO" @@ -18009,6 +18815,30 @@ "text": " If sharingMode is VK_SHARING_MODE_CONCURRENT, each element of pQueueFamilyIndices must be unique and must be less than pQueueFamilyPropertyCount returned by either vkGetPhysicalDeviceQueueFamilyProperties or vkGetPhysicalDeviceQueueFamilyProperties2 for the physicalDevice that was used to create device" } ], + "!(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkBufferCreateInfo-flags-00915", + "text": " If the sparseBinding feature is not enabled, flags must not contain VK_BUFFER_CREATE_SPARSE_BINDING_BIT" + }, + { + "vuid": "VUID-VkBufferCreateInfo-flags-00916", + "text": " If the sparseResidencyBuffer feature is not enabled, flags must not contain VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT" + }, + { + "vuid": "VUID-VkBufferCreateInfo-flags-00917", + "text": " If the sparseResidencyAliased feature is not enabled, flags must not contain VK_BUFFER_CREATE_SPARSE_ALIASED_BIT" + }, + { + "vuid": "VUID-VkBufferCreateInfo-flags-00918", + "text": " If flags contains VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT or VK_BUFFER_CREATE_SPARSE_ALIASED_BIT, it must also contain VK_BUFFER_CREATE_SPARSE_BINDING_BIT" + } + ], + "(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkBufferCreateInfo-flags-05061", + "text": " flags must not contain VK_BUFFER_CREATE_SPARSE_BINDING_BIT, VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT, or VK_BUFFER_CREATE_SPARSE_ALIASED_BIT" + } + ], "(VK_VERSION_1_1,VK_KHR_external_memory)": [ { "vuid": "VUID-VkBufferCreateInfo-pNext-00920", @@ -18019,7 +18849,9 @@ { "vuid": "VUID-VkBufferCreateInfo-flags-01887", "text": " If the protectedMemory feature is not enabled, flags must not contain VK_BUFFER_CREATE_PROTECTED_BIT" - }, + } + ], + "(VK_VERSION_1_1)+!(VKSC_VERSION_1_0)": [ { "vuid": "VUID-VkBufferCreateInfo-None-01888", "text": " If any of the bits VK_BUFFER_CREATE_SPARSE_BINDING_BIT, VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT, or VK_BUFFER_CREATE_SPARSE_ALIASED_BIT are set, VK_BUFFER_CREATE_PROTECTED_BIT must not also be set" @@ -18160,14 +18992,6 @@ "vuid": "VUID-vkDestroyBuffer-buffer-00922", "text": " All submitted commands that refer to buffer, either directly or via a VkBufferView, must have completed execution" }, - { - "vuid": "VUID-vkDestroyBuffer-buffer-00923", - "text": " If VkAllocationCallbacks were provided when buffer was created, a compatible set of callbacks must be provided here" - }, - { - "vuid": "VUID-vkDestroyBuffer-buffer-00924", - "text": " If no VkAllocationCallbacks were provided when buffer was created, pAllocator must be NULL" - }, { "vuid": "VUID-vkDestroyBuffer-device-parameter", "text": " device must be a valid VkDevice handle" @@ -18184,9 +19008,25 @@ "vuid": "VUID-vkDestroyBuffer-buffer-parent", "text": " If buffer is a valid handle, it must have been created, allocated, or retrieved from device" } + ], + "!(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkDestroyBuffer-buffer-00923", + "text": " If VkAllocationCallbacks were provided when buffer was created, a compatible set of callbacks must be provided here" + }, + { + "vuid": "VUID-vkDestroyBuffer-buffer-00924", + "text": " If no VkAllocationCallbacks were provided when buffer was created, pAllocator must be NULL" + } ] }, "vkCreateBufferView": { + "(VKSC_VERSION_1_0)+(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkCreateBufferView-device-05068", + "text": " The number of {objectnameplural} currently allocated from device plus {objectcount} must be less than or equal to the total number of {objectnameplural} requested via VkDeviceObjectReservationCreateInfo::pname:{objectnamecamelcase}RequestCount specified when device was created" + } + ], "core": [ { "vuid": "VUID-vkCreateBufferView-device-parameter", @@ -18306,14 +19146,6 @@ "vuid": "VUID-vkDestroyBufferView-bufferView-00936", "text": " All submitted commands that refer to bufferView must have completed execution" }, - { - "vuid": "VUID-vkDestroyBufferView-bufferView-00937", - "text": " If VkAllocationCallbacks were provided when bufferView was created, a compatible set of callbacks must be provided here" - }, - { - "vuid": "VUID-vkDestroyBufferView-bufferView-00938", - "text": " If no VkAllocationCallbacks were provided when bufferView was created, pAllocator must be NULL" - }, { "vuid": "VUID-vkDestroyBufferView-device-parameter", "text": " device must be a valid VkDevice handle" @@ -18330,14 +19162,38 @@ "vuid": "VUID-vkDestroyBufferView-bufferView-parent", "text": " If bufferView is a valid handle, it must have been created, allocated, or retrieved from device" } + ], + "!(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkDestroyBufferView-bufferView-00937", + "text": " If VkAllocationCallbacks were provided when bufferView was created, a compatible set of callbacks must be provided here" + }, + { + "vuid": "VUID-vkDestroyBufferView-bufferView-00938", + "text": " If no VkAllocationCallbacks were provided when bufferView was created, pAllocator must be NULL" + } ] }, "vkCreateImage": { - "core": [ + "!(VKSC_VERSION_1_0)": [ { "vuid": "VUID-vkCreateImage-flags-00939", "text": " If the flags member of pCreateInfo includes VK_IMAGE_CREATE_SPARSE_BINDING_BIT, creating this VkImage must not cause the total required sparse memory for all currently valid sparse resources on the device to exceed VkPhysicalDeviceLimits::sparseAddressSpaceSize" - }, + } + ], + "(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkCreateImage-device-05068", + "text": " The number of {objectnameplural} currently allocated from device plus {objectcount} must be less than or equal to the total number of {objectnameplural} requested via VkDeviceObjectReservationCreateInfo::pname:{objectnamecamelcase}RequestCount specified when device was created" + } + ], + "(VK_FUCHSIA_buffer_collection)": [ + { + "vuid": "VUID-vkCreateImage-pNext-06389", + "text": " If a VkBufferCollectionImageCreateInfoFUCHSIA has been chained to pNext, pCreateInfo must match the Sysmem chosen VkImageCreateInfo excepting members VkImageCreateInfo::extent and VkImageCreateInfo::usage in the match criteria" + } + ], + "core": [ { "vuid": "VUID-vkCreateImage-device-parameter", "text": " device must be a valid VkDevice handle" @@ -18354,12 +19210,6 @@ "vuid": "VUID-vkCreateImage-pImage-parameter", "text": " pImage must be a valid pointer to a VkImage handle" } - ], - "(VK_FUCHSIA_buffer_collection)": [ - { - "vuid": "VUID-vkCreateImage-pNext-06389", - "text": " If a VkBufferCollectionImageCreateInfoFUCHSIA has been chained to pNext, pCreateInfo must match the Sysmem chosen VkImageCreateInfo excepting members VkImageCreateInfo::extent and VkImageCreateInfo::usage in the match criteria" - } ] }, "VkImageCreateInfo": { @@ -18472,54 +19322,6 @@ "vuid": "VUID-VkImageCreateInfo-usage-00968", "text": " If the shaderStorageImageMultisample feature is not enabled, and usage contains VK_IMAGE_USAGE_STORAGE_BIT, samples must be VK_SAMPLE_COUNT_1_BIT" }, - { - "vuid": "VUID-VkImageCreateInfo-flags-00969", - "text": " If the sparseBinding feature is not enabled, flags must not contain VK_IMAGE_CREATE_SPARSE_BINDING_BIT" - }, - { - "vuid": "VUID-VkImageCreateInfo-flags-01924", - "text": " If the sparseResidencyAliased feature is not enabled, flags must not contain VK_IMAGE_CREATE_SPARSE_ALIASED_BIT" - }, - { - "vuid": "VUID-VkImageCreateInfo-tiling-04121", - "text": " If tiling is VK_IMAGE_TILING_LINEAR, flags must not contain VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT" - }, - { - "vuid": "VUID-VkImageCreateInfo-imageType-00970", - "text": " If imageType is VK_IMAGE_TYPE_1D, flags must not contain VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT" - }, - { - "vuid": "VUID-VkImageCreateInfo-imageType-00971", - "text": " If the sparseResidencyImage2D feature is not enabled, and imageType is VK_IMAGE_TYPE_2D, flags must not contain VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT" - }, - { - "vuid": "VUID-VkImageCreateInfo-imageType-00972", - "text": " If the sparseResidencyImage3D feature is not enabled, and imageType is VK_IMAGE_TYPE_3D, flags must not contain VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT" - }, - { - "vuid": "VUID-VkImageCreateInfo-imageType-00973", - "text": " If the sparseResidency2Samples feature is not enabled, imageType is VK_IMAGE_TYPE_2D, and samples is VK_SAMPLE_COUNT_2_BIT, flags must not contain VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT" - }, - { - "vuid": "VUID-VkImageCreateInfo-imageType-00974", - "text": " If the sparseResidency4Samples feature is not enabled, imageType is VK_IMAGE_TYPE_2D, and samples is VK_SAMPLE_COUNT_4_BIT, flags must not contain VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT" - }, - { - "vuid": "VUID-VkImageCreateInfo-imageType-00975", - "text": " If the sparseResidency8Samples feature is not enabled, imageType is VK_IMAGE_TYPE_2D, and samples is VK_SAMPLE_COUNT_8_BIT, flags must not contain VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT" - }, - { - "vuid": "VUID-VkImageCreateInfo-imageType-00976", - "text": " If the sparseResidency16Samples feature is not enabled, imageType is VK_IMAGE_TYPE_2D, and samples is VK_SAMPLE_COUNT_16_BIT, flags must not contain VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT" - }, - { - "vuid": "VUID-VkImageCreateInfo-flags-00987", - "text": " If flags contains VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT or VK_IMAGE_CREATE_SPARSE_ALIASED_BIT, it must also contain VK_IMAGE_CREATE_SPARSE_BINDING_BIT" - }, - { - "vuid": "VUID-VkImageCreateInfo-None-01925", - "text": " If any of the bits VK_IMAGE_CREATE_SPARSE_BINDING_BIT, VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT, or VK_IMAGE_CREATE_SPARSE_ALIASED_BIT are set, VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT must not also be set" - }, { "vuid": "VUID-VkImageCreateInfo-initialLayout-00993", "text": " initialLayout must be VK_IMAGE_LAYOUT_UNDEFINED or VK_IMAGE_LAYOUT_PREINITIALIZED" @@ -18679,11 +19481,69 @@ "text": " If the fragmentDensityMapOffset feature is not enabled and usage includes VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT, extent.height must be less than or equal to \\(\\left\\lceil{\\frac{maxFramebufferHeight}{minFragmentDensityTexelSize_{height}}}\\right\\rceil\\)" } ], + "!(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkImageCreateInfo-flags-00969", + "text": " If the sparseBinding feature is not enabled, flags must not contain VK_IMAGE_CREATE_SPARSE_BINDING_BIT" + }, + { + "vuid": "VUID-VkImageCreateInfo-flags-01924", + "text": " If the sparseResidencyAliased feature is not enabled, flags must not contain VK_IMAGE_CREATE_SPARSE_ALIASED_BIT" + }, + { + "vuid": "VUID-VkImageCreateInfo-tiling-04121", + "text": " If tiling is VK_IMAGE_TILING_LINEAR, flags must not contain VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT" + }, + { + "vuid": "VUID-VkImageCreateInfo-imageType-00970", + "text": " If imageType is VK_IMAGE_TYPE_1D, flags must not contain VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT" + }, + { + "vuid": "VUID-VkImageCreateInfo-imageType-00971", + "text": " If the sparseResidencyImage2D feature is not enabled, and imageType is VK_IMAGE_TYPE_2D, flags must not contain VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT" + }, + { + "vuid": "VUID-VkImageCreateInfo-imageType-00972", + "text": " If the sparseResidencyImage3D feature is not enabled, and imageType is VK_IMAGE_TYPE_3D, flags must not contain VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT" + }, + { + "vuid": "VUID-VkImageCreateInfo-imageType-00973", + "text": " If the sparseResidency2Samples feature is not enabled, imageType is VK_IMAGE_TYPE_2D, and samples is VK_SAMPLE_COUNT_2_BIT, flags must not contain VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT" + }, + { + "vuid": "VUID-VkImageCreateInfo-imageType-00974", + "text": " If the sparseResidency4Samples feature is not enabled, imageType is VK_IMAGE_TYPE_2D, and samples is VK_SAMPLE_COUNT_4_BIT, flags must not contain VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT" + }, + { + "vuid": "VUID-VkImageCreateInfo-imageType-00975", + "text": " If the sparseResidency8Samples feature is not enabled, imageType is VK_IMAGE_TYPE_2D, and samples is VK_SAMPLE_COUNT_8_BIT, flags must not contain VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT" + }, + { + "vuid": "VUID-VkImageCreateInfo-imageType-00976", + "text": " If the sparseResidency16Samples feature is not enabled, imageType is VK_IMAGE_TYPE_2D, and samples is VK_SAMPLE_COUNT_16_BIT, flags must not contain VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT" + }, + { + "vuid": "VUID-VkImageCreateInfo-flags-00987", + "text": " If flags contains VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT or VK_IMAGE_CREATE_SPARSE_ALIASED_BIT, it must also contain VK_IMAGE_CREATE_SPARSE_BINDING_BIT" + }, + { + "vuid": "VUID-VkImageCreateInfo-None-01925", + "text": " If any of the bits VK_IMAGE_CREATE_SPARSE_BINDING_BIT, VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT, or VK_IMAGE_CREATE_SPARSE_ALIASED_BIT are set, VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT must not also be set" + } + ], + "(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkImageCreateInfo-flags-05062", + "text": " flags must not contain VK_IMAGE_CREATE_SPARSE_BINDING_BIT, VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT, VK_IMAGE_CREATE_SPARSE_ALIASED_BIT, or VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT" + } + ], "(VK_VERSION_1_1)": [ { "vuid": "VUID-VkImageCreateInfo-flags-01890", "text": " If the protectedMemory feature is not enabled, flags must not contain VK_IMAGE_CREATE_PROTECTED_BIT" - }, + } + ], + "(VK_VERSION_1_1)+!(VKSC_VERSION_1_0)": [ { "vuid": "VUID-VkImageCreateInfo-None-01891", "text": " If any of the bits VK_IMAGE_CREATE_SPARSE_BINDING_BIT, VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT, or VK_IMAGE_CREATE_SPARSE_ALIASED_BIT are set, VK_IMAGE_CREATE_PROTECTED_BIT must not also be set" @@ -18707,7 +19567,7 @@ "text": " If the pNext chain includes a VkExternalMemoryImageCreateInfoNV structure, its handleTypes member must only contain bits that are also in VkExternalImageFormatPropertiesNV::externalMemoryProperties.compatibleHandleTypes, as returned by vkGetPhysicalDeviceExternalImageFormatPropertiesNV with format, imageType, tiling, usage, and flags equal to those in this structure, and with externalHandleType equal to any one of the handle types specified in VkExternalMemoryImageCreateInfoNV::handleTypes" } ], - "(VK_VERSION_1_1,VK_KHR_device_group)": [ + "(VK_VERSION_1_1,VK_KHR_device_group)+!(VKSC_VERSION_1_0)": [ { "vuid": "VUID-VkImageCreateInfo-physicalDeviceCount-01421", "text": " If the logical device was created with VkDeviceGroupDeviceCreateInfo::physicalDeviceCount equal to 1, flags must not contain VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT" @@ -19394,14 +20254,6 @@ "vuid": "VUID-vkDestroyImage-image-01000", "text": " All submitted commands that refer to image, either directly or via a VkImageView, must have completed execution" }, - { - "vuid": "VUID-vkDestroyImage-image-01001", - "text": " If VkAllocationCallbacks were provided when image was created, a compatible set of callbacks must be provided here" - }, - { - "vuid": "VUID-vkDestroyImage-image-01002", - "text": " If no VkAllocationCallbacks were provided when image was created, pAllocator must be NULL" - }, { "vuid": "VUID-vkDestroyImage-device-parameter", "text": " device must be a valid VkDevice handle" @@ -19419,6 +20271,16 @@ "text": " If image is a valid handle, it must have been created, allocated, or retrieved from device" } ], + "!(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkDestroyImage-image-01001", + "text": " If VkAllocationCallbacks were provided when image was created, a compatible set of callbacks must be provided here" + }, + { + "vuid": "VUID-vkDestroyImage-image-01002", + "text": " If no VkAllocationCallbacks were provided when image was created, pAllocator must be NULL" + } + ], "(VK_KHR_swapchain)": [ { "vuid": "VUID-vkDestroyImage-image-04882", @@ -19427,6 +20289,18 @@ ] }, "vkCreateImageView": { + "(VKSC_VERSION_1_0)+(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkCreateImageView-device-05068", + "text": " The number of {objectnameplural} currently allocated from device plus {objectcount} must be less than or equal to the total number of {objectnameplural} requested via VkDeviceObjectReservationCreateInfo::pname:{objectnamecamelcase}RequestCount specified when device was created" + } + ], + "(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkCreateImageView-subresourceRange-05063", + "text": " If VkImageViewCreateInfo::subresourceRange.layerCount is greater than 1, the number of image views with more than one array layer currently allocated from device plus 1 must be less than or equal to the total number of image views requested via VkDeviceObjectReservationCreateInfo::layeredImageViewRequestCount specified when device was created" + } + ], "core": [ { "vuid": "VUID-vkCreateImageView-device-parameter", @@ -19570,10 +20444,6 @@ "vuid": "VUID-VkImageViewCreateInfo-image-04970", "text": " If image was created with VK_IMAGE_TYPE_3D and viewType is VK_IMAGE_VIEW_TYPE_2D or VK_IMAGE_VIEW_TYPE_2D_ARRAY then subresourceRange.levelCount must be 1" }, - { - "vuid": "VUID-VkImageViewCreateInfo-image-04971", - "text": " If image was created with VK_IMAGE_TYPE_3D and viewType is VK_IMAGE_VIEW_TYPE_2D or VK_IMAGE_VIEW_TYPE_2D_ARRAY then VkImageCreateInfo::flags must not contain any of VK_IMAGE_CREATE_SPARSE_BINDING_BIT, VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT, and VK_IMAGE_CREATE_SPARSE_ALIASED_BIT" - }, { "vuid": "VUID-VkImageViewCreateInfo-image-04972", "text": " If image was created with a samples value not equal to VK_SAMPLE_COUNT_1_BIT then viewType must be either VK_IMAGE_VIEW_TYPE_2D or VK_IMAGE_VIEW_TYPE_2D_ARRAY" @@ -19615,6 +20485,12 @@ "text": " If subresourceRange.layerCount is not VK_REMAINING_ARRAY_LAYERS, image is not a 3D image created with VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT or VK_IMAGE_CREATE_2D_VIEW_COMPATIBLE_BIT_EXT set, or viewType is not VK_IMAGE_VIEW_TYPE_2D or VK_IMAGE_VIEW_TYPE_2D_ARRAY, subresourceRange.layerCount must be non-zero and subresourceRange.baseArrayLayer + subresourceRange.layerCount must be less than or equal to the arrayLayers specified in VkImageCreateInfo when image was created" } ], + "(VK_VERSION_1_1,VK_KHR_maintenance1)+!(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkImageViewCreateInfo-image-04971", + "text": " If image was created with VK_IMAGE_TYPE_3D and viewType is VK_IMAGE_VIEW_TYPE_2D or VK_IMAGE_VIEW_TYPE_2D_ARRAY then VkImageCreateInfo::flags must not contain any of VK_IMAGE_CREATE_SPARSE_BINDING_BIT, VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT, and VK_IMAGE_CREATE_SPARSE_ALIASED_BIT" + } + ], "(VK_NV_linear_color_attachment)": [ { "vuid": "VUID-VkImageViewCreateInfo-usage-06516", @@ -19815,6 +20691,20 @@ "text": " If the VK_KHR_portability_subset extension is enabled, and VkPhysicalDevicePortabilitySubsetFeaturesKHR::imageViewFormatReinterpretation is VK_FALSE, the VkFormat in format must not contain a different number of components, or a different number of bits in each component, than the format of the VkImage in image" } ], + "(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkImageViewCreateInfo-subresourceRange-05064", + "text": " subresourceRange.levelCount must be less than or equal to VkDeviceObjectReservationCreateInfo::maxImageViewMipLevels" + }, + { + "vuid": "VUID-VkImageViewCreateInfo-subresourceRange-05065", + "text": " subresourceRange.layerCount must be less than or equal to VkDeviceObjectReservationCreateInfo::maxImageViewArrayLayers" + }, + { + "vuid": "VUID-VkImageViewCreateInfo-subresourceRange-05066", + "text": " If subresourceRange.layerCount is greater than 1, subresourceRange.levelCount must be less than or equal to VkDeviceObjectReservationCreateInfo::maxLayeredImageViewMipLevels" + } + ], "(VK_KHR_video_decode_queue)": [ { "vuid": "VUID-VkImageViewCreateInfo-image-04817", @@ -20068,14 +20958,6 @@ "vuid": "VUID-vkDestroyImageView-imageView-01026", "text": " All submitted commands that refer to imageView must have completed execution" }, - { - "vuid": "VUID-vkDestroyImageView-imageView-01027", - "text": " If VkAllocationCallbacks were provided when imageView was created, a compatible set of callbacks must be provided here" - }, - { - "vuid": "VUID-vkDestroyImageView-imageView-01028", - "text": " If no VkAllocationCallbacks were provided when imageView was created, pAllocator must be NULL" - }, { "vuid": "VUID-vkDestroyImageView-device-parameter", "text": " device must be a valid VkDevice handle" @@ -20092,6 +20974,16 @@ "vuid": "VUID-vkDestroyImageView-imageView-parent", "text": " If imageView is a valid handle, it must have been created, allocated, or retrieved from device" } + ], + "!(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkDestroyImageView-imageView-01027", + "text": " If VkAllocationCallbacks were provided when imageView was created, a compatible set of callbacks must be provided here" + }, + { + "vuid": "VUID-vkDestroyImageView-imageView-01028", + "text": " If no VkAllocationCallbacks were provided when imageView was created, pAllocator must be NULL" + } ] }, "vkGetImageViewHandleNVX": { @@ -20634,14 +21526,6 @@ "vuid": "VUID-vkDestroyAccelerationStructureKHR-accelerationStructure-02442", "text": " All submitted commands that refer to accelerationStructure must have completed execution" }, - { - "vuid": "VUID-vkDestroyAccelerationStructureKHR-accelerationStructure-02443", - "text": " If VkAllocationCallbacks were provided when accelerationStructure was created, a compatible set of callbacks must be provided here" - }, - { - "vuid": "VUID-vkDestroyAccelerationStructureKHR-accelerationStructure-02444", - "text": " If no VkAllocationCallbacks were provided when accelerationStructure was created, pAllocator must be NULL" - }, { "vuid": "VUID-vkDestroyAccelerationStructureKHR-device-parameter", "text": " device must be a valid VkDevice handle" @@ -20658,6 +21542,16 @@ "vuid": "VUID-vkDestroyAccelerationStructureKHR-accelerationStructure-parent", "text": " If accelerationStructure is a valid handle, it must have been created, allocated, or retrieved from device" } + ], + "(VK_NV_ray_tracing,VK_KHR_acceleration_structure)+!(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkDestroyAccelerationStructureKHR-accelerationStructure-02443", + "text": " If VkAllocationCallbacks were provided when accelerationStructure was created, a compatible set of callbacks must be provided here" + }, + { + "vuid": "VUID-vkDestroyAccelerationStructureKHR-accelerationStructure-02444", + "text": " If no VkAllocationCallbacks were provided when accelerationStructure was created, pAllocator must be NULL" + } ] }, "vkDestroyAccelerationStructureNV": { @@ -20666,14 +21560,6 @@ "vuid": "VUID-vkDestroyAccelerationStructureNV-accelerationStructure-03752", "text": " All submitted commands that refer to accelerationStructure must have completed execution" }, - { - "vuid": "VUID-vkDestroyAccelerationStructureNV-accelerationStructure-03753", - "text": " If VkAllocationCallbacks were provided when accelerationStructure was created, a compatible set of callbacks must be provided here" - }, - { - "vuid": "VUID-vkDestroyAccelerationStructureNV-accelerationStructure-03754", - "text": " If no VkAllocationCallbacks were provided when accelerationStructure was created, pAllocator must be NULL" - }, { "vuid": "VUID-vkDestroyAccelerationStructureNV-device-parameter", "text": " device must be a valid VkDevice handle" @@ -20690,6 +21576,16 @@ "vuid": "VUID-vkDestroyAccelerationStructureNV-accelerationStructure-parent", "text": " If accelerationStructure is a valid handle, it must have been created, allocated, or retrieved from device" } + ], + "(VK_NV_ray_tracing,VK_KHR_acceleration_structure)+(VK_NV_ray_tracing)+!(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkDestroyAccelerationStructureNV-accelerationStructure-03753", + "text": " If VkAllocationCallbacks were provided when accelerationStructure was created, a compatible set of callbacks must be provided here" + }, + { + "vuid": "VUID-vkDestroyAccelerationStructureNV-accelerationStructure-03754", + "text": " If no VkAllocationCallbacks were provided when accelerationStructure was created, pAllocator must be NULL" + } ] }, "vkGetAccelerationStructureMemoryRequirementsNV": { @@ -21381,7 +22277,7 @@ "text": " If buffer was not created with VkDedicatedAllocationBufferCreateInfoNV::dedicatedAllocation equal to VK_TRUE, memory must not have been allocated dedicated for a specific buffer or image" } ], - "(VK_NV_dedicated_allocation)+(VK_VERSION_1_1,VK_KHR_dedicated_allocation)": [ + "(VK_NV_dedicated_allocation)+(VK_VERSION_1_1,VK_KHR_dedicated_allocation)+!(VKSC_VERSION_1_0)": [ { "vuid": "VUID-vkBindBufferMemory-apiVersion-07920", "text": " If the VK_KHR_dedicated_allocation extension is not enabled, VkPhysicalDeviceProperties::apiVersion is less than Vulkan 1.1, and buffer was not created with VkDedicatedAllocationBufferCreateInfoNV::dedicatedAllocation equal to VK_TRUE, memory must not have been allocated dedicated for a specific buffer or image" @@ -21527,7 +22423,7 @@ "text": " If buffer was not created with VkDedicatedAllocationBufferCreateInfoNV::dedicatedAllocation equal to VK_TRUE, memory must not have been allocated dedicated for a specific buffer or image" } ], - "(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_NV_dedicated_allocation)+(VK_VERSION_1_1,VK_KHR_dedicated_allocation)": [ + "(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_NV_dedicated_allocation)+(VK_VERSION_1_1,VK_KHR_dedicated_allocation)+!(VKSC_VERSION_1_0)": [ { "vuid": "VUID-VkBindBufferMemoryInfo-apiVersion-07920", "text": " If the VK_KHR_dedicated_allocation extension is not enabled, VkPhysicalDeviceProperties::apiVersion is less than Vulkan 1.1, and buffer was not created with VkDedicatedAllocationBufferCreateInfoNV::dedicatedAllocation equal to VK_TRUE, memory must not have been allocated dedicated for a specific buffer or image" @@ -21691,7 +22587,7 @@ "text": " If image was not created with VkDedicatedAllocationImageCreateInfoNV::dedicatedAllocation equal to VK_TRUE, memory must not have been allocated dedicated for a specific buffer or image" } ], - "(VK_NV_dedicated_allocation)+(VK_VERSION_1_1,VK_KHR_dedicated_allocation)": [ + "(VK_NV_dedicated_allocation)+(VK_VERSION_1_1,VK_KHR_dedicated_allocation)+!(VKSC_VERSION_1_0)": [ { "vuid": "VUID-vkBindImageMemory-apiVersion-07921", "text": " If the VK_KHR_dedicated_allocation extension is not enabled, VkPhysicalDeviceProperties::apiVersion is less than Vulkan 1.1, and image was not created with VkDedicatedAllocationImageCreateInfoNV::dedicatedAllocation equal to VK_TRUE, memory must not have been allocated dedicated for a specific buffer or image" @@ -21843,7 +22739,7 @@ "text": " If image was not created with VkDedicatedAllocationImageCreateInfoNV::dedicatedAllocation equal to VK_TRUE, memory must not have been allocated dedicated for a specific buffer or image" } ], - "(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_NV_dedicated_allocation)+(VK_VERSION_1_1,VK_KHR_dedicated_allocation)": [ + "(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_NV_dedicated_allocation)+(VK_VERSION_1_1,VK_KHR_dedicated_allocation)+!(VKSC_VERSION_1_0)": [ { "vuid": "VUID-VkBindImageMemoryInfo-apiVersion-07921", "text": " If the VK_KHR_dedicated_allocation extension is not enabled, VkPhysicalDeviceProperties::apiVersion is less than Vulkan 1.1, and image was not created with VkDedicatedAllocationImageCreateInfoNV::dedicatedAllocation equal to VK_TRUE, memory must not have been allocated dedicated for a specific buffer or image" @@ -21935,7 +22831,9 @@ { "vuid": "VUID-VkBindImageMemoryInfo-pNext-01626", "text": " If the pNext chain includes a VkBindImageMemoryDeviceGroupInfo structure, all instances of memory specified by VkBindImageMemoryDeviceGroupInfo::pDeviceIndices must have been allocated" - }, + } + ], + "(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_device_group)+!(VKSC_VERSION_1_0)": [ { "vuid": "VUID-VkBindImageMemoryInfo-pNext-01627", "text": " If the pNext chain includes a VkBindImageMemoryDeviceGroupInfo structure, and VkBindImageMemoryDeviceGroupInfo::splitInstanceBindRegionCount is not zero, then image must have been created with the VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT bit set" @@ -21965,19 +22863,11 @@ ] }, "VkBindImageMemoryDeviceGroupInfo": { - "(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_device_group)": [ + "(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_device_group)+!(VKSC_VERSION_1_0)": [ { "vuid": "VUID-VkBindImageMemoryDeviceGroupInfo-deviceIndexCount-01633", "text": " At least one of deviceIndexCount and splitInstanceBindRegionCount must be zero" }, - { - "vuid": "VUID-VkBindImageMemoryDeviceGroupInfo-deviceIndexCount-01634", - "text": " deviceIndexCount must either be zero or equal to the number of physical devices in the logical device" - }, - { - "vuid": "VUID-VkBindImageMemoryDeviceGroupInfo-pDeviceIndices-01635", - "text": " All elements of pDeviceIndices must be valid device indices" - }, { "vuid": "VUID-VkBindImageMemoryDeviceGroupInfo-splitInstanceBindRegionCount-01636", "text": " splitInstanceBindRegionCount must either be zero or equal to the number of physical devices in the logical device squared" @@ -22001,6 +22891,16 @@ { "vuid": "VUID-VkBindImageMemoryDeviceGroupInfo-extent-01641", "text": " The extent.height member of any element of pSplitInstanceBindRegions must either be a multiple of the sparse image block height of all non-metadata aspects of the image, or else extent.height + offset.y must equal the height of the image subresource" + } + ], + "(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_device_group)": [ + { + "vuid": "VUID-VkBindImageMemoryDeviceGroupInfo-deviceIndexCount-01634", + "text": " deviceIndexCount must either be zero or equal to the number of physical devices in the logical device" + }, + { + "vuid": "VUID-VkBindImageMemoryDeviceGroupInfo-pDeviceIndices-01635", + "text": " All elements of pDeviceIndices must be valid device indices" }, { "vuid": "VUID-VkBindImageMemoryDeviceGroupInfo-sType-sType", @@ -22014,6 +22914,12 @@ "vuid": "VUID-VkBindImageMemoryDeviceGroupInfo-pSplitInstanceBindRegions-parameter", "text": " If splitInstanceBindRegionCount is not 0, pSplitInstanceBindRegions must be a valid pointer to an array of splitInstanceBindRegionCount VkRect2D structures" } + ], + "(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_device_group)+(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkBindImageMemoryDeviceGroupInfo-splitInstanceBindRegionCount-05067", + "text": " splitInstanceBindRegionCount must be zero" + } ] }, "VkBindImageMemorySwapchainInfoKHR": { @@ -22430,6 +23336,12 @@ "vuid": "VUID-vkCreateSampler-pSampler-parameter", "text": " pSampler must be a valid pointer to a VkSampler handle" } + ], + "(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkCreateSampler-device-05068", + "text": " The number of {objectnameplural} currently allocated from device plus {objectcount} must be less than or equal to the total number of {objectnameplural} requested via VkDeviceObjectReservationCreateInfo::pname:{objectnamecamelcase}RequestCount specified when device was created" + } ] }, "VkSamplerCreateInfo": { @@ -22690,14 +23602,6 @@ "vuid": "VUID-vkDestroySampler-sampler-01082", "text": " All submitted commands that refer to sampler must have completed execution" }, - { - "vuid": "VUID-vkDestroySampler-sampler-01083", - "text": " If VkAllocationCallbacks were provided when sampler was created, a compatible set of callbacks must be provided here" - }, - { - "vuid": "VUID-vkDestroySampler-sampler-01084", - "text": " If no VkAllocationCallbacks were provided when sampler was created, pAllocator must be NULL" - }, { "vuid": "VUID-vkDestroySampler-device-parameter", "text": " device must be a valid VkDevice handle" @@ -22714,6 +23618,16 @@ "vuid": "VUID-vkDestroySampler-sampler-parent", "text": " If sampler is a valid handle, it must have been created, allocated, or retrieved from device" } + ], + "!(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkDestroySampler-sampler-01083", + "text": " If VkAllocationCallbacks were provided when sampler was created, a compatible set of callbacks must be provided here" + }, + { + "vuid": "VUID-vkDestroySampler-sampler-01084", + "text": " If no VkAllocationCallbacks were provided when sampler was created, pAllocator must be NULL" + } ] }, "VkSamplerYcbcrConversionInfo": { @@ -22750,6 +23664,12 @@ "vuid": "VUID-vkCreateSamplerYcbcrConversion-pYcbcrConversion-parameter", "text": " pYcbcrConversion must be a valid pointer to a VkSamplerYcbcrConversion handle" } + ], + "(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)+(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkCreateSamplerYcbcrConversion-device-05068", + "text": " The number of {objectnameplural} currently allocated from device plus {objectcount} must be less than or equal to the total number of {objectnameplural} requested via VkDeviceObjectReservationCreateInfo::pname:{objectnamecamelcase}RequestCount specified when device was created" + } ] }, "VkSamplerYcbcrConversionCreateInfo": { @@ -22921,6 +23841,16 @@ ] }, "vkCreateDescriptorSetLayout": { + "(VKSC_VERSION_1_0)+(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkCreateDescriptorSetLayout-device-05068", + "text": " The number of {objectnameplural} currently allocated from device plus {objectcount} must be less than or equal to the total number of {objectnameplural} requested via VkDeviceObjectReservationCreateInfo::pname:{objectnamecamelcase}RequestCount specified when device was created" + }, + { + "vuid": "VUID-vkCreateDescriptorSetLayout-layoutbindings-device-05089", + "text": " The number of descriptor set layout bindings currently allocated from device across all slink:VkDescriptorSetLayout objects plus pname:pCreateInfo->bindingCount must be less than or equal to the total number of descriptor set layout bindings requested via VkDeviceObjectReservationCreateInfo::pname:descriptorSetLayoutBindingRequestCount specified when device was created" + } + ], "core": [ { "vuid": "VUID-vkCreateDescriptorSetLayout-device-parameter", @@ -23027,6 +23957,16 @@ "text": " If flags contains VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_EXT, VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT::mutableDescriptorType must be enabled" } ], + "(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkDescriptorSetLayoutCreateInfo-bindingCount-05011", + "text": " bindingCount must be less than or equal to maxDescriptorSetLayoutBindings" + }, + { + "vuid": "VUID-VkDescriptorSetLayoutCreateInfo-descriptorCount-05071", + "text": " The sum of descriptorCount over all bindings in pBindings that have descriptorType of VK_DESCRIPTOR_TYPE_SAMPLER or VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER and pImmutableSamplers not equal to NULL must be less than or equal to VkDeviceObjectReservationCreateInfo::maxImmutableSamplersPerDescriptorSetLayout" + } + ], "(VK_EXT_descriptor_buffer)": [ { "vuid": "VUID-VkDescriptorSetLayoutCreateInfo-flags-08000", @@ -23164,6 +24104,12 @@ "vuid": "VUID-VkDescriptorSetLayoutBinding-descriptorType-04605", "text": " If descriptorType is VK_DESCRIPTOR_TYPE_MUTABLE_EXT, then pImmutableSamplers must be NULL" } + ], + "(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkDescriptorSetLayoutBinding-binding-05012", + "text": " binding must be less than the value of VkDeviceObjectReservationCreateInfo::descriptorSetLayoutBindingLimit provided when the device was created" + } ] }, "VkDescriptorSetLayoutBindingFlagsCreateInfo": { @@ -23289,7 +24235,7 @@ ] }, "vkDestroyDescriptorSetLayout": { - "core": [ + "!(VKSC_VERSION_1_0)": [ { "vuid": "VUID-vkDestroyDescriptorSetLayout-descriptorSetLayout-00284", "text": " If VkAllocationCallbacks were provided when descriptorSetLayout was created, a compatible set of callbacks must be provided here" @@ -23297,7 +24243,9 @@ { "vuid": "VUID-vkDestroyDescriptorSetLayout-descriptorSetLayout-00285", "text": " If no VkAllocationCallbacks were provided when descriptorSetLayout was created, pAllocator must be NULL" - }, + } + ], + "core": [ { "vuid": "VUID-vkDestroyDescriptorSetLayout-device-parameter", "text": " device must be a valid VkDevice handle" @@ -23317,6 +24265,12 @@ ] }, "vkCreatePipelineLayout": { + "(VKSC_VERSION_1_0)+(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkCreatePipelineLayout-device-05068", + "text": " The number of {objectnameplural} currently allocated from device plus {objectcount} must be less than or equal to the total number of {objectnameplural} requested via VkDeviceObjectReservationCreateInfo::pname:{objectnamecamelcase}RequestCount specified when device was created" + } + ], "core": [ { "vuid": "VUID-vkCreatePipelineLayout-device-parameter", @@ -23683,7 +24637,7 @@ ] }, "vkDestroyPipelineLayout": { - "core": [ + "!(VKSC_VERSION_1_0)": [ { "vuid": "VUID-vkDestroyPipelineLayout-pipelineLayout-00299", "text": " If VkAllocationCallbacks were provided when pipelineLayout was created, a compatible set of callbacks must be provided here" @@ -23691,7 +24645,9 @@ { "vuid": "VUID-vkDestroyPipelineLayout-pipelineLayout-00300", "text": " If no VkAllocationCallbacks were provided when pipelineLayout was created, pAllocator must be NULL" - }, + } + ], + "core": [ { "vuid": "VUID-vkDestroyPipelineLayout-pipelineLayout-02004", "text": " pipelineLayout must not have been passed to any vkCmd* command for any command buffers that are still in the recording state when vkDestroyPipelineLayout is called" @@ -23715,6 +24671,12 @@ ] }, "vkCreateDescriptorPool": { + "(VKSC_VERSION_1_0)+(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkCreateDescriptorPool-device-05068", + "text": " The number of {objectnameplural} currently allocated from device plus {objectcount} must be less than or equal to the total number of {objectnameplural} requested via VkDeviceObjectReservationCreateInfo::pname:{objectnamecamelcase}RequestCount specified when device was created" + } + ], "core": [ { "vuid": "VUID-vkCreateDescriptorPool-device-parameter", @@ -23809,7 +24771,7 @@ ] }, "vkDestroyDescriptorPool": { - "core": [ + "!(VKSC_VERSION_1_0)": [ { "vuid": "VUID-vkDestroyDescriptorPool-descriptorPool-00303", "text": " All submitted commands that refer to descriptorPool (via any allocated descriptor sets) must have completed execution" @@ -23841,6 +24803,12 @@ ] }, "vkAllocateDescriptorSets": { + "(VKSC_VERSION_1_0)+(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkAllocateDescriptorSets-device-05068", + "text": " The number of {objectnameplural} currently allocated from device plus {objectcount} must be less than or equal to the total number of {objectnameplural} requested via VkDeviceObjectReservationCreateInfo::pname:{objectnamecamelcase}RequestCount specified when device was created" + } + ], "core": [ { "vuid": "VUID-vkAllocateDescriptorSets-device-parameter", @@ -23861,7 +24829,7 @@ ] }, "VkDescriptorSetAllocateInfo": { - "(VK_VERSION_1_1,VK_KHR_maintenance1)": [ + "(VK_VERSION_1_1,VK_KHR_maintenance1)+!(VKSC_VERSION_1_0)": [ { "vuid": "VUID-VkDescriptorSetAllocateInfo-apiVersion-07895", "text": " If the VK_KHR_maintenance1 extension is not enabled, VkPhysicalDeviceProperties::apiVersion is less than Vulkan 1.1, descriptorSetCount must not be greater than the number of sets that are currently available for allocation in descriptorPool" @@ -24587,7 +25555,7 @@ ] }, "vkCreateDescriptorUpdateTemplate": { - "(VK_VERSION_1_1,VK_KHR_descriptor_update_template)": [ + "!(VKSC_VERSION_1_0)+(VK_VERSION_1_1,VK_KHR_descriptor_update_template)": [ { "vuid": "VUID-vkCreateDescriptorUpdateTemplate-device-parameter", "text": " device must be a valid VkDevice handle" @@ -24607,7 +25575,7 @@ ] }, "VkDescriptorUpdateTemplateCreateInfo": { - "(VK_VERSION_1_1,VK_KHR_descriptor_update_template)": [ + "!(VKSC_VERSION_1_0)+(VK_VERSION_1_1,VK_KHR_descriptor_update_template)": [ { "vuid": "VUID-VkDescriptorUpdateTemplateCreateInfo-templateType-00350", "text": " If templateType is VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET, descriptorSetLayout must be a valid VkDescriptorSetLayout handle" @@ -24641,7 +25609,7 @@ "text": " Both of descriptorSetLayout, and pipelineLayout that are valid handles of non-ignored parameters must have been created, allocated, or retrieved from the same VkDevice" } ], - "(VK_VERSION_1_1,VK_KHR_descriptor_update_template)+(VK_KHR_push_descriptor)": [ + "!(VKSC_VERSION_1_0)+(VK_VERSION_1_1,VK_KHR_descriptor_update_template)+(VK_KHR_push_descriptor)": [ { "vuid": "VUID-VkDescriptorUpdateTemplateCreateInfo-templateType-00351", "text": " If templateType is VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR, pipelineBindPoint must be a valid VkPipelineBindPoint value" @@ -24655,7 +25623,7 @@ "text": " If templateType is VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR, set must be the unique set number in the pipeline layout that uses a descriptor set layout that was created with VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR" } ], - "(VK_VERSION_1_1,VK_KHR_descriptor_update_template)+(VK_EXT_mutable_descriptor_type,VK_VALVE_mutable_descriptor_type)": [ + "!(VKSC_VERSION_1_0)+(VK_VERSION_1_1,VK_KHR_descriptor_update_template)+(VK_EXT_mutable_descriptor_type,VK_VALVE_mutable_descriptor_type)": [ { "vuid": "VUID-VkDescriptorUpdateTemplateCreateInfo-templateType-04615", "text": " If templateType is VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET, descriptorSetLayout must not contain a binding with type VK_DESCRIPTOR_TYPE_MUTABLE_EXT" @@ -24663,7 +25631,7 @@ ] }, "VkDescriptorUpdateTemplateEntry": { - "(VK_VERSION_1_1,VK_KHR_descriptor_update_template)": [ + "!(VKSC_VERSION_1_0)+(VK_VERSION_1_1,VK_KHR_descriptor_update_template)": [ { "vuid": "VUID-VkDescriptorUpdateTemplateEntry-dstBinding-00354", "text": " dstBinding must be a valid binding in the descriptor set layout implicitly specified when using a descriptor update template to update descriptors" @@ -24677,7 +25645,7 @@ "text": " descriptorType must be a valid VkDescriptorType value" } ], - "(VK_VERSION_1_1,VK_KHR_descriptor_update_template)+(VK_VERSION_1_3,VK_EXT_inline_uniform_block)": [ + "!(VKSC_VERSION_1_0)+(VK_VERSION_1_1,VK_KHR_descriptor_update_template)+(VK_VERSION_1_3,VK_EXT_inline_uniform_block)": [ { "vuid": "VUID-VkDescriptorUpdateTemplateEntry-descriptor-02226", "text": " If descriptor type is VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK, dstArrayElement must be an integer multiple of 4" @@ -24689,7 +25657,7 @@ ] }, "vkDestroyDescriptorUpdateTemplate": { - "(VK_VERSION_1_1,VK_KHR_descriptor_update_template)": [ + "!(VKSC_VERSION_1_0)+(VK_VERSION_1_1,VK_KHR_descriptor_update_template)+!(VKSC_VERSION_1_0)": [ { "vuid": "VUID-vkDestroyDescriptorUpdateTemplate-descriptorSetLayout-00356", "text": " If VkAllocationCallbacks were provided when descriptorUpdateTemplate was created, a compatible set of callbacks must be provided here" @@ -24697,7 +25665,9 @@ { "vuid": "VUID-vkDestroyDescriptorUpdateTemplate-descriptorSetLayout-00357", "text": " If no VkAllocationCallbacks were provided when descriptorUpdateTemplate was created, pAllocator must be NULL" - }, + } + ], + "!(VKSC_VERSION_1_0)+(VK_VERSION_1_1,VK_KHR_descriptor_update_template)": [ { "vuid": "VUID-vkDestroyDescriptorUpdateTemplate-device-parameter", "text": " device must be a valid VkDevice handle" @@ -24717,7 +25687,7 @@ ] }, "vkUpdateDescriptorSetWithTemplate": { - "(VK_VERSION_1_1,VK_KHR_descriptor_update_template)": [ + "!(VKSC_VERSION_1_0)+(VK_VERSION_1_1,VK_KHR_descriptor_update_template)": [ { "vuid": "VUID-vkUpdateDescriptorSetWithTemplate-pData-01685", "text": " pData must be a valid pointer to a memory containing one or more valid instances of VkDescriptorImageInfo, VkDescriptorBufferInfo, or VkBufferView in a layout defined by descriptorUpdateTemplate when it was created with vkCreateDescriptorUpdateTemplate" @@ -24739,13 +25709,13 @@ "text": " descriptorUpdateTemplate must have been created, allocated, or retrieved from device" } ], - "(VK_VERSION_1_1,VK_KHR_descriptor_update_template)+!(VK_VERSION_1_2,VK_EXT_descriptor_indexing)": [ + "!(VKSC_VERSION_1_0)+(VK_VERSION_1_1,VK_KHR_descriptor_update_template)+!(VK_VERSION_1_2,VK_EXT_descriptor_indexing)": [ { "vuid": "VUID-vkUpdateDescriptorSetWithTemplate-descriptorSet-06994", "text": " Host access to descriptorSet must be externally synchronized" } ], - "(VK_VERSION_1_1,VK_KHR_descriptor_update_template)+(VK_VERSION_1_2,VK_EXT_descriptor_indexing)": [ + "!(VKSC_VERSION_1_0)+(VK_VERSION_1_1,VK_KHR_descriptor_update_template)+(VK_VERSION_1_2,VK_EXT_descriptor_indexing)": [ { "vuid": "VUID-vkUpdateDescriptorSetWithTemplate-descriptorSet-06995", "text": " Host access to descriptorSet must be externally synchronized unless explicitly denoted otherwise for specific flags" @@ -27813,6 +28783,12 @@ ] }, "vkCreateQueryPool": { + "(VKSC_VERSION_1_0)+(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkCreateQueryPool-device-05068", + "text": " The number of {objectnameplural} currently allocated from device plus {objectcount} must be less than or equal to the total number of {objectnameplural} requested via VkDeviceObjectReservationCreateInfo::pname:{objectnamecamelcase}RequestCount specified when device was created" + } + ], "core": [ { "vuid": "VUID-vkCreateQueryPool-device-parameter", @@ -27883,6 +28859,26 @@ "text": " If queryType is VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR, the pNext chain must include a VkQueryPoolPerformanceCreateInfoKHR structure" } ], + "(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkQueryPoolCreateInfo-queryType-05046", + "text": " If queryType is VK_QUERY_TYPE_OCCLUSION then queryCount must be less than or equal to the maximum of all VkDeviceObjectReservationCreateInfo::maxOcclusionQueriesPerPool values specified when device was created" + }, + { + "vuid": "VUID-VkQueryPoolCreateInfo-queryType-05047", + "text": " If queryType is VK_QUERY_TYPE_PIPELINE_STATISTICS then queryCount must be less than or equal to the maximum of all VkDeviceObjectReservationCreateInfo::maxPipelineStatisticsQueriesPerPool values specified when device was created" + }, + { + "vuid": "VUID-VkQueryPoolCreateInfo-queryType-05048", + "text": " If queryType is VK_QUERY_TYPE_TIMESTAMP then queryCount must be less than or equal to the maximum of all VkDeviceObjectReservationCreateInfo::maxTimestampQueriesPerPool values specified when device was created" + } + ], + "(VKSC_VERSION_1_0)+(VK_KHR_performance_query)": [ + { + "vuid": "VUID-VkQueryPoolCreateInfo-queryType-05049", + "text": " If queryType is VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR then queryCount must be less than or equal to the maximum of all VkPerformanceQueryReservationInfoKHR::maxPerformanceQueriesPerPool values specified when device was created" + } + ], "(VK_KHR_video_encode_queue)": [ { "vuid": "VUID-VkQueryPoolCreateInfo-queryType-07133", @@ -27943,7 +28939,7 @@ ] }, "vkDestroyQueryPool": { - "core": [ + "!(VKSC_VERSION_1_0)": [ { "vuid": "VUID-vkDestroyQueryPool-queryPool-00793", "text": " All submitted commands that refer to queryPool must have completed execution" @@ -29851,7 +30847,7 @@ "text": " Both of commandBuffer, and dstBuffer must have been created, allocated, or retrieved from the same VkDevice" } ], - "(VK_VERSION_1_1,VK_KHR_maintenance1)": [ + "(VK_VERSION_1_1,VK_KHR_maintenance1)+!(VKSC_VERSION_1_0)": [ { "vuid": "VUID-vkCmdFillBuffer-apiVersion-07894", "text": " If the VK_KHR_maintenance1 extension is not enabled and VkPhysicalDeviceProperties::apiVersion is less than Vulkan 1.1, the VkCommandPool that commandBuffer was allocated from must support graphics or compute operations" @@ -30398,10 +31394,6 @@ "vuid": "VUID-vkCmdCopyImage-dstImage-01996", "text": " The format features of dstImage must contain VK_FORMAT_FEATURE_TRANSFER_DST_BIT" }, - { - "vuid": "VUID-vkCmdCopyImage-apiVersion-07932", - "text": " If the VK_KHR_maintenance1 extension is not enabled, VkPhysicalDeviceProperties::apiVersion is less than Vulkan 1.1, and either srcImage or dstImage is of type VK_IMAGE_TYPE_3D, then for each element of pRegions, srcSubresource.baseArrayLayer and dstSubresource.baseArrayLayer must each be 0, and srcSubresource.layerCount and dstSubresource.layerCount must each be 1" - }, { "vuid": "VUID-vkCmdCopyImage-srcImage-04443", "text": " If srcImage is of type VK_IMAGE_TYPE_3D, then for each element of pRegions, srcSubresource.baseArrayLayer must be 0 and srcSubresource.layerCount must be 1" @@ -30410,10 +31402,6 @@ "vuid": "VUID-vkCmdCopyImage-dstImage-04444", "text": " If dstImage is of type VK_IMAGE_TYPE_3D, then for each element of pRegions, dstSubresource.baseArrayLayer must be 0 and dstSubresource.layerCount must be 1" }, - { - "vuid": "VUID-vkCmdCopyImage-apiVersion-07933", - "text": " If the VK_KHR_maintenance1 extension is not enabled, VkPhysicalDeviceProperties::apiVersion is less than Vulkan 1.1, srcImage and dstImage must have the same VkImageType" - }, { "vuid": "VUID-vkCmdCopyImage-srcImage-07743", "text": " If srcImage and dstImage have a different VkImageType, one must be VK_IMAGE_TYPE_3D and the other must be VK_IMAGE_TYPE_2D" @@ -30521,6 +31509,16 @@ "text": " If srcImage or dstImage is of type VK_IMAGE_TYPE_2D, then for each element of pRegions, extent.depth must be 1" } ], + "(VK_VERSION_1_1,VK_KHR_maintenance1)+!(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkCmdCopyImage-apiVersion-07932", + "text": " If the VK_KHR_maintenance1 extension is not enabled, VkPhysicalDeviceProperties::apiVersion is less than Vulkan 1.1, and either srcImage or dstImage is of type VK_IMAGE_TYPE_3D, then for each element of pRegions, srcSubresource.baseArrayLayer and dstSubresource.baseArrayLayer must each be 0, and srcSubresource.layerCount and dstSubresource.layerCount must each be 1" + }, + { + "vuid": "VUID-vkCmdCopyImage-apiVersion-07933", + "text": " If the VK_KHR_maintenance1 extension is not enabled, VkPhysicalDeviceProperties::apiVersion is less than Vulkan 1.1, srcImage and dstImage must have the same VkImageType" + } + ], "!(VK_VERSION_1_2,VK_EXT_separate_stencil_usage)": [ { "vuid": "VUID-vkCmdCopyImage-srcImage-00126", @@ -30567,13 +31565,13 @@ "text": " The aspectMask member of srcSubresource and dstSubresource must match" } ], - "(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + "(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)+!(VKSC_VERSION_1_0)": [ { "vuid": "VUID-VkImageCopy-apiVersion-07940", "text": " If the VK_KHR_sampler_ycbcr_conversion extension is not enabled and VkPhysicalDeviceProperties::apiVersion is less than Vulkan 1.1, the aspectMask member of srcSubresource and dstSubresource must match" } ], - "(VK_VERSION_1_1,VK_KHR_maintenance1)": [ + "(VK_VERSION_1_1,VK_KHR_maintenance1)+!(VKSC_VERSION_1_0)": [ { "vuid": "VUID-VkImageCopy-apiVersion-07941", "text": " If the VK_KHR_maintenance1 extension is not enabled and VkPhysicalDeviceProperties::apiVersion is less than Vulkan 1.1, the layerCount member of srcSubresource and dstSubresource must match" @@ -30872,10 +31870,6 @@ "vuid": "VUID-VkCopyImageInfo2-dstImage-01996", "text": " The format features of dstImage must contain VK_FORMAT_FEATURE_TRANSFER_DST_BIT" }, - { - "vuid": "VUID-VkCopyImageInfo2-apiVersion-07932", - "text": " If the VK_KHR_maintenance1 extension is not enabled, VkPhysicalDeviceProperties::apiVersion is less than Vulkan 1.1, and either srcImage or dstImage is of type VK_IMAGE_TYPE_3D, then for each element of pRegions, srcSubresource.baseArrayLayer and dstSubresource.baseArrayLayer must each be 0, and srcSubresource.layerCount and dstSubresource.layerCount must each be 1" - }, { "vuid": "VUID-VkCopyImageInfo2-srcImage-04443", "text": " If srcImage is of type VK_IMAGE_TYPE_3D, then for each element of pRegions, srcSubresource.baseArrayLayer must be 0 and srcSubresource.layerCount must be 1" @@ -30884,10 +31878,6 @@ "vuid": "VUID-VkCopyImageInfo2-dstImage-04444", "text": " If dstImage is of type VK_IMAGE_TYPE_3D, then for each element of pRegions, dstSubresource.baseArrayLayer must be 0 and dstSubresource.layerCount must be 1" }, - { - "vuid": "VUID-VkCopyImageInfo2-apiVersion-07933", - "text": " If the VK_KHR_maintenance1 extension is not enabled, VkPhysicalDeviceProperties::apiVersion is less than Vulkan 1.1, srcImage and dstImage must have the same VkImageType" - }, { "vuid": "VUID-VkCopyImageInfo2-srcImage-07743", "text": " If srcImage and dstImage have a different VkImageType, one must be VK_IMAGE_TYPE_3D and the other must be VK_IMAGE_TYPE_2D" @@ -30995,6 +31985,16 @@ "text": " If srcImage or dstImage is of type VK_IMAGE_TYPE_2D, then for each element of pRegions, extent.depth must be 1" } ], + "(VK_VERSION_1_3,VK_KHR_copy_commands2)+(VK_VERSION_1_1,VK_KHR_maintenance1)+!(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkCopyImageInfo2-apiVersion-07932", + "text": " If the VK_KHR_maintenance1 extension is not enabled, VkPhysicalDeviceProperties::apiVersion is less than Vulkan 1.1, and either srcImage or dstImage is of type VK_IMAGE_TYPE_3D, then for each element of pRegions, srcSubresource.baseArrayLayer and dstSubresource.baseArrayLayer must each be 0, and srcSubresource.layerCount and dstSubresource.layerCount must each be 1" + }, + { + "vuid": "VUID-VkCopyImageInfo2-apiVersion-07933", + "text": " If the VK_KHR_maintenance1 extension is not enabled, VkPhysicalDeviceProperties::apiVersion is less than Vulkan 1.1, srcImage and dstImage must have the same VkImageType" + } + ], "(VK_VERSION_1_3,VK_KHR_copy_commands2)+!(VK_VERSION_1_2,VK_EXT_separate_stencil_usage)": [ { "vuid": "VUID-VkCopyImageInfo2-srcImage-00126", @@ -31041,13 +32041,13 @@ "text": " The aspectMask member of srcSubresource and dstSubresource must match" } ], - "(VK_VERSION_1_3,VK_KHR_copy_commands2)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + "(VK_VERSION_1_3,VK_KHR_copy_commands2)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)+!(VKSC_VERSION_1_0)": [ { "vuid": "VUID-VkImageCopy2-apiVersion-07940", "text": " If the VK_KHR_sampler_ycbcr_conversion extension is not enabled and VkPhysicalDeviceProperties::apiVersion is less than Vulkan 1.1, the aspectMask member of srcSubresource and dstSubresource must match" } ], - "(VK_VERSION_1_3,VK_KHR_copy_commands2)+(VK_VERSION_1_1,VK_KHR_maintenance1)": [ + "(VK_VERSION_1_3,VK_KHR_copy_commands2)+(VK_VERSION_1_1,VK_KHR_maintenance1)+!(VKSC_VERSION_1_0)": [ { "vuid": "VUID-VkImageCopy2-apiVersion-07941", "text": " If the VK_KHR_maintenance1 extension is not enabled and VkPhysicalDeviceProperties::apiVersion is less than Vulkan 1.1, the layerCount member of srcSubresource and dstSubresource must match" @@ -33522,6 +34522,18 @@ } ] }, + "VkRefreshObjectKHR": { + "(VK_KHR_object_refresh)": [ + { + "vuid": "VUID-VkRefreshObjectKHR-objectHandle-05069", + "text": " objectHandle must be a valid Vulkan handle of the type associated with objectType as defined in the VkObjectType and Vulkan Handle Relationship table" + }, + { + "vuid": "VUID-VkRefreshObjectKHR-objectType-05070", + "text": " objectType must not be VK_OBJECT_TYPE_UNKNOWN" + } + ] + }, "vkCmdWriteBufferMarker2AMD": { "(VK_AMD_buffer_marker)+(VK_VERSION_1_3,VK_KHR_synchronization2)": [ { @@ -63156,10 +64168,6 @@ "vuid": "VUID-VkViewport-width-01771", "text": " width must be less than or equal to VkPhysicalDeviceLimits::maxViewportDimensions[0]" }, - { - "vuid": "VUID-VkViewport-apiVersion-07917", - "text": " If the VK_KHR_maintenance1 extension is not enabled, the VK_AMD_negative_viewport_height extension is not enabled, and VkPhysicalDeviceProperties::apiVersion is less than Vulkan 1.1, height must be greater than 0.0" - }, { "vuid": "VUID-VkViewport-height-01773", "text": " The absolute value of height must be less than or equal to VkPhysicalDeviceLimits::maxViewportDimensions[1]" @@ -63181,6 +64189,12 @@ "text": " (y + height) must be less than or equal to viewportBoundsRange[1]" } ], + "!(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkViewport-apiVersion-07917", + "text": " If the VK_KHR_maintenance1 extension is not enabled, the VK_AMD_negative_viewport_height extension is not enabled, and VkPhysicalDeviceProperties::apiVersion is less than Vulkan 1.1, height must be greater than 0.0" + } + ], "(VK_VERSION_1_1,VK_KHR_maintenance1,VK_AMD_negative_viewport_height)": [ { "vuid": "VUID-VkViewport-y-01776", @@ -67950,14 +68964,6 @@ "vuid": "VUID-vkDestroyIndirectCommandsLayoutNV-indirectCommandsLayout-02938", "text": " All submitted commands that refer to indirectCommandsLayout must have completed execution" }, - { - "vuid": "VUID-vkDestroyIndirectCommandsLayoutNV-indirectCommandsLayout-02939", - "text": " If VkAllocationCallbacks were provided when indirectCommandsLayout was created, a compatible set of callbacks must be provided here" - }, - { - "vuid": "VUID-vkDestroyIndirectCommandsLayoutNV-indirectCommandsLayout-02940", - "text": " If no VkAllocationCallbacks were provided when indirectCommandsLayout was created, pAllocator must be NULL" - }, { "vuid": "VUID-vkDestroyIndirectCommandsLayoutNV-deviceGeneratedCommands-02941", "text": " The VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV::deviceGeneratedCommands feature must be enabled" @@ -67978,6 +68984,16 @@ "vuid": "VUID-vkDestroyIndirectCommandsLayoutNV-indirectCommandsLayout-parent", "text": " If indirectCommandsLayout is a valid handle, it must have been created, allocated, or retrieved from device" } + ], + "(VK_NV_device_generated_commands)+!(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkDestroyIndirectCommandsLayoutNV-indirectCommandsLayout-02939", + "text": " If VkAllocationCallbacks were provided when indirectCommandsLayout was created, a compatible set of callbacks must be provided here" + }, + { + "vuid": "VUID-vkDestroyIndirectCommandsLayoutNV-indirectCommandsLayout-02940", + "text": " If no VkAllocationCallbacks were provided when indirectCommandsLayout was created, pAllocator must be NULL" + } ] }, "VkIndirectCommandsStreamNV": { @@ -69999,7 +71015,7 @@ ] }, "vkGetPhysicalDeviceSparseImageFormatProperties": { - "core": [ + "!(VKSC_VERSION_1_0)": [ { "vuid": "VUID-vkGetPhysicalDeviceSparseImageFormatProperties-samples-01094", "text": " samples must be a bit value that is set in VkImageFormatProperties::sampleCounts returned by vkGetPhysicalDeviceImageFormatProperties with format, type, tiling, and usage equal to those in this command and flags equal to the value that is set in VkImageCreateInfo::flags when the image is created" @@ -70043,7 +71059,7 @@ ] }, "vkGetPhysicalDeviceSparseImageFormatProperties2": { - "(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)": [ + "!(VKSC_VERSION_1_0)+(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)": [ { "vuid": "VUID-vkGetPhysicalDeviceSparseImageFormatProperties2-physicalDevice-parameter", "text": " physicalDevice must be a valid VkPhysicalDevice handle" @@ -70063,7 +71079,7 @@ ] }, "VkPhysicalDeviceSparseImageFormatInfo2": { - "(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)": [ + "!(VKSC_VERSION_1_0)+(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)": [ { "vuid": "VUID-VkPhysicalDeviceSparseImageFormatInfo2-samples-01095", "text": " samples must be a bit value that is set in VkImageFormatProperties::sampleCounts returned by vkGetPhysicalDeviceImageFormatProperties with format, type, tiling, and usage equal to those in this command and flags equal to the value that is set in VkImageCreateInfo::flags when the image is created" @@ -70103,7 +71119,7 @@ ] }, "VkSparseImageFormatProperties2": { - "(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)": [ + "!(VKSC_VERSION_1_0)+(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)": [ { "vuid": "VUID-VkSparseImageFormatProperties2-sType-sType", "text": " sType must be VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2" @@ -70115,7 +71131,7 @@ ] }, "vkGetImageSparseMemoryRequirements": { - "core": [ + "!(VKSC_VERSION_1_0)": [ { "vuid": "VUID-vkGetImageSparseMemoryRequirements-device-parameter", "text": " device must be a valid VkDevice handle" @@ -70139,7 +71155,7 @@ ] }, "vkGetImageSparseMemoryRequirements2": { - "(VK_VERSION_1_1,VK_KHR_get_memory_requirements2)": [ + "!(VKSC_VERSION_1_0)+(VK_VERSION_1_1,VK_KHR_get_memory_requirements2)": [ { "vuid": "VUID-vkGetImageSparseMemoryRequirements2-device-parameter", "text": " device must be a valid VkDevice handle" @@ -70159,7 +71175,7 @@ ] }, "vkGetDeviceImageSparseMemoryRequirements": { - "(VK_VERSION_1_1,VK_KHR_get_memory_requirements2)+(VK_VERSION_1_3,VK_KHR_maintenance4)": [ + "!(VKSC_VERSION_1_0)+(VK_VERSION_1_1,VK_KHR_get_memory_requirements2)+(VK_VERSION_1_3,VK_KHR_maintenance4)": [ { "vuid": "VUID-vkGetDeviceImageSparseMemoryRequirements-device-parameter", "text": " device must be a valid VkDevice handle" @@ -70179,7 +71195,7 @@ ] }, "VkImageSparseMemoryRequirementsInfo2": { - "(VK_VERSION_1_1,VK_KHR_get_memory_requirements2)": [ + "!(VKSC_VERSION_1_0)+(VK_VERSION_1_1,VK_KHR_get_memory_requirements2)": [ { "vuid": "VUID-VkImageSparseMemoryRequirementsInfo2-sType-sType", "text": " sType must be VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2" @@ -70195,7 +71211,7 @@ ] }, "VkSparseImageMemoryRequirements2": { - "(VK_VERSION_1_1,VK_KHR_get_memory_requirements2)": [ + "!(VKSC_VERSION_1_0)+(VK_VERSION_1_1,VK_KHR_get_memory_requirements2)": [ { "vuid": "VUID-VkSparseImageMemoryRequirements2-sType-sType", "text": " sType must be VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2" @@ -70207,7 +71223,7 @@ ] }, "VkSparseMemoryBind": { - "core": [ + "!(VKSC_VERSION_1_0)": [ { "vuid": "VUID-VkSparseMemoryBind-memory-01096", "text": " If memory is not VK_NULL_HANDLE, memory and memoryOffset must match the memory requirements of the resource, as described in section Resource Memory Association" @@ -70245,7 +71261,7 @@ "text": " flags must be a valid combination of VkSparseMemoryBindFlagBits values" } ], - "(VK_VERSION_1_1,VK_KHR_external_memory)": [ + "!(VKSC_VERSION_1_0)+(VK_VERSION_1_1,VK_KHR_external_memory)": [ { "vuid": "VUID-VkSparseMemoryBind-memory-02730", "text": " If memory was created with VkExportMemoryAllocateInfo::handleTypes not equal to 0, at least one handle type it contained must also have been set in VkExternalMemoryBufferCreateInfo::handleTypes or VkExternalMemoryImageCreateInfo::handleTypes when the resource was created" @@ -70257,7 +71273,7 @@ ] }, "VkSparseBufferMemoryBindInfo": { - "core": [ + "!(VKSC_VERSION_1_0)": [ { "vuid": "VUID-VkSparseBufferMemoryBindInfo-buffer-parameter", "text": " buffer must be a valid VkBuffer handle" @@ -70273,7 +71289,7 @@ ] }, "VkSparseImageOpaqueMemoryBindInfo": { - "core": [ + "!(VKSC_VERSION_1_0)": [ { "vuid": "VUID-VkSparseImageOpaqueMemoryBindInfo-pBinds-01103", "text": " If the flags member of any element of pBinds contains VK_SPARSE_MEMORY_BIND_METADATA_BIT, the binding range defined must be within the mip tail region of the metadata aspect of image" @@ -70293,7 +71309,7 @@ ] }, "VkSparseImageMemoryBindInfo": { - "core": [ + "!(VKSC_VERSION_1_0)": [ { "vuid": "VUID-VkSparseImageMemoryBindInfo-subresource-01722", "text": " The subresource.mipLevel member of each element of pBinds must be less than the mipLevels specified in VkImageCreateInfo when image was created" @@ -70321,7 +71337,7 @@ ] }, "VkSparseImageMemoryBind": { - "core": [ + "!(VKSC_VERSION_1_0)": [ { "vuid": "VUID-VkSparseImageMemoryBind-memory-01104", "text": " If the sparseResidencyAliased feature is not enabled, and if any other resources are bound to ranges of memory, the range of memory being bound must not overlap with those bound ranges" @@ -70371,7 +71387,7 @@ "text": " flags must be a valid combination of VkSparseMemoryBindFlagBits values" } ], - "(VK_VERSION_1_1,VK_KHR_external_memory)": [ + "!(VKSC_VERSION_1_0)+(VK_VERSION_1_1,VK_KHR_external_memory)": [ { "vuid": "VUID-VkSparseImageMemoryBind-memory-02732", "text": " If memory was created with VkExportMemoryAllocateInfo::handleTypes not equal to 0, at least one handle type it contained must also have been set in VkExternalMemoryImageCreateInfo::handleTypes when the image was created" @@ -70383,7 +71399,7 @@ ] }, "vkQueueBindSparse": { - "core": [ + "!(VKSC_VERSION_1_0)": [ { "vuid": "VUID-vkQueueBindSparse-fence-01113", "text": " If fence is not VK_NULL_HANDLE, fence must be unsignaled" @@ -70425,7 +71441,7 @@ "text": " Both of fence, and queue that are valid handles of non-ignored parameters must have been created, allocated, or retrieved from the same VkDevice" } ], - "(VK_VERSION_1_2,VK_KHR_timeline_semaphore)": [ + "!(VKSC_VERSION_1_0)+(VK_VERSION_1_2,VK_KHR_timeline_semaphore)": [ { "vuid": "VUID-vkQueueBindSparse-pWaitSemaphores-03245", "text": " All elements of the pWaitSemaphores member of all elements of pBindInfo created with a VkSemaphoreType of VK_SEMAPHORE_TYPE_BINARY must reference a semaphore signal operation that has been submitted for execution and any semaphore signal operations on which it depends (if any) must have also been submitted for execution" @@ -70433,7 +71449,7 @@ ] }, "VkBindSparseInfo": { - "(VK_VERSION_1_2,VK_KHR_timeline_semaphore)": [ + "!(VKSC_VERSION_1_0)+(VK_VERSION_1_2,VK_KHR_timeline_semaphore)": [ { "vuid": "VUID-VkBindSparseInfo-pWaitSemaphores-03246", "text": " If any element of pWaitSemaphores or pSignalSemaphores was created with a VkSemaphoreType of VK_SEMAPHORE_TYPE_TIMELINE then the pNext chain must include a VkTimelineSemaphoreSubmitInfo structure" @@ -70459,7 +71475,7 @@ "text": " For each element of pSignalSemaphores created with a VkSemaphoreType of VK_SEMAPHORE_TYPE_TIMELINE the corresponding element of VkTimelineSemaphoreSubmitInfo::pSignalSemaphoreValues must have a value which does not differ from the current value of the semaphore or from the value of any outstanding semaphore wait or signal operation on that semaphore by more than maxTimelineSemaphoreValueDifference" } ], - "core": [ + "!(VKSC_VERSION_1_0)": [ { "vuid": "VUID-VkBindSparseInfo-sType-sType", "text": " sType must be VK_STRUCTURE_TYPE_BIND_SPARSE_INFO" @@ -70499,7 +71515,7 @@ ] }, "VkDeviceGroupBindSparseInfo": { - "(VK_VERSION_1_1,VK_KHR_device_group)": [ + "!(VKSC_VERSION_1_0)+(VK_VERSION_1_1,VK_KHR_device_group)": [ { "vuid": "VUID-VkDeviceGroupBindSparseInfo-resourceDeviceIndex-01118", "text": " resourceDeviceIndex and memoryDeviceIndex must both be valid device indices" @@ -71068,14 +72084,6 @@ "vuid": "VUID-vkDestroySurfaceKHR-surface-01266", "text": " All VkSwapchainKHR objects created for surface must have been destroyed prior to destroying surface" }, - { - "vuid": "VUID-vkDestroySurfaceKHR-surface-01267", - "text": " If VkAllocationCallbacks were provided when surface was created, a compatible set of callbacks must be provided here" - }, - { - "vuid": "VUID-vkDestroySurfaceKHR-surface-01268", - "text": " If no VkAllocationCallbacks were provided when surface was created, pAllocator must be NULL" - }, { "vuid": "VUID-vkDestroySurfaceKHR-instance-parameter", "text": " instance must be a valid VkInstance handle" @@ -71092,6 +72100,16 @@ "vuid": "VUID-vkDestroySurfaceKHR-surface-parent", "text": " If surface is a valid handle, it must have been created, allocated, or retrieved from instance" } + ], + "(VK_KHR_surface)+!(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkDestroySurfaceKHR-surface-01267", + "text": " If VkAllocationCallbacks were provided when surface was created, a compatible set of callbacks must be provided here" + }, + { + "vuid": "VUID-vkDestroySurfaceKHR-surface-01268", + "text": " If no VkAllocationCallbacks were provided when surface was created, pAllocator must be NULL" + } ] }, "vkGetPhysicalDeviceDisplayPropertiesKHR": { @@ -72451,6 +73469,12 @@ ] }, "vkCreateSwapchainKHR": { + "(VK_KHR_surface)+(VK_KHR_swapchain)+(VKSC_VERSION_1_0)+(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkCreateSwapchainKHR-device-05068", + "text": " The number of {objectnameplural} currently allocated from device plus {objectcount} must be less than or equal to the total number of {objectnameplural} requested via VkDeviceObjectReservationCreateInfo::pname:{objectnamecamelcase}RequestCount specified when device was created" + } + ], "(VK_KHR_surface)+(VK_KHR_swapchain)": [ { "vuid": "VUID-vkCreateSwapchainKHR-device-parameter", @@ -72516,10 +73540,6 @@ "vuid": "VUID-VkSwapchainCreateInfoKHR-presentMode-01281", "text": " presentMode must be one of the VkPresentModeKHR values returned by vkGetPhysicalDeviceSurfacePresentModesKHR for the surface" }, - { - "vuid": "VUID-VkSwapchainCreateInfoKHR-oldSwapchain-01933", - "text": " If oldSwapchain is not VK_NULL_HANDLE, oldSwapchain must be a non-retired swapchain associated with native window referred to by surface" - }, { "vuid": "VUID-VkSwapchainCreateInfoKHR-imageFormat-01778", "text": " The implied image creation parameters of the swapchain must be supported as reported by vkGetPhysicalDeviceImageFormatProperties" @@ -72633,12 +73653,30 @@ "text": " If imageSharingMode is VK_SHARING_MODE_CONCURRENT, each element of pQueueFamilyIndices must be unique and must be less than pQueueFamilyPropertyCount returned by either vkGetPhysicalDeviceQueueFamilyProperties or vkGetPhysicalDeviceQueueFamilyProperties2 for the physicalDevice that was used to create device" } ], - "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_VERSION_1_1,VK_KHR_device_group)": [ + "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_VERSION_1_1,VK_KHR_device_group)+!(VKSC_VERSION_1_0)": [ { "vuid": "VUID-VkSwapchainCreateInfoKHR-physicalDeviceCount-01429", "text": " If the logical device was created with VkDeviceGroupDeviceCreateInfo::physicalDeviceCount equal to 1, flags must not contain VK_SWAPCHAIN_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR" } ], + "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_VERSION_1_1,VK_KHR_device_group)+(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkSwapchainCreateInfoKHR-flags-05072", + "text": " flags must not contain VK_SWAPCHAIN_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR" + } + ], + "(VK_KHR_surface)+(VK_KHR_swapchain)+!(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkSwapchainCreateInfoKHR-oldSwapchain-01933", + "text": " If oldSwapchain is not VK_NULL_HANDLE, oldSwapchain must be a non-retired swapchain associated with native window referred to by surface" + } + ], + "(VK_KHR_surface)+(VK_KHR_swapchain)+(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkSwapchainCreateInfoKHR-oldSwapchain-05073", + "text": " oldSwapchain must be VK_NULL_HANDLE" + } + ], "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_KHR_swapchain_mutable_format)": [ { "vuid": "VUID-VkSwapchainCreateInfoKHR-flags-03168", @@ -72863,19 +73901,11 @@ ] }, "vkDestroySwapchainKHR": { - "(VK_KHR_surface)+(VK_KHR_swapchain)": [ + "(VK_KHR_surface)+(VK_KHR_swapchain)+!(VKSC_VERSION_1_0)": [ { "vuid": "VUID-vkDestroySwapchainKHR-swapchain-01282", "text": " All uses of presentable images acquired from swapchain must have completed execution" }, - { - "vuid": "VUID-vkDestroySwapchainKHR-swapchain-01283", - "text": " If VkAllocationCallbacks were provided when swapchain was created, a compatible set of callbacks must be provided here" - }, - { - "vuid": "VUID-vkDestroySwapchainKHR-swapchain-01284", - "text": " If no VkAllocationCallbacks were provided when swapchain was created, pAllocator must be NULL" - }, { "vuid": "VUID-vkDestroySwapchainKHR-device-parameter", "text": " device must be a valid VkDevice handle" @@ -72892,9 +73922,25 @@ "vuid": "VUID-vkDestroySwapchainKHR-swapchain-parent", "text": " If swapchain is a valid handle, it must have been created, allocated, or retrieved from device" } + ], + "(VK_KHR_surface)+(VK_KHR_swapchain)+!(VKSC_VERSION_1_0)+!(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkDestroySwapchainKHR-swapchain-01283", + "text": " If VkAllocationCallbacks were provided when swapchain was created, a compatible set of callbacks must be provided here" + }, + { + "vuid": "VUID-vkDestroySwapchainKHR-swapchain-01284", + "text": " If no VkAllocationCallbacks were provided when swapchain was created, pAllocator must be NULL" + } ] }, "vkCreateSharedSwapchainsKHR": { + "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_KHR_display_swapchain)+(VKSC_VERSION_1_0)+(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkCreateSharedSwapchainsKHR-device-05068", + "text": " The number of {objectnameplural} currently allocated from device plus {objectcount} must be less than or equal to the total number of {objectnameplural} requested via VkDeviceObjectReservationCreateInfo::pname:{objectnamecamelcase}RequestCount specified when device was created" + } + ], "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_KHR_display_swapchain)": [ { "vuid": "VUID-vkCreateSharedSwapchainsKHR-device-parameter", @@ -73545,7 +74591,7 @@ ] }, "vkDestroyDeferredOperationKHR": { - "(VK_KHR_deferred_host_operations)": [ + "(VK_KHR_deferred_host_operations)+!(VKSC_VERSION_1_0)": [ { "vuid": "VUID-vkDestroyDeferredOperationKHR-operation-03434", "text": " If VkAllocationCallbacks were provided when operation was created, a compatible set of callbacks must be provided here" @@ -73553,7 +74599,9 @@ { "vuid": "VUID-vkDestroyDeferredOperationKHR-operation-03435", "text": " If no VkAllocationCallbacks were provided when operation was created, pAllocator must be NULL" - }, + } + ], + "(VK_KHR_deferred_host_operations)": [ { "vuid": "VUID-vkDestroyDeferredOperationKHR-operation-03436", "text": " operation must be completed" @@ -73630,6 +74678,12 @@ "vuid": "VUID-vkCreatePrivateDataSlot-pPrivateDataSlot-parameter", "text": " pPrivateDataSlot must be a valid pointer to a VkPrivateDataSlot handle" } + ], + "(VK_VERSION_1_3,VK_EXT_private_data)+(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkCreatePrivateDataSlotEXT-device-05000", + "text": " The number of private data slots currently allocated from device plus 1 must be less than or equal to the total number of private data slots requested via VkDevicePrivateDataCreateInfoEXT::privateDataSlotRequestCount when device was created" + } ] }, "VkPrivateDataSlotCreateInfo": { @@ -73649,7 +74703,7 @@ ] }, "vkDestroyPrivateDataSlot": { - "(VK_VERSION_1_3,VK_EXT_private_data)": [ + "(VK_VERSION_1_3,VK_EXT_private_data)+!(VKSC_VERSION_1_0)": [ { "vuid": "VUID-vkDestroyPrivateDataSlot-privateDataSlot-04062", "text": " If VkAllocationCallbacks were provided when privateDataSlot was created, a compatible set of callbacks must be provided here" @@ -73657,7 +74711,9 @@ { "vuid": "VUID-vkDestroyPrivateDataSlot-privateDataSlot-04063", "text": " If no VkAllocationCallbacks were provided when privateDataSlot was created, pAllocator must be NULL" - }, + } + ], + "(VK_VERSION_1_3,VK_EXT_private_data)": [ { "vuid": "VUID-vkDestroyPrivateDataSlot-device-parameter", "text": " device must be a valid VkDevice handle" @@ -83973,7 +85029,7 @@ ] }, "vkDestroyDebugUtilsMessengerEXT": { - "(VK_EXT_debug_utils)": [ + "(VK_EXT_debug_utils)+!(VKSC_VERSION_1_0)": [ { "vuid": "VUID-vkDestroyDebugUtilsMessengerEXT-messenger-01915", "text": " If VkAllocationCallbacks were provided when messenger was created, a compatible set of callbacks must be provided here" @@ -83981,7 +85037,9 @@ { "vuid": "VUID-vkDestroyDebugUtilsMessengerEXT-messenger-01916", "text": " If no VkAllocationCallbacks were provided when messenger was created, pAllocator must be NULL" - }, + } + ], + "(VK_EXT_debug_utils)": [ { "vuid": "VUID-vkDestroyDebugUtilsMessengerEXT-instance-parameter", "text": " instance must be a valid VkInstance handle" @@ -84257,7 +85315,7 @@ ] }, "vkDestroyDebugReportCallbackEXT": { - "(VK_EXT_debug_report)": [ + "(VK_EXT_debug_report)+!(VKSC_VERSION_1_0)": [ { "vuid": "VUID-vkDestroyDebugReportCallbackEXT-instance-01242", "text": " If VkAllocationCallbacks were provided when callback was created, a compatible set of callbacks must be provided here" @@ -84265,7 +85323,9 @@ { "vuid": "VUID-vkDestroyDebugReportCallbackEXT-instance-01243", "text": " If no VkAllocationCallbacks were provided when callback was created, pAllocator must be NULL" - }, + } + ], + "(VK_EXT_debug_report)": [ { "vuid": "VUID-vkDestroyDebugReportCallbackEXT-instance-parameter", "text": " instance must be a valid VkInstance handle" @@ -84368,6 +85428,30 @@ } ] }, + "VkFaultData": { + "(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkFaultData-pNext-05019", + "text": " pNext must be NULL or a valid pointer to an implementation-specific structure" + } + ] + }, + "vkGetFaultData": { + "(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkGetFaultData-pFaultCount-05020", + "text": " pFaultCount must be less than or equal to maxQueryFaultCount" + } + ] + }, + "VkFaultCallbackInfo": { + "(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkFaultCallbackInfo-faultCount-05138", + "text": " faultCount must either be 0, or equal to VkPhysicalDeviceVulkanSC10Properties::maxCallbackFaultCount" + } + ] + }, "vkGetDeviceFaultInfoEXT": { "(VK_EXT_device_fault)": [ { @@ -85583,6 +86667,12 @@ "text": " If storageInputOutput16 is VK_FALSE, then objects containing 16-bit integer or 16-bit floating-point elements must not have {StorageClass} of Input or Output" } ], + "(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-RuntimeSpirv-OpAtomic-05091", + "text": " If shaderAtomicInstructions is not enabled, the SPIR-V Atomic Instructions listed in 3.37.18 (OpAtomic*) must not be used [SCID-1]" + } + ], "(VK_VERSION_1_1)": [ { "vuid": "VUID-RuntimeSpirv-None-06343", diff --git a/registry/vk.xml b/registry/vk.xml index d3907eb..f5300a3 100644 --- a/registry/vk.xml +++ b/registry/vk.xml @@ -174,7 +174,7 @@ branch of the member gitlab server. #define VKSC_API_VERSION_1_0 VK_MAKE_API_VERSION(VKSC_API_VARIANT, 1, 0, 0)// Patch version should always be set to 0 // Version of this file -#define VK_HEADER_VERSION 251 +#define VK_HEADER_VERSION 252 // Complete version of this file #define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 3, VK_HEADER_VERSION) // Version of this file @@ -2881,7 +2881,7 @@ typedef void* MTLSharedEvent_id; VkSemaphoreSciSyncPoolNV semaphorePool const NvSciSyncFence* pFence - + VkStructureType sType const void* pNext uint32_t semaphoreSciSyncPoolRequestCount @@ -5028,7 +5028,7 @@ typedef void* MTLSharedEvent_id; const void* pNext uint32_t counterPassIndexIndex for which counter pass to submit - + VkStructureType sType const void* pNext uint32_t maxPerformanceQueriesPerPoolMaximum number of VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR queries in a query pool @@ -5539,7 +5539,7 @@ typedef void* MTLSharedEvent_id; VkStructureType sType - void* pNext + const void* pNext uint32_t faultCount VkFaultData*pFaults PFN_vkFaultCallbackFunction pfnFaultCallback @@ -7728,6 +7728,11 @@ typedef void* MTLSharedEvent_id; void* pNext VkBool32 shaderEarlyAndLateFragmentTests + + VkStructureType sType + const void* pNext + VkBool32 acquireUnmodifiedMemory + VkStructureType sType const void* pNext @@ -10345,6 +10350,7 @@ typedef void* MTLSharedEvent_id; uint32_t* pPropertyCount VkLayerProperties* pProperties + VkResult vkEnumerateDeviceExtensionProperties VkPhysicalDevice physicalDevice @@ -15486,13 +15492,11 @@ typedef void* MTLSharedEvent_id; - - @@ -21391,10 +21395,12 @@ typedef void* MTLSharedEvent_id; - + - - + + + + diff --git a/registry/vkconventions.py b/registry/vkconventions.py old mode 100644 new mode 100755 index 5cc5890..b4e7966 --- a/registry/vkconventions.py +++ b/registry/vkconventions.py @@ -108,6 +108,7 @@ class VulkanConventions(ConventionsBase): subpats = [ [ r'_H_(26[45])_', r'_H\1_' ], [ r'_VULKAN_([0-9])([0-9])_', r'_VULKAN_\1_\2_' ], + [ r'_VULKAN_SC_([0-9])([0-9])_',r'_VULKAN_SC_\1_\2_' ], [ r'_DIRECT_FB_', r'_DIRECTFB_' ], [ r'_VULKAN_SC_10', r'_VULKAN_SC_1_0' ], @@ -277,3 +278,21 @@ class VulkanConventions(ConventionsBase): """Return any extra text (following the title) for generated reference pages.""" return 'include::{generated}/specattribs.adoc[]' + + +class VulkanSCConventions(VulkanConventions): + + def specURL(self, spectype='api'): + """Return public registry URL which ref pages should link to for the + current all-extensions HTML specification, so xrefs in the + asciidoc source that are not to ref pages can link into it + instead. N.b. this may need to change on a per-refpage basis if + there are multiple documents involved. + """ + return 'https://registry.khronos.org/vulkansc/specs/1.0-extensions/html/vkspec.html' + + @property + def xml_api_name(self): + """Return the name used in the default API XML registry for the default API""" + return 'vulkansc' +