Merge pull request #896 from asuessenbach/171

Update to VK_HEADER_VERSION 171

Vulkan-Headers

@@ -1 +1 @@
-Subproject commit 1d99b835ec3cd5a7fb2f2a2dd9a615ee2d1f0101
+Subproject commit c428484bc886f60efd98334b80ea777ae2e24089

VulkanHppGenerator.cpp

@@ -89,7 +89,9 @@ const std::set<std::string> ignoreLens          = { "null-terminated",
                                            R"(latexmath:[\lceil{\mathit{rasterizationSamples} \over 32}\rceil])",
                                            "2*VK_UUID_SIZE",
                                            "2*ename:VK_UUID_SIZE" };
-const std::set<std::string> specialPointerTypes = { "Display", "IDirectFB", "wl_display", "xcb_connection_t", "_screen_window" };
+const std::set<std::string> 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<size_t, size_t> vectorParamIndices          = determineVectorParamIndicesNew( commandData.params );
   std::vector<size_t>      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 );
@@ -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 <protect> is \"VK_ENABLE_BETA_EXTENSIONS\", but the extensions platform is not \"provisional\" but \"" +
+          extIt->second.platform + "\"" );
+    }
     else if ( attribute.first == "value" )
     {
       value = attribute.second;

vulkan/vulkan.hpp

@@ -93,7 +93,7 @@ extern "C" __declspec( dllimport ) FARPROC __stdcall GetProcAddress( HINSTANCE h
 #  include <compare>
 #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,
@@ -10518,6 +10537,9 @@ namespace VULKAN_HPP_NAMESPACE
     ePhysicalDeviceMutableDescriptorTypeFeaturesVALVE =
       VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_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<uint32_t>( 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<ScreenSurfaceCreateFlagBitsQNX>;
+
+  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 <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    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 <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    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 <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     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<ScreenSurfaceCreateInfoQNX const *>( &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<VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX const *>( &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<const VkScreenSurfaceCreateInfoQNX *>( this );
+    }
+
+    operator VkScreenSurfaceCreateInfoQNX &() VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<VkScreenSurfaceCreateInfoQNX *>( 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<ScreenSurfaceCreateInfoQNX>::value,
+                 "struct wrapper is not a standard layout!" );
+
+  template <>
+  struct CppType<StructureType, StructureType::eScreenSurfaceCreateInfoQNX>
+  {
+    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 <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    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 <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
+      createScreenSurfaceQNX( const ScreenSurfaceCreateInfoQNX & createInfo,
+                              Optional<const AllocationCallbacks> allocator
+                                                 VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                              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::SurfaceKHR, Dispatch>>::type
+      createScreenSurfaceQNXUnique( const ScreenSurfaceCreateInfoQNX & createInfo,
+                                    Optional<const AllocationCallbacks> 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 <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     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 <typename Dispatch>
+  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<Result>(
+      d.vkCreateScreenSurfaceQNX( m_instance,
+                                  reinterpret_cast<const VkScreenSurfaceCreateInfoQNX *>( pCreateInfo ),
+                                  reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
+                                  reinterpret_cast<VkSurfaceKHR *>( pSurface ) ) );
+  }
+
+#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
+    Instance::createScreenSurfaceQNX( const ScreenSurfaceCreateInfoQNX &  createInfo,
+                                      Optional<const AllocationCallbacks> allocator,
+                                      Dispatch const &                    d ) const
+  {
+    VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
+    Result                           result = static_cast<Result>(
+      d.vkCreateScreenSurfaceQNX( m_instance,
+                                  reinterpret_cast<const VkScreenSurfaceCreateInfoQNX *>( &createInfo ),
+                                  reinterpret_cast<const VkAllocationCallbacks *>(
+                                    static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                  reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
+    return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createScreenSurfaceQNX" );
+  }
+
+#    ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
+    Instance::createScreenSurfaceQNXUnique( const ScreenSurfaceCreateInfoQNX &  createInfo,
+                                            Optional<const AllocationCallbacks> allocator,
+                                            Dispatch const &                    d ) const
+  {
+    VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
+    Result                           result = static_cast<Result>(
+      d.vkCreateScreenSurfaceQNX( m_instance,
+                                  reinterpret_cast<const VkScreenSurfaceCreateInfoQNX *>( &createInfo ),
+                                  reinterpret_cast<const VkAllocationCallbacks *>(
+                                    static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+                                  reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
+    ObjectDestroy<Instance, Dispatch> deleter( *this, allocator, d );
+    return createResultValue<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>(
+      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 <typename Dispatch>
   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 <typename Dispatch>
+  VULKAN_HPP_INLINE Bool32 PhysicalDevice::getScreenPresentationSupportQNX(
+    uint32_t queueFamilyIndex, struct _screen_window * window, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Bool32>(
+      d.vkGetPhysicalDeviceScreenPresentationSupportQNX( m_physicalDevice, queueFamilyIndex, window ) );
+  }
+
+#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  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 <typename Dispatch>
   VULKAN_HPP_INLINE void
     PhysicalDevice::getSparseImageFormatProperties( VULKAN_HPP_NAMESPACE::Format                        format,
@@ -111619,6 +111879,11 @@ namespace VULKAN_HPP_NAMESPACE
     PFN_vkCreateSampler                   vkCreateSampler                   = 0;
     PFN_vkCreateSamplerYcbcrConversionKHR vkCreateSamplerYcbcrConversionKHR = 0;
     PFN_vkCreateSamplerYcbcrConversion    vkCreateSamplerYcbcrConversion    = 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;
@@ -111838,6 +112103,11 @@ namespace VULKAN_HPP_NAMESPACE
     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;
@@ -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(

vulkan/vulkan_raii.hpp

@@ -340,6 +340,12 @@ namespace VULKAN_HPP_NAMESPACE
       template <typename StructureChain>
       VULKAN_HPP_NODISCARD std::vector<StructureChain> 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<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties>
                            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<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
+        : m_instance( *instance )
+        , m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
+            static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
+        , m_dispatcher( instance.getDispatcher() )
+      {
+        VULKAN_HPP_NAMESPACE::Result result =
+          static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateScreenSurfaceQNX(
+            static_cast<VkInstance>( *instance ),
+            reinterpret_cast<const VkScreenSurfaceCreateInfoQNX *>( &createInfo ),
+            m_allocator,
+            reinterpret_cast<VkSurfaceKHR *>( &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<VULKAN_HPP_NAMESPACE::Bool32>(
+        getDispatcher()->vkGetPhysicalDeviceScreenPresentationSupportQNX(
+          static_cast<VkPhysicalDevice>( m_physicalDevice ), queueFamilyIndex, &window ) );
+    }
+#  endif /*VK_USE_PLATFORM_SCREEN_QNX*/
+
     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties>
                          PhysicalDevice::getSparseImageFormatProperties( VULKAN_HPP_NAMESPACE::Format              format,
                                                       VULKAN_HPP_NAMESPACE::ImageType           type,