diff options
Diffstat (limited to 'include/vulkan/vulkan.hpp')
| -rw-r--r-- | include/vulkan/vulkan.hpp | 464 |
1 files changed, 444 insertions, 20 deletions
diff --git a/include/vulkan/vulkan.hpp b/include/vulkan/vulkan.hpp index c164086..0f21fb2 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 <typename OwnerType, typename Dispatch> + 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 <typename T> + 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 <typename OwnerType, typename PoolType, typename Dispatch> 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<uint32_t>( 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<uint32_t>( 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<uint32_t>( 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<uint32_t>( 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<uint32_t>( 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 VULKAN_HPP_NAMESPACE::DescriptorSetLayout> const & setLayouts_ ) - : descriptorPool( descriptorPool_ ), descriptorSetCount( static_cast<uint32_t>( 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 VULKAN_HPP_NAMESPACE::DescriptorSetLayout> const & setLayouts_ ) VULKAN_HPP_NOEXCEPT - { - descriptorSetCount = static_cast<uint32_t>( 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 <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> + VULKAN_HPP_NODISCARD Result acquireWinrtDisplayNV( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#else + template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::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 <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> 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 <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> + 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 <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayKHR>::type getWinrtDisplayNV( uint32_t deviceRelativeId, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# ifndef VULKAN_HPP_NO_SMART_HANDLE + template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DisplayKHR, Dispatch>>::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 <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> 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 VULKAN_HPP_NAMESPACE::DescriptorType> const & descriptorTypes_ ) + : descriptorTypeCount( static_cast<uint32_t>( 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<VULKAN_HPP_NAMESPACE::MutableDescriptorTypeListVALVE const *>( &rhs ); + return *this; + } + + MutableDescriptorTypeListVALVE & operator=( MutableDescriptorTypeListVALVE const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( static_cast<void *>( 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 VULKAN_HPP_NAMESPACE::DescriptorType> const & descriptorTypes_ ) VULKAN_HPP_NOEXCEPT + { + descriptorTypeCount = static_cast<uint32_t>( descriptorTypes_.size() ); + pDescriptorTypes = descriptorTypes_.data(); + return *this; + } +#endif // !defined(VULKAN_HPP_DISABLE_ENHANCED_MODE) + + + operator VkMutableDescriptorTypeListVALVE const&() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast<const VkMutableDescriptorTypeListVALVE*>( this ); + } + + operator VkMutableDescriptorTypeListVALVE &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast<VkMutableDescriptorTypeListVALVE*>( 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<MutableDescriptorTypeListVALVE>::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 VULKAN_HPP_NAMESPACE::MutableDescriptorTypeListVALVE> const & mutableDescriptorTypeLists_ ) + : mutableDescriptorTypeListCount( static_cast<uint32_t>( 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<VULKAN_HPP_NAMESPACE::MutableDescriptorTypeCreateInfoVALVE const *>( &rhs ); + return *this; + } + + MutableDescriptorTypeCreateInfoVALVE & operator=( MutableDescriptorTypeCreateInfoVALVE const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( static_cast<void *>( 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 VULKAN_HPP_NAMESPACE::MutableDescriptorTypeListVALVE> const & mutableDescriptorTypeLists_ ) VULKAN_HPP_NOEXCEPT + { + mutableDescriptorTypeListCount = static_cast<uint32_t>( mutableDescriptorTypeLists_.size() ); + pMutableDescriptorTypeLists = mutableDescriptorTypeLists_.data(); + return *this; + } +#endif // !defined(VULKAN_HPP_DISABLE_ENHANCED_MODE) + + + operator VkMutableDescriptorTypeCreateInfoVALVE const&() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast<const VkMutableDescriptorTypeCreateInfoVALVE*>( this ); + } + + operator VkMutableDescriptorTypeCreateInfoVALVE &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast<VkMutableDescriptorTypeCreateInfoVALVE*>( 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<MutableDescriptorTypeCreateInfoVALVE>::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType<StructureType, StructureType::eMutableDescriptorTypeCreateInfoVALVE> + { + 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<VULKAN_HPP_NAMESPACE::PhysicalDeviceMutableDescriptorTypeFeaturesVALVE const *>( &rhs ); + return *this; + } + + PhysicalDeviceMutableDescriptorTypeFeaturesVALVE & operator=( PhysicalDeviceMutableDescriptorTypeFeaturesVALVE const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( static_cast<void *>( 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<const VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE*>( this ); + } + + operator VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast<VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE*>( 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<PhysicalDeviceMutableDescriptorTypeFeaturesVALVE>::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceMutableDescriptorTypeFeaturesVALVE> + { + 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 <typename Dispatch> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::acquireWinrtDisplayNV( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + return static_cast<Result>( d.vkAcquireWinrtDisplayNV( m_physicalDevice, static_cast<VkDisplayKHR>( display ) ) ); + } +#else + template <typename Dispatch> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type PhysicalDevice::acquireWinrtDisplayNV( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d ) const + { + Result result = static_cast<Result>( d.vkAcquireWinrtDisplayNV( m_physicalDevice, static_cast<VkDisplayKHR>( 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 <typename Dispatch> 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 <typename Dispatch> + 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<Result>( d.vkGetWinrtDisplayNV( m_physicalDevice, deviceRelativeId, reinterpret_cast< VkDisplayKHR *>( pDisplay ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template <typename Dispatch> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayKHR>::type PhysicalDevice::getWinrtDisplayNV( uint32_t deviceRelativeId, Dispatch const & d ) const + { + VULKAN_HPP_NAMESPACE::DisplayKHR display; + Result result = static_cast<Result>( d.vkGetWinrtDisplayNV( m_physicalDevice, deviceRelativeId, reinterpret_cast<VkDisplayKHR *>( &display ) ) ); + return createResultValue( result, display, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getWinrtDisplayNV" ); + } + +# ifndef VULKAN_HPP_NO_SMART_HANDLE + template <typename Dispatch> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DisplayKHR, Dispatch>>::type PhysicalDevice::getWinrtDisplayNVUnique( uint32_t deviceRelativeId, Dispatch const & d ) const + { + VULKAN_HPP_NAMESPACE::DisplayKHR display; + Result result = static_cast<Result>( d.vkGetWinrtDisplayNV( m_physicalDevice, deviceRelativeId, reinterpret_cast<VkDisplayKHR *>( &display ) ) ); + ObjectReleaseExt<PhysicalDevice, Dispatch> deleter( *this, d ); + return createResultValue<VULKAN_HPP_NAMESPACE::DisplayKHR, Dispatch>( 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 <typename Dispatch> 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<MemoryDedicatedRequirements, MemoryRequirements2>{ enum { value = true }; }; template <> struct StructExtends<MemoryOpaqueCaptureAddressAllocateInfo, MemoryAllocateInfo>{ enum { value = true }; }; template <> struct StructExtends<MemoryPriorityAllocateInfoEXT, MemoryAllocateInfo>{ enum { value = true }; }; + template <> struct StructExtends<MutableDescriptorTypeCreateInfoVALVE, DescriptorSetLayoutCreateInfo>{ enum { value = true }; }; + template <> struct StructExtends<MutableDescriptorTypeCreateInfoVALVE, DescriptorPoolCreateInfo>{ enum { value = true }; }; template <> struct StructExtends<PerformanceQuerySubmitInfoKHR, SubmitInfo>{ enum { value = true }; }; template <> struct StructExtends<PhysicalDevice16BitStorageFeatures, PhysicalDeviceFeatures2>{ enum { value = true }; }; template <> struct StructExtends<PhysicalDevice16BitStorageFeatures, DeviceCreateInfo>{ enum { value = true }; }; @@ -92143,6 +92553,8 @@ namespace VULKAN_HPP_NAMESPACE template <> struct StructExtends<PhysicalDeviceMultiviewFeatures, DeviceCreateInfo>{ enum { value = true }; }; template <> struct StructExtends<PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX, PhysicalDeviceProperties2>{ enum { value = true }; }; template <> struct StructExtends<PhysicalDeviceMultiviewProperties, PhysicalDeviceProperties2>{ enum { value = true }; }; + template <> struct StructExtends<PhysicalDeviceMutableDescriptorTypeFeaturesVALVE, PhysicalDeviceFeatures2>{ enum { value = true }; }; + template <> struct StructExtends<PhysicalDeviceMutableDescriptorTypeFeaturesVALVE, DeviceCreateInfo>{ enum { value = true }; }; template <> struct StructExtends<PhysicalDevicePCIBusInfoPropertiesEXT, PhysicalDeviceProperties2>{ enum { value = true }; }; template <> struct StructExtends<PhysicalDevicePerformanceQueryFeaturesKHR, PhysicalDeviceFeatures2>{ enum { value = true }; }; template <> struct StructExtends<PhysicalDevicePerformanceQueryFeaturesKHR, DeviceCreateInfo>{ 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<VkInstance>(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 |