From 5c33370234bce7abfb310782fff81629ea7665cc Mon Sep 17 00:00:00 2001 From: asuessenbach Date: Tue, 2 Mar 2021 09:06:31 +0100 Subject: [PATCH] Update to VK_HEADER_VERSION 171 --- Vulkan-Headers | 2 +- VulkanHppGenerator.cpp | 29 +++- vulkan/vulkan.hpp | 302 +++++++++++++++++++++++++++++++++++++++-- vulkan/vulkan_raii.hpp | 39 ++++++ 4 files changed, 352 insertions(+), 20 deletions(-) diff --git a/Vulkan-Headers b/Vulkan-Headers index 1d99b83..c428484 160000 --- a/Vulkan-Headers +++ b/Vulkan-Headers @@ -1 +1 @@ -Subproject commit 1d99b835ec3cd5a7fb2f2a2dd9a615ee2d1f0101 +Subproject commit c428484bc886f60efd98334b80ea777ae2e24089 diff --git a/VulkanHppGenerator.cpp b/VulkanHppGenerator.cpp index a7b307b..83c99f8 100644 --- a/VulkanHppGenerator.cpp +++ b/VulkanHppGenerator.cpp @@ -89,7 +89,9 @@ const std::set ignoreLens = { "null-terminated", R"(latexmath:[\lceil{\mathit{rasterizationSamples} \over 32}\rceil])", "2*VK_UUID_SIZE", "2*ename:VK_UUID_SIZE" }; -const std::set specialPointerTypes = { "Display", "IDirectFB", "wl_display", "xcb_connection_t", "_screen_window" }; +const std::set specialPointerTypes = { + "Display", "IDirectFB", "wl_display", "xcb_connection_t", "_screen_window" +}; void appendArgumentCount( std::string & str, size_t vectorIndex, @@ -1122,7 +1124,6 @@ void VulkanHppGenerator::appendCommand( std::string & str, std::map vectorParamIndices = determineVectorParamIndicesNew( commandData.params ); std::vector nonConstPointerParamIndices = determineNonConstPointerParamIndices( commandData.params ); - switch ( nonConstPointerParamIndices.size() ) { case 0: @@ -1232,7 +1233,8 @@ void VulkanHppGenerator::appendCommand( std::string & str, auto returnVectorParamIt = vectorParamIndices.find( nonConstPointerParamIndices[0] ); if ( returnVectorParamIt == vectorParamIndices.end() ) { - if ( ( commandData.returnType == "VkBool32" ) || ( commandData.returnType == "VkResult" ) || ( commandData.returnType == "void" ) ) + if ( ( commandData.returnType == "VkBool32" ) || ( commandData.returnType == "VkResult" ) || + ( commandData.returnType == "void" ) ) { appendCommandStandardAndEnhanced( str, name, commandData, initialSkipCount, definition, vectorParamIndices, nonConstPointerParamIndices ); @@ -4048,10 +4050,10 @@ std::string VulkanHppGenerator::constructCallArgumentsStandard( std::string cons } std::string VulkanHppGenerator::constructCommandBoolGetValue( std::string const & name, - CommandData const & commandData, - size_t initialSkipCount, - bool definition, - size_t nonConstPointerIndex ) const + CommandData const & commandData, + size_t initialSkipCount, + bool definition, + size_t nonConstPointerIndex ) const { assert( commandData.returnType == "VkBool32" ); @@ -12496,6 +12498,7 @@ void VulkanHppGenerator::readRequireEnum( tinyxml2::XMLElement const * { "dir", { "-" } }, { "extnumber", {} }, { "offset", {} }, + { "protect", { "VK_ENABLE_BETA_EXTENSIONS" } }, { "value", {} } } ); checkElements( line, getChildElements( element ), {} ); @@ -12518,6 +12521,18 @@ void VulkanHppGenerator::readRequireEnum( tinyxml2::XMLElement const * { offset = attribute.second; } + else if ( attribute.first == "protect" ) + { + // for now, attribute "protect" is, if set at all, set to "VK_ENABLE_BETA_EXTENSIONS" + // and it's redundant with the platform set for this extension! + auto extIt = m_extensions.find( extension ); + assert( extIt != m_extensions.end() ); + check( + extIt->second.platform == "provisional", + line, + "attribute is \"VK_ENABLE_BETA_EXTENSIONS\", but the extensions platform is not \"provisional\" but \"" + + extIt->second.platform + "\"" ); + } else if ( attribute.first == "value" ) { value = attribute.second; diff --git a/vulkan/vulkan.hpp b/vulkan/vulkan.hpp index aad952a..ebee69b 100644 --- a/vulkan/vulkan.hpp +++ b/vulkan/vulkan.hpp @@ -93,7 +93,7 @@ extern "C" __declspec( dllimport ) FARPROC __stdcall GetProcAddress( HINSTANCE h # include #endif -static_assert( VK_HEADER_VERSION == 170, "Wrong VK_HEADER_VERSION!" ); +static_assert( VK_HEADER_VERSION == 171, "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 @@ -3012,6 +3012,16 @@ namespace VULKAN_HPP_NAMESPACE return ::vkCreateSamplerYcbcrConversionKHR( device, pCreateInfo, pAllocator, pYcbcrConversion ); } +# ifdef VK_USE_PLATFORM_SCREEN_QNX + VkResult vkCreateScreenSurfaceQNX( VkInstance instance, + const VkScreenSurfaceCreateInfoQNX * pCreateInfo, + const VkAllocationCallbacks * pAllocator, + VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCreateScreenSurfaceQNX( instance, pCreateInfo, pAllocator, pSurface ); + } +# endif /*VK_USE_PLATFORM_SCREEN_QNX*/ + VkResult vkCreateSemaphore( VkDevice device, const VkSemaphoreCreateInfo * pCreateInfo, const VkAllocationCallbacks * pAllocator, @@ -4231,6 +4241,15 @@ namespace VULKAN_HPP_NAMESPACE physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties ); } +# ifdef VK_USE_PLATFORM_SCREEN_QNX + VkBool32 vkGetPhysicalDeviceScreenPresentationSupportQNX( VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + struct _screen_window * window ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetPhysicalDeviceScreenPresentationSupportQNX( physicalDevice, queueFamilyIndex, window ); + } +# endif /*VK_USE_PLATFORM_SCREEN_QNX*/ + void vkGetPhysicalDeviceSparseImageFormatProperties( VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, @@ -10517,7 +10536,10 @@ namespace VULKAN_HPP_NAMESPACE #endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ ePhysicalDeviceMutableDescriptorTypeFeaturesVALVE = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE, - eMutableDescriptorTypeCreateInfoVALVE = VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE, + eMutableDescriptorTypeCreateInfoVALVE = VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE, +#ifdef VK_USE_PLATFORM_SCREEN_QNX + eScreenSurfaceCreateInfoQNX = VK_STRUCTURE_TYPE_SCREEN_SURFACE_CREATE_INFO_QNX, +#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ 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, @@ -11342,6 +11364,9 @@ namespace VULKAN_HPP_NAMESPACE case StructureType::ePhysicalDeviceMutableDescriptorTypeFeaturesVALVE: return "PhysicalDeviceMutableDescriptorTypeFeaturesVALVE"; case StructureType::eMutableDescriptorTypeCreateInfoVALVE: return "MutableDescriptorTypeCreateInfoVALVE"; +#ifdef VK_USE_PLATFORM_SCREEN_QNX + case StructureType::eScreenSurfaceCreateInfoQNX: return "ScreenSurfaceCreateInfoQNX"; +#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast( value ) ) + " )"; } } @@ -16323,6 +16348,24 @@ namespace VULKAN_HPP_NAMESPACE return "{ " + result.substr( 0, result.size() - 3 ) + " }"; } +#ifdef VK_USE_PLATFORM_SCREEN_QNX + enum class ScreenSurfaceCreateFlagBitsQNX : VkFlags + { + }; + + VULKAN_HPP_INLINE std::string to_string( ScreenSurfaceCreateFlagBitsQNX ) + { + return "(void)"; + } + + using ScreenSurfaceCreateFlagsQNX = Flags; + + VULKAN_HPP_INLINE std::string to_string( ScreenSurfaceCreateFlagsQNX ) + { + return "{}"; + } +#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ + enum class SemaphoreCreateFlagBits : VkFlags { }; @@ -62357,6 +62400,21 @@ namespace VULKAN_HPP_NAMESPACE Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#ifdef VK_USE_PLATFORM_SCREEN_QNX + template + Bool32 getScreenPresentationSupportQNX( uint32_t queueFamilyIndex, + struct _screen_window * window, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const + VULKAN_HPP_NOEXCEPT; +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + Bool32 getScreenPresentationSupportQNX( uint32_t queueFamilyIndex, + struct _screen_window & window, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const + VULKAN_HPP_NOEXCEPT; +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ + template void getSparseImageFormatProperties( VULKAN_HPP_NAMESPACE::Format format, VULKAN_HPP_NAMESPACE::ImageType type, @@ -87473,6 +87531,107 @@ namespace VULKAN_HPP_NAMESPACE }; using SamplerYcbcrConversionInfoKHR = SamplerYcbcrConversionInfo; +#ifdef VK_USE_PLATFORM_SCREEN_QNX + struct ScreenSurfaceCreateInfoQNX + { + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eScreenSurfaceCreateInfoQNX; + +# if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ScreenSurfaceCreateInfoQNX( VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateFlagsQNX flags_ = {}, + struct _screen_context * context_ = {}, + struct _screen_window * window_ = {} ) VULKAN_HPP_NOEXCEPT + : flags( flags_ ) + , context( context_ ) + , window( window_ ) + {} + + VULKAN_HPP_CONSTEXPR + ScreenSurfaceCreateInfoQNX( ScreenSurfaceCreateInfoQNX const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ScreenSurfaceCreateInfoQNX( VkScreenSurfaceCreateInfoQNX const & rhs ) VULKAN_HPP_NOEXCEPT + : ScreenSurfaceCreateInfoQNX( *reinterpret_cast( &rhs ) ) + {} +# endif // !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + + VULKAN_HPP_CONSTEXPR_14 ScreenSurfaceCreateInfoQNX & + operator=( ScreenSurfaceCreateInfoQNX const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ScreenSurfaceCreateInfoQNX & operator=( VkScreenSurfaceCreateInfoQNX const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + ScreenSurfaceCreateInfoQNX & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + ScreenSurfaceCreateInfoQNX & + setFlags( VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateFlagsQNX flags_ ) VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + ScreenSurfaceCreateInfoQNX & setContext( struct _screen_context * context_ ) VULKAN_HPP_NOEXCEPT + { + context = context_; + return *this; + } + + ScreenSurfaceCreateInfoQNX & setWindow( struct _screen_window * window_ ) VULKAN_HPP_NOEXCEPT + { + window = window_; + return *this; + } + + operator VkScreenSurfaceCreateInfoQNX const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkScreenSurfaceCreateInfoQNX &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ScreenSurfaceCreateInfoQNX const & ) const = default; +# else + bool operator==( ScreenSurfaceCreateInfoQNX const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( context == rhs.context ) && + ( window == rhs.window ); + } + + bool operator!=( ScreenSurfaceCreateInfoQNX const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eScreenSurfaceCreateInfoQNX; + const void * pNext = {}; + VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateFlagsQNX flags = {}; + struct _screen_context * context = {}; + struct _screen_window * window = {}; + }; + static_assert( sizeof( ScreenSurfaceCreateInfoQNX ) == sizeof( VkScreenSurfaceCreateInfoQNX ), + "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 = ScreenSurfaceCreateInfoQNX; + }; +#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ + struct SemaphoreTypeCreateInfo { static const bool allowDuplicate = false; @@ -91043,6 +91202,32 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VK_USE_PLATFORM_METAL_EXT*/ +#ifdef VK_USE_PLATFORM_SCREEN_QNX + template + VULKAN_HPP_NODISCARD Result + createScreenSurfaceQNX( const VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX * pCreateInfo, + const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, + VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface, + 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 + createScreenSurfaceQNX( const ScreenSurfaceCreateInfoQNX & createInfo, + Optional allocator + VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, + 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 + createScreenSurfaceQNXUnique( const ScreenSurfaceCreateInfoQNX & createInfo, + Optional allocator + VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, + 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_SCREEN_QNX*/ + #ifdef VK_USE_PLATFORM_GGP template VULKAN_HPP_NODISCARD Result createStreamDescriptorSurfaceGGP( @@ -103726,6 +103911,62 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VK_USE_PLATFORM_METAL_EXT*/ +#ifdef VK_USE_PLATFORM_SCREEN_QNX + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result + Instance::createScreenSurfaceQNX( const VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX * pCreateInfo, + const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, + VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + return static_cast( + d.vkCreateScreenSurfaceQNX( m_instance, + reinterpret_cast( pCreateInfo ), + reinterpret_cast( pAllocator ), + reinterpret_cast( pSurface ) ) ); + } + +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE + typename ResultValueType::type + Instance::createScreenSurfaceQNX( const ScreenSurfaceCreateInfoQNX & createInfo, + Optional allocator, + Dispatch const & d ) const + { + VULKAN_HPP_NAMESPACE::SurfaceKHR surface; + Result result = static_cast( + d.vkCreateScreenSurfaceQNX( m_instance, + reinterpret_cast( &createInfo ), + reinterpret_cast( + static_cast( allocator ) ), + reinterpret_cast( &surface ) ) ); + return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createScreenSurfaceQNX" ); + } + +# ifndef VULKAN_HPP_NO_SMART_HANDLE + template + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE + typename ResultValueType>::type + Instance::createScreenSurfaceQNXUnique( const ScreenSurfaceCreateInfoQNX & createInfo, + Optional allocator, + Dispatch const & d ) const + { + VULKAN_HPP_NAMESPACE::SurfaceKHR surface; + Result result = static_cast( + d.vkCreateScreenSurfaceQNX( m_instance, + reinterpret_cast( &createInfo ), + reinterpret_cast( + static_cast( allocator ) ), + reinterpret_cast( &surface ) ) ); + ObjectDestroy deleter( *this, allocator, d ); + return createResultValue( + result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createScreenSurfaceQNXUnique", deleter ); + } +# endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ + #ifdef VK_USE_PLATFORM_GGP template VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::createStreamDescriptorSurfaceGGP( @@ -106975,6 +107216,25 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#ifdef VK_USE_PLATFORM_SCREEN_QNX + template + VULKAN_HPP_INLINE Bool32 PhysicalDevice::getScreenPresentationSupportQNX( + uint32_t queueFamilyIndex, struct _screen_window * window, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + return static_cast( + d.vkGetPhysicalDeviceScreenPresentationSupportQNX( m_physicalDevice, queueFamilyIndex, window ) ); + } + +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE Bool32 PhysicalDevice::getScreenPresentationSupportQNX( + uint32_t queueFamilyIndex, struct _screen_window & window, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + return d.vkGetPhysicalDeviceScreenPresentationSupportQNX( m_physicalDevice, queueFamilyIndex, &window ); + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ + template VULKAN_HPP_INLINE void PhysicalDevice::getSparseImageFormatProperties( VULKAN_HPP_NAMESPACE::Format format, @@ -111619,9 +111879,14 @@ namespace VULKAN_HPP_NAMESPACE PFN_vkCreateSampler vkCreateSampler = 0; PFN_vkCreateSamplerYcbcrConversionKHR vkCreateSamplerYcbcrConversionKHR = 0; PFN_vkCreateSamplerYcbcrConversion vkCreateSamplerYcbcrConversion = 0; - PFN_vkCreateSemaphore vkCreateSemaphore = 0; - PFN_vkCreateShaderModule vkCreateShaderModule = 0; - PFN_vkCreateSharedSwapchainsKHR vkCreateSharedSwapchainsKHR = 0; +#ifdef VK_USE_PLATFORM_SCREEN_QNX + PFN_vkCreateScreenSurfaceQNX vkCreateScreenSurfaceQNX = 0; +#else + PFN_dummy placeholder_dont_call_vkCreateScreenSurfaceQNX = 0; +#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ + PFN_vkCreateSemaphore vkCreateSemaphore = 0; + PFN_vkCreateShaderModule vkCreateShaderModule = 0; + PFN_vkCreateSharedSwapchainsKHR vkCreateSharedSwapchainsKHR = 0; #ifdef VK_USE_PLATFORM_GGP PFN_vkCreateStreamDescriptorSurfaceGGP vkCreateStreamDescriptorSurfaceGGP = 0; #else @@ -111834,13 +112099,18 @@ namespace VULKAN_HPP_NAMESPACE PFN_vkGetPhysicalDeviceProperties2KHR vkGetPhysicalDeviceProperties2KHR = 0; PFN_vkGetPhysicalDeviceProperties2 vkGetPhysicalDeviceProperties2 = 0; PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR - vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR = 0; - PFN_vkGetPhysicalDeviceQueueFamilyProperties vkGetPhysicalDeviceQueueFamilyProperties = 0; - PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR vkGetPhysicalDeviceQueueFamilyProperties2KHR = 0; - PFN_vkGetPhysicalDeviceQueueFamilyProperties2 vkGetPhysicalDeviceQueueFamilyProperties2 = 0; - PFN_vkGetPhysicalDeviceSparseImageFormatProperties vkGetPhysicalDeviceSparseImageFormatProperties = 0; - PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR vkGetPhysicalDeviceSparseImageFormatProperties2KHR = 0; - PFN_vkGetPhysicalDeviceSparseImageFormatProperties2 vkGetPhysicalDeviceSparseImageFormatProperties2 = 0; + vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR = 0; + PFN_vkGetPhysicalDeviceQueueFamilyProperties vkGetPhysicalDeviceQueueFamilyProperties = 0; + PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR vkGetPhysicalDeviceQueueFamilyProperties2KHR = 0; + PFN_vkGetPhysicalDeviceQueueFamilyProperties2 vkGetPhysicalDeviceQueueFamilyProperties2 = 0; +#ifdef VK_USE_PLATFORM_SCREEN_QNX + PFN_vkGetPhysicalDeviceScreenPresentationSupportQNX vkGetPhysicalDeviceScreenPresentationSupportQNX = 0; +#else + PFN_dummy placeholder_dont_call_vkGetPhysicalDeviceScreenPresentationSupportQNX = 0; +#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ + PFN_vkGetPhysicalDeviceSparseImageFormatProperties vkGetPhysicalDeviceSparseImageFormatProperties = 0; + PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR vkGetPhysicalDeviceSparseImageFormatProperties2KHR = 0; + PFN_vkGetPhysicalDeviceSparseImageFormatProperties2 vkGetPhysicalDeviceSparseImageFormatProperties2 = 0; PFN_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV = 0; PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT vkGetPhysicalDeviceSurfaceCapabilities2EXT = 0; @@ -112102,6 +112372,10 @@ namespace VULKAN_HPP_NAMESPACE vkCreateMetalSurfaceEXT = PFN_vkCreateMetalSurfaceEXT( vkGetInstanceProcAddr( instance, "vkCreateMetalSurfaceEXT" ) ); #endif /*VK_USE_PLATFORM_METAL_EXT*/ +#ifdef VK_USE_PLATFORM_SCREEN_QNX + vkCreateScreenSurfaceQNX = + PFN_vkCreateScreenSurfaceQNX( vkGetInstanceProcAddr( instance, "vkCreateScreenSurfaceQNX" ) ); +#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ #ifdef VK_USE_PLATFORM_GGP vkCreateStreamDescriptorSurfaceGGP = PFN_vkCreateStreamDescriptorSurfaceGGP( vkGetInstanceProcAddr( instance, "vkCreateStreamDescriptorSurfaceGGP" ) ); @@ -112251,6 +112525,10 @@ namespace VULKAN_HPP_NAMESPACE vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceQueueFamilyProperties2" ) ); if ( !vkGetPhysicalDeviceQueueFamilyProperties2 ) vkGetPhysicalDeviceQueueFamilyProperties2 = vkGetPhysicalDeviceQueueFamilyProperties2KHR; +#ifdef VK_USE_PLATFORM_SCREEN_QNX + vkGetPhysicalDeviceScreenPresentationSupportQNX = PFN_vkGetPhysicalDeviceScreenPresentationSupportQNX( + vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceScreenPresentationSupportQNX" ) ); +#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ vkGetPhysicalDeviceSparseImageFormatProperties = PFN_vkGetPhysicalDeviceSparseImageFormatProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSparseImageFormatProperties" ) ); vkGetPhysicalDeviceSparseImageFormatProperties2KHR = PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR( diff --git a/vulkan/vulkan_raii.hpp b/vulkan/vulkan_raii.hpp index 04d7df8..12b31ac 100644 --- a/vulkan/vulkan_raii.hpp +++ b/vulkan/vulkan_raii.hpp @@ -340,6 +340,12 @@ namespace VULKAN_HPP_NAMESPACE template VULKAN_HPP_NODISCARD std::vector getQueueFamilyProperties2() const; +# ifdef VK_USE_PLATFORM_SCREEN_QNX + VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Bool32 + getScreenPresentationSupportQNX( uint32_t queueFamilyIndex, + struct _screen_window & window ) const VULKAN_HPP_NOEXCEPT; +# endif /*VK_USE_PLATFORM_SCREEN_QNX*/ + VULKAN_HPP_NODISCARD std::vector getSparseImageFormatProperties( VULKAN_HPP_NAMESPACE::Format format, VULKAN_HPP_NAMESPACE::ImageType type, @@ -5099,6 +5105,28 @@ namespace VULKAN_HPP_NAMESPACE } # endif /*VK_USE_PLATFORM_METAL_EXT*/ +# ifdef VK_USE_PLATFORM_SCREEN_QNX + SurfaceKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance, + VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) + : m_instance( *instance ) + , m_allocator( reinterpret_cast( + static_cast( allocator ) ) ) + , m_dispatcher( instance.getDispatcher() ) + { + VULKAN_HPP_NAMESPACE::Result result = + static_cast( getDispatcher()->vkCreateScreenSurfaceQNX( + static_cast( *instance ), + reinterpret_cast( &createInfo ), + m_allocator, + reinterpret_cast( &m_surfaceKHR ) ) ); + if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) + { + throwResultException( result, "vkCreateScreenSurfaceQNX" ); + } + } +# endif /*VK_USE_PLATFORM_SCREEN_QNX*/ + # ifdef VK_USE_PLATFORM_GGP SurfaceKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance, VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP const & createInfo, @@ -6424,6 +6452,17 @@ namespace VULKAN_HPP_NAMESPACE return returnVector; } +# ifdef VK_USE_PLATFORM_SCREEN_QNX + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Bool32 + PhysicalDevice::getScreenPresentationSupportQNX( uint32_t queueFamilyIndex, + struct _screen_window & window ) const VULKAN_HPP_NOEXCEPT + { + return static_cast( + getDispatcher()->vkGetPhysicalDeviceScreenPresentationSupportQNX( + static_cast( m_physicalDevice ), queueFamilyIndex, &window ) ); + } +# endif /*VK_USE_PLATFORM_SCREEN_QNX*/ + VULKAN_HPP_NODISCARD std::vector PhysicalDevice::getSparseImageFormatProperties( VULKAN_HPP_NAMESPACE::Format format, VULKAN_HPP_NAMESPACE::ImageType type,