From fe9850767d00e46b230da6cfbc15eb86636017bd Mon Sep 17 00:00:00 2001 From: Jon Leech Date: Mon, 7 Dec 2020 04:14:23 -0800 Subject: [PATCH] Update for Vulkan-Docs 1.2.164 --- include/vulkan/vulkan.hpp | 464 +++++++++++++++++++++++++++++++++-- include/vulkan/vulkan_core.h | 49 +++- registry/validusage.json | 322 ++++++++++++++++++------ registry/vk.xml | 60 ++++- 4 files changed, 789 insertions(+), 106 deletions(-) diff --git a/include/vulkan/vulkan.hpp b/include/vulkan/vulkan.hpp index c164086b..0f21fb27 100644 --- a/include/vulkan/vulkan.hpp +++ b/include/vulkan/vulkan.hpp @@ -94,7 +94,7 @@ extern "C" __declspec( dllimport ) FARPROC __stdcall GetProcAddress( HINSTANCE h #endif -static_assert( VK_HEADER_VERSION == 163 , "Wrong VK_HEADER_VERSION!" ); +static_assert( VK_HEADER_VERSION == 164 , "Wrong VK_HEADER_VERSION!" ); // 32-bit vulkan is not typesafe for 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 @@ -1235,6 +1235,13 @@ namespace VULKAN_HPP_NAMESPACE return ::vkAcquireProfilingLockKHR( device, pInfo ); } +#ifdef VK_USE_PLATFORM_WIN32_KHR + VkResult vkAcquireWinrtDisplayNV( VkPhysicalDevice physicalDevice, VkDisplayKHR display ) const VULKAN_HPP_NOEXCEPT + { + return ::vkAcquireWinrtDisplayNV( physicalDevice, display ); + } +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + #ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT VkResult vkAcquireXlibDisplayEXT( VkPhysicalDevice physicalDevice, Display* dpy, VkDisplayKHR display ) const VULKAN_HPP_NOEXCEPT { @@ -3236,6 +3243,13 @@ namespace VULKAN_HPP_NAMESPACE return ::vkGetValidationCacheDataEXT( device, validationCache, pDataSize, pData ); } +#ifdef VK_USE_PLATFORM_WIN32_KHR + VkResult vkGetWinrtDisplayNV( VkPhysicalDevice physicalDevice, uint32_t deviceRelativeId, VkDisplayKHR* pDisplay ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetWinrtDisplayNV( physicalDevice, deviceRelativeId, pDisplay ); + } +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + VkResult vkImportFenceFdKHR( VkDevice device, const VkImportFenceFdInfoKHR* pImportFenceFdInfo ) const VULKAN_HPP_NOEXCEPT { return ::vkImportFenceFdKHR( device, pImportFenceFdInfo ); @@ -3672,6 +3686,36 @@ namespace VULKAN_HPP_NAMESPACE Dispatch const * m_dispatch = nullptr; }; + template + class ObjectReleaseExt + { + public: + ObjectReleaseExt() = default; + + ObjectReleaseExt( OwnerType owner, Dispatch const & dispatch = VULKAN_HPP_DEFAULT_DISPATCHER ) VULKAN_HPP_NOEXCEPT + : m_owner( owner ) + , m_dispatch( &dispatch ) + {} + + OwnerType getOwner() const VULKAN_HPP_NOEXCEPT + { + return m_owner; + } + + protected: + template + void destroy( T t ) VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( m_owner && m_dispatch ); + m_owner.releaseExt( t, *m_dispatch ); + } + + private: + OwnerType m_owner = {}; + Dispatch const * m_dispatch = nullptr; + }; + + template class PoolFree { @@ -4851,6 +4895,7 @@ namespace VULKAN_HPP_NAMESPACE { eFreeDescriptorSet = VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, eUpdateAfterBind = VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT, + eHostOnlyVALVE = VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_VALVE, eUpdateAfterBindEXT = VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT_EXT }; @@ -4860,6 +4905,7 @@ namespace VULKAN_HPP_NAMESPACE { case DescriptorPoolCreateFlagBits::eFreeDescriptorSet : return "FreeDescriptorSet"; case DescriptorPoolCreateFlagBits::eUpdateAfterBind : return "UpdateAfterBind"; + case DescriptorPoolCreateFlagBits::eHostOnlyVALVE : return "HostOnlyVALVE"; default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast( value ) ) + " )"; } } @@ -4868,6 +4914,7 @@ namespace VULKAN_HPP_NAMESPACE { eUpdateAfterBindPool = VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT, ePushDescriptorKHR = VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR, + eHostOnlyPoolVALVE = VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_VALVE, eUpdateAfterBindPoolEXT = VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT }; @@ -4877,6 +4924,7 @@ namespace VULKAN_HPP_NAMESPACE { case DescriptorSetLayoutCreateFlagBits::eUpdateAfterBindPool : return "UpdateAfterBindPool"; case DescriptorSetLayoutCreateFlagBits::ePushDescriptorKHR : return "PushDescriptorKHR"; + case DescriptorSetLayoutCreateFlagBits::eHostOnlyPoolVALVE : return "HostOnlyPoolVALVE"; default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast( value ) ) + " )"; } } @@ -4896,7 +4944,8 @@ namespace VULKAN_HPP_NAMESPACE eInputAttachment = VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, eInlineUniformBlockEXT = VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT, eAccelerationStructureKHR = VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR, - eAccelerationStructureNV = VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV + eAccelerationStructureNV = VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV, + eMutableVALVE = VK_DESCRIPTOR_TYPE_MUTABLE_VALVE }; VULKAN_HPP_INLINE std::string to_string( DescriptorType value ) @@ -4917,6 +4966,7 @@ namespace VULKAN_HPP_NAMESPACE case DescriptorType::eInlineUniformBlockEXT : return "InlineUniformBlockEXT"; case DescriptorType::eAccelerationStructureKHR : return "AccelerationStructureKHR"; case DescriptorType::eAccelerationStructureNV : return "AccelerationStructureNV"; + case DescriptorType::eMutableVALVE : return "MutableVALVE"; default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast( value ) ) + " )"; } } @@ -8630,6 +8680,8 @@ namespace VULKAN_HPP_NAMESPACE eImageResolve2KHR = VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2_KHR, ePhysicalDevice4444FormatsFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT, eDirectfbSurfaceCreateInfoEXT = VK_STRUCTURE_TYPE_DIRECTFB_SURFACE_CREATE_INFO_EXT, + ePhysicalDeviceMutableDescriptorTypeFeaturesVALVE = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE, + eMutableDescriptorTypeCreateInfoVALVE = VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE, eAttachmentDescription2KHR = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2_KHR, eAttachmentDescriptionStencilLayoutKHR = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT_KHR, eAttachmentReference2KHR = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2_KHR, @@ -9220,6 +9272,8 @@ namespace VULKAN_HPP_NAMESPACE case StructureType::eImageResolve2KHR : return "ImageResolve2KHR"; case StructureType::ePhysicalDevice4444FormatsFeaturesEXT : return "PhysicalDevice4444FormatsFeaturesEXT"; case StructureType::eDirectfbSurfaceCreateInfoEXT : return "DirectfbSurfaceCreateInfoEXT"; + case StructureType::ePhysicalDeviceMutableDescriptorTypeFeaturesVALVE : return "PhysicalDeviceMutableDescriptorTypeFeaturesVALVE"; + case StructureType::eMutableDescriptorTypeCreateInfoVALVE : return "MutableDescriptorTypeCreateInfoVALVE"; default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast( value ) ) + " )"; } } @@ -9521,7 +9575,8 @@ namespace VULKAN_HPP_NAMESPACE eVSI = VK_VENDOR_ID_VSI, eKazan = VK_VENDOR_ID_KAZAN, eCodeplay = VK_VENDOR_ID_CODEPLAY, - eMESA = VK_VENDOR_ID_MESA + eMESA = VK_VENDOR_ID_MESA, + ePocl = VK_VENDOR_ID_POCL }; VULKAN_HPP_INLINE std::string to_string( VendorId value ) @@ -9533,6 +9588,7 @@ namespace VULKAN_HPP_NAMESPACE case VendorId::eKazan : return "Kazan"; case VendorId::eCodeplay : return "Codeplay"; case VendorId::eMESA : return "MESA"; + case VendorId::ePocl : return "Pocl"; default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast( value ) ) + " )"; } } @@ -10579,7 +10635,7 @@ namespace VULKAN_HPP_NAMESPACE { enum : VkFlags { - allFlags = VkFlags(DescriptorPoolCreateFlagBits::eFreeDescriptorSet) | VkFlags(DescriptorPoolCreateFlagBits::eUpdateAfterBind) + allFlags = VkFlags(DescriptorPoolCreateFlagBits::eFreeDescriptorSet) | VkFlags(DescriptorPoolCreateFlagBits::eUpdateAfterBind) | VkFlags(DescriptorPoolCreateFlagBits::eHostOnlyVALVE) }; }; @@ -10611,6 +10667,7 @@ namespace VULKAN_HPP_NAMESPACE if ( value & DescriptorPoolCreateFlagBits::eFreeDescriptorSet ) result += "FreeDescriptorSet | "; if ( value & DescriptorPoolCreateFlagBits::eUpdateAfterBind ) result += "UpdateAfterBind | "; + if ( value & DescriptorPoolCreateFlagBits::eHostOnlyVALVE ) result += "HostOnlyVALVE | "; return "{ " + result.substr(0, result.size() - 3) + " }"; } @@ -10637,7 +10694,7 @@ namespace VULKAN_HPP_NAMESPACE { enum : VkFlags { - allFlags = VkFlags(DescriptorSetLayoutCreateFlagBits::eUpdateAfterBindPool) | VkFlags(DescriptorSetLayoutCreateFlagBits::ePushDescriptorKHR) + allFlags = VkFlags(DescriptorSetLayoutCreateFlagBits::eUpdateAfterBindPool) | VkFlags(DescriptorSetLayoutCreateFlagBits::ePushDescriptorKHR) | VkFlags(DescriptorSetLayoutCreateFlagBits::eHostOnlyPoolVALVE) }; }; @@ -10669,6 +10726,7 @@ namespace VULKAN_HPP_NAMESPACE if ( value & DescriptorSetLayoutCreateFlagBits::eUpdateAfterBindPool ) result += "UpdateAfterBindPool | "; if ( value & DescriptorSetLayoutCreateFlagBits::ePushDescriptorKHR ) result += "PushDescriptorKHR | "; + if ( value & DescriptorSetLayoutCreateFlagBits::eHostOnlyPoolVALVE ) result += "HostOnlyPoolVALVE | "; return "{ " + result.substr(0, result.size() - 3) + " }"; } @@ -29549,12 +29607,6 @@ namespace VULKAN_HPP_NAMESPACE { *this = rhs; } - -#if !defined(VULKAN_HPP_DISABLE_ENHANCED_MODE) - DescriptorSetAllocateInfo( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool_, VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries const & setLayouts_ ) - : descriptorPool( descriptorPool_ ), descriptorSetCount( static_cast( setLayouts_.size() ) ), pSetLayouts( setLayouts_.data() ) - {} -#endif // !defined(VULKAN_HPP_DISABLE_ENHANCED_MODE) #endif // !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) DescriptorSetAllocateInfo & operator=( VkDescriptorSetAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT @@ -29593,15 +29645,6 @@ namespace VULKAN_HPP_NAMESPACE return *this; } -#if !defined(VULKAN_HPP_DISABLE_ENHANCED_MODE) - DescriptorSetAllocateInfo & setSetLayouts( VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries const & setLayouts_ ) VULKAN_HPP_NOEXCEPT - { - descriptorSetCount = static_cast( setLayouts_.size() ); - pSetLayouts = setLayouts_.data(); - return *this; - } -#endif // !defined(VULKAN_HPP_DISABLE_ENHANCED_MODE) - operator VkDescriptorSetAllocateInfo const&() const VULKAN_HPP_NOEXCEPT { @@ -54231,6 +54274,18 @@ namespace VULKAN_HPP_NAMESPACE #endif +#ifdef VK_USE_PLATFORM_WIN32_KHR +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_NODISCARD Result acquireWinrtDisplayNV( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#else + template + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type acquireWinrtDisplayNV( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + + #ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT template VULKAN_HPP_NODISCARD Result acquireXlibDisplayEXT( Display* dpy, VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; @@ -54851,6 +54906,20 @@ namespace VULKAN_HPP_NAMESPACE #endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/ +#ifdef VK_USE_PLATFORM_WIN32_KHR + template + VULKAN_HPP_NODISCARD Result getWinrtDisplayNV( uint32_t deviceRelativeId, VULKAN_HPP_NAMESPACE::DisplayKHR* pDisplay, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type getWinrtDisplayNV( uint32_t deviceRelativeId, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# ifndef VULKAN_HPP_NO_SMART_HANDLE + template + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType>::type getWinrtDisplayNVUnique( uint32_t deviceRelativeId, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE template Result releaseDisplayEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; @@ -61089,6 +61158,209 @@ namespace VULKAN_HPP_NAMESPACE }; #endif /*VK_USE_PLATFORM_METAL_EXT*/ + struct MutableDescriptorTypeListVALVE + { + + +#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR MutableDescriptorTypeListVALVE(uint32_t descriptorTypeCount_ = {}, const VULKAN_HPP_NAMESPACE::DescriptorType* pDescriptorTypes_ = {}) VULKAN_HPP_NOEXCEPT + : descriptorTypeCount( descriptorTypeCount_ ), pDescriptorTypes( pDescriptorTypes_ ) + {} + + VULKAN_HPP_CONSTEXPR MutableDescriptorTypeListVALVE( MutableDescriptorTypeListVALVE const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + MutableDescriptorTypeListVALVE( VkMutableDescriptorTypeListVALVE const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = rhs; + } + +#if !defined(VULKAN_HPP_DISABLE_ENHANCED_MODE) + MutableDescriptorTypeListVALVE( VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries const & descriptorTypes_ ) + : descriptorTypeCount( static_cast( descriptorTypes_.size() ) ), pDescriptorTypes( descriptorTypes_.data() ) + {} +#endif // !defined(VULKAN_HPP_DISABLE_ENHANCED_MODE) +#endif // !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + + MutableDescriptorTypeListVALVE & operator=( VkMutableDescriptorTypeListVALVE const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + MutableDescriptorTypeListVALVE & operator=( MutableDescriptorTypeListVALVE const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( static_cast( this ), &rhs, sizeof( MutableDescriptorTypeListVALVE ) ); + return *this; + } + + MutableDescriptorTypeListVALVE & setDescriptorTypeCount( uint32_t descriptorTypeCount_ ) VULKAN_HPP_NOEXCEPT + { + descriptorTypeCount = descriptorTypeCount_; + return *this; + } + + MutableDescriptorTypeListVALVE & setPDescriptorTypes( const VULKAN_HPP_NAMESPACE::DescriptorType* pDescriptorTypes_ ) VULKAN_HPP_NOEXCEPT + { + pDescriptorTypes = pDescriptorTypes_; + return *this; + } + +#if !defined(VULKAN_HPP_DISABLE_ENHANCED_MODE) + MutableDescriptorTypeListVALVE & setDescriptorTypes( VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries const & descriptorTypes_ ) VULKAN_HPP_NOEXCEPT + { + descriptorTypeCount = static_cast( descriptorTypes_.size() ); + pDescriptorTypes = descriptorTypes_.data(); + return *this; + } +#endif // !defined(VULKAN_HPP_DISABLE_ENHANCED_MODE) + + + operator VkMutableDescriptorTypeListVALVE const&() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMutableDescriptorTypeListVALVE &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + +#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) + auto operator<=>( MutableDescriptorTypeListVALVE const& ) const = default; +#else + bool operator==( MutableDescriptorTypeListVALVE const& rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( descriptorTypeCount == rhs.descriptorTypeCount ) + && ( pDescriptorTypes == rhs.pDescriptorTypes ); + } + + bool operator!=( MutableDescriptorTypeListVALVE const& rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + + + public: + uint32_t descriptorTypeCount = {}; + const VULKAN_HPP_NAMESPACE::DescriptorType* pDescriptorTypes = {}; + + }; + static_assert( sizeof( MutableDescriptorTypeListVALVE ) == sizeof( VkMutableDescriptorTypeListVALVE ), "struct and wrapper have different size!" ); + static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + + struct MutableDescriptorTypeCreateInfoVALVE + { + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMutableDescriptorTypeCreateInfoVALVE; + +#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR MutableDescriptorTypeCreateInfoVALVE(uint32_t mutableDescriptorTypeListCount_ = {}, const VULKAN_HPP_NAMESPACE::MutableDescriptorTypeListVALVE* pMutableDescriptorTypeLists_ = {}) VULKAN_HPP_NOEXCEPT + : mutableDescriptorTypeListCount( mutableDescriptorTypeListCount_ ), pMutableDescriptorTypeLists( pMutableDescriptorTypeLists_ ) + {} + + VULKAN_HPP_CONSTEXPR MutableDescriptorTypeCreateInfoVALVE( MutableDescriptorTypeCreateInfoVALVE const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + MutableDescriptorTypeCreateInfoVALVE( VkMutableDescriptorTypeCreateInfoVALVE const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = rhs; + } + +#if !defined(VULKAN_HPP_DISABLE_ENHANCED_MODE) + MutableDescriptorTypeCreateInfoVALVE( VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries const & mutableDescriptorTypeLists_ ) + : mutableDescriptorTypeListCount( static_cast( mutableDescriptorTypeLists_.size() ) ), pMutableDescriptorTypeLists( mutableDescriptorTypeLists_.data() ) + {} +#endif // !defined(VULKAN_HPP_DISABLE_ENHANCED_MODE) +#endif // !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + + MutableDescriptorTypeCreateInfoVALVE & operator=( VkMutableDescriptorTypeCreateInfoVALVE const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + MutableDescriptorTypeCreateInfoVALVE & operator=( MutableDescriptorTypeCreateInfoVALVE const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( static_cast( this ), &rhs, sizeof( MutableDescriptorTypeCreateInfoVALVE ) ); + return *this; + } + + MutableDescriptorTypeCreateInfoVALVE & setPNext( const void* pNext_ ) VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + MutableDescriptorTypeCreateInfoVALVE & setMutableDescriptorTypeListCount( uint32_t mutableDescriptorTypeListCount_ ) VULKAN_HPP_NOEXCEPT + { + mutableDescriptorTypeListCount = mutableDescriptorTypeListCount_; + return *this; + } + + MutableDescriptorTypeCreateInfoVALVE & setPMutableDescriptorTypeLists( const VULKAN_HPP_NAMESPACE::MutableDescriptorTypeListVALVE* pMutableDescriptorTypeLists_ ) VULKAN_HPP_NOEXCEPT + { + pMutableDescriptorTypeLists = pMutableDescriptorTypeLists_; + return *this; + } + +#if !defined(VULKAN_HPP_DISABLE_ENHANCED_MODE) + MutableDescriptorTypeCreateInfoVALVE & setMutableDescriptorTypeLists( VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries const & mutableDescriptorTypeLists_ ) VULKAN_HPP_NOEXCEPT + { + mutableDescriptorTypeListCount = static_cast( mutableDescriptorTypeLists_.size() ); + pMutableDescriptorTypeLists = mutableDescriptorTypeLists_.data(); + return *this; + } +#endif // !defined(VULKAN_HPP_DISABLE_ENHANCED_MODE) + + + operator VkMutableDescriptorTypeCreateInfoVALVE const&() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMutableDescriptorTypeCreateInfoVALVE &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + +#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) + auto operator<=>( MutableDescriptorTypeCreateInfoVALVE const& ) const = default; +#else + bool operator==( MutableDescriptorTypeCreateInfoVALVE const& rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( mutableDescriptorTypeListCount == rhs.mutableDescriptorTypeListCount ) + && ( pMutableDescriptorTypeLists == rhs.pMutableDescriptorTypeLists ); + } + + bool operator!=( MutableDescriptorTypeCreateInfoVALVE const& rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + + + public: + const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eMutableDescriptorTypeCreateInfoVALVE; + const void* pNext = {}; + uint32_t mutableDescriptorTypeListCount = {}; + const VULKAN_HPP_NAMESPACE::MutableDescriptorTypeListVALVE* pMutableDescriptorTypeLists = {}; + + }; + static_assert( sizeof( MutableDescriptorTypeCreateInfoVALVE ) == sizeof( VkMutableDescriptorTypeCreateInfoVALVE ), "struct and wrapper have different size!" ); + static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType + { + using Type = MutableDescriptorTypeCreateInfoVALVE; + }; + union PerformanceCounterResultKHR { PerformanceCounterResultKHR( VULKAN_HPP_NAMESPACE::PerformanceCounterResultKHR const& rhs ) VULKAN_HPP_NOEXCEPT @@ -67445,6 +67717,93 @@ namespace VULKAN_HPP_NAMESPACE }; using PhysicalDeviceMultiviewPropertiesKHR = PhysicalDeviceMultiviewProperties; + struct PhysicalDeviceMutableDescriptorTypeFeaturesVALVE + { + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceMutableDescriptorTypeFeaturesVALVE; + +#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceMutableDescriptorTypeFeaturesVALVE(VULKAN_HPP_NAMESPACE::Bool32 mutableDescriptorType_ = {}) VULKAN_HPP_NOEXCEPT + : mutableDescriptorType( mutableDescriptorType_ ) + {} + + VULKAN_HPP_CONSTEXPR PhysicalDeviceMutableDescriptorTypeFeaturesVALVE( PhysicalDeviceMutableDescriptorTypeFeaturesVALVE const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceMutableDescriptorTypeFeaturesVALVE( VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = rhs; + } +#endif // !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + + PhysicalDeviceMutableDescriptorTypeFeaturesVALVE & operator=( VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + PhysicalDeviceMutableDescriptorTypeFeaturesVALVE & operator=( PhysicalDeviceMutableDescriptorTypeFeaturesVALVE const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( static_cast( this ), &rhs, sizeof( PhysicalDeviceMutableDescriptorTypeFeaturesVALVE ) ); + return *this; + } + + PhysicalDeviceMutableDescriptorTypeFeaturesVALVE & setPNext( void* pNext_ ) VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + PhysicalDeviceMutableDescriptorTypeFeaturesVALVE & setMutableDescriptorType( VULKAN_HPP_NAMESPACE::Bool32 mutableDescriptorType_ ) VULKAN_HPP_NOEXCEPT + { + mutableDescriptorType = mutableDescriptorType_; + return *this; + } + + + operator VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE const&() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + +#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) + auto operator<=>( PhysicalDeviceMutableDescriptorTypeFeaturesVALVE const& ) const = default; +#else + bool operator==( PhysicalDeviceMutableDescriptorTypeFeaturesVALVE const& rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( mutableDescriptorType == rhs.mutableDescriptorType ); + } + + bool operator!=( PhysicalDeviceMutableDescriptorTypeFeaturesVALVE const& rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + + + public: + const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceMutableDescriptorTypeFeaturesVALVE; + void* pNext = {}; + VULKAN_HPP_NAMESPACE::Bool32 mutableDescriptorType = {}; + + }; + static_assert( sizeof( PhysicalDeviceMutableDescriptorTypeFeaturesVALVE ) == sizeof( VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE ), "struct and wrapper have different size!" ); + static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType + { + using Type = PhysicalDeviceMutableDescriptorTypeFeaturesVALVE; + }; + struct PhysicalDevicePCIBusInfoPropertiesEXT { static const bool allowDuplicate = false; @@ -89549,6 +89908,25 @@ namespace VULKAN_HPP_NAMESPACE #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#ifdef VK_USE_PLATFORM_WIN32_KHR +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::acquireWinrtDisplayNV( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + return static_cast( d.vkAcquireWinrtDisplayNV( m_physicalDevice, static_cast( display ) ) ); + } +#else + template + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type PhysicalDevice::acquireWinrtDisplayNV( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d ) const + { + Result result = static_cast( d.vkAcquireWinrtDisplayNV( m_physicalDevice, static_cast( display ) ) ); + return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::acquireWinrtDisplayNV" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + + #ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT template VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::acquireXlibDisplayEXT( Display* dpy, VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT @@ -91771,6 +92149,36 @@ namespace VULKAN_HPP_NAMESPACE #endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/ +#ifdef VK_USE_PLATFORM_WIN32_KHR + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getWinrtDisplayNV( uint32_t deviceRelativeId, VULKAN_HPP_NAMESPACE::DisplayKHR* pDisplay, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + return static_cast( d.vkGetWinrtDisplayNV( m_physicalDevice, deviceRelativeId, reinterpret_cast< VkDisplayKHR *>( pDisplay ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type PhysicalDevice::getWinrtDisplayNV( uint32_t deviceRelativeId, Dispatch const & d ) const + { + VULKAN_HPP_NAMESPACE::DisplayKHR display; + Result result = static_cast( d.vkGetWinrtDisplayNV( m_physicalDevice, deviceRelativeId, reinterpret_cast( &display ) ) ); + return createResultValue( result, display, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getWinrtDisplayNV" ); + } + +# ifndef VULKAN_HPP_NO_SMART_HANDLE + template + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType>::type PhysicalDevice::getWinrtDisplayNVUnique( uint32_t deviceRelativeId, Dispatch const & d ) const + { + VULKAN_HPP_NAMESPACE::DisplayKHR display; + Result result = static_cast( d.vkGetWinrtDisplayNV( m_physicalDevice, deviceRelativeId, reinterpret_cast( &display ) ) ); + ObjectReleaseExt deleter( *this, d ); + return createResultValue( result, display, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getWinrtDisplayNVUnique", deleter ); + } +# endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE template VULKAN_HPP_INLINE Result PhysicalDevice::releaseDisplayEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT @@ -92038,6 +92446,8 @@ namespace VULKAN_HPP_NAMESPACE template <> struct StructExtends{ enum { value = true }; }; template <> struct StructExtends{ enum { value = true }; }; template <> struct StructExtends{ enum { value = true }; }; + template <> struct StructExtends{ enum { value = true }; }; + template <> struct StructExtends{ enum { value = true }; }; template <> struct StructExtends{ enum { value = true }; }; template <> struct StructExtends{ enum { value = true }; }; template <> struct StructExtends{ enum { value = true }; }; @@ -92143,6 +92553,8 @@ namespace VULKAN_HPP_NAMESPACE template <> struct StructExtends{ enum { value = true }; }; template <> struct StructExtends{ enum { value = true }; }; template <> struct StructExtends{ enum { value = true }; }; + template <> struct StructExtends{ enum { value = true }; }; + template <> struct StructExtends{ enum { value = true }; }; template <> struct StructExtends{ enum { value = true }; }; template <> struct StructExtends{ enum { value = true }; }; template <> struct StructExtends{ enum { value = true }; }; @@ -92441,6 +92853,9 @@ namespace VULKAN_HPP_NAMESPACE PFN_vkAcquireNextImageKHR vkAcquireNextImageKHR = 0; PFN_vkAcquirePerformanceConfigurationINTEL vkAcquirePerformanceConfigurationINTEL = 0; PFN_vkAcquireProfilingLockKHR vkAcquireProfilingLockKHR = 0; +#ifdef VK_USE_PLATFORM_WIN32_KHR + PFN_vkAcquireWinrtDisplayNV vkAcquireWinrtDisplayNV = 0; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ #ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT PFN_vkAcquireXlibDisplayEXT vkAcquireXlibDisplayEXT = 0; #endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/ @@ -92886,6 +93301,9 @@ namespace VULKAN_HPP_NAMESPACE PFN_vkGetSwapchainImagesKHR vkGetSwapchainImagesKHR = 0; PFN_vkGetSwapchainStatusKHR vkGetSwapchainStatusKHR = 0; PFN_vkGetValidationCacheDataEXT vkGetValidationCacheDataEXT = 0; +#ifdef VK_USE_PLATFORM_WIN32_KHR + PFN_vkGetWinrtDisplayNV vkGetWinrtDisplayNV = 0; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ PFN_vkImportFenceFdKHR vkImportFenceFdKHR = 0; #ifdef VK_USE_PLATFORM_WIN32_KHR PFN_vkImportFenceWin32HandleKHR vkImportFenceWin32HandleKHR = 0; @@ -93005,6 +93423,9 @@ namespace VULKAN_HPP_NAMESPACE void init( VULKAN_HPP_NAMESPACE::Instance instanceCpp ) VULKAN_HPP_NOEXCEPT { VkInstance instance = static_cast(instanceCpp); +#ifdef VK_USE_PLATFORM_WIN32_KHR + vkAcquireWinrtDisplayNV = PFN_vkAcquireWinrtDisplayNV( vkGetInstanceProcAddr( instance, "vkAcquireWinrtDisplayNV" ) ); +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ #ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT vkAcquireXlibDisplayEXT = PFN_vkAcquireXlibDisplayEXT( vkGetInstanceProcAddr( instance, "vkAcquireXlibDisplayEXT" ) ); #endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/ @@ -93146,6 +93567,9 @@ namespace VULKAN_HPP_NAMESPACE #ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT vkGetRandROutputDisplayEXT = PFN_vkGetRandROutputDisplayEXT( vkGetInstanceProcAddr( instance, "vkGetRandROutputDisplayEXT" ) ); #endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/ +#ifdef VK_USE_PLATFORM_WIN32_KHR + vkGetWinrtDisplayNV = PFN_vkGetWinrtDisplayNV( vkGetInstanceProcAddr( instance, "vkGetWinrtDisplayNV" ) ); +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ vkReleaseDisplayEXT = PFN_vkReleaseDisplayEXT( vkGetInstanceProcAddr( instance, "vkReleaseDisplayEXT" ) ); vkSubmitDebugUtilsMessageEXT = PFN_vkSubmitDebugUtilsMessageEXT( vkGetInstanceProcAddr( instance, "vkSubmitDebugUtilsMessageEXT" ) ); #ifdef VK_USE_PLATFORM_WIN32_KHR diff --git a/include/vulkan/vulkan_core.h b/include/vulkan/vulkan_core.h index ec5f0612..0faf4ca3 100644 --- a/include/vulkan/vulkan_core.h +++ b/include/vulkan/vulkan_core.h @@ -43,7 +43,7 @@ extern "C" { #define VK_API_VERSION_1_0 VK_MAKE_VERSION(1, 0, 0)// Patch version should always be set to 0 // Version of this file -#define VK_HEADER_VERSION 163 +#define VK_HEADER_VERSION 164 // Complete version of this file #define VK_HEADER_VERSION_COMPLETE VK_MAKE_VERSION(1, 2, VK_HEADER_VERSION) @@ -620,6 +620,8 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2_KHR = 1000337010, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT = 1000340000, VK_STRUCTURE_TYPE_DIRECTFB_SURFACE_CREATE_INFO_EXT = 1000346000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE = 1000351000, + VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE = 1000351002, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES, VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT, @@ -820,6 +822,7 @@ typedef enum VkVendorId { VK_VENDOR_ID_KAZAN = 0x10003, VK_VENDOR_ID_CODEPLAY = 0x10004, VK_VENDOR_ID_MESA = 0x10005, + VK_VENDOR_ID_POCL = 0x10006, VK_VENDOR_ID_MAX_ENUM = 0x7FFFFFFF } VkVendorId; @@ -1429,6 +1432,7 @@ typedef enum VkDescriptorType { VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT = 1000138000, VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR = 1000150000, VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV = 1000165000, + VK_DESCRIPTOR_TYPE_MUTABLE_VALVE = 1000351000, VK_DESCRIPTOR_TYPE_MAX_ENUM = 0x7FFFFFFF } VkDescriptorType; @@ -1903,6 +1907,7 @@ typedef VkFlags VkSamplerCreateFlags; typedef enum VkDescriptorPoolCreateFlagBits { VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT = 0x00000001, VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT = 0x00000002, + VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_VALVE = 0x00000004, VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT_EXT = VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT, VK_DESCRIPTOR_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF } VkDescriptorPoolCreateFlagBits; @@ -1912,6 +1917,7 @@ typedef VkFlags VkDescriptorPoolResetFlags; typedef enum VkDescriptorSetLayoutCreateFlagBits { VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT = 0x00000002, VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR = 0x00000001, + VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_VALVE = 0x00000004, VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT = VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT, VK_DESCRIPTOR_SET_LAYOUT_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF } VkDescriptorSetLayoutCreateFlagBits; @@ -11397,6 +11403,47 @@ typedef struct VkPhysicalDevice4444FormatsFeaturesEXT { +#define VK_NV_acquire_winrt_display 1 +#define VK_NV_ACQUIRE_WINRT_DISPLAY_SPEC_VERSION 1 +#define VK_NV_ACQUIRE_WINRT_DISPLAY_EXTENSION_NAME "VK_NV_acquire_winrt_display" +typedef VkResult (VKAPI_PTR *PFN_vkAcquireWinrtDisplayNV)(VkPhysicalDevice physicalDevice, VkDisplayKHR display); +typedef VkResult (VKAPI_PTR *PFN_vkGetWinrtDisplayNV)(VkPhysicalDevice physicalDevice, uint32_t deviceRelativeId, VkDisplayKHR* pDisplay); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkAcquireWinrtDisplayNV( + VkPhysicalDevice physicalDevice, + VkDisplayKHR display); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetWinrtDisplayNV( + VkPhysicalDevice physicalDevice, + uint32_t deviceRelativeId, + VkDisplayKHR* pDisplay); +#endif + + +#define VK_VALVE_mutable_descriptor_type 1 +#define VK_VALVE_MUTABLE_DESCRIPTOR_TYPE_SPEC_VERSION 1 +#define VK_VALVE_MUTABLE_DESCRIPTOR_TYPE_EXTENSION_NAME "VK_VALVE_mutable_descriptor_type" +typedef struct VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE { + VkStructureType sType; + void* pNext; + VkBool32 mutableDescriptorType; +} VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE; + +typedef struct VkMutableDescriptorTypeListVALVE { + uint32_t descriptorTypeCount; + const VkDescriptorType* pDescriptorTypes; +} VkMutableDescriptorTypeListVALVE; + +typedef struct VkMutableDescriptorTypeCreateInfoVALVE { + VkStructureType sType; + const void* pNext; + uint32_t mutableDescriptorTypeListCount; + const VkMutableDescriptorTypeListVALVE* pMutableDescriptorTypeLists; +} VkMutableDescriptorTypeCreateInfoVALVE; + + + #define VK_KHR_acceleration_structure 1 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkAccelerationStructureKHR) #define VK_KHR_ACCELERATION_STRUCTURE_SPEC_VERSION 11 diff --git a/registry/validusage.json b/registry/validusage.json index d202961b..ede24ef7 100644 --- a/registry/validusage.json +++ b/registry/validusage.json @@ -1,9 +1,9 @@ { "version info": { "schema version": 2, - "api version": "1.2.163", - "comment": "from git branch: github-main commit: a48d8432aacf8a23de3c471d6fa074d0a326cfcc", - "date": "2020-11-30 07:53:12Z" + "api version": "1.2.164", + "comment": "from git branch: github-main commit: 8f718b4194ed1e0a572d37072e5558dd9ceabcb0", + "date": "2020-12-07 11:19:04Z" }, "validation": { "vkGetInstanceProcAddr": { @@ -550,7 +550,7 @@ }, { "vuid": "VUID-VkDeviceCreateInfo-pNext-pNext", - "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 VkDeviceDeviceMemoryReportCreateInfoEXT, VkDeviceDiagnosticsConfigCreateInfoNV, VkDeviceGroupDeviceCreateInfo, VkDeviceMemoryOverallocationCreateInfoAMD, VkDevicePrivateDataCreateInfoEXT, VkPhysicalDevice16BitStorageFeatures, VkPhysicalDevice4444FormatsFeaturesEXT, VkPhysicalDevice8BitStorageFeatures, VkPhysicalDeviceASTCDecodeFeaturesEXT, VkPhysicalDeviceAccelerationStructureFeaturesKHR, VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT, VkPhysicalDeviceBufferDeviceAddressFeatures, VkPhysicalDeviceBufferDeviceAddressFeaturesEXT, VkPhysicalDeviceCoherentMemoryFeaturesAMD, VkPhysicalDeviceComputeShaderDerivativesFeaturesNV, VkPhysicalDeviceConditionalRenderingFeaturesEXT, VkPhysicalDeviceCooperativeMatrixFeaturesNV, VkPhysicalDeviceCornerSampledImageFeaturesNV, VkPhysicalDeviceCoverageReductionModeFeaturesNV, VkPhysicalDeviceCustomBorderColorFeaturesEXT, VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV, VkPhysicalDeviceDepthClipEnableFeaturesEXT, VkPhysicalDeviceDescriptorIndexingFeatures, VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV, VkPhysicalDeviceDeviceMemoryReportFeaturesEXT, VkPhysicalDeviceDiagnosticsConfigFeaturesNV, VkPhysicalDeviceExclusiveScissorFeaturesNV, VkPhysicalDeviceExtendedDynamicStateFeaturesEXT, VkPhysicalDeviceFeatures2, VkPhysicalDeviceFragmentDensityMap2FeaturesEXT, VkPhysicalDeviceFragmentDensityMapFeaturesEXT, VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV, VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT, VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV, VkPhysicalDeviceFragmentShadingRateFeaturesKHR, VkPhysicalDeviceHostQueryResetFeatures, VkPhysicalDeviceImageRobustnessFeaturesEXT, VkPhysicalDeviceImagelessFramebufferFeatures, VkPhysicalDeviceIndexTypeUint8FeaturesEXT, VkPhysicalDeviceInlineUniformBlockFeaturesEXT, VkPhysicalDeviceLineRasterizationFeaturesEXT, VkPhysicalDeviceMemoryPriorityFeaturesEXT, VkPhysicalDeviceMeshShaderFeaturesNV, VkPhysicalDeviceMultiviewFeatures, VkPhysicalDevicePerformanceQueryFeaturesKHR, VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT, VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR, VkPhysicalDevicePortabilitySubsetFeaturesKHR, VkPhysicalDevicePrivateDataFeaturesEXT, VkPhysicalDeviceProtectedMemoryFeatures, VkPhysicalDeviceRayQueryFeaturesKHR, VkPhysicalDeviceRayTracingPipelineFeaturesKHR, VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV, VkPhysicalDeviceRobustness2FeaturesEXT, VkPhysicalDeviceSamplerYcbcrConversionFeatures, VkPhysicalDeviceScalarBlockLayoutFeatures, VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures, VkPhysicalDeviceShaderAtomicFloatFeaturesEXT, VkPhysicalDeviceShaderAtomicInt64Features, VkPhysicalDeviceShaderClockFeaturesKHR, VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT, VkPhysicalDeviceShaderDrawParametersFeatures, VkPhysicalDeviceShaderFloat16Int8Features, VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT, VkPhysicalDeviceShaderImageFootprintFeaturesNV, VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL, VkPhysicalDeviceShaderSMBuiltinsFeaturesNV, VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures, VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR, VkPhysicalDeviceShadingRateImageFeaturesNV, VkPhysicalDeviceSubgroupSizeControlFeaturesEXT, VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT, VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT, VkPhysicalDeviceTimelineSemaphoreFeatures, VkPhysicalDeviceTransformFeedbackFeaturesEXT, VkPhysicalDeviceUniformBufferStandardLayoutFeatures, VkPhysicalDeviceVariablePointersFeatures, VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT, VkPhysicalDeviceVulkan11Features, VkPhysicalDeviceVulkan12Features, VkPhysicalDeviceVulkanMemoryModelFeatures, or VkPhysicalDeviceYcbcrImageArraysFeaturesEXT" + "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 VkDeviceDeviceMemoryReportCreateInfoEXT, VkDeviceDiagnosticsConfigCreateInfoNV, VkDeviceGroupDeviceCreateInfo, VkDeviceMemoryOverallocationCreateInfoAMD, VkDevicePrivateDataCreateInfoEXT, VkPhysicalDevice16BitStorageFeatures, VkPhysicalDevice4444FormatsFeaturesEXT, VkPhysicalDevice8BitStorageFeatures, VkPhysicalDeviceASTCDecodeFeaturesEXT, VkPhysicalDeviceAccelerationStructureFeaturesKHR, VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT, VkPhysicalDeviceBufferDeviceAddressFeatures, VkPhysicalDeviceBufferDeviceAddressFeaturesEXT, VkPhysicalDeviceCoherentMemoryFeaturesAMD, VkPhysicalDeviceComputeShaderDerivativesFeaturesNV, VkPhysicalDeviceConditionalRenderingFeaturesEXT, VkPhysicalDeviceCooperativeMatrixFeaturesNV, VkPhysicalDeviceCornerSampledImageFeaturesNV, VkPhysicalDeviceCoverageReductionModeFeaturesNV, VkPhysicalDeviceCustomBorderColorFeaturesEXT, VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV, VkPhysicalDeviceDepthClipEnableFeaturesEXT, VkPhysicalDeviceDescriptorIndexingFeatures, VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV, VkPhysicalDeviceDeviceMemoryReportFeaturesEXT, VkPhysicalDeviceDiagnosticsConfigFeaturesNV, VkPhysicalDeviceExclusiveScissorFeaturesNV, VkPhysicalDeviceExtendedDynamicStateFeaturesEXT, VkPhysicalDeviceFeatures2, VkPhysicalDeviceFragmentDensityMap2FeaturesEXT, VkPhysicalDeviceFragmentDensityMapFeaturesEXT, VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV, VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT, VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV, VkPhysicalDeviceFragmentShadingRateFeaturesKHR, VkPhysicalDeviceHostQueryResetFeatures, VkPhysicalDeviceImageRobustnessFeaturesEXT, VkPhysicalDeviceImagelessFramebufferFeatures, VkPhysicalDeviceIndexTypeUint8FeaturesEXT, VkPhysicalDeviceInlineUniformBlockFeaturesEXT, VkPhysicalDeviceLineRasterizationFeaturesEXT, VkPhysicalDeviceMemoryPriorityFeaturesEXT, VkPhysicalDeviceMeshShaderFeaturesNV, VkPhysicalDeviceMultiviewFeatures, VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE, VkPhysicalDevicePerformanceQueryFeaturesKHR, VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT, VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR, VkPhysicalDevicePortabilitySubsetFeaturesKHR, VkPhysicalDevicePrivateDataFeaturesEXT, VkPhysicalDeviceProtectedMemoryFeatures, VkPhysicalDeviceRayQueryFeaturesKHR, VkPhysicalDeviceRayTracingPipelineFeaturesKHR, VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV, VkPhysicalDeviceRobustness2FeaturesEXT, VkPhysicalDeviceSamplerYcbcrConversionFeatures, VkPhysicalDeviceScalarBlockLayoutFeatures, VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures, VkPhysicalDeviceShaderAtomicFloatFeaturesEXT, VkPhysicalDeviceShaderAtomicInt64Features, VkPhysicalDeviceShaderClockFeaturesKHR, VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT, VkPhysicalDeviceShaderDrawParametersFeatures, VkPhysicalDeviceShaderFloat16Int8Features, VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT, VkPhysicalDeviceShaderImageFootprintFeaturesNV, VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL, VkPhysicalDeviceShaderSMBuiltinsFeaturesNV, VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures, VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR, VkPhysicalDeviceShadingRateImageFeaturesNV, VkPhysicalDeviceSubgroupSizeControlFeaturesEXT, VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT, VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT, VkPhysicalDeviceTimelineSemaphoreFeatures, VkPhysicalDeviceTransformFeedbackFeaturesEXT, VkPhysicalDeviceUniformBufferStandardLayoutFeatures, VkPhysicalDeviceVariablePointersFeatures, VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT, VkPhysicalDeviceVulkan11Features, VkPhysicalDeviceVulkan12Features, VkPhysicalDeviceVulkanMemoryModelFeatures, or VkPhysicalDeviceYcbcrImageArraysFeaturesEXT" }, { "vuid": "VUID-VkDeviceCreateInfo-sType-unique", @@ -960,10 +960,6 @@ }, "VkCommandBufferAllocateInfo": { "core": [ - { - "vuid": "VUID-VkCommandBufferAllocateInfo-commandBufferCount-00044", - "text": " commandBufferCount must be greater than 0" - }, { "vuid": "VUID-VkCommandBufferAllocateInfo-sType-sType", "text": " sType must be VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO" @@ -5432,22 +5428,6 @@ "vuid": "VUID-vkCmdBeginRenderPass-framebuffer-02532", "text": " For any attachment in framebuffer that is used by renderPass and is bound to memory locations that are also bound to another attachment used by renderPass, and if at least one of those uses causes either attachment to be written to, both attachments must have had the VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT set" }, - { - "vuid": "VUID-vkCmdBeginRenderPass-pAttachments-04102", - "text": " Each element of the pAttachments of framebuffer that is referenced by any element of the pInputAttachments of any element of pSubpasses of renderPass must have image view format features containing at least VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT or VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT" - }, - { - "vuid": "VUID-vkCmdBeginRenderPass-pAttachments-04103", - "text": " Each element of the pAttachments of framebuffer that is referenced by any element of the pColorAttachments of any element of pSubpasses of renderPass must have image view format features containing VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT" - }, - { - "vuid": "VUID-vkCmdBeginRenderPass-pAttachments-04104", - "text": " Each element of the pAttachments of framebuffer that is referenced by any element of the pResolveAttachments of any element of pSubpasses of renderPass must have image view format features containing VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT" - }, - { - "vuid": "VUID-vkCmdBeginRenderPass-pAttachments-04105", - "text": " Each element of the pAttachments of framebuffer that is referenced by any element of the pDepthStencilAttachment of any element of pSubpasses of renderPass must have image view format features containing VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT" - }, { "vuid": "VUID-vkCmdBeginRenderPass-commandBuffer-parameter", "text": " commandBuffer must be a valid VkCommandBuffer handle" @@ -5538,22 +5518,6 @@ "vuid": "VUID-vkCmdBeginRenderPass2-framebuffer-02533", "text": " For any attachment in framebuffer that is used by renderPass and is bound to memory locations that are also bound to another attachment used by renderPass, and if at least one of those uses causes either attachment to be written to, both attachments must have had the VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT set" }, - { - "vuid": "VUID-vkCmdBeginRenderPass2-pAttachments-04106", - "text": " Each element of the pAttachments of framebuffer that is referenced by any element of the pInputAttachments of any element of pSubpasses of renderPass must have image view format features contain at least VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT or VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT" - }, - { - "vuid": "VUID-vkCmdBeginRenderPass2-pAttachments-04107", - "text": " Each element of the pAttachments of framebuffer that is referenced by any element of the pColorAttachments of any element of pSubpasses of renderPass must have image view format features contain VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT" - }, - { - "vuid": "VUID-vkCmdBeginRenderPass2-pAttachments-04108", - "text": " Each element of the pAttachments of framebuffer that is referenced by any element of the pResolveAttachments of any element of pSubpasses of renderPass must have image view format features contain VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT" - }, - { - "vuid": "VUID-vkCmdBeginRenderPass2-pAttachments-04109", - "text": " Each element of the pAttachments of framebuffer that is referenced by any element of the pDepthStencilAttachment of any element of pSubpasses of renderPass must have image view format features contain VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT" - }, { "vuid": "VUID-vkCmdBeginRenderPass2-commandBuffer-parameter", "text": " commandBuffer must be a valid VkCommandBuffer handle" @@ -8520,6 +8484,10 @@ }, "vkGetRayTracingShaderGroupHandlesKHR": { "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)": [ + { + "vuid": "VUID-vkGetRayTracingShaderGroupHandlesKHR-pipeline-04619", + "text": " pipeline must be a ray tracing pipeline" + }, { "vuid": "VUID-vkGetRayTracingShaderGroupHandlesKHR-firstGroup-04050", "text": " firstGroup must be less than the number of shader groups in pipeline" @@ -8562,6 +8530,10 @@ }, "vkGetRayTracingCaptureReplayShaderGroupHandlesKHR": { "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)": [ + { + "vuid": "VUID-vkGetRayTracingCaptureReplayShaderGroupHandlesKHR-pipeline-04620", + "text": " pipeline must be a ray tracing pipeline" + }, { "vuid": "VUID-vkGetRayTracingCaptureReplayShaderGroupHandlesKHR-firstGroup-04051", "text": " firstGroup must be less than the number of shader groups in pipeline" @@ -8606,6 +8578,10 @@ }, "vkCompileDeferredNV": { "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_NV_ray_tracing)": [ + { + "vuid": "VUID-vkCompileDeferredNV-pipeline-04621", + "text": " pipeline must be a ray tracing pipeline" + }, { "vuid": "VUID-vkCompileDeferredNV-pipeline-02237", "text": " pipeline must have been created with VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NV" @@ -8630,6 +8606,10 @@ }, "vkGetRayTracingShaderGroupStackSizeKHR": { "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)": [ + { + "vuid": "VUID-vkGetRayTracingShaderGroupStackSizeKHR-pipeline-04622", + "text": " pipeline must be a ray tracing pipeline" + }, { "vuid": "VUID-vkGetRayTracingShaderGroupStackSizeKHR-group-03608", "text": " The value of group must be less than the number of shader groups in pipeline" @@ -12630,6 +12610,12 @@ "vuid": "VUID-VkAccelerationStructureInfoNV-pGeometries-parameter", "text": " If geometryCount is not 0, pGeometries must be a valid pointer to an array of geometryCount valid VkGeometryNV structures" } + ], + "(VK_NV_ray_tracing,VK_KHR_acceleration_structure)+(VK_NV_ray_tracing)+(VK_KHR_acceleration_structure)": [ + { + "vuid": "VUID-VkAccelerationStructureInfoNV-type-04623", + "text": " type must not be VK_ACCELERATION_STRUCTURE_TYPE_GENERIC_KHR" + } ] }, "vkCreateAccelerationStructureKHR": { @@ -13618,7 +13604,7 @@ }, { "vuid": "VUID-VkDescriptorSetLayoutCreateInfo-pNext-pNext", - "text": " pNext must be NULL or a pointer to a valid instance of VkDescriptorSetLayoutBindingFlagsCreateInfo" + "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 VkDescriptorSetLayoutBindingFlagsCreateInfo or VkMutableDescriptorTypeCreateInfoVALVE" }, { "vuid": "VUID-VkDescriptorSetLayoutCreateInfo-sType-unique", @@ -13649,6 +13635,16 @@ "text": " If flags contains VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR, then all elements of pBindings must not have a descriptorType of VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT" } ], + "(VK_KHR_push_descriptor)+(VK_VALVE_mutable_descriptor_type)": [ + { + "vuid": "VUID-VkDescriptorSetLayoutCreateInfo-flags-04590", + "text": " If flags contains VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR, flags must not contain VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_VALVE" + }, + { + "vuid": "VUID-VkDescriptorSetLayoutCreateInfo-flags-04591", + "text": " If flags contains VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR, pBindings must not have a descriptorType of VK_DESCRIPTOR_TYPE_MUTABLE_VALVE" + } + ], "(VK_VERSION_1_2,VK_EXT_descriptor_indexing)": [ { "vuid": "VUID-VkDescriptorSetLayoutCreateInfo-flags-03000", @@ -13658,6 +13654,80 @@ "vuid": "VUID-VkDescriptorSetLayoutCreateInfo-descriptorType-03001", "text": " If any binding has the VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT bit set, then all bindings must not have descriptorType of VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC or VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC" } + ], + "(VK_VERSION_1_2,VK_EXT_descriptor_indexing)+(VK_VALVE_mutable_descriptor_type)": [ + { + "vuid": "VUID-VkDescriptorSetLayoutCreateInfo-flags-04592", + "text": " If flags contains VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT, flags must not contain VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_VALVE" + } + ], + "(VK_VALVE_mutable_descriptor_type)": [ + { + "vuid": "VUID-VkDescriptorSetLayoutCreateInfo-descriptorType-04593", + "text": " If any binding has a descriptorType of VK_DESCRIPTOR_TYPE_MUTABLE_VALVE, then a VkMutableDescriptorTypeCreateInfoVALVE must be present in the pNext chain" + }, + { + "vuid": "VUID-VkDescriptorSetLayoutCreateInfo-descriptorType-04594", + "text": " If a binding has a descriptorType value of VK_DESCRIPTOR_TYPE_MUTABLE_VALVE, then pImmutableSamplers must be NULL" + }, + { + "vuid": "VUID-VkDescriptorSetLayoutCreateInfo-mutableDescriptorType-04595", + "text": " If VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE::mutableDescriptorType is not enabled, pBindings must not contain a descriptorType of VK_DESCRIPTOR_TYPE_MUTABLE_VALVE" + }, + { + "vuid": "VUID-VkDescriptorSetLayoutCreateInfo-flags-04596", + "text": " If flags contains VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_VALVE, VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE::mutableDescriptorType must be enabled" + } + ] + }, + "VkMutableDescriptorTypeCreateInfoVALVE": { + "(VK_VALVE_mutable_descriptor_type)": [ + { + "vuid": "VUID-VkMutableDescriptorTypeCreateInfoVALVE-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE" + }, + { + "vuid": "VUID-VkMutableDescriptorTypeCreateInfoVALVE-pMutableDescriptorTypeLists-parameter", + "text": " If mutableDescriptorTypeListCount is not 0, pMutableDescriptorTypeLists must be a valid pointer to an array of mutableDescriptorTypeListCount valid VkMutableDescriptorTypeListVALVE structures" + } + ] + }, + "VkMutableDescriptorTypeListVALVE": { + "(VK_VALVE_mutable_descriptor_type)": [ + { + "vuid": "VUID-VkMutableDescriptorTypeListVALVE-descriptorTypeCount-04597", + "text": " descriptorTypeCount must not be 0 if the corresponding binding is of VK_DESCRIPTOR_TYPE_MUTABLE_VALVE" + }, + { + "vuid": "VUID-VkMutableDescriptorTypeListVALVE-pDescriptorTypes-04598", + "text": " pDescriptorTypes must be a valid pointer to an array of descriptorTypeCount valid, unique VkDescriptorType values if the given binding is of VK_DESCRIPTOR_TYPE_MUTABLE_VALVE type" + }, + { + "vuid": "VUID-VkMutableDescriptorTypeListVALVE-descriptorTypeCount-04599", + "text": " descriptorTypeCount must be 0 if the corresponding binding is not of VK_DESCRIPTOR_TYPE_MUTABLE_VALVE" + }, + { + "vuid": "VUID-VkMutableDescriptorTypeListVALVE-pDescriptorTypes-04600", + "text": " pDescriptorTypes must not contain VK_DESCRIPTOR_TYPE_MUTABLE_VALVE" + }, + { + "vuid": "VUID-VkMutableDescriptorTypeListVALVE-pDescriptorTypes-04601", + "text": " pDescriptorTypes must not contain VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC" + }, + { + "vuid": "VUID-VkMutableDescriptorTypeListVALVE-pDescriptorTypes-04602", + "text": " pDescriptorTypes must not contain VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC" + }, + { + "vuid": "VUID-VkMutableDescriptorTypeListVALVE-pDescriptorTypes-parameter", + "text": " If descriptorTypeCount is not 0, pDescriptorTypes must be a valid pointer to an array of descriptorTypeCount valid VkDescriptorType values" + } + ], + "(VK_VALVE_mutable_descriptor_type)+(VK_EXT_inline_uniform_block)": [ + { + "vuid": "VUID-VkMutableDescriptorTypeListVALVE-pDescriptorTypes-04603", + "text": " pDescriptorTypes must not contain VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT" + } ] }, "VkDescriptorSetLayoutBinding": { @@ -13680,6 +13750,10 @@ } ], "(VK_EXT_inline_uniform_block)": [ + { + "vuid": "VUID-VkDescriptorSetLayoutBinding-descriptorType-04604", + "text": " If the inlineUniformBlock feature is not enabled, descriptorType must not be VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT" + }, { "vuid": "VUID-VkDescriptorSetLayoutBinding-descriptorType-02209", "text": " If descriptorType is VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT then descriptorCount must be a multiple of 4" @@ -13694,6 +13768,12 @@ "vuid": "VUID-VkDescriptorSetLayoutBinding-pImmutableSamplers-04009", "text": " The sampler objects indicated by pImmutableSamplers must not have a borderColor with one of the values VK_BORDER_COLOR_FLOAT_CUSTOM_EXT or VK_BORDER_COLOR_INT_CUSTOM_EXT" } + ], + "(VK_VALVE_mutable_descriptor_type)": [ + { + "vuid": "VUID-VkDescriptorSetLayoutBinding-descriptorType-04605", + "text": " If descriptorType is VK_DESCRIPTOR_TYPE_MUTABLE_VALVE, then pImmutableSamplers must be NULL." + } ] }, "VkDescriptorSetLayoutBindingFlagsCreateInfo": { @@ -14132,6 +14212,12 @@ "vuid": "VUID-VkPipelineLayoutCreateInfo-pImmutableSamplers-03566", "text": " The total number of pImmutableSamplers created with flags containing VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT or VK_SAMPLER_CREATE_SUBSAMPLED_COARSE_RECONSTRUCTION_BIT_EXT across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceFragmentDensityMap2PropertiesEXT::maxDescriptorSetSubsampledSamplers" } + ], + "(VK_VALVE_mutable_descriptor_type)": [ + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-pSetLayouts-04606", + "text": " Any element of pSetLayouts must not have been created with the VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_VALVE bit set" + } ] }, "VkPushConstantRange": { @@ -14230,7 +14316,7 @@ }, { "vuid": "VUID-VkDescriptorPoolCreateInfo-pNext-pNext", - "text": " pNext must be NULL or a pointer to a valid instance of VkDescriptorPoolInlineUniformBlockCreateInfoEXT" + "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 VkDescriptorPoolInlineUniformBlockCreateInfoEXT or VkMutableDescriptorTypeCreateInfoVALVE" }, { "vuid": "VUID-VkDescriptorPoolCreateInfo-sType-unique", @@ -14248,6 +14334,22 @@ "vuid": "VUID-VkDescriptorPoolCreateInfo-poolSizeCount-arraylength", "text": " poolSizeCount must be greater than 0" } + ], + "(VK_VERSION_1_2,VK_EXT_descriptor_indexing)+(VK_VALVE_mutable_descriptor_type)": [ + { + "vuid": "VUID-VkDescriptorPoolCreateInfo-flags-04607", + "text": " If flags has the VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_VALVE bit set, then the VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT bit must not be set" + } + ], + "(VK_VALVE_mutable_descriptor_type)": [ + { + "vuid": "VUID-VkDescriptorPoolCreateInfo-mutableDescriptorType-04608", + "text": " If VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE::mutableDescriptorType is not enabled, pPoolSizes must not contain a descriptorType of VK_DESCRIPTOR_TYPE_MUTABLE_VALVE" + }, + { + "vuid": "VUID-VkDescriptorPoolCreateInfo-flags-04609", + "text": " If flags has the VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_VALVE bit set, VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE::mutableDescriptorType must be enabled" + } ] }, "VkDescriptorPoolInlineUniformBlockCreateInfoEXT": { @@ -14351,6 +14453,12 @@ "text": " If any element of pSetLayouts was created with the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set, descriptorPool must have been created with the VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT flag set" } ], + "(VK_VALVE_mutable_descriptor_type)": [ + { + "vuid": "VUID-VkDescriptorSetAllocateInfo-pSetLayouts-04610", + "text": " If any element of pSetLayouts was created with the VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_VALVE bit set, descriptorPool must have been created with the VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_VALVE flag set" + } + ], "core": [ { "vuid": "VUID-VkDescriptorSetAllocateInfo-sType-sType", @@ -14370,15 +14478,11 @@ }, { "vuid": "VUID-VkDescriptorSetAllocateInfo-pSetLayouts-parameter", - "text": " pSetLayouts must be a valid pointer to an array of descriptorSetCount valid VkDescriptorSetLayout handles" - }, - { - "vuid": "VUID-VkDescriptorSetAllocateInfo-descriptorSetCount-arraylength", - "text": " descriptorSetCount must be greater than 0" + "text": " pSetLayouts must be a valid pointer to a valid VkDescriptorSetLayout handle" }, { "vuid": "VUID-VkDescriptorSetAllocateInfo-commonparent", - "text": " Both of descriptorPool, and the elements of pSetLayouts must have been created, allocated, or retrieved from the same VkDevice" + "text": " Both of descriptorPool, and pSetLayouts must have been created, allocated, or retrieved from the same VkDevice" } ] }, @@ -14690,6 +14794,12 @@ "vuid": "VUID-VkWriteDescriptorSet-descriptorCount-03048", "text": " All consecutive bindings updated via a single VkWriteDescriptorSet structure, except those with a descriptorCount of zero, must have identical VkDescriptorBindingFlagBits" } + ], + "(VK_VALVE_mutable_descriptor_type)": [ + { + "vuid": "VUID-VkWriteDescriptorSet-dstSet-04611", + "text": " If the VkDescriptorSetLayoutBinding for dstSet at dstBinding is VK_DESCRIPTOR_TYPE_MUTABLE_VALVE, the new active descriptor type descriptorType must exist in the corresponding pMutableDescriptorTypeLists list for dstBinding" + } ] }, "VkDescriptorBufferInfo": { @@ -14916,6 +15026,20 @@ "vuid": "VUID-VkCopyDescriptorSet-srcSet-01921", "text": " If the descriptor pool from which srcSet was allocated was created without the VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT flag set, then the descriptor pool from which dstSet was allocated must also have been created without the VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT flag set" } + ], + "(VK_VALVE_mutable_descriptor_type)": [ + { + "vuid": "VUID-VkCopyDescriptorSet-dstSet-04612", + "text": " If VkDescriptorSetLayoutBinding for dstSet at dstBinding is VK_DESCRIPTOR_TYPE_MUTABLE_VALVE, the new active descriptor type must exist in the corresponding pMutableDescriptorTypeLists list for dstBinding if the new active descriptor type is not VK_DESCRIPTOR_TYPE_MUTABLE_VALVE" + }, + { + "vuid": "VUID-VkCopyDescriptorSet-srcSet-04613", + "text": " If VkDescriptorSetLayoutBinding for srcSet at srcBinding is VK_DESCRIPTOR_TYPE_MUTABLE_VALVE and the VkDescriptorSetLayoutBinding for dstSet at dstBinding is not VK_DESCRIPTOR_TYPE_MUTABLE_VALVE, the active descriptor type for the source descriptor must match the descriptor type of dstBinding" + }, + { + "vuid": "VUID-VkCopyDescriptorSet-dstSet-04614", + "text": " If VkDescriptorSetLayoutBinding for dstSet at dstBinding is VK_DESCRIPTOR_TYPE_MUTABLE_VALVE, and the new active descriptor type is VK_DESCRIPTOR_TYPE_MUTABLE_VALVE, the pMutableDescriptorTypeLists for srcBinding and dstBinding must match exactly" + } ] }, "vkCreateDescriptorUpdateTemplate": { @@ -14986,6 +15110,12 @@ "vuid": "VUID-VkDescriptorUpdateTemplateCreateInfo-templateType-00353", "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_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_VALVE" + } ] }, "VkDescriptorUpdateTemplateEntry": { @@ -15132,6 +15262,12 @@ "vuid": "VUID-vkCmdBindDescriptorSets-commonparent", "text": " Each of commandBuffer, layout, and the elements of pDescriptorSets must have been created, allocated, or retrieved from the same VkDevice" } + ], + "(VK_VALVE_mutable_descriptor_type)": [ + { + "vuid": "VUID-vkCmdBindDescriptorSets-pDescriptorSets-04616", + "text": " Each element of pDescriptorSets must not have been allocated from a VkDescriptorPool with the VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_VALVE flag set" + } ] }, "vkCmdPushDescriptorSetKHR": { @@ -15936,19 +16072,19 @@ } ] }, - "LaunchIDKHR": { + "LaunchIdKHR": { "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)": [ { - "vuid": "VUID-LaunchIDKHR-LaunchIDKHR-04266", - "text": " The LaunchIDKHR decoration must be used only within the RayGenerationKHR, IntersectionKHR, AnyHitKHR, ClosestHitKHR, or MissKHR {ExecutionModel}" + "vuid": "VUID-LaunchIdKHR-LaunchIdKHR-04266", + "text": " The LaunchIdKHR decoration must be used only within the RayGenerationKHR, IntersectionKHR, AnyHitKHR, ClosestHitKHR, MissKHR, or CallableKHR {ExecutionModel}" }, { - "vuid": "VUID-LaunchIDKHR-LaunchIDKHR-04267", - "text": " The variable decorated with LaunchIDKHR must be declared using the Input {StorageClass}" + "vuid": "VUID-LaunchIdKHR-LaunchIdKHR-04267", + "text": " The variable decorated with LaunchIdKHR must be declared using the Input {StorageClass}" }, { - "vuid": "VUID-LaunchIDKHR-LaunchIDKHR-04268", - "text": " The variable decorated with LaunchIDKHR must be declared as a three-component vector of 32-bit integer values" + "vuid": "VUID-LaunchIdKHR-LaunchIdKHR-04268", + "text": " The variable decorated with LaunchIdKHR must be declared as a three-component vector of 32-bit integer values" } ] }, @@ -15956,7 +16092,7 @@ "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)": [ { "vuid": "VUID-LaunchSizeKHR-LaunchSizeKHR-04269", - "text": " The LaunchSizeKHR decoration must be used only within the RayGenerationKHR, IntersectionKHR, AnyHitKHR, ClosestHitKHR, or MissKHR {ExecutionModel}" + "text": " The LaunchSizeKHR decoration must be used only within the RayGenerationKHR, IntersectionKHR, AnyHitKHR, ClosestHitKHR, MissKHR, or CallableKHR {ExecutionModel}" }, { "vuid": "VUID-LaunchSizeKHR-LaunchSizeKHR-04270", @@ -21873,6 +22009,10 @@ { "vuid": "VUID-vkCmdDraw-commandBuffer-02713", "text": " If commandBuffer is a protected command buffer, pipeline stages other than the framebuffer-space and compute stages in the VkPipeline object bound to the pipeline bind point must not write to any resource" + }, + { + "vuid": "VUID-vkCmdDraw-commandBuffer-04617", + "text": " If any of the shader stages of the VkPipeline bound to the pipeline bind point used by this command uses the RayQueryKHR capability, then commandBuffer must not be a protected command buffer" } ], "(VK_EXT_shader_image_atomic_int64)": [ @@ -22121,6 +22261,10 @@ { "vuid": "VUID-vkCmdDrawIndexed-commandBuffer-02713", "text": " If commandBuffer is a protected command buffer, pipeline stages other than the framebuffer-space and compute stages in the VkPipeline object bound to the pipeline bind point must not write to any resource" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-commandBuffer-04617", + "text": " If any of the shader stages of the VkPipeline bound to the pipeline bind point used by this command uses the RayQueryKHR capability, then commandBuffer must not be a protected command buffer" } ], "(VK_EXT_shader_image_atomic_int64)": [ @@ -27161,6 +27305,10 @@ { "vuid": "VUID-vkCmdDispatch-commandBuffer-02713", "text": " If commandBuffer is a protected command buffer, pipeline stages other than the framebuffer-space and compute stages in the VkPipeline object bound to the pipeline bind point must not write to any resource" + }, + { + "vuid": "VUID-vkCmdDispatch-commandBuffer-04617", + "text": " If any of the shader stages of the VkPipeline bound to the pipeline bind point used by this command uses the RayQueryKHR capability, then commandBuffer must not be a protected command buffer" } ], "(VK_EXT_shader_image_atomic_int64)": [ @@ -29406,6 +29554,34 @@ } ] }, + "vkAcquireWinrtDisplayNV": { + "(VK_KHR_surface)+(VK_KHR_display)+(VK_EXT_direct_mode_display)+(VK_NV_acquire_winrt_display)": [ + { + "vuid": "VUID-vkAcquireWinrtDisplayNV-physicalDevice-parameter", + "text": " physicalDevice must be a valid VkPhysicalDevice handle" + }, + { + "vuid": "VUID-vkAcquireWinrtDisplayNV-display-parameter", + "text": " display must be a valid VkDisplayKHR handle" + }, + { + "vuid": "VUID-vkAcquireWinrtDisplayNV-display-parent", + "text": " display must have been created, allocated, or retrieved from physicalDevice" + } + ] + }, + "vkGetWinrtDisplayNV": { + "(VK_KHR_surface)+(VK_KHR_display)+(VK_EXT_direct_mode_display)+(VK_NV_acquire_winrt_display)": [ + { + "vuid": "VUID-vkGetWinrtDisplayNV-physicalDevice-parameter", + "text": " physicalDevice must be a valid VkPhysicalDevice handle" + }, + { + "vuid": "VUID-vkGetWinrtDisplayNV-pDisplay-parameter", + "text": " pDisplay must be a valid pointer to a VkDisplayKHR handle" + } + ] + }, "vkReleaseDisplayEXT": { "(VK_KHR_surface)+(VK_KHR_display)+(VK_EXT_direct_mode_display)": [ { @@ -30633,7 +30809,7 @@ "text": " Both of device, and swapChain must have been created, allocated, or retrieved from the same VkInstance" }, { - "vuid": "VUID-vkSetLocalDimmingAMD-XXXXX", + "vuid": "VUID-vkSetLocalDimmingAMD-localDimmingSupport-04618", "text": " It is only valid to call vkSetLocalDimmingAMD if VkDisplayNativeHdrSurfaceCapabilitiesAMD::localDimmingSupport is supported" } ] @@ -31460,6 +31636,10 @@ "vuid": "VUID-vkCmdTraceRaysNV-None-03429", "text": " Any shader group handle referenced by this call must have been queried from the currently bound ray tracing shader pipeline" }, + { + "vuid": "VUID-vkCmdTraceRaysNV-commandBuffer-04624", + "text": " commandBuffer must not be a protected command buffer" + }, { "vuid": "VUID-vkCmdTraceRaysNV-maxRecursionDepth-03625", "text": " This command must not cause a trace ray instruction to be executed from a shader invocation with a recursion depth greater than the value of maxRecursionDepth used to create the bound ray tracing pipeline" @@ -31581,14 +31761,6 @@ { "vuid": "VUID-vkCmdTraceRaysNV-commandBuffer-02707", "text": " If commandBuffer is an unprotected command buffer, any resource accessed by the VkPipeline object bound to the pipeline bind point used by this command must not be a protected resource" - }, - { - "vuid": "VUID-vkCmdTraceRaysNV-commandBuffer-02712", - "text": " If commandBuffer is a protected command buffer, any resource written to by the VkPipeline object bound to the pipeline bind point used by this command must not be an unprotected resource" - }, - { - "vuid": "VUID-vkCmdTraceRaysNV-commandBuffer-02713", - "text": " If commandBuffer is a protected command buffer, pipeline stages other than the framebuffer-space and compute stages in the VkPipeline object bound to the pipeline bind point must not write to any resource" } ], "(VK_EXT_shader_image_atomic_int64)": [ @@ -31838,6 +32010,10 @@ "vuid": "VUID-vkCmdTraceRaysKHR-pHitShaderBindingTable-03721", "text": " Any hit group entries in pHitShaderBindingTable accessed by this call from a geometry with a geometryType of VK_GEOMETRY_TYPE_AABBS_KHR must have been created with VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_KHR" }, + { + "vuid": "VUID-vkCmdTraceRaysKHR-commandBuffer-04625", + "text": " commandBuffer must not be a protected command buffer" + }, { "vuid": "VUID-vkCmdTraceRaysKHR-width-03626", "text": " width must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupCount[0] {times} VkPhysicalDeviceLimits::maxComputeWorkGroupSize[0]" @@ -31887,14 +32063,6 @@ { "vuid": "VUID-vkCmdTraceRaysKHR-commandBuffer-02707", "text": " If commandBuffer is an unprotected command buffer, any resource accessed by the VkPipeline object bound to the pipeline bind point used by this command must not be a protected resource" - }, - { - "vuid": "VUID-vkCmdTraceRaysKHR-commandBuffer-02712", - "text": " If commandBuffer is a protected command buffer, any resource written to by the VkPipeline object bound to the pipeline bind point used by this command must not be an unprotected resource" - }, - { - "vuid": "VUID-vkCmdTraceRaysKHR-commandBuffer-02713", - "text": " If commandBuffer is a protected command buffer, pipeline stages other than the framebuffer-space and compute stages in the VkPipeline object bound to the pipeline bind point must not write to any resource" } ], "(VK_EXT_shader_image_atomic_int64)": [ @@ -34872,6 +35040,14 @@ } ] }, + "VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE": { + "(VK_VALVE_mutable_descriptor_type)": [ + { + "vuid": "VUID-VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE" + } + ] + }, "VkPhysicalDeviceFragmentShadingRateFeaturesKHR": { "(VK_KHR_fragment_shading_rate)": [ { diff --git a/registry/vk.xml b/registry/vk.xml index f6cd00cc..0b9d3db1 100644 --- a/registry/vk.xml +++ b/registry/vk.xml @@ -67,6 +67,7 @@ branch of the member gitlab server. + @@ -136,7 +137,7 @@ branch of the member gitlab server. // Vulkan 1.2 version number #define VK_API_VERSION_1_2 VK_MAKE_VERSION(1, 2, 0)// Patch version should always be set to 0 // Version of this file -#define VK_HEADER_VERSION 163 +#define VK_HEADER_VERSION 164 // Complete version of this file #define VK_HEADER_VERSION_COMPLETE VK_MAKE_VERSION(1, 2, VK_HEADER_VERSION) @@ -337,7 +338,7 @@ typedef void CAMetalLayer; typedef VkFlags VkToolPurposeFlagsEXT; Types which can be void pointers or class pointers, selected at compile time - VK_DEFINE_HANDLE(VkInstance) + VK_DEFINE_HANDLE(VkInstance) VK_DEFINE_HANDLE(VkPhysicalDevice) VK_DEFINE_HANDLE(VkDevice) VK_DEFINE_HANDLE(VkQueue) @@ -1082,7 +1083,7 @@ typedef void CAMetalLayer; const void* pNext VkDescriptorPool descriptorPool uint32_t descriptorSetCount - const VkDescriptorSetLayout* pSetLayouts + const VkDescriptorSetLayout* pSetLayouts uint32_t constantIDThe SpecConstant ID specified in the BIL @@ -5117,6 +5118,21 @@ typedef void CAMetalLayer; VkDeviceSize updateScratchSize VkDeviceSize buildScratchSize + + VkStructureType sType + void* pNext + VkBool32 mutableDescriptorType + + + uint32_t descriptorTypeCount + const VkDescriptorType* pDescriptorTypes + + + VkStructureType sType + const void* pNext + uint32_t mutableDescriptorTypeListCount + const VkMutableDescriptorTypeListVALVE* pMutableDescriptorTypeLists + Vulkan enumerant (token) definitions @@ -6256,7 +6272,8 @@ typedef void CAMetalLayer; - + + Driver IDs are now represented as enums instead of the old @@ -7994,6 +8011,17 @@ typedef void CAMetalLayer; RROutput rrOutput VkDisplayKHR* pDisplay + + VkResult vkAcquireWinrtDisplayNV + VkPhysicalDevice physicalDevice + VkDisplayKHR display + + + VkResult vkGetWinrtDisplayNV + VkPhysicalDevice physicalDevice + uint32_t deviceRelativeId + VkDisplayKHR* pDisplay + VkResult vkDisplayPowerControlEXT VkDevice device @@ -14357,10 +14385,12 @@ typedef void CAMetalLayer; - + - - + + + + @@ -14387,12 +14417,18 @@ typedef void CAMetalLayer; - + - - - - + + + + + + + + + +